Struct MeshRenderer 

pub struct MeshRenderer<'window> {

    pub gpu_context: GpuContext,
    pub surface: Surface<'window>,
    pub surface_config: SurfaceConfiguration,
    pub pbr_pipeline: RenderPipeline,
    pub flat_pipeline: RenderPipeline,
    pub screenshot_pbr_pipeline: RenderPipeline,
    pub screenshot_flat_pipeline: RenderPipeline,
    pub camera_uniform: MeshCameraUniform,
    pub camera_buffer: Buffer,
    pub lighting_params: MeshLightingParams,
    pub lighting_buffer: Buffer,
    pub bind_group_layout: BindGroupLayout,
    pub config: MeshRenderConfig,
    pub msaa_texture: Option<Texture>,
    pub msaa_view: Option<TextureView>,
}

GPU-accelerated mesh renderer with PBR and flat shading

Fields

gpu_context: GpuContext

surface: Surface<'window>

surface_config: SurfaceConfiguration

pbr_pipeline: RenderPipeline

flat_pipeline: RenderPipeline

screenshot_pbr_pipeline: RenderPipeline

Single-sample PBR pipeline used for screenshot capture (no MSAA)

screenshot_flat_pipeline: RenderPipeline

Single-sample flat pipeline used for screenshot capture (no MSAA)

camera_uniform: MeshCameraUniform

camera_buffer: Buffer

lighting_params: MeshLightingParams

lighting_buffer: Buffer

bind_group_layout: BindGroupLayout

config: MeshRenderConfig

msaa_texture: Option<Texture>

msaa_view: Option<TextureView>

Implementations

impl<'window> MeshRenderer<'window>

pub async fn new( window: &'window Window, config: MeshRenderConfig, ) -> Result<Self>

Create new mesh renderer with PBR and flat shading support

pub fn update_camera( &mut self, view_matrix: Matrix4<f32>, proj_matrix: Matrix4<f32>, camera_pos: Vector3<f32>, )

Update camera matrices and position

pub fn update_lighting(&mut self, params: MeshLightingParams)

Update lighting parameters

pub fn resize(&mut self, new_size: PhysicalSize<u32>)

Resize renderer

pub fn create_vertex_buffer(&self, vertices: &[MeshVertex]) -> Buffer

Create vertex buffer

pub fn create_index_buffer(&self, indices: &[u32]) -> Buffer

Create index buffer

pub fn create_depth_texture(&self) -> Texture

Create depth texture

pub fn render(&self, mesh: &GpuMesh, shading_mode: ShadingMode) -> Result<()>

Render mesh with specified shading mode

pub fn render_to_texture( &self, mesh: &GpuMesh, shading_mode: ShadingMode, ) -> Result<(Vec<u8>, TextureFormat, u32, u32)>

Render mesh to an offscreen texture and return raw RGBA pixel bytes.

Returns (pixels, format, width, height). The caller is responsible for interpreting the format (BGRA vs RGBA) when encoding the image.