astrelis 0.2.2

A modular 2D/3D game engine framework
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
99
100
101

//! Example demonstrating the Astrelis engine integrated with the windowing system.
//!
//! This example shows how to:
//! - Create an Engine with RenderPlugin
//! - Use the engine within an App
//! - Render to a window using the plugin-provided resources
//!
//! Run with: cargo run -p astrelis --example window_app

use astrelis::prelude::*;
use astrelis::render::{RenderTarget, RenderableWindow, WindowContextDescriptor};
use astrelis::winit::window::WindowBackend;
use std::sync::Arc;

struct WindowApp {
    #[allow(dead_code)]
    engine: Engine,
    renderable: Option<RenderableWindow>,
}

impl App for WindowApp {
    fn render(&mut self, _ctx: &mut AppCtx, window_id: WindowId, events: &mut EventBatch) {
        // Get the renderable window
        let renderable = match &mut self.renderable {
            Some(r) if r.id() == window_id => r,
            _ => return,
        };

        // Handle events
        events.dispatch(|event| {
            match event {
                Event::WindowResized(new_size) => {
                    renderable.resized(*new_size);
                    HandleStatus::consumed()
                }
                Event::CloseRequested => {
                    HandleStatus::ignored() // Let default handling close the window
                }
                _ => HandleStatus::ignored(),
            }
        });

        // Begin drawing
        let mut frame = renderable.begin_drawing();

        // Clear with automatic scoping (no manual {} block needed)
        frame.clear_and_render(
            RenderTarget::Surface,
            Color::rgb(0.1, 0.1, 0.15), // Dark blue-gray
            |_pass| {
                // In a real app, you would draw here
            },
        );

        // Frame is automatically submitted when dropped
    }
}

fn main() {
    println!("Window App Example");
    println!("==================");
    println!();
    println!("This example demonstrates:");
    println!("  - Creating an Engine with RenderPlugin");
    println!("  - Using RenderableWindow for window rendering");
    println!("  - Handling window events (resize, close)");
    println!("  - Rendering a simple clear pass");
    println!();
    println!("Press Ctrl+C or close the window to exit.");
    println!();

    // Run the app
    run_app(|ctx| {
        // Create a window
        let window = ctx
            .create_window(WindowDescriptor {
                title: "Astrelis Window App".to_string(),
                ..Default::default()
            })
            .expect("Failed to create window");

        // Create the engine with render plugin
        let engine = Engine::builder().add_plugin(RenderPlugin).build();

        // Get the graphics context from the engine
        let graphics = engine.get::<Arc<GraphicsContext>>().unwrap();

        // Create a renderable window
        let renderable = RenderableWindow::new_with_descriptor(
            window,
            graphics.clone(),
            WindowContextDescriptor::default(),
        )
        .expect("Failed to create renderable window");

        Box::new(WindowApp {
            engine,
            renderable: Some(renderable),
        })
    });
}