Struct GraphicsContext 

pub struct GraphicsContext { /* private fields */ }

A globally shared graphics context.

Ownership Pattern

This type uses Arc for shared ownership:

use astrelis_render::GraphicsContext;
use std::sync::Arc;

// Synchronous creation (blocks on async internally)
let ctx = GraphicsContext::new_owned_sync()
    .expect("Failed to create graphics context"); // Returns Arc<Self>
let ctx2 = ctx.clone(); // Cheap clone (Arc)

// Asynchronous creation (for async contexts)
let ctx = GraphicsContext::new_owned().await; // Returns Arc<Self>

Benefits of the Arc pattern:

• No memory leak
• Proper cleanup on drop
• Better for testing (can create/destroy contexts)
• Arc internally makes cloning cheap

Implementations

impl GraphicsContext

pub async fn new_owned() -> Result<Arc<Self>, GraphicsError>

Creates a new graphics context with owned ownership (recommended).

Returns Arc<Self> which can be cheaply cloned and shared. This is the preferred method for new code as it doesn’t leak memory.

Example

use astrelis_render::GraphicsContext;

let ctx = GraphicsContext::new_owned().await;
let ctx2 = ctx.clone(); // Cheap clone

pub fn new_owned_sync() -> Result<Arc<Self>, GraphicsError>

Creates a new graphics context synchronously with owned ownership (recommended).

Warning: This blocks the current thread until the context is created. For async contexts, use new_owned() instead.

Errors

Returns GraphicsError if:

• No suitable GPU adapter is found
• Required GPU features are not supported
• Device creation fails

Example

use astrelis_render::GraphicsContext;

// For examples/tests: use .expect() for simplicity
let ctx = GraphicsContext::new_owned_sync()
    .expect("Failed to create graphics context");

// For production: handle the error properly
let ctx = match GraphicsContext::new_owned_sync() {
    Ok(ctx) => ctx,
    Err(e) => {
        eprintln!("GPU initialization failed: {:?}", e);
        return;
    }
};

Examples found in repository

examples/window_manager_demo.rs (line 45)

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/multi_window.rs (line 31)

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

    run_app(|ctx| {
        let graphics_ctx = GraphicsContext::new_owned_sync().expect("Failed to create graphics context");

        let mut windows = HashMap::new();

        // Create 3 windows with different colors
        let colors = [
            wgpu::Color {
                r: 0.8,
                g: 0.2,
                b: 0.2,
                a: 1.0,
            },
            wgpu::Color {
                r: 0.2,
                g: 0.8,
                b: 0.2,
                a: 1.0,
            },
            wgpu::Color {
                r: 0.2,
                g: 0.2,
                b: 0.8,
                a: 1.0,
            },
        ];

        for (i, color) in colors.iter().enumerate() {
            let window = ctx
                .create_window(WindowDescriptor {
                    title: format!("Window {} - Multi-Window Example", i + 1),
                    size: Some(WinitPhysicalSize::new(400.0, 300.0)),
                    ..Default::default()
                })
                .expect("Failed to create window");

            let renderable_window = RenderableWindow::new_with_descriptor(
                window,
                graphics_ctx.clone(),
                WindowContextDescriptor {
                    format: Some(wgpu::TextureFormat::Bgra8UnormSrgb),
                    ..Default::default()
                },
            ).expect("Failed to create renderable window");

            let window_id = renderable_window.id();
            windows.insert(window_id, (renderable_window, *color));
        }

        Box::new(App {
            windows,
        })
    });
}

examples/performance_benchmark.rs (line 40)

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

    run_app(|ctx| {
        let graphics_ctx = GraphicsContext::new_owned_sync().expect("Failed to create graphics context");

        let window = ctx
            .create_window(WindowDescriptor {
                title: "Performance Benchmark - Render Stress Test".to_string(),
                size: Some(WinitPhysicalSize::new(1280.0, 720.0)),
                ..Default::default()
            })
            .expect("Failed to create window");

        let window = RenderableWindow::new_with_descriptor(
            window,
            graphics_ctx.clone(),
            WindowContextDescriptor {
                format: Some(wgpu::TextureFormat::Bgra8UnormSrgb),
                ..Default::default()
            },
        ).expect("Failed to create renderable window");

        let window_id = window.id();

        println!("\n═══════════════════════════════════════════════════════");
        println!("  ⚡ PERFORMANCE BENCHMARK - Render Stress Test");
        println!("═══════════════════════════════════════════════════════");
        println!("  CONTROLS:");
        println!("    [Space]  Toggle rendering on/off");
        println!("    [+/-]    Increase/decrease object count");
        println!("  Starting with 1000 objects");
        println!("═══════════════════════════════════════════════════════\n");

        Box::new(PerformanceBenchmark {
            _context: graphics_ctx,
            window,
            window_id,
            object_count: 1000,
            rendering: true,
            frame_count: 0,
            last_fps_time: Instant::now(),
            fps: 0.0,
            last_frame_time: 0.0,
        })
    });
}

examples/camera_demo.rs (line 34)

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

    run_app(|ctx| {
        let graphics_ctx = GraphicsContext::new_owned_sync().expect("Failed to create graphics context");

        let window = ctx
            .create_window(WindowDescriptor {
                title: "Camera Demo - View & Projection".to_string(),
                size: Some(WinitPhysicalSize::new(1024.0, 768.0)),
                ..Default::default()
            })
            .expect("Failed to create window");

        let window = RenderableWindow::new_with_descriptor(
            window,
            graphics_ctx.clone(),
            WindowContextDescriptor {
                format: Some(wgpu::TextureFormat::Bgra8UnormSrgb),
                ..Default::default()
            },
        ).expect("Failed to create renderable window");

        let window_id = window.id();

        println!("\n═══════════════════════════════════════════════════════");
        println!("  📹 CAMERA DEMO - View & Projection");
        println!("═══════════════════════════════════════════════════════");
        println!("\n  CAMERA API FEATURES:");
        println!("    • Orthographic cameras (2D, UI, isometric)");
        println!("    • Perspective cameras (3D scenes)");
        println!("    • View matrix (position, rotation, look-at)");
        println!("    • Projection matrix (FOV, aspect, near/far planes)");
        println!("    • Screen-to-world coordinate conversion");
        println!("    • Camera movement helpers");
        println!("\n  CAMERA TYPES:");
        println!("    • OrthographicCamera - 2D games, UI overlays");
        println!("      camera.orthographic(left, right, bottom, top, near, far)");
        println!("    • PerspectiveCamera - 3D scenes");
        println!("      camera.perspective(fov, aspect, near, far)");
        println!("\n  Camera API Usage:");
        println!("    let camera = Camera::new()");
        println!("        .position(Vec3::new(0.0, 5.0, 10.0))");
        println!("        .look_at(Vec3::ZERO)");
        println!("        .perspective(60.0, aspect, 0.1, 100.0);");
        println!("    let view_proj = camera.view_projection_matrix();");
        println!("═══════════════════════════════════════════════════════\n");

        tracing::info!("Camera demo initialized");

        Box::new(CameraDemo {
            _context: graphics_ctx,
            window,
            window_id,
        })
    });
}

examples/render_graph_demo.rs (line 33)

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

    run_app(|ctx| {
        let graphics_ctx = GraphicsContext::new_owned_sync().expect("Failed to create graphics context");

        let window = ctx
            .create_window(WindowDescriptor {
                title: "Render Graph Demo - Multi-Pass Rendering".to_string(),
                size: Some(WinitPhysicalSize::new(1024.0, 768.0)),
                ..Default::default()
            })
            .expect("Failed to create window");

        let window = RenderableWindow::new_with_descriptor(
            window,
            graphics_ctx.clone(),
            WindowContextDescriptor {
                format: Some(wgpu::TextureFormat::Bgra8UnormSrgb),
                ..Default::default()
            },
        ).expect("Failed to create renderable window");

        let window_id = window.id();

        println!("\n═══════════════════════════════════════════════════════");
        println!("  🔀 RENDER GRAPH DEMO - Multi-Pass Rendering");
        println!("═══════════════════════════════════════════════════════");
        println!("\n  RENDER GRAPH FEATURES:");
        println!("    • Declarative pass definition");
        println!("    • Automatic dependency resolution");
        println!("    • Resource lifetime management");
        println!("    • Parallel pass execution");
        println!("    • Automatic optimization");
        println!("\n  EXAMPLE PIPELINE:");
        println!("    1. Shadow Pass → depth texture");
        println!("    2. Geometry Pass → color + normal + depth");
        println!("    3. Lighting Pass → lit scene");
        println!("    4. Post-Processing → bloom, tone mapping");
        println!("    5. UI Pass → final composite");
        println!("\n  Render Graph API Usage:");
        println!("    let mut graph = RenderGraph::new();");
        println!("    graph.add_pass(\"shadow\", shadow_pass_descriptor);");
        println!("    graph.add_pass(\"geometry\", geometry_pass_descriptor);");
        println!("    graph.add_dependency(\"lighting\", \"geometry\");");
        println!("    graph.compile();");
        println!("    graph.execute(&mut encoder);");
        println!("═══════════════════════════════════════════════════════\n");

        tracing::info!("Render graph demo initialized");

        Box::new(RenderGraphDemo {
            _context: graphics_ctx,
            window,
            window_id,
        })
    });
}

