Struct Color 

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

An RGBA color with f32 components in the 0.0..=1.0 range.

Colors are stored in linear RGBA order and can be constructed from floats, u8 values, or hex codes:

use astrelis_render::Color;

let red = Color::rgb(1.0, 0.0, 0.0);
let semi_transparent = Color::rgba(1.0, 1.0, 1.0, 0.5);
let from_hex = Color::from_hex(0xFF8800);
let from_bytes = Color::from_rgba_u8(128, 64, 32, 255);

The struct is #[repr(C)] and implements bytemuck::Pod, so it can be used directly in GPU uniform/vertex buffers.

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

Create a color from RGB components with full opacity (alpha = 1.0).

Examples found in repository

examples/sprite_sheet.rs (line 457)

    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 Some(frame) = window.begin_frame() else {
            return; // Surface not available
        };
        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.1, 0.1, 0.15))
                .label("sprite_sheet_pass")
                .build();
            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 auto-submits on drop
    }

examples/image_blitting.rs (line 513)

    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 Some(frame) = window.begin_frame() else {
            return; // Surface not available
        };

        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.05, 0.05, 0.08))
                .label("image_blitting_pass")
                .build();
            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 auto-submits on drop
    }

examples/textured_window.rs (line 288)

    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()
            }
        });

        // --- Render Loop ---
        let Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };

        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.1, 0.2, 0.3))
                .label("textured_window_pass")
                .build();
            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 auto-submits on drop
    }

examples/window_manager_demo.rs (line 49)

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

    run_app(|ctx| {
        let graphics_ctx =
            GraphicsContext::new_owned_sync().expect("Failed to create graphics context");
        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/profiling_demo.rs (line 162)

    fn render(&mut self, _ctx: &mut AppCtx, window_id: WindowId, events: &mut EventBatch) {
        new_frame();
        profile_function!();

        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()
            }
        });

        // Cycle the background color to visualize frames
        let t = (self.frame_count as f32 * 0.01).sin() * 0.5 + 0.5;
        let clear_color = Color::rgb(0.05 + t * 0.1, 0.05, 0.15 + (1.0 - t) * 0.1);

        // GPU profiling is now automatic — no special handling needed!
        // If a profiler is attached, render passes auto-create GPU scopes,
        // and Frame::Drop auto-resolves queries and ends the profiler frame.
        let Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };

        {
            profile_scope!("render_frame");
            let _pass = frame
                .render_pass()
                .clear_color(clear_color)
                .label("profiling_pass")
                .build();
            profile_scope!("draw_commands");
            // In a real app, you would issue draw calls here.
        }
        // Frame auto-submits on drop

        // Simulate some post-render work
        {
            profile_scope!("post_render");
            let _ = &self.context;
        }
    }

examples/renderer_api.rs (line 308)

    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 Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };

        // Pass 1: Render to offscreen framebuffer
        {
            let mut pass = frame
                .render_pass()
                .target(RenderTarget::Framebuffer(&self.offscreen_fb))
                .clear_color(Color::rgb(0.2, 0.1, 0.3))
                .label("offscreen_pass")
                .build();
            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
        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.1, 0.2, 0.3))
                .label("blit_pass")
                .build();
            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 auto-submits on drop
    }

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

Create a color from RGBA components.

Examples found in repository

examples/multi_window.rs (lines 118-123)

    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 resize: each window dispatches events independently.
        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 Some(frame) = window.begin_frame() else {
            return; // Surface not available
        };

        {
            let _pass = frame
                .render_pass()
                .clear_color(Color::rgba(
                    color.r as f32,
                    color.g as f32,
                    color.b as f32,
                    color.a as f32,
                ))
                .label("multi_window_pass")
                .build();
            // Just clearing - no rendering commands needed
        }
        // Frame auto-submits on drop
    }

