Struct Color 

#[repr(C)]
pub struct Color {
    pub r: f32,
    pub g: f32,
    pub b: f32,
    pub a: f32,
}

Color represented as RGBA (0.0 - 1.0).

Fields

r: f32

g: f32

b: f32

a: f32

Implementations

impl Color

pub const WHITE: Color

pub const BLACK: Color

pub const RED: Color

pub const GREEN: Color

pub const BLUE: Color

pub const YELLOW: Color

pub const CYAN: Color

pub const MAGENTA: Color

pub const TRANSPARENT: Color

pub const fn rgb(r: f32, g: f32, b: f32) -> Self

Examples found in repository

examples/textured_window.rs (line 266)

    fn render(
        &mut self,
        _ctx: &mut astrelis_winit::app::AppCtx,
        window_id: WindowId,
        events: &mut astrelis_winit::event::EventBatch,
    ) {
        if window_id != self.window_id {
            return;
        }

        // Handle window resize events
        events.dispatch(|event| {
            if let astrelis_winit::event::Event::WindowResized(size) = event {
                self.window.resized(*size);
                astrelis_winit::event::HandleStatus::consumed()
            } else {
                astrelis_winit::event::HandleStatus::ignored()
            }
        });

        let mut frame = self.window.begin_drawing();

        // Render with automatic scoping (no manual {} block needed)
        frame.clear_and_render(
            RenderTarget::Surface,
            Color::rgb(0.1, 0.2, 0.3),
            |pass| {
                let pass = pass.descriptor();
                pass.set_pipeline(&self.pipeline);
                pass.set_bind_group(0, &self.bind_group, &[]);
                pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
                pass.draw(0..6, 0..1);
            },
        );

        frame.finish();
    }

examples/sprite_sheet.rs (line 411)

    fn render(
        &mut self,
        _ctx: &mut astrelis_winit::app::AppCtx,
        window_id: WindowId,
        events: &mut astrelis_winit::event::EventBatch,
    ) {
        let Some(window) = self.windows.get_mut(&window_id) else {
            return;
        };

        // Handle resize
        events.dispatch(|event| {
            if let astrelis_winit::event::Event::WindowResized(size) = event {
                window.resized(*size);
                astrelis_winit::event::HandleStatus::consumed()
            } else {
                astrelis_winit::event::HandleStatus::ignored()
            }
        });

        let mut frame = window.begin_drawing();

        // Render with automatic scoping (no manual {} block needed)
        frame.clear_and_render(
            RenderTarget::Surface,
            Color::rgb(0.1, 0.1, 0.15),
            |pass| {
                let pass = pass.descriptor();
                pass.set_pipeline(&self.pipeline);
                pass.set_bind_group(0, &self.bind_group, &[]);
                pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
                pass.draw(0..6, 0..1);
            },
        );

        frame.finish();
    }

examples/image_blitting.rs (line 469)

    fn render(
        &mut self,
        _ctx: &mut astrelis_winit::app::AppCtx,
        window_id: WindowId,
        events: &mut astrelis_winit::event::EventBatch,
    ) {
        let Some(window) = self.windows.get_mut(&window_id) else {
            return;
        };

        // Handle resize
        events.dispatch(|event| {
            if let astrelis_winit::event::Event::WindowResized(size) = event {
                window.resized(*size);
                astrelis_winit::event::HandleStatus::consumed()
            } else {
                astrelis_winit::event::HandleStatus::ignored()
            }
        });

        let mut frame = window.begin_drawing();

        // Render with automatic scoping (no manual {} block needed)
        frame.clear_and_render(
            RenderTarget::Surface,
            Color::rgb(0.05, 0.05, 0.08),
            |pass| {
                let pass = pass.descriptor();
                pass.set_pipeline(&self.pipeline);
                pass.set_bind_group(0, &self.bind_group, &[]);
                pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
                pass.draw(0..6, 0..1);
            },
        );

        frame.finish();
    }

examples/window_manager_demo.rs (line 43)

fn main() {
    logging::init();

    run_app(|ctx| {
        let graphics_ctx = GraphicsContext::new_owned_sync_or_panic();
        let mut window_manager = WindowManager::new(graphics_ctx);
        let mut window_colors = HashMap::new();

        // Create 3 windows with different colors
        let colors = [
            Color::rgb(0.8, 0.2, 0.2), // Red
            Color::rgb(0.2, 0.8, 0.2), // Green
            Color::rgb(0.2, 0.2, 0.8), // Blue
        ];

        for (i, color) in colors.iter().enumerate() {
            let window_id = window_manager.create_window_with_descriptor(
                ctx,
                WindowDescriptor {
                    title: format!("Window {} - WindowManager Demo", i + 1),
                    size: Some(WinitPhysicalSize::new(400.0, 300.0)),
                    ..Default::default()
                },
                WindowContextDescriptor {
                    format: Some(wgpu::TextureFormat::Bgra8UnormSrgb),
                    ..Default::default()
                },
            ).expect("Failed to create window");

            window_colors.insert(window_id, *color);
        }

        Box::new(WindowManagerApp {
            window_manager,
            window_colors,
        })
    });
}