examples/mesh_primitives.rs (line 33)

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

    run_app(|ctx| {
        let graphics_ctx = GraphicsContext::new_owned_sync().expect("Failed to create graphics context");

        let window = ctx
            .create_window(WindowDescriptor {
                title: "Mesh Primitives Demo - Geometry API".to_string(),
                size: Some(WinitPhysicalSize::new(1024.0, 768.0)),
                ..Default::default()
            })
            .expect("Failed to create window");

        let window = RenderableWindow::new_with_descriptor(
            window,
            graphics_ctx.clone(),
            WindowContextDescriptor {
                format: Some(wgpu::TextureFormat::Bgra8UnormSrgb),
                ..Default::default()
            },
        ).expect("Failed to create renderable window");

        let window_id = window.id();

        println!("\n═══════════════════════════════════════════════════════");
        println!("  📐 MESH PRIMITIVES DEMO - Geometry API");
        println!("═══════════════════════════════════════════════════════");
        println!("\n  MESH API FEATURES:");
        println!("    • MeshBuilder for custom geometry");
        println!("    • Primitive generation (cube, sphere, plane, etc.)");
        println!("    • Flexible vertex formats (Position, Normal, UV, Color)");
        println!("    • Index buffer optimization");
        println!("    • Instanced rendering support");
        println!("\n  EXAMPLE PRIMITIVES:");
        println!("    • Cube - box with 24 vertices (6 faces × 4 vertices)");
        println!("    • Sphere - tessellated sphere with UV mapping");
        println!("    • Plane - quad with optional subdivisions");
        println!("    • Cylinder - sides + caps");
        println!("    • Custom - arbitrary vertex/index data");
        println!("\n  Mesh API Usage:");
        println!("    let mesh = MeshBuilder::new()");
        println!("        .with_positions(vertices)");
        println!("        .with_normals(normals)");
        println!("        .with_uvs(uvs)");
        println!("        .with_indices(indices)");
        println!("        .build(&ctx);");
        println!("    mesh.draw(&mut pass);");
        println!("    mesh.draw_instanced(&mut pass, instance_count);");
        println!("═══════════════════════════════════════════════════════\n");

        tracing::info!("Mesh primitives demo initialized");

        Box::new(MeshPrimitivesDemo {
            _context: graphics_ctx,
            window,
            window_id,
        })
    });
}

Additional examples can be found in:

• examples/material_system.rs
• examples/sprite_sheet.rs
• examples/image_blitting.rs
• examples/textured_window.rs
• examples/renderer_api.rs

pub async fn new_owned_with_descriptor( descriptor: GraphicsContextDescriptor, ) -> Result<Arc<Self>, GraphicsError>

Creates a new graphics context with custom descriptor (owned).

Examples found in repository

examples/batched_renderer.rs (line 295)

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

    run_app(|ctx| {
        let tier_override = parse_tier();

        // Use the capability API to configure GPU requirements.
        // For auto-detect, request the best capability (graceful degradation).
        // For a specific tier, require that tier's capability.
        let descriptor = match tier_override {
            None => GraphicsContextDescriptor::new()
                .request_capability::<BestBatchCapability2D>(),
            Some(RenderTier::Direct) => GraphicsContextDescriptor::new()
                .require_capability::<DirectBatchCapability2D>(),
            Some(RenderTier::Indirect) => GraphicsContextDescriptor::new()
                .require_capability::<IndirectBatchCapability2D>(),
            Some(RenderTier::Bindless) => GraphicsContextDescriptor::new()
                .require_capability::<BindlessBatchCapability2D>(),
        };
        let graphics_ctx =
            pollster::block_on(GraphicsContext::new_owned_with_descriptor(descriptor))
                .expect("Failed to create graphics context");

        let window = ctx
            .create_window(WindowDescriptor {
                title: "Batched Renderer Example".to_string(),
                size: Some(WinitPhysicalSize::new(800.0, 600.0)),
                ..Default::default()
            })
            .expect("Failed to create window");

        let surface_format = wgpu::TextureFormat::Bgra8UnormSrgb;

        let renderable_window = RenderableWindow::new_with_descriptor(
            window,
            graphics_ctx.clone(),
            WindowContextDescriptor {
                format: Some(surface_format),
                ..Default::default()
            },
        )
        .expect("Failed to create renderable window");

        let window_id = renderable_window.id();

        let renderer = create_batch_renderer_2d(
            graphics_ctx.clone(),
            surface_format,
            tier_override,
        );

        tracing::info!("Using render tier: {}", renderer.tier());

        // Create initial depth buffer
        let depth_texture = graphics_ctx
            .device()
            .create_texture(&wgpu::TextureDescriptor {
                label: Some("example_depth"),
                size: wgpu::Extent3d {
                    width: 1,
                    height: 1,
                    depth_or_array_layers: 1,
                },
                mip_level_count: 1,
                sample_count: 1,
                dimension: wgpu::TextureDimension::D2,
                format: DEPTH_FORMAT,
                usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
                view_formats: &[],
            });
        let depth_view = depth_texture.create_view(&wgpu::TextureViewDescriptor::default());

        let mut windows = HashMap::new();
        windows.insert(window_id, renderable_window);

        Box::new(App {
            context: graphics_ctx,
            windows,
            renderer,
            depth_texture,
            depth_view,
            depth_width: 1,
            depth_height: 1,
            frame_count: 0,
        })
    });
}

examples/profiling_demo.rs (lines 47-50)

fn main() {
    logging::init();
    init_profiling(ProfilingBackend::PuffinHttp);

    run_app(|ctx| {
        profile_function!();

        // Request TIMESTAMP_QUERY for GPU profiling (best-effort, won't fail if unavailable)
        let graphics_ctx = pollster::block_on(GraphicsContext::new_owned_with_descriptor(
            GraphicsContextDescriptor::new()
                .request_capability::<astrelis_render::gpu_profiling::GpuFrameProfiler>(),
        ))
        .expect("Failed to create graphics context");

        let window = ctx
            .create_window(WindowDescriptor {
                title: "Profiling Demo — CPU + GPU".to_string(),
                size: Some(WinitPhysicalSize::new(800.0, 600.0)),
                ..Default::default()
            })
            .expect("Failed to create window");

        #[allow(unused_mut)]
        let mut window = RenderableWindow::new_with_descriptor(
            window,
            graphics_ctx.clone(),
            WindowContextDescriptor {
                format: Some(wgpu::TextureFormat::Bgra8UnormSrgb),
                ..Default::default()
            },
        )
        .expect("Failed to create renderable window");

        let window_id = window.id();

        // Attach GPU profiler to the window — all frames will be automatically profiled
        let has_gpu_profiling;
        #[cfg(feature = "gpu-profiling")]
        {
            match astrelis_render::gpu_profiling::GpuFrameProfiler::new(&graphics_ctx) {
                Ok(profiler) => {
                    let has_timestamps = profiler.has_timestamp_queries();
                    window.set_gpu_profiler(Arc::new(profiler));
                    has_gpu_profiling = true;
                    if has_timestamps {
                        println!("  GPU profiling: enabled with TIMESTAMP_QUERY (full timing)");
                    } else {
                        println!("  GPU profiling: enabled (debug groups only, no timing data)");
                        println!("                 TIMESTAMP_QUERY not supported by this GPU");
                    }
                }
                Err(e) => {
                    has_gpu_profiling = false;
                    tracing::warn!("Failed to create GPU profiler: {e}. GPU profiling disabled.");
                    println!("  GPU profiling: failed to create profiler");
                }
            }
        }
        #[cfg(not(feature = "gpu-profiling"))]
        {
            has_gpu_profiling = false;
        }

        println!();
        println!("═══════════════════════════════════════════════════");
        println!("  PROFILING DEMO — CPU + GPU");
        println!("═══════════════════════════════════════════════════");
        println!();
        println!("  CPU profiling: enabled (puffin)");
        if !has_gpu_profiling {
            #[cfg(not(feature = "gpu-profiling"))]
            println!("  GPU profiling: disabled (compile with --features gpu-profiling)");
        }
        println!();
        println!("  Open puffin_viewer at 127.0.0.1:8585 to see the flame graph.");
        println!("  Install with: cargo install puffin_viewer");
        println!("═══════════════════════════════════════════════════");
        println!();

        Box::new(ProfilingDemo {
            context: graphics_ctx,
            window,
            window_id,
            frame_count: 0,
        })
    });
}

pub fn device(&self) -> &Device

Get a reference to the wgpu device.

Examples found in repository

