Struct ForwardPlusLane 

pub struct ForwardPlusLane {
    pub tile_config: ForwardPlusTileConfig,
    pub shader_complexity: ShaderComplexity,
    pub gpu_resources: ForwardPlusGpuResources,
    /* private fields */
}

A rendering lane that implements Forward+ (Tiled Forward) rendering.

Forward+ divides the screen into tiles and uses a compute shader to determine which lights affect each tile before the main render pass. This significantly reduces per-fragment lighting cost for scenes with many lights.

Configuration

The lane is configured via ForwardPlusTileConfig, which controls:

• Tile size: 16x16 or 32x32 pixels (trade-off between culling granularity and overhead)
• Max lights per tile: Memory budget for per-tile light lists
• Depth pre-pass: Optional optimization for depth-bounded light culling

Fields

tile_config: ForwardPlusTileConfig

Tile configuration for light culling.

shader_complexity: ShaderComplexity

Shader complexity for cost estimation.

gpu_resources: ForwardPlusGpuResources

GPU resources for compute and render passes.

Implementations

impl ForwardPlusLane

pub fn new() -> Self

Creates a new ForwardPlusLane with default settings.

Default configuration:

• Tile size: 16x16 pixels
• Max lights per tile: 128
• No depth pre-pass

pub fn with_config(config: ForwardPlusTileConfig) -> Self

Creates a new ForwardPlusLane with the specified configuration.

Arguments

• config - The tile configuration for light culling

pub fn with_complexity(complexity: ShaderComplexity) -> Self

Creates a new ForwardPlusLane with the specified shader complexity.

pub fn set_screen_size(&mut self, width: u32, height: u32)

Updates the screen size used for tile calculations.

This should be called when the window is resized to recalculate tile counts and buffer sizes.

pub fn tile_count(&self) -> (u32, u32)

Calculates the number of tiles in each dimension.

pub fn total_tiles(&self) -> u32

Calculates the total number of tiles on screen.

pub fn effective_light_count(&self, render_world: &RenderWorld) -> usize

Returns the effective number of lights in the scene.

This counts all light types (directional, point, spot) that will be processed by the light culling pass.

Trait Implementations

impl Clone for ForwardPlusLane

fn clone(&self) -> ForwardPlusLane

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ForwardPlusLane

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ForwardPlusLane

fn default() -> Self

Returns the “default value” for a type.

impl RenderLane for ForwardPlusLane

fn strategy_name(&self) -> &'static str

Returns a human-readable identifier for this rendering strategy.

fn get_pipeline_for_material( &self, material_uuid: Option<AssetUUID>, materials: &Assets<Box<dyn Material>>, ) -> RenderPipelineId

Gets the appropriate render pipeline for a given material.

fn render( &self, render_world: &RenderWorld, encoder: &mut dyn CommandEncoder, render_ctx: &RenderContext<'_>, gpu_meshes: &RwLock<Assets<GpuMesh>>, materials: &RwLock<Assets<Box<dyn Material>>>, )

Encodes GPU commands to render the scene into the provided command encoder.

fn estimate_cost( &self, render_world: &RenderWorld, gpu_meshes: &RwLock<Assets<GpuMesh>>, ) -> f32

Estimates the GPU cost of rendering the given RenderWorld with this strategy.