examples/renderer_api.rs (line 297)

    fn render(&mut self, _ctx: &mut AppCtx, window_id: WindowId, events: &mut EventBatch) {
        if window_id != self.window_id {
            return;
        }

        // Handle window-specific resize events
        events.dispatch(|event| {
            if let astrelis_winit::event::Event::WindowResized(size) = event {
                self.window.resized(*size);
                astrelis_winit::event::HandleStatus::consumed()
            } else {
                astrelis_winit::event::HandleStatus::ignored()
            }
        });

        let mut frame = self.window.begin_drawing();

        // Pass 1: Render to offscreen framebuffer with automatic scoping
        frame.clear_and_render(
            RenderTarget::Framebuffer(&self.offscreen_fb),
            Color::rgb(0.2, 0.1, 0.3),
            |pass| {
                let pass = pass.descriptor();
                pass.set_pipeline(&self.pipeline);
                pass.set_bind_group(0, &self.bind_group, &[]);
                pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
                pass.draw(0..6, 0..1);
            },
        );

        // Pass 2: Blit framebuffer to surface with automatic scoping
        frame.clear_and_render(
            RenderTarget::Surface,
            Color::rgb(0.1, 0.2, 0.3),
            |pass| {
                let pass = pass.descriptor();
                pass.set_pipeline(&self.blit_pipeline);
                pass.set_bind_group(0, &self.blit_bind_group, &[]);
                // Draw fullscreen triangle
                pass.draw(0..3, 0..1);
            },
        );

        frame.finish();
    }

pub const fn rgba(r: f32, g: f32, b: f32, a: f32) -> Self

Examples found in repository

examples/multi_window.rs (line 120)

    fn render(
        &mut self,
        _ctx: &mut astrelis_winit::app::AppCtx,
        window_id: WindowId,
        events: &mut astrelis_winit::event::EventBatch,
    ) {
        // Get the window and color for this specific window
        let Some((window, color)) = self.windows.get_mut(&window_id) else {
            return;
        };

        // Handle window-specific resize events
        events.dispatch(|event| {
            if let astrelis_winit::event::Event::WindowResized(size) = event {
                window.resized(*size);
                astrelis_winit::event::HandleStatus::consumed()
            } else {
                astrelis_winit::event::HandleStatus::ignored()
            }
        });

        // Render this specific window
        let mut frame = window.begin_drawing();

        // Render with automatic scoping (no manual {} block needed)
        frame.clear_and_render(
            RenderTarget::Surface,
            astrelis_render::Color::rgba(color.r as f32, color.g as f32, color.b as f32, color.a as f32),
            |_pass| {
                // Just clearing - no rendering commands needed
            },
        );

        frame.finish();
    }

pub fn from_rgba_u8(r: u8, g: u8, b: u8, a: u8) -> Self

pub fn from_rgb_u8(r: u8, g: u8, b: u8) -> Self

Examples found in repository

examples/camera_demo.rs (line 107)

    fn render(&mut self, _ctx: &mut AppCtx, window_id: WindowId, events: &mut EventBatch) {
        if window_id != self.window_id {
            return;
        }

        events.dispatch(|event| {
            if let astrelis_winit::event::Event::WindowResized(size) = event {
                self.window.resized(*size);
                astrelis_winit::event::HandleStatus::consumed()
            } else {
                astrelis_winit::event::HandleStatus::ignored()
            }
        });

        let mut frame = self.window.begin_drawing();
        frame.clear_and_render(
            RenderTarget::Surface,
            Color::from_rgb_u8(20, 30, 40),
            |_pass| {},
        );
        frame.finish();
    }

examples/mesh_primitives.rs (line 110)

    fn render(&mut self, _ctx: &mut AppCtx, window_id: WindowId, events: &mut EventBatch) {
        if window_id != self.window_id {
            return;
        }

        events.dispatch(|event| {
            if let astrelis_winit::event::Event::WindowResized(size) = event {
                self.window.resized(*size);
                astrelis_winit::event::HandleStatus::consumed()
            } else {
                astrelis_winit::event::HandleStatus::ignored()
            }
        });

        let mut frame = self.window.begin_drawing();
        frame.clear_and_render(
            RenderTarget::Surface,
            Color::from_rgb_u8(20, 30, 40),
            |_pass| {},
        );
        frame.finish();
    }

