windjammer 0.48.0

A simple language inspired by Go, Ruby, and Elixir that transpiles to Rust - 80% of Rust's power with 20% of the complexity
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

// Real rendering with FFI to winit + wgpu
// This demonstrates Windjammer's Rust interop capability

// FFI declarations for window and rendering
extern fn wgpu_init() -> i32
extern fn wgpu_create_window(width: i32, height: i32, title: &str) -> i32
extern fn wgpu_should_close() -> bool
extern fn wgpu_poll_events()
extern fn wgpu_clear(r: f32, g: f32, b: f32)
extern fn wgpu_present()
extern fn wgpu_shutdown()

struct Color {
    r: f32,
    g: f32,
    b: f32,
}

impl Color {
    fn new(r: f32, g: f32, b: f32) -> Color {
        Color { r, g, b }
    }
    
    fn from_hue(hue: f32) -> Color {
        let h = hue % 360.0
        let s = 1.0
        let v = 1.0
        
        let c = v * s
        let x = c * (1.0 - ((h / 60.0) % 2.0 - 1.0))
        let m = v - c
        
        // Simplified HSV to RGB
        let r = if h < 60.0 { c } else if h < 120.0 { x } else if h < 180.0{ 0.0 } else if h < 240.0 { 0.0 } else if h < 300.0 { x } else { c }
        let g = if h < 60.0 { x } else if h < 120.0 { c } else if h < 180.0 { c } else if h < 240.0 { x } else { 0.0 }
        let b = if h < 60.0 { 0.0 } else if h < 120.0 { 0.0 } else if h < 180.0 { x } else if h < 240.0 { c } else if h < 300.0 { c } else { x }
        
        Color::new(r + m, g + m, b + m)
    }
}

pub fn main() {
    println("╔═══════════════════════════════════════════╗")
    println("║  WINDJAMMER REAL RENDERING TEST           ║")
    println("╚═══════════════════════════════════════════╝")
    println("")
    
    // Initialize graphics
    let result = wgpu_init()
    if result != 0 {
        println("❌ Failed to initialize wgpu: {}", result)
        return
    }
    
    let window = wgpu_create_window(800, 600, "Windjammer Rendering Test")
    if window != 0 {
        println("❌ Failed to create window: {}", window)
        return
    }
    
    println("✅ Window created successfully!")
    println("   - Size: 800x600")
    println("   - Backend: wgpu")
    println("")
    println("Rendering color cycle...")
    
    // Main render loop
    let mut frame = 0
    while !wgpu_should_close() {
        wgpu_poll_events()
        
        // Animate color through rainbow
        let hue = (frame % 360) as f32
        let color = Color::from_hue(hue)
        
        // Clear to animated color
        wgpu_clear(color.r, color.g, color.b)
        wgpu_present()
        
        frame += 1
        
        // Print status every 60 frames
        if frame % 60 == 0 {
            println("Frame {} - Hue: {}", frame, hue)
        }
    }
    
    println("")
    println("✅ Render loop complete!")
    println("   Frames rendered: {}", frame)
    
    wgpu_shutdown()
    
    println("")
    println("╔═══════════════════════════════════════════╗")
    println("║  WINDJAMMER RENDERING SUCCESS!            ║")
    println("╚═══════════════════════════════════════════╝")
}