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 415)

    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.wgpu_pass();
                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.wgpu_pass();
                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 51)

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/textured_window.rs (line 289)

    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 mut frame = self.window.begin_drawing();

        // clear_and_render handles render pass scoping automatically:
        // the pass is created, the closure runs, then the pass drops.
        frame.clear_and_render(
            RenderTarget::Surface,
            Color::rgb(0.1, 0.2, 0.3),
            |pass| {
                let pass = pass.wgpu_pass();
                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/profiling_demo.rs (line 165)

    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, with_pass/clear_and_render auto-create GPU scopes,
        // and FrameContext::Drop auto-resolves queries and ends the profiler frame.
        let mut frame = self.window.begin_drawing();

        {
            profile_scope!("render_frame");
            frame.clear_and_render(RenderTarget::Surface, clear_color, |_pass| {
                profile_scope!("draw_commands");
                // In a real app, you would issue draw calls here.
            });
        }

        frame.finish();

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

examples/renderer_api.rs (line 306)

    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.wgpu_pass();
                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.wgpu_pass();
                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

Create a color from RGBA components.

Examples found in repository

examples/multi_window.rs (line 118)

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

examples/batched_renderer.rs (line 437)

    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 % 120 == 0 {
            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 mut frame = window.begin_drawing();

        // Use RenderPassBuilder with depth stencil attachment
        frame.with_pass(
            astrelis_render::RenderPassBuilder::new()
                .label("batched_example_pass")
                .target(astrelis_render::RenderTarget::Surface)
                .clear_color(astrelis_render::Color::rgba(0.08, 0.08, 0.1, 1.0))
                .clear_depth(0.0) // 0.0 = far with GreaterEqual
                .depth_stencil_attachment(
                    &self.depth_view,
                    Some(wgpu::Operations {
                        load: wgpu::LoadOp::Clear(0.0),
                        store: wgpu::StoreOp::Store,
                    }),
                    None,
                ),
            |pass| {
                self.renderer.render(pass.wgpu_pass());
            },
        );

        frame.finish();
    }

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 108)

    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 108)

    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

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 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