examples/batched_renderer.rs (line 54)

    fn ensure_depth_buffer(&mut self, width: u32, height: u32) {
        if self.depth_width == width && self.depth_height == height {
            return;
        }
        let w = width.max(1);
        let h = height.max(1);
        let texture = self.context.device().create_texture(&wgpu::TextureDescriptor {
            label: Some("example_depth"),
            size: wgpu::Extent3d {
                width: w,
                height: h,
                depth_or_array_layers: 1,
            },
            mip_level_count: 1,
            sample_count: 1,
            dimension: wgpu::TextureDimension::D2,
            format: DEPTH_FORMAT,
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
            view_formats: &[],
        });
        let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
        self.depth_texture = texture;
        self.depth_view = view;
        self.depth_width = w;
        self.depth_height = h;
    }

    /// Build an orthographic projection matrix for the given viewport size.
    /// Maps (0,0) at top-left to (width, height) at bottom-right.
    /// Z range: 0.0 (far) to 1.0 (near), matching GreaterEqual depth compare.
    fn ortho_projection(width: f32, height: f32) -> [[f32; 4]; 4] {
        [
            [2.0 / width, 0.0, 0.0, 0.0],
            [0.0, -2.0 / height, 0.0, 0.0],
            [0.0, 0.0, 1.0, 0.0],
            [-1.0, 1.0, 0.0, 1.0],
        ]
    }

    /// Generate the demo instances for the current frame.
    fn build_instances(&self, width: f32, height: f32) -> Vec<UnifiedInstance2D> {
        let t = self.frame_count as f32 / 60.0;
        let mut instances = Vec::new();

        // --- Background panel (gray, full viewport, furthest back) ---
        instances.push(UnifiedInstance2D {
            position: [10.0, 10.0],
            size: [width - 20.0, height - 20.0],
            color: [0.15, 0.15, 0.18, 1.0],
            border_radius: 12.0,
            z_depth: 0.01,
            draw_type: DrawType2D::Quad as u32,
            ..Default::default()
        });

        // --- Grid of colored quads ---
        let cols = 5;
        let rows = 3;
        let margin = 30.0;
        let gap = 10.0;
        let cell_w = (width - 2.0 * margin - (cols as f32 - 1.0) * gap) / cols as f32;
        let cell_h = (height * 0.5 - margin - (rows as f32 - 1.0) * gap) / rows as f32;

        for row in 0..rows {
            for col in 0..cols {
                let x = margin + col as f32 * (cell_w + gap);
                let y = margin + row as f32 * (cell_h + gap);
                let idx = row * cols + col;

                // Hue-shift color based on grid position
                let hue = (idx as f32 / (rows * cols) as f32) * 360.0;
                let (r, g, b) = hsl_to_rgb(hue, 0.7, 0.55);

                instances.push(UnifiedInstance2D {
                    position: [x, y],
                    size: [cell_w, cell_h],
                    color: [r, g, b, 1.0],
                    border_radius: 6.0,
                    z_depth: 0.1 + idx as f32 * 0.001,
                    draw_type: DrawType2D::Quad as u32,
                    ..Default::default()
                });
            }
        }

        // --- Animated floating rounded rect ---
        let float_x = width * 0.5 + (t * 0.8).sin() * width * 0.25 - 60.0;
        let float_y = height * 0.35 + (t * 1.2).cos() * 30.0;
        instances.push(UnifiedInstance2D {
            position: [float_x, float_y],
            size: [120.0, 50.0],
            color: [1.0, 0.85, 0.2, 0.9],
            border_radius: 25.0,
            z_depth: 0.8,
            draw_type: DrawType2D::Quad as u32,
            ..Default::default()
        });

        // --- Border-only outlines (bottom area) ---
        let outline_y = height * 0.6;
        for i in 0..4 {
            let x = margin + i as f32 * 140.0;
            let thickness = 1.0 + i as f32;
            let radius = 4.0 + i as f32 * 8.0;
            instances.push(UnifiedInstance2D {
                position: [x, outline_y],
                size: [120.0, 80.0],
                color: [0.4, 0.8, 1.0, 1.0],
                border_radius: radius,
                border_thickness: thickness,
                z_depth: 0.5,
                draw_type: DrawType2D::Quad as u32,
                ..Default::default()
            });
        }

        // --- Overlapping transparent quads (demonstrating depth + alpha) ---
        let overlap_x = width * 0.5 - 100.0;
        let overlap_y = height * 0.75;
        let colors = [
            [1.0, 0.3, 0.3, 0.6],
            [0.3, 1.0, 0.3, 0.6],
            [0.3, 0.3, 1.0, 0.6],
        ];
        for (i, color) in colors.iter().enumerate() {
            let offset = i as f32 * 40.0;
            instances.push(UnifiedInstance2D {
                position: [overlap_x + offset, overlap_y + offset * 0.5],
                size: [120.0, 80.0],
                color: *color,
                border_radius: 8.0,
                z_depth: 0.6 + i as f32 * 0.05,
                draw_type: DrawType2D::Quad as u32,
                ..Default::default()
            });
        }

        // --- Pulsing circle (via large border_radius) ---
        let pulse = ((t * 2.0).sin() * 0.5 + 0.5) * 0.4 + 0.6;
        let circle_size = 60.0 * pulse;
        instances.push(UnifiedInstance2D {
            position: [width - margin - circle_size, outline_y + 10.0],
            size: [circle_size, circle_size],
            color: [1.0, 0.5, 0.0, 0.95],
            border_radius: circle_size * 0.5,
            z_depth: 0.7,
            draw_type: DrawType2D::Quad as u32,
            ..Default::default()
        });

        // --- Small shader-clipped quad (demonstrating clip rect) ---
        let clip_x = margin;
        let clip_y = height * 0.75;
        instances.push(UnifiedInstance2D {
            position: [clip_x, clip_y],
            size: [200.0, 60.0],
            color: [0.9, 0.2, 0.7, 1.0],
            border_radius: 4.0,
            z_depth: 0.55,
            draw_type: DrawType2D::Quad as u32,
            // Clip to a smaller region to demonstrate shader clipping
            clip_min: [clip_x + 20.0, clip_y + 10.0],
            clip_max: [clip_x + 160.0, clip_y + 50.0],
            ..Default::default()
        });

        instances
    }
}

/// Simple HSL to RGB conversion.
fn hsl_to_rgb(h: f32, s: f32, l: f32) -> (f32, f32, f32) {
    let c = (1.0 - (2.0 * l - 1.0).abs()) * s;
    let h_prime = h / 60.0;
    let x = c * (1.0 - (h_prime % 2.0 - 1.0).abs());
    let (r1, g1, b1) = if h_prime < 1.0 {
        (c, x, 0.0)
    } else if h_prime < 2.0 {
        (x, c, 0.0)
    } else if h_prime < 3.0 {
        (0.0, c, x)
    } else if h_prime < 4.0 {
        (0.0, x, c)
    } else if h_prime < 5.0 {
        (x, 0.0, c)
    } else {
        (c, 0.0, x)
    };
    let m = l - c * 0.5;
    (r1 + m, g1 + m, b1 + m)
}

/// Parse the `--tier` CLI argument to select a render tier.
///
/// The three tiers represent increasing levels of GPU capability:
/// - **Tier 1 (Direct):** One `draw()` call per texture group. Works on all hardware.
/// - **Tier 2 (Indirect):** Uses `multi_draw_indirect()` per texture group, batching
///   draw calls into GPU-side indirect buffers. Requires `MULTI_DRAW_INDIRECT`.
/// - **Tier 3 (Bindless):** Single `multi_draw_indirect()` per frame using texture
///   binding arrays. Requires `TEXTURE_BINDING_ARRAY` + `MULTI_DRAW_INDIRECT`.
///
/// Passing `--tier auto` (or omitting the flag) lets the engine choose the best
/// tier supported by the current GPU.
fn parse_tier() -> Option<RenderTier> {
    let args: Vec<String> = std::env::args().collect();
    for (i, arg) in args.iter().enumerate() {
        if arg == "--tier" {
            if let Some(value) = args.get(i + 1) {
                return match value.as_str() {
                    "1" | "direct" => Some(RenderTier::Direct),
                    "2" | "indirect" => Some(RenderTier::Indirect),
                    "3" | "bindless" => Some(RenderTier::Bindless),
                    "auto" => None,
                    other => {
                        eprintln!(
                            "Unknown tier '{other}'. Options: 1|direct, 2|indirect, 3|bindless, auto"
                        );
                        std::process::exit(1);
                    }
                };
            }
        }
    }
    // Default: auto-detect
    None
}

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

    run_app(|ctx| {
        let tier_override = parse_tier();

        // Use the capability API to configure GPU requirements.
        // For auto-detect, request the best capability (graceful degradation).
        // For a specific tier, require that tier's capability.
        let descriptor = match tier_override {
            None => GraphicsContextDescriptor::new()
                .request_capability::<BestBatchCapability2D>(),
            Some(RenderTier::Direct) => GraphicsContextDescriptor::new()
                .require_capability::<DirectBatchCapability2D>(),
            Some(RenderTier::Indirect) => GraphicsContextDescriptor::new()
                .require_capability::<IndirectBatchCapability2D>(),
            Some(RenderTier::Bindless) => GraphicsContextDescriptor::new()
                .require_capability::<BindlessBatchCapability2D>(),
        };
        let graphics_ctx =
            pollster::block_on(GraphicsContext::new_owned_with_descriptor(descriptor))
                .expect("Failed to create graphics context");

        let window = ctx
            .create_window(WindowDescriptor {
                title: "Batched Renderer Example".to_string(),
                size: Some(WinitPhysicalSize::new(800.0, 600.0)),
                ..Default::default()
            })
            .expect("Failed to create window");

        let surface_format = wgpu::TextureFormat::Bgra8UnormSrgb;

        let renderable_window = RenderableWindow::new_with_descriptor(
            window,
            graphics_ctx.clone(),
            WindowContextDescriptor {
                format: Some(surface_format),
                ..Default::default()
            },
        )
        .expect("Failed to create renderable window");

        let window_id = renderable_window.id();

        let renderer = create_batch_renderer_2d(
            graphics_ctx.clone(),
            surface_format,
            tier_override,
        );

        tracing::info!("Using render tier: {}", renderer.tier());

        // Create initial depth buffer
        let depth_texture = graphics_ctx
            .device()
            .create_texture(&wgpu::TextureDescriptor {
                label: Some("example_depth"),
                size: wgpu::Extent3d {
                    width: 1,
                    height: 1,
                    depth_or_array_layers: 1,
                },
                mip_level_count: 1,
                sample_count: 1,
                dimension: wgpu::TextureDimension::D2,
                format: DEPTH_FORMAT,
                usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
                view_formats: &[],
            });
        let depth_view = depth_texture.create_view(&wgpu::TextureViewDescriptor::default());

        let mut windows = HashMap::new();
        windows.insert(window_id, renderable_window);

        Box::new(App {
            context: graphics_ctx,
            windows,
            renderer,
            depth_texture,
            depth_view,
            depth_width: 1,
            depth_height: 1,
            frame_count: 0,
        })
    });
}

