Struct GraphicsContext 

pub struct GraphicsContext {
    pub instance: Instance,
    pub adapter: Adapter,
    pub device: Device,
    pub queue: Queue,
    /* 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_or_panic(); // 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

Fields

instance: Instance

adapter: Adapter

device: Device

queue: Queue

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

This blocks the current thread until the context is created.

Errors

Returns GraphicsError if:

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

pub fn new_owned_sync_or_panic() -> Arc<Self>

Creates a new graphics context synchronously, panicking on error.

This is a convenience method for tests and examples where error handling is not needed. For production code, prefer new_owned_sync() which returns a Result.

Panics

Panics if graphics context creation fails.

Examples found in repository

examples/window_manager_demo.rs (line 37)

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

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

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

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

            window_colors.insert(window_id, *color);
        }

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

examples/multi_window.rs (line 32)

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

    run_app(|ctx| {
        let graphics_ctx = GraphicsContext::new_owned_sync_or_panic();

        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 {
            context: graphics_ctx,
            windows,
        })
    });
}

examples/performance_benchmark.rs (line 40)

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

    run_app(|ctx| {
        let graphics_ctx = GraphicsContext::new_owned_sync_or_panic();

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

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

    run_app(|ctx| {
        let graphics_ctx = GraphicsContext::new_owned_sync_or_panic();

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

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

    run_app(|ctx| {
        let graphics_ctx = GraphicsContext::new_owned_sync_or_panic();

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

        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/textured_window.rs
• examples/image_blitting.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).

pub fn info(&self) -> AdapterInfo

Get device info

Examples found in repository

examples/renderer_api.rs (line 253)

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

    run_app(|ctx| {
        let graphics_ctx = GraphicsContext::new_owned_sync_or_panic();
        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 {
                    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.

pub fn max_texture_dimension_2d(&self) -> u32

Get the maximum 2D texture dimension.

This is the maximum width and height for 2D textures.

pub fn max_buffer_size(&self) -> u64

Get the maximum buffer size in bytes.

This is the maximum size for any buffer.

pub fn min_uniform_buffer_offset_alignment(&self) -> u32

Get the minimum uniform buffer offset alignment.

When using dynamic uniform buffers, offsets must be aligned to this value.

pub fn min_storage_buffer_offset_alignment(&self) -> u32

Get the minimum storage buffer offset alignment.

When using dynamic storage buffers, offsets must be aligned to this value.

pub fn max_push_constant_size(&self) -> u32

Get the maximum push constant size in bytes.

Push constants require the PUSH_CONSTANTS feature. Returns 0 if push constants are not supported.

pub fn max_texture_dimension_1d(&self) -> u32

Get the maximum 1D texture dimension.

pub fn max_texture_dimension_3d(&self) -> u32

Get the maximum 3D texture dimension.

pub fn max_texture_array_layers(&self) -> u32

Get the maximum texture array layers.

pub fn max_bind_groups(&self) -> u32

Get the maximum bind groups.

pub fn max_bindings_per_bind_group(&self) -> u32

Get the maximum bindings per bind group.

pub fn max_dynamic_uniform_buffers_per_pipeline_layout(&self) -> u32

Get the maximum dynamic uniform buffers per pipeline layout.

pub fn max_dynamic_storage_buffers_per_pipeline_layout(&self) -> u32

Get the maximum dynamic storage buffers per pipeline layout.

pub fn max_sampled_textures_per_shader_stage(&self) -> u32

Get the maximum sampled textures per shader stage.

pub fn max_samplers_per_shader_stage(&self) -> u32

Get the maximum samplers per shader stage.

pub fn max_storage_buffers_per_shader_stage(&self) -> u32

Get the maximum storage buffers per shader stage.

pub fn max_storage_textures_per_shader_stage(&self) -> u32

Get the maximum storage textures per shader stage.

pub fn max_uniform_buffers_per_shader_stage(&self) -> u32

Get the maximum uniform buffers per shader stage.

pub fn max_uniform_buffer_binding_size(&self) -> u32

Get the maximum uniform buffer binding size.

pub fn max_storage_buffer_binding_size(&self) -> u32

Get the maximum storage buffer binding size.

pub fn max_vertex_buffers(&self) -> u32

Get the maximum vertex buffers.

pub fn max_vertex_attributes(&self) -> u32

Get the maximum vertex attributes.

pub fn max_vertex_buffer_array_stride(&self) -> u32

Get the maximum vertex buffer array stride.

pub fn max_compute_workgroup_storage_size(&self) -> u32

Get the maximum compute workgroup storage size.

pub fn max_compute_invocations_per_workgroup(&self) -> u32

Get the maximum compute invocations per workgroup.

pub fn max_compute_workgroup_size_x(&self) -> u32

Get the maximum compute workgroup size X.

pub fn max_compute_workgroup_size_y(&self) -> u32

Get the maximum compute workgroup size Y.

pub fn max_compute_workgroup_size_z(&self) -> u32

Get the maximum compute workgroup size Z.

pub fn max_compute_workgroups_per_dimension(&self) -> u32

Get the maximum compute workgroups per dimension.

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 GraphicsContextExt for GraphicsContext

fn device(&self) -> &Device

Get a reference to the wgpu device.

fn queue(&self) -> &Queue

Get a reference to the wgpu queue.

fn adapter(&self) -> &Adapter

Get a reference to the wgpu adapter.

fn instance(&self) -> &Instance

Get a reference to the wgpu instance.

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.