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

// Simple Rendering with Window - FFI Approach
// This demonstrates how to create a window and render using external libraries

// FFI declarations for GLFW (or we'll use winit in Rust)
// For now, let's prove the concept with println-based "rendering"

struct Window {
    width: i32,
    height: i32,
    title: string,
    is_open: bool,
}

impl Window {
    fn new(width: i32, height: i32, title: string) -> Window {
        println("Creating window: {} ({}x{})", title, width, height)
        Window {
            width: width,
            height: height,
            title: title,
            is_open: true,
        }
    }
    
    fn update(&mut self) -> bool {
        // Simulate frame update
        self.is_open
    }
    
    fn clear(&self, r: f32, g: f32, b: f32) {
        println("Clear color: ({}, {}, {})", r, g, b)
    }
    
    fn draw_rect(&self, x: f32, y: f32, w: f32, h: f32) {
        println("Draw rect at ({}, {}) size {}x{}", x, y, w, h)
    }
    
    fn close(&mut self) {
        println("Closing window: {}", self.title)
        self.is_open = false
    }
}

pub fn main() {
    println("=== WINDJAMMER RENDERING DEMO ===")
    println("")
    
    let mut window = Window::new(800, 600, "Windjammer Game")
    
    println("Entering render loop...")
    let mut frame = 0
    
    // Simulate 10 frames
    while window.update() && frame < 10 {
        let time = (frame as f32) * 0.1
        // TODO: Fix compiler bug - f32 method calls generate wrong code
        let r = 0.5  // time.sin() * 0.5 + 0.5
        let g = 0.7  // (time + 2.0).sin() * 0.5 + 0.5
        let b = 0.9  // (time + 4.0).sin() * 0.5 + 0.5
        
        window.clear(r, g, b)
        
        // Draw a simple "paddle"
        let paddle_x = 350.0
        let paddle_y = 550.0
        window.draw_rect(paddle_x, paddle_y, 100.0, 20.0)
        
        // Draw a "ball"
        let ball_x = 400.0 + (frame as f32) * 10.0
        let ball_y = 300.0
        window.draw_rect(ball_x, ball_y, 10.0, 10.0)
        
        frame += 1
        
        if frame % 5 == 0 {
            println("--- Frame {} ---", frame)
        }
    }
    
    window.close()
    
    println("")
    println("✅ Rendering demo complete!")
    println("   - Window created")
    println("   - 10 frames rendered")
    println("   - Simulated paddle + ball")
    println("")
    println("Next: Add real FFI to winit/wgpu for actual rendering!")
}