examples/sprite_sheet.rs (line 200)

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

    run_app(|ctx| {
        let graphics_ctx = GraphicsContext::new_owned_sync().expect("Failed to create graphics context");
        let mut windows = HashMap::new();

        let scale = Window::platform_dpi() as f32;
        let window = ctx
            .create_window(WindowDescriptor {
                title: "Sprite Sheet Animation Example".to_string(),
                size: Some(WinitPhysicalSize::new(400.0 * scale, 400.0 * scale)),
                ..Default::default()
            })
            .expect("Failed to create window");

        let renderable_window = RenderableWindow::new_with_descriptor(
            window,
            graphics_ctx.clone(),
            WindowContextDescriptor {
                format: Some(wgpu::TextureFormat::Bgra8UnormSrgb),
                ..Default::default()
            },
        ).expect("Failed to create renderable window");

        let window_id = renderable_window.id();
        windows.insert(window_id, renderable_window);

        // Generate sprite sheet
        let (sprite_data, tex_width, tex_height) = generate_sprite_sheet_data();
        let sprite_sheet = SpriteSheet::from_data(
            &graphics_ctx,
            &sprite_data,
            tex_width,
            tex_height,
            SpriteSheetDescriptor {
                sprite_width: 64,
                sprite_height: 64,
                columns: 4,
                rows: 1,
                ..Default::default()
            },
        );

        // Create animation (4 frames at 8 fps)
        let animation = SpriteAnimation::new(4, 8.0);

        // Create shader module
        let shader = graphics_ctx.device().create_shader_module(wgpu::ShaderModuleDescriptor {
            label: Some("Sprite Shader"),
            source: wgpu::ShaderSource::Wgsl(SHADER.into()),
        });

        // Create bind group layout
        let bind_group_layout = graphics_ctx.device().create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
            label: Some("Sprite Bind Group Layout"),
            entries: &[
                wgpu::BindGroupLayoutEntry {
                    binding: 0,
                    visibility: wgpu::ShaderStages::VERTEX,
                    ty: wgpu::BindingType::Buffer {
                        ty: wgpu::BufferBindingType::Uniform,
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                },
                wgpu::BindGroupLayoutEntry {
                    binding: 1,
                    visibility: wgpu::ShaderStages::FRAGMENT,
                    ty: wgpu::BindingType::Texture {
                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
                        view_dimension: wgpu::TextureViewDimension::D2,
                        multisampled: false,
                    },
                    count: None,
                },
                wgpu::BindGroupLayoutEntry {
                    binding: 2,
                    visibility: wgpu::ShaderStages::FRAGMENT,
                    ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
                    count: None,
                },
            ],
        });

        // Create pipeline layout
        let pipeline_layout = graphics_ctx.device().create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
            label: Some("Sprite Pipeline Layout"),
            bind_group_layouts: &[&bind_group_layout],
            push_constant_ranges: &[],
        });

        // Create render pipeline
        let pipeline = graphics_ctx.device().create_render_pipeline(&wgpu::RenderPipelineDescriptor {
            label: Some("Sprite Pipeline"),
            layout: Some(&pipeline_layout),
            vertex: wgpu::VertexState {
                module: &shader,
                entry_point: Some("vs_main"),
                buffers: &[wgpu::VertexBufferLayout {
                    array_stride: std::mem::size_of::<Vertex>() as u64,
                    step_mode: wgpu::VertexStepMode::Vertex,
                    attributes: &[
                        wgpu::VertexAttribute {
                            offset: 0,
                            shader_location: 0,
                            format: wgpu::VertexFormat::Float32x2,
                        },
                        wgpu::VertexAttribute {
                            offset: 8,
                            shader_location: 1,
                            format: wgpu::VertexFormat::Float32x2,
                        },
                    ],
                }],
                compilation_options: wgpu::PipelineCompilationOptions::default(),
            },
            fragment: Some(wgpu::FragmentState {
                module: &shader,
                entry_point: Some("fs_main"),
                targets: &[Some(wgpu::ColorTargetState {
                    format: wgpu::TextureFormat::Bgra8UnormSrgb,
                    blend: Some(wgpu::BlendState::ALPHA_BLENDING),
                    write_mask: wgpu::ColorWrites::ALL,
                })],
                compilation_options: wgpu::PipelineCompilationOptions::default(),
            }),
            primitive: wgpu::PrimitiveState {
                topology: wgpu::PrimitiveTopology::TriangleList,
                ..Default::default()
            },
            depth_stencil: None,
            multisample: wgpu::MultisampleState::default(),
            multiview: None,
            cache: None,
        });

        // Create uniform buffer
        let uniforms = Uniforms {
            mvp: [
                [1.0, 0.0, 0.0, 0.0],
                [0.0, 1.0, 0.0, 0.0],
                [0.0, 0.0, 1.0, 0.0],
                [0.0, 0.0, 0.0, 1.0],
            ],
        };
        let uniform_buffer = graphics_ctx.device().create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("Uniform Buffer"),
            contents: bytemuck::cast_slice(&[uniforms]),
            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
        });

        // Create sampler
        let sampler = graphics_ctx.device().create_sampler(&wgpu::SamplerDescriptor {
            label: Some("Sprite Sampler"),
            mag_filter: wgpu::FilterMode::Linear,
            min_filter: wgpu::FilterMode::Linear,
            ..Default::default()
        });

        // Create bind group
        let bind_group = graphics_ctx.device().create_bind_group(&wgpu::BindGroupDescriptor {
            label: Some("Sprite Bind Group"),
            layout: &bind_group_layout,
            entries: &[
                wgpu::BindGroupEntry {
                    binding: 0,
                    resource: uniform_buffer.as_entire_binding(),
                },
                wgpu::BindGroupEntry {
                    binding: 1,
                    resource: wgpu::BindingResource::TextureView(sprite_sheet.view()),
                },
                wgpu::BindGroupEntry {
                    binding: 2,
                    resource: wgpu::BindingResource::Sampler(&sampler),
                },
            ],
        });

        // Initial vertex buffer (will be updated each frame with new UVs)
        let vertices = create_quad_vertices(0.0, 0.0, 1.0, 1.0);
        let vertex_buffer = graphics_ctx.device().create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("Vertex Buffer"),
            contents: bytemuck::cast_slice(&vertices),
            usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
        });

        Box::new(App {
            _context: graphics_ctx,
            windows,
            pipeline,
            bind_group,
            vertex_buffer,
            uniform_buffer,
            sprite_sheet,
            animation,
            last_update: Instant::now(),
        })
    });
}