examples/render_graph_demo.rs (line 107)

    fn render(&mut self, _ctx: &mut AppCtx, window_id: WindowId, events: &mut EventBatch) {
        if window_id != self.window_id {
            return;
        }

        events.dispatch(|event| {
            if let astrelis_winit::event::Event::WindowResized(size) = event {
                self.window.resized(*size);
                astrelis_winit::event::HandleStatus::consumed()
            } else {
                astrelis_winit::event::HandleStatus::ignored()
            }
        });

        let mut frame = self.window.begin_drawing();
        frame.clear_and_render(
            RenderTarget::Surface,
            Color::from_rgb_u8(20, 30, 40),
            |_pass| {},
        );
        frame.finish();
    }

examples/material_system.rs (line 131)

    fn render(&mut self, _ctx: &mut AppCtx, window_id: WindowId, events: &mut EventBatch) {
        if window_id != self.window_id {
            return;
        }

        // Handle resize
        events.dispatch(|event| {
            if let astrelis_winit::event::Event::WindowResized(size) = event {
                self.window.resized(*size);
                astrelis_winit::event::HandleStatus::consumed()
            } else {
                astrelis_winit::event::HandleStatus::ignored()
            }
        });

        // In a real application, materials would be bound during rendering:
        // material.bind(&mut render_pass);
        // draw_mesh(&mesh);

        // Begin frame
        let mut frame = self.window.begin_drawing();

        frame.clear_and_render(
            RenderTarget::Surface,
            Color::from_rgb_u8(20, 30, 40),
            |_pass| {
                // Materials would be applied here in actual rendering
                // This is a conceptual demonstration
            },
        );

        frame.finish();
    }

examples/performance_benchmark.rs (line 160)

    fn render(&mut self, _ctx: &mut AppCtx, window_id: WindowId, events: &mut EventBatch) {
        if window_id != self.window_id {
            return;
        }

        let frame_start = Instant::now();

        // Handle resize
        events.dispatch(|event| {
            if let Event::WindowResized(size) = event {
                self.window.resized(*size);
                HandleStatus::consumed()
            } else {
                HandleStatus::ignored()
            }
        });

        // Handle keyboard input
        events.dispatch(|event| {
            if let Event::KeyInput(key) = event {
                if key.state == astrelis_winit::event::ElementState::Pressed {
                    match &key.logical_key {
                        Key::Named(NamedKey::Space) => {
                            self.rendering = !self.rendering;
                            println!("Rendering: {}", self.rendering);
                            return HandleStatus::consumed();
                        }
                        Key::Character(c) if c == "+" || c == "=" => {
                            self.object_count = (self.object_count + 500).min(50000);
                            println!("Object count: {}", self.object_count);
                            return HandleStatus::consumed();
                        }
                        Key::Character(c) if c == "-" => {
                            self.object_count = self.object_count.saturating_sub(500).max(100);
                            println!("Object count: {}", self.object_count);
                            return HandleStatus::consumed();
                        }
                        _ => {}
                    }
                }
            }
            HandleStatus::ignored()
        });

        // Begin frame
        let mut frame = self.window.begin_drawing();

        if self.rendering {
            // Simulate rendering thousands of objects
            // In a real scenario, this would involve:
            // - Instanced draw calls
            // - Uniform buffer updates
            // - Texture binding
            // - Shader state changes

            frame.clear_and_render(
                RenderTarget::Surface,
                Color::from_rgb_u8(10, 10, 15),
                |_pass| {
                    // Actual rendering would happen here
                    // For benchmark purposes, we're measuring the overhead
                    // of the render pass itself with clear operations
                },
            );
        } else {
            frame.clear_and_render(
                RenderTarget::Surface,
                Color::from_rgb_u8(10, 10, 15),
                |_pass| {},
            );
        }

        frame.finish();

        let frame_end = Instant::now();
        self.last_frame_time = frame_end.duration_since(frame_start).as_secs_f32() * 1000.0;
    }

pub fn from_hex(hex: u32) -> Self

pub fn from_hex_alpha(hex: u32) -> Self

pub fn to_wgpu(self) -> Color

pub fn to_array(self) -> [f32; 4]

Trait Implementations

impl Clone for Color

fn clone(&self) -> Color

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Color

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Color

fn default() -> Self

Returns the “default value” for a type.

impl From<[f32; 3]> for Color

fn from(arr: [f32; 3]) -> Self

Converts to this type from the input type.

impl From<[f32; 4]> for Color

fn from(arr: [f32; 4]) -> Self

Converts to this type from the input type.

impl From<Color> for [f32; 4]

fn from(color: Color) -> Self

Converts to this type from the input type.

impl From<Color> for ClearOp

fn from(color: Color) -> Self

Converts to this type from the input type.

impl PartialEq for Color

fn eq(&self, other: &Color) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Zeroable for Color

fn zeroed() -> Self

Calls zeroed.

impl Copy for Color

impl Pod for Color

impl StructuralPartialEq for Color