examples/batched_renderer.rs (line 436)

    fn render(
        &mut self,
        _ctx: &mut astrelis_winit::app::AppCtx,
        window_id: WindowId,
        events: &mut astrelis_winit::event::EventBatch,
    ) {
        // Handle resize and get dimensions (scoped to release window borrow)
        let (phys_width, phys_height) = {
            let Some(window) = self.windows.get_mut(&window_id) else {
                return;
            };

            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 phys = window.physical_size();
            (phys.width, phys.height)
        };

        let width = phys_width as f32;
        let height = phys_height as f32;

        if width < 1.0 || height < 1.0 {
            return;
        }

        // Ensure depth buffer matches viewport
        self.ensure_depth_buffer(phys_width, phys_height);

        // Build instances and prepare GPU data
        let instances = self.build_instances(width, height);
        let batch = DrawBatch2D {
            instances,
            textures: vec![],
            projection: Self::ortho_projection(width, height),
        };
        self.renderer.prepare(&batch);

        let stats = self.renderer.stats();
        if self.frame_count.is_multiple_of(120) {
            tracing::info!(
                "Frame {}: {} instances ({} opaque, {} transparent), {} draw calls",
                self.frame_count,
                stats.instance_count,
                stats.opaque_count,
                stats.transparent_count,
                stats.draw_calls,
            );
        }

        // Re-borrow window for rendering
        let window = self.windows.get_mut(&window_id).unwrap();
        let Some(frame) = window.begin_frame() else {
            return; // Surface not available
        };

        // Create render pass with depth stencil attachment
        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgba(0.08, 0.08, 0.1, 1.0))
                .depth_attachment(&self.depth_view)
                .clear_depth(0.0) // 0.0 = far with GreaterEqual
                .label("batched_example_pass")
                .build();
            self.renderer.render(pass.wgpu_pass());
        }
        // Frame auto-submits on drop
    }

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

Create a color from 8-bit RGBA values (0–255 mapped to 0.0–1.0).

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

Create a color from 8-bit RGB values with full opacity.

Examples found in repository

examples/camera_demo.rs (line 109)

    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 Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };
        {
            let _pass = frame
                .render_pass()
                .clear_color(Color::from_rgb_u8(20, 30, 40))
                .label("camera_demo_pass")
                .build();
        }
        // Frame auto-submits on drop
    }

examples/mesh_primitives.rs (line 111)

    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 Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };
        {
            let _pass = frame
                .render_pass()
                .clear_color(Color::from_rgb_u8(20, 30, 40))
                .label("mesh_primitives_pass")
                .build();
        }
        // Frame auto-submits on drop
    }

examples/render_graph_demo.rs (line 109)

    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 Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };
        {
            let _pass = frame
                .render_pass()
                .clear_color(Color::from_rgb_u8(20, 30, 40))
                .label("render_graph_demo_pass")
                .build();
        }
        // Frame auto-submits on drop
    }

examples/material_system.rs (line 132)

    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 Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };

        {
            let _pass = frame
                .render_pass()
                .clear_color(Color::from_rgb_u8(20, 30, 40))
                .label("material_system_pass")
                .build();
            // Materials would be applied here in actual rendering
            // This is a conceptual demonstration
        }
        // Frame auto-submits on drop
    }

examples/performance_benchmark.rs (line 157)

    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
                && 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 Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };

        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

            let _pass = frame
                .render_pass()
                .clear_color(Color::from_rgb_u8(10, 10, 15))
                .label("benchmark_pass")
                .build();
            // Actual rendering would happen here
            // For benchmark purposes, we're measuring the overhead
            // of the render pass itself with clear operations
        } else {
            let _pass = frame
                .render_pass()
                .clear_color(Color::from_rgb_u8(10, 10, 15))
                .label("benchmark_pass")
                .build();
        }
        // Frame auto-submits on drop

        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

Create a color from a 24-bit RGB hex value (e.g. 0xFF8800).

pub fn from_hex_alpha(hex: u32) -> Self

Create a color from a 32-bit RGBA hex value (e.g. 0xFF880080).

pub fn to_wgpu(self) -> Color

Convert to the equivalent wgpu::Color (f64 components).

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

Convert to an [r, g, b, a] array.

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 From<Color> for ColorOp

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