examples/image_blitting.rs (line 196)

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

    run_app(|ctx| {
        let graphics_ctx = GraphicsContext::new_owned_sync().expect("Failed to create graphics context");
        let mut windows = HashMap::new();

        let scale = Window::platform_dpi() as f32;
        let window = ctx
            .create_window(WindowDescriptor {
                title: "Image Blitting Example".to_string(),
                size: Some(WinitPhysicalSize::new(800.0 * scale, 600.0 * scale)),
                ..Default::default()
            })
            .expect("Failed to create window");

        let renderable_window = RenderableWindow::new_with_descriptor(
            window,
            graphics_ctx.clone(),
            WindowContextDescriptor {
                format: Some(wgpu::TextureFormat::Bgra8UnormSrgb),
                ..Default::default()
            },
        ).expect("Failed to create renderable window");

        let window_id = renderable_window.id();
        windows.insert(window_id, renderable_window);

        // Create shader module
        let shader = graphics_ctx.device().create_shader_module(wgpu::ShaderModuleDescriptor {
            label: Some("Blit Shader"),
            source: wgpu::ShaderSource::Wgsl(SHADER.into()),
        });

        // Create bind group layout
        let bind_group_layout = graphics_ctx.device().create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
            label: Some("Blit Bind Group Layout"),
            entries: &[
                wgpu::BindGroupLayoutEntry {
                    binding: 0,
                    visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
                    ty: wgpu::BindingType::Buffer {
                        ty: wgpu::BufferBindingType::Uniform,
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                },
                wgpu::BindGroupLayoutEntry {
                    binding: 1,
                    visibility: wgpu::ShaderStages::FRAGMENT,
                    ty: wgpu::BindingType::Texture {
                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
                        view_dimension: wgpu::TextureViewDimension::D2,
                        multisampled: false,
                    },
                    count: None,
                },
                wgpu::BindGroupLayoutEntry {
                    binding: 2,
                    visibility: wgpu::ShaderStages::FRAGMENT,
                    ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
                    count: None,
                },
            ],
        });

        // Create pipeline layout
        let pipeline_layout = graphics_ctx.device().create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
            label: Some("Blit Pipeline Layout"),
            bind_group_layouts: &[&bind_group_layout],
            push_constant_ranges: &[],
        });

        // Create render pipeline
        let pipeline = graphics_ctx.device().create_render_pipeline(&wgpu::RenderPipelineDescriptor {
            label: Some("Blit Pipeline"),
            layout: Some(&pipeline_layout),
            vertex: wgpu::VertexState {
                module: &shader,
                entry_point: Some("vs_main"),
                buffers: &[wgpu::VertexBufferLayout {
                    array_stride: std::mem::size_of::<Vertex>() as u64,
                    step_mode: wgpu::VertexStepMode::Vertex,
                    attributes: &[
                        wgpu::VertexAttribute {
                            offset: 0,
                            shader_location: 0,
                            format: wgpu::VertexFormat::Float32x2,
                        },
                        wgpu::VertexAttribute {
                            offset: 8,
                            shader_location: 1,
                            format: wgpu::VertexFormat::Float32x2,
                        },
                    ],
                }],
                compilation_options: wgpu::PipelineCompilationOptions::default(),
            },
            fragment: Some(wgpu::FragmentState {
                module: &shader,
                entry_point: Some("fs_main"),
                targets: &[Some(wgpu::ColorTargetState {
                    format: wgpu::TextureFormat::Bgra8UnormSrgb,
                    blend: Some(wgpu::BlendState::ALPHA_BLENDING),
                    write_mask: wgpu::ColorWrites::ALL,
                })],
                compilation_options: wgpu::PipelineCompilationOptions::default(),
            }),
            primitive: wgpu::PrimitiveState {
                topology: wgpu::PrimitiveTopology::TriangleList,
                strip_index_format: None,
                front_face: wgpu::FrontFace::Ccw,
                cull_mode: None,
                polygon_mode: wgpu::PolygonMode::Fill,
                unclipped_depth: false,
                conservative: false,
            },
            depth_stencil: None,
            multisample: wgpu::MultisampleState::default(),
            multiview: None,
            cache: None,
        });

        // Create vertex buffer for a fullscreen quad
        let vertices = [
            Vertex { position: [-0.8, -0.8], uv: [0.0, 1.0] },
            Vertex { position: [0.8, -0.8], uv: [1.0, 1.0] },
            Vertex { position: [0.8, 0.8], uv: [1.0, 0.0] },
            Vertex { position: [-0.8, -0.8], uv: [0.0, 1.0] },
            Vertex { position: [0.8, 0.8], uv: [1.0, 0.0] },
            Vertex { position: [-0.8, 0.8], uv: [0.0, 0.0] },
        ];
        let vertex_buffer = graphics_ctx.device().create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("Vertex Buffer"),
            contents: bytemuck::cast_slice(&vertices),
            usage: wgpu::BufferUsages::VERTEX,
        });

        // Create uniform buffer
        let uniforms = Uniforms {
            mvp: [
                [1.0, 0.0, 0.0, 0.0],
                [0.0, 1.0, 0.0, 0.0],
                [0.0, 0.0, 1.0, 0.0],
                [0.0, 0.0, 0.0, 1.0],
            ],
            tint: [1.0, 1.0, 1.0, 1.0],
        };
        let uniform_buffer = graphics_ctx.device().create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("Uniform Buffer"),
            contents: bytemuck::cast_slice(&[uniforms]),
            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
        });

        // Create CPU-side image buffer
        let mut image_buffer = ImageBuffer::new(256, 256);
        image_buffer.clear(30, 30, 40, 255);

        // Create GPU texture
        let texture = graphics_ctx.device().create_texture(&wgpu::TextureDescriptor {
            label: Some("Blit Texture"),
            size: wgpu::Extent3d {
                width: 256,
                height: 256,
                depth_or_array_layers: 1,
            },
            mip_level_count: 1,
            sample_count: 1,
            dimension: wgpu::TextureDimension::D2,
            format: wgpu::TextureFormat::Rgba8UnormSrgb,
            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
            view_formats: &[],
        });

        // Create texture view and sampler
        let texture_view = texture.create_view(&wgpu::TextureViewDescriptor::default());
        let sampler = graphics_ctx.device().create_sampler(&wgpu::SamplerDescriptor {
            label: Some("Blit Sampler"),
            address_mode_u: wgpu::AddressMode::ClampToEdge,
            address_mode_v: wgpu::AddressMode::ClampToEdge,
            address_mode_w: wgpu::AddressMode::ClampToEdge,
            mag_filter: wgpu::FilterMode::Nearest, // Pixel-perfect rendering
            min_filter: wgpu::FilterMode::Nearest,
            mipmap_filter: wgpu::FilterMode::Nearest,
            ..Default::default()
        });

        // Create bind group
        let bind_group = graphics_ctx.device().create_bind_group(&wgpu::BindGroupDescriptor {
            label: Some("Blit Bind Group"),
            layout: &bind_group_layout,
            entries: &[
                wgpu::BindGroupEntry {
                    binding: 0,
                    resource: uniform_buffer.as_entire_binding(),
                },
                wgpu::BindGroupEntry {
                    binding: 1,
                    resource: wgpu::BindingResource::TextureView(&texture_view),
                },
                wgpu::BindGroupEntry {
                    binding: 2,
                    resource: wgpu::BindingResource::Sampler(&sampler),
                },
            ],
        });

        Box::new(App {
            context: graphics_ctx,
            windows,
            pipeline,
            bind_group_layout,
            vertex_buffer,
            texture,
            bind_group,
            uniform_buffer,
            image_buffer,
            start_time: Instant::now(),
        })
    });
}

examples/textured_window.rs (line 52)

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

    run_app(|ctx| {
        let graphics_ctx = GraphicsContext::new_owned_sync().expect("Failed to create graphics context");

        let window = ctx
            .create_window(WindowDescriptor {
                title: "Textured Window".to_string(),
                ..Default::default()
            })
            .expect("Failed to create window");

        let window = RenderableWindow::new_with_descriptor(
            window,
            graphics_ctx.clone(),
            WindowContextDescriptor {
                format: Some(wgpu::TextureFormat::Bgra8UnormSrgb),
                ..Default::default()
            },
        ).expect("Failed to create renderable window");

        // --- Shader ---
        let shader = graphics_ctx
            .device()
            .create_shader_module(wgpu::ShaderModuleDescriptor {
                label: Some("Texture Shader"),
                source: wgpu::ShaderSource::Wgsl(include_str!("textured_window.wgsl").into()),
            });

        // --- Texture Upload ---
        // Create a 256x256 RGBA texture with a procedural gradient pattern.
        // Rgba8UnormSrgb applies sRGB gamma correction so colors appear correct on screen.
        let texture_size = wgpu::Extent3d {
            width: 256,
            height: 256,
            depth_or_array_layers: 1,
        };

        let texture = graphics_ctx
            .device()
            .create_texture(&wgpu::TextureDescriptor {
                label: Some("Example Texture"),
                size: texture_size,
                mip_level_count: 1,
                sample_count: 1,
                dimension: wgpu::TextureDimension::D2,
                format: wgpu::TextureFormat::Rgba8UnormSrgb,
                usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
                view_formats: &[],
            });

        let mut texture_data = vec![0u8; (256 * 256 * 4) as usize];
        for y in 0..256 {
            for x in 0..256 {
                let idx = ((y * 256 + x) * 4) as usize;
                texture_data[idx] = x as u8;
                texture_data[idx + 1] = y as u8;
                texture_data[idx + 2] = ((x + y) / 2) as u8;
                texture_data[idx + 3] = 255;
            }
        }

        graphics_ctx.queue().write_texture(
            wgpu::TexelCopyTextureInfo {
                texture: &texture,
                mip_level: 0,
                origin: wgpu::Origin3d::ZERO,
                aspect: wgpu::TextureAspect::All,
            },
            &texture_data,
            wgpu::TexelCopyBufferLayout {
                offset: 0,
                bytes_per_row: Some(256 * 4),
                rows_per_image: Some(256),
            },
            texture_size,
        );

        // --- Sampler ---
        let texture_view = texture.create_view(&wgpu::TextureViewDescriptor::default());
        // ClampToEdge prevents sampling beyond texture edges; Linear mag filter
        // gives smooth results when the quad is larger than the texture.
        let sampler = graphics_ctx
            .device()
            .create_sampler(&wgpu::SamplerDescriptor {
                address_mode_u: wgpu::AddressMode::ClampToEdge,
                address_mode_v: wgpu::AddressMode::ClampToEdge,
                address_mode_w: wgpu::AddressMode::ClampToEdge,
                mag_filter: wgpu::FilterMode::Linear,
                min_filter: wgpu::FilterMode::Nearest,
                mipmap_filter: wgpu::FilterMode::Nearest,
                ..Default::default()
            });

        // --- Bind Group ---
        // Binding 0: texture (Float filterable = supports linear sampling)
        // Binding 1: sampler (Filtering = pairs with filterable textures)
        let bind_group_layout =
            graphics_ctx
                .device()
                .create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                    label: Some("Texture Bind Group Layout"),
                    entries: &[
                        wgpu::BindGroupLayoutEntry {
                            binding: 0,
                            visibility: wgpu::ShaderStages::FRAGMENT,
                            ty: wgpu::BindingType::Texture {
                                multisampled: false,
                                view_dimension: wgpu::TextureViewDimension::D2,
                                sample_type: wgpu::TextureSampleType::Float { filterable: true },
                            },
                            count: None,
                        },
                        wgpu::BindGroupLayoutEntry {
                            binding: 1,
                            visibility: wgpu::ShaderStages::FRAGMENT,
                            ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
                            count: None,
                        },
                    ],
                });

        let bind_group = graphics_ctx
            .device()
            .create_bind_group(&wgpu::BindGroupDescriptor {
                label: Some("Texture Bind Group"),
                layout: &bind_group_layout,
                entries: &[
                    wgpu::BindGroupEntry {
                        binding: 0,
                        resource: wgpu::BindingResource::TextureView(&texture_view),
                    },
                    wgpu::BindGroupEntry {
                        binding: 1,
                        resource: wgpu::BindingResource::Sampler(&sampler),
                    },
                ],
            });

        // --- Pipeline ---
        let pipeline_layout =
            graphics_ctx
                .device()
                .create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
                    label: Some("Render Pipeline Layout"),
                    bind_group_layouts: &[&bind_group_layout],
                    push_constant_ranges: &[],
                });

        let pipeline =
            graphics_ctx
                .device()
                .create_render_pipeline(&wgpu::RenderPipelineDescriptor {
                    label: Some("Render Pipeline"),
                    layout: Some(&pipeline_layout),
                    vertex: wgpu::VertexState {
                        module: &shader,
                        entry_point: Some("vs_main"),
                        buffers: &[wgpu::VertexBufferLayout {
                            // 4 floats × 4 bytes = 16 bytes per vertex (2×f32 pos + 2×f32 UV)
                            array_stride: 4 * 4,
                            step_mode: wgpu::VertexStepMode::Vertex,
                            attributes: &wgpu::vertex_attr_array![0 => Float32x2, 1 => Float32x2],
                        }],
                        compilation_options: wgpu::PipelineCompilationOptions::default(),
                    },
                    fragment: Some(wgpu::FragmentState {
                        module: &shader,
                        entry_point: Some("fs_main"),
                        targets: &[Some(wgpu::ColorTargetState {
                            format: wgpu::TextureFormat::Bgra8UnormSrgb,
                            blend: Some(wgpu::BlendState::REPLACE),
                            write_mask: wgpu::ColorWrites::ALL,
                        })],
                        compilation_options: wgpu::PipelineCompilationOptions::default(),
                    }),
                    primitive: wgpu::PrimitiveState {
                        topology: wgpu::PrimitiveTopology::TriangleList,
                        strip_index_format: None,
                        front_face: wgpu::FrontFace::Ccw,
                        cull_mode: Some(wgpu::Face::Back),
                        polygon_mode: wgpu::PolygonMode::Fill,
                        unclipped_depth: false,
                        conservative: false,
                    },
                    depth_stencil: None,
                    multisample: wgpu::MultisampleState {
                        count: 1,
                        mask: !0,
                        alpha_to_coverage_enabled: false,
                    },
                    multiview: None,
                    cache: None,
                });

        #[rustfmt::skip]
        let vertices: &[f32] = &[
            -0.8, -0.8,  0.0, 1.0,
             0.8, -0.8,  1.0, 1.0,
             0.8,  0.8,  1.0, 0.0,
            -0.8, -0.8,  0.0, 1.0,
             0.8,  0.8,  1.0, 0.0,
            -0.8,  0.8,  0.0, 0.0,
        ];

        let vertex_buffer = graphics_ctx.device().create_buffer(&wgpu::BufferDescriptor {
            label: Some("Vertex Buffer"),
            size: (vertices.len() * std::mem::size_of::<f32>()) as u64,
            usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });

        graphics_ctx
            .queue()
            .write_buffer(&vertex_buffer, 0, bytemuck::cast_slice(vertices));

        let window_id = window.id();

        Box::new(App {
            window,
            window_id,
            pipeline,
            bind_group,
            vertex_buffer,
        })
    });
}

pub fn queue(&self) -> &Queue

Get a reference to the wgpu queue.

Examples found in repository

examples/sprite_sheet.rs (line 381)

    fn update(&mut self, _ctx: &mut astrelis_winit::app::AppCtx, _time: &astrelis_winit::FrameTime) {
        let now = Instant::now();
        let dt = now.duration_since(self.last_update).as_secs_f32();
        self.last_update = now;

        // Update animation
        if self.animation.update(dt) {
            // Frame changed - update vertex buffer with new UVs
            let frame = self.animation.current_frame();
            let uv = self.sprite_sheet.sprite_uv(frame);
            let vertices = create_quad_vertices(uv.u_min, uv.v_min, uv.u_max, uv.v_max);
            
            // Get context from first window
            if let Some(window) = self.windows.values().next() {
                window.context().graphics_context().queue().write_buffer(
                    &self.vertex_buffer,
                    0,
                    bytemuck::cast_slice(&vertices),
                );
            }
        }
    }

examples/image_blitting.rs (line 423)

    fn update(&mut self, _ctx: &mut astrelis_winit::app::AppCtx, _time: &astrelis_winit::FrameTime) {
        let time = self.start_time.elapsed().as_secs_f32();
        
        // Animate the CPU-side image buffer
        self.image_buffer.clear(30, 30, 40, 255);
        
        // Draw animated gradient background
        let phase = (time * 0.5).sin() * 0.5 + 0.5;
        let r1 = (50.0 + phase * 50.0) as u8;
        let b1 = (80.0 + (1.0 - phase) * 50.0) as u8;
        self.image_buffer.gradient_h(0, 256, r1, 40, b1, 40, r1, b1);
        
        // Draw bouncing circles
        for i in 0..5 {
            let offset = i as f32 * 0.4;
            let x = 128.0 + (time * 2.0 + offset).sin() * 80.0;
            let y = 128.0 + (time * 3.0 + offset).cos() * 80.0;
            let hue = (time * 0.5 + offset) % 1.0;
            let (r, g, b) = hsv_to_rgb(hue, 0.8, 1.0);
            self.image_buffer.fill_circle(x as i32, y as i32, 20, r, g, b, 255);
        }
        
        // Draw animated rectangles
        for i in 0..3 {
            let x = ((time * (1.0 + i as f32 * 0.3)).sin() * 100.0 + 128.0) as u32;
            let y = 20 + i * 80;
            let w = 30 + (time.sin() * 10.0) as u32;
            let h = 20;
            self.image_buffer.fill_rect(x.saturating_sub(w/2), y, w, h, 255, 255, 255, 200);
        }
        
        // Upload to GPU (this is the "blit" operation)
        self.context.queue().write_texture(
            wgpu::TexelCopyTextureInfo {
                texture: &self.texture,
                mip_level: 0,
                origin: wgpu::Origin3d::ZERO,
                aspect: wgpu::TextureAspect::All,
            },
            &self.image_buffer.pixels,
            wgpu::TexelCopyBufferLayout {
                offset: 0,
                bytes_per_row: Some(self.image_buffer.width * 4),
                rows_per_image: Some(self.image_buffer.height),
            },
            wgpu::Extent3d {
                width: self.image_buffer.width,
                height: self.image_buffer.height,
                depth_or_array_layers: 1,
            },
        );
    }

examples/textured_window.rs (line 91)

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

    run_app(|ctx| {
        let graphics_ctx = GraphicsContext::new_owned_sync().expect("Failed to create graphics context");

        let window = ctx
            .create_window(WindowDescriptor {
                title: "Textured Window".to_string(),
                ..Default::default()
            })
            .expect("Failed to create window");

        let window = RenderableWindow::new_with_descriptor(
            window,
            graphics_ctx.clone(),
            WindowContextDescriptor {
                format: Some(wgpu::TextureFormat::Bgra8UnormSrgb),
                ..Default::default()
            },
        ).expect("Failed to create renderable window");

        // --- Shader ---
        let shader = graphics_ctx
            .device()
            .create_shader_module(wgpu::ShaderModuleDescriptor {
                label: Some("Texture Shader"),
                source: wgpu::ShaderSource::Wgsl(include_str!("textured_window.wgsl").into()),
            });

        // --- Texture Upload ---
        // Create a 256x256 RGBA texture with a procedural gradient pattern.
        // Rgba8UnormSrgb applies sRGB gamma correction so colors appear correct on screen.
        let texture_size = wgpu::Extent3d {
            width: 256,
            height: 256,
            depth_or_array_layers: 1,
        };

        let texture = graphics_ctx
            .device()
            .create_texture(&wgpu::TextureDescriptor {
                label: Some("Example Texture"),
                size: texture_size,
                mip_level_count: 1,
                sample_count: 1,
                dimension: wgpu::TextureDimension::D2,
                format: wgpu::TextureFormat::Rgba8UnormSrgb,
                usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
                view_formats: &[],
            });

        let mut texture_data = vec![0u8; (256 * 256 * 4) as usize];
        for y in 0..256 {
            for x in 0..256 {
                let idx = ((y * 256 + x) * 4) as usize;
                texture_data[idx] = x as u8;
                texture_data[idx + 1] = y as u8;
                texture_data[idx + 2] = ((x + y) / 2) as u8;
                texture_data[idx + 3] = 255;
            }
        }

        graphics_ctx.queue().write_texture(
            wgpu::TexelCopyTextureInfo {
                texture: &texture,
                mip_level: 0,
                origin: wgpu::Origin3d::ZERO,
                aspect: wgpu::TextureAspect::All,
            },
            &texture_data,
            wgpu::TexelCopyBufferLayout {
                offset: 0,
                bytes_per_row: Some(256 * 4),
                rows_per_image: Some(256),
            },
            texture_size,
        );

        // --- Sampler ---
        let texture_view = texture.create_view(&wgpu::TextureViewDescriptor::default());
        // ClampToEdge prevents sampling beyond texture edges; Linear mag filter
        // gives smooth results when the quad is larger than the texture.
        let sampler = graphics_ctx
            .device()
            .create_sampler(&wgpu::SamplerDescriptor {
                address_mode_u: wgpu::AddressMode::ClampToEdge,
                address_mode_v: wgpu::AddressMode::ClampToEdge,
                address_mode_w: wgpu::AddressMode::ClampToEdge,
                mag_filter: wgpu::FilterMode::Linear,
                min_filter: wgpu::FilterMode::Nearest,
                mipmap_filter: wgpu::FilterMode::Nearest,
                ..Default::default()
            });

        // --- Bind Group ---
        // Binding 0: texture (Float filterable = supports linear sampling)
        // Binding 1: sampler (Filtering = pairs with filterable textures)
        let bind_group_layout =
            graphics_ctx
                .device()
                .create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                    label: Some("Texture Bind Group Layout"),
                    entries: &[
                        wgpu::BindGroupLayoutEntry {
                            binding: 0,
                            visibility: wgpu::ShaderStages::FRAGMENT,
                            ty: wgpu::BindingType::Texture {
                                multisampled: false,
                                view_dimension: wgpu::TextureViewDimension::D2,
                                sample_type: wgpu::TextureSampleType::Float { filterable: true },
                            },
                            count: None,
                        },
                        wgpu::BindGroupLayoutEntry {
                            binding: 1,
                            visibility: wgpu::ShaderStages::FRAGMENT,
                            ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
                            count: None,
                        },
                    ],
                });

        let bind_group = graphics_ctx
            .device()
            .create_bind_group(&wgpu::BindGroupDescriptor {
                label: Some("Texture Bind Group"),
                layout: &bind_group_layout,
                entries: &[
                    wgpu::BindGroupEntry {
                        binding: 0,
                        resource: wgpu::BindingResource::TextureView(&texture_view),
                    },
                    wgpu::BindGroupEntry {
                        binding: 1,
                        resource: wgpu::BindingResource::Sampler(&sampler),
                    },
                ],
            });

        // --- Pipeline ---
        let pipeline_layout =
            graphics_ctx
                .device()
                .create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
                    label: Some("Render Pipeline Layout"),
                    bind_group_layouts: &[&bind_group_layout],
                    push_constant_ranges: &[],
                });

        let pipeline =
            graphics_ctx
                .device()
                .create_render_pipeline(&wgpu::RenderPipelineDescriptor {
                    label: Some("Render Pipeline"),
                    layout: Some(&pipeline_layout),
                    vertex: wgpu::VertexState {
                        module: &shader,
                        entry_point: Some("vs_main"),
                        buffers: &[wgpu::VertexBufferLayout {
                            // 4 floats × 4 bytes = 16 bytes per vertex (2×f32 pos + 2×f32 UV)
                            array_stride: 4 * 4,
                            step_mode: wgpu::VertexStepMode::Vertex,
                            attributes: &wgpu::vertex_attr_array![0 => Float32x2, 1 => Float32x2],
                        }],
                        compilation_options: wgpu::PipelineCompilationOptions::default(),
                    },
                    fragment: Some(wgpu::FragmentState {
                        module: &shader,
                        entry_point: Some("fs_main"),
                        targets: &[Some(wgpu::ColorTargetState {
                            format: wgpu::TextureFormat::Bgra8UnormSrgb,
                            blend: Some(wgpu::BlendState::REPLACE),
                            write_mask: wgpu::ColorWrites::ALL,
                        })],
                        compilation_options: wgpu::PipelineCompilationOptions::default(),
                    }),
                    primitive: wgpu::PrimitiveState {
                        topology: wgpu::PrimitiveTopology::TriangleList,
                        strip_index_format: None,
                        front_face: wgpu::FrontFace::Ccw,
                        cull_mode: Some(wgpu::Face::Back),
                        polygon_mode: wgpu::PolygonMode::Fill,
                        unclipped_depth: false,
                        conservative: false,
                    },
                    depth_stencil: None,
                    multisample: wgpu::MultisampleState {
                        count: 1,
                        mask: !0,
                        alpha_to_coverage_enabled: false,
                    },
                    multiview: None,
                    cache: None,
                });

        #[rustfmt::skip]
        let vertices: &[f32] = &[
            -0.8, -0.8,  0.0, 1.0,
             0.8, -0.8,  1.0, 1.0,
             0.8,  0.8,  1.0, 0.0,
            -0.8, -0.8,  0.0, 1.0,
             0.8,  0.8,  1.0, 0.0,
            -0.8,  0.8,  0.0, 0.0,
        ];

        let vertex_buffer = graphics_ctx.device().create_buffer(&wgpu::BufferDescriptor {
            label: Some("Vertex Buffer"),
            size: (vertices.len() * std::mem::size_of::<f32>()) as u64,
            usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });

        graphics_ctx
            .queue()
            .write_buffer(&vertex_buffer, 0, bytemuck::cast_slice(vertices));

        let window_id = window.id();

        Box::new(App {
            window,
            window_id,
            pipeline,
            bind_group,
            vertex_buffer,
        })
    });
}

pub fn adapter(&self) -> &Adapter

Get a reference to the wgpu adapter.

pub fn instance(&self) -> &Instance

Get a reference to the wgpu instance.

pub fn info(&self) -> AdapterInfo

Get device info

Examples found in repository

examples/renderer_api.rs (line 262)

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

    run_app(|ctx| {
        let graphics_ctx = GraphicsContext::new_owned_sync().expect("Failed to create graphics context");
        let renderer = Renderer::new(graphics_ctx.clone());

        let window = ctx
            .create_window(WindowDescriptor {
                title: "Renderer API Example".to_string(),
                size: Some(WinitPhysicalSize::new(800.0, 600.0)),
                ..Default::default()
            })
            .expect("Failed to create window");

        let window = RenderableWindow::new_with_descriptor(
            window,
            graphics_ctx.clone(),
            WindowContextDescriptor {
                format: Some(wgpu::TextureFormat::Bgra8UnormSrgb),
                ..Default::default()
            },
        ).expect("Failed to create renderable window");

        let window_id = window.id();

        // Create shader using Renderer API
        let shader = renderer.create_shader(Some("Color Shader"), SHADER_SOURCE);

        // Create texture using Renderer helper
        let texture_data = create_gradient_texture();
        let texture = renderer.create_texture_2d(
            Some("Gradient Texture"),
            256,
            256,
            wgpu::TextureFormat::Rgba8UnormSrgb,
            wgpu::TextureUsages::TEXTURE_BINDING,
            &texture_data,
        );

        let texture_view = texture.create_view(&wgpu::TextureViewDescriptor::default());
        let sampler = renderer.create_linear_sampler(Some("Linear Sampler"));

        // Create bind group using Renderer API
        let bind_group_layout = renderer.create_bind_group_layout(
            Some("Texture Bind Group Layout"),
            &[
                wgpu::BindGroupLayoutEntry {
                    binding: 0,
                    visibility: wgpu::ShaderStages::FRAGMENT,
                    ty: wgpu::BindingType::Texture {
                        multisampled: false,
                        view_dimension: wgpu::TextureViewDimension::D2,
                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
                    },
                    count: None,
                },
                wgpu::BindGroupLayoutEntry {
                    binding: 1,
                    visibility: wgpu::ShaderStages::FRAGMENT,
                    ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
                    count: None,
                },
            ],
        );

        let bind_group = renderer.create_bind_group(
            Some("Texture Bind Group"),
            &bind_group_layout,
            &[
                wgpu::BindGroupEntry {
                    binding: 0,
                    resource: wgpu::BindingResource::TextureView(&texture_view),
                },
                wgpu::BindGroupEntry {
                    binding: 1,
                    resource: wgpu::BindingResource::Sampler(&sampler),
                },
            ],
        );

        let pipeline_layout = renderer.create_pipeline_layout(
            Some("Render Pipeline Layout"),
            &[&bind_group_layout],
            &[],
        );

        // Create pipeline using Renderer API with BlendMode
        let pipeline = renderer.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
            label: Some("Render Pipeline"),
            layout: Some(&pipeline_layout),
            vertex: wgpu::VertexState {
                module: &shader,
                entry_point: Some("vs_main"),
                buffers: &[wgpu::VertexBufferLayout {
                    // 4 floats × 4 bytes = 16 bytes per vertex (2×f32 pos + 2×f32 UV)
                    array_stride: 4 * 4,
                    step_mode: wgpu::VertexStepMode::Vertex,
                    attributes: &wgpu::vertex_attr_array![0 => Float32x2, 1 => Float32x2],
                }],
                compilation_options: wgpu::PipelineCompilationOptions::default(),
            },
            fragment: Some(wgpu::FragmentState {
                module: &shader,
                entry_point: Some("fs_main"),
                // Use BlendMode for transparent rendering
                targets: &[Some(
                    BlendMode::Alpha.to_color_target_state(wgpu::TextureFormat::Rgba8UnormSrgb),
                )],
                compilation_options: wgpu::PipelineCompilationOptions::default(),
            }),
            primitive: wgpu::PrimitiveState {
                topology: wgpu::PrimitiveTopology::TriangleList,
                strip_index_format: None,
                front_face: wgpu::FrontFace::Ccw,
                cull_mode: Some(wgpu::Face::Back),
                polygon_mode: wgpu::PolygonMode::Fill,
                unclipped_depth: false,
                conservative: false,
            },
            depth_stencil: None,
            multisample: wgpu::MultisampleState {
                count: 1,
                mask: !0,
                alpha_to_coverage_enabled: false,
            },
            multiview: None,
            cache: None,
        });

        #[rustfmt::skip]
        let vertices: &[f32] = &[
            -0.8, -0.8,  0.0, 1.0,
             0.8, -0.8,  1.0, 1.0,
             0.8,  0.8,  1.0, 0.0,
            -0.8, -0.8,  0.0, 1.0,
             0.8,  0.8,  1.0, 0.0,
            -0.8,  0.8,  0.0, 0.0,
        ];

        // Create vertex buffer using Renderer helper
        let vertex_buffer = renderer.create_vertex_buffer(Some("Vertex Buffer"), vertices);

        // Create offscreen framebuffer using the new Framebuffer abstraction
        let offscreen_fb = Framebuffer::builder(400, 300)
            .format(wgpu::TextureFormat::Rgba8UnormSrgb)
            .label("Offscreen FB")
            .build(&graphics_ctx);

        // Create blit shader and pipeline for rendering framebuffer to surface
        let blit_shader = renderer.create_shader(Some("Blit Shader"), BLIT_SHADER_SOURCE);

        let blit_bind_group_layout = renderer.create_bind_group_layout(
            Some("Blit Bind Group Layout"),
            &[
                wgpu::BindGroupLayoutEntry {
                    binding: 0,
                    visibility: wgpu::ShaderStages::FRAGMENT,
                    ty: wgpu::BindingType::Texture {
                        multisampled: false,
                        view_dimension: wgpu::TextureViewDimension::D2,
                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
                    },
                    count: None,
                },
                wgpu::BindGroupLayoutEntry {
                    binding: 1,
                    visibility: wgpu::ShaderStages::FRAGMENT,
                    ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
                    count: None,
                },
            ],
        );

        let blit_bind_group = renderer.create_bind_group(
            Some("Blit Bind Group"),
            &blit_bind_group_layout,
            &[
                wgpu::BindGroupEntry {
                    binding: 0,
                    resource: wgpu::BindingResource::TextureView(offscreen_fb.color_view()),
                },
                wgpu::BindGroupEntry {
                    binding: 1,
                    resource: wgpu::BindingResource::Sampler(&sampler),
                },
            ],
        );

        let blit_pipeline_layout = renderer.create_pipeline_layout(
            Some("Blit Pipeline Layout"),
            &[&blit_bind_group_layout],
            &[],
        );

        let blit_pipeline = renderer.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
            label: Some("Blit Pipeline"),
            layout: Some(&blit_pipeline_layout),
            vertex: wgpu::VertexState {
                module: &blit_shader,
                entry_point: Some("vs_main"),
                buffers: &[],
                compilation_options: wgpu::PipelineCompilationOptions::default(),
            },
            fragment: Some(wgpu::FragmentState {
                module: &blit_shader,
                entry_point: Some("fs_main"),
                // Use PremultipliedAlpha for framebuffer blitting
                targets: &[Some(
                    BlendMode::PremultipliedAlpha
                        .to_color_target_state(wgpu::TextureFormat::Bgra8UnormSrgb),
                )],
                compilation_options: wgpu::PipelineCompilationOptions::default(),
            }),
            primitive: wgpu::PrimitiveState {
                topology: wgpu::PrimitiveTopology::TriangleList,
                ..Default::default()
            },
            depth_stencil: None,
            multisample: wgpu::MultisampleState::default(),
            multiview: None,
            cache: None,
        });

        tracing::info!("Renderer initialized successfully");
        tracing::info!("Device: {:?}", renderer.context().info());

        Box::new(RendererApp {
            context: graphics_ctx,
            renderer,
            window,
            window_id,
            pipeline,
            bind_group,
            vertex_buffer,
            offscreen_fb,
            blit_pipeline,
            blit_bind_group,
            time: 0.0,
        })
    });
}

pub fn limits(&self) -> Limits

Get device limits

pub fn wgpu_features(&self) -> Features

Get raw wgpu device features

pub fn gpu_features(&self) -> GpuFeatures

Get the enabled GPU features (high-level wrapper).

pub fn has_feature(&self, feature: GpuFeatures) -> bool

Check if a specific GPU feature is enabled.

pub fn has_all_features(&self, features: GpuFeatures) -> bool

Check if all specified GPU features are enabled.

pub fn require_feature(&self, feature: GpuFeatures)

Assert that a feature is available, panicking with a clear message if not.

Use this before operations that require specific features.

pub fn supports_texture_format( &self, format: TextureFormat, usages: TextureUsages, ) -> bool

Check if a texture format is supported for the given usages.

Example

let supported = ctx.supports_texture_format(
    wgpu::TextureFormat::Rgba8Unorm,
    wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING
);

pub fn texture_format_capabilities( &self, format: TextureFormat, ) -> TextureFormatFeatures

Get texture format capabilities.

Returns detailed information about what operations are supported for a given texture format.

Trait Implementations

impl AsWgpu for GraphicsContext

type WgpuType = Device

The underlying wgpu type.

fn as_wgpu(&self) -> &Self::WgpuType

Get a reference to the underlying wgpu type.

impl RenderContext for GraphicsContext

fn create_buffer(&self, desc: &BufferDescriptor<'_>) -> GpuBuffer

Create a GPU buffer.

fn write_buffer(&self, buffer: &GpuBuffer, offset: u64, data: &[u8])

Write data to a buffer.

fn create_texture(&self, desc: &TextureDescriptor<'_>) -> GpuTexture

Create a GPU texture.

fn create_shader_module( &self, desc: &ShaderModuleDescriptor<'_>, ) -> GpuShaderModule

Create a shader module from source code.

fn create_render_pipeline( &self, desc: &RenderPipelineDescriptor<'_>, ) -> GpuRenderPipeline

Create a render pipeline.

fn create_compute_pipeline( &self, desc: &ComputePipelineDescriptor<'_>, ) -> GpuComputePipeline

Create a compute pipeline.

fn create_bind_group_layout( &self, desc: &BindGroupLayoutDescriptor<'_>, ) -> GpuBindGroupLayout

Create a bind group layout.

fn create_bind_group(&self, desc: &BindGroupDescriptor<'_>) -> GpuBindGroup

Create a bind group.

fn create_sampler(&self, desc: &SamplerDescriptor<'_>) -> GpuSampler

Create a texture sampler.