Struct ForwardPlusLane 

pub struct ForwardPlusLane {
    pub tile_config: ForwardPlusTileConfig,
    pub shader_complexity: ShaderComplexity,
    pub gpu_resources: Mutex<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: Mutex<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.

impl ForwardPlusLane

pub fn get_pipeline_for_material( &self, _material: Option<&AssetHandle<Box<dyn Material>>>, ) -> RenderPipelineId

Returns the render pipeline for the given material (or default).

Trait Implementations

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 Lane for ForwardPlusLane

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

Human-readable name identifying this lane’s strategy.

fn lane_kind(&self) -> LaneKind

The kind of processing this lane performs.

fn estimate_cost(&self, ctx: &LaneContext) -> f32

Estimated computational cost of running this lane.

fn on_initialize(&self, ctx: &mut LaneContext) -> Result<(), LaneError>

Called once when the lane is registered or the underlying context resets.

fn execute(&self, ctx: &mut LaneContext) -> Result<(), LaneError>

Main execution entry point — called each frame/tick by the owning agent.

fn on_shutdown(&self, ctx: &mut LaneContext)

Called when the lane is being destroyed or the context is shutting down.

fn as_any(&self) -> &dyn Any

Downcast to a concrete type for type-specific operations.

fn as_any_mut(&mut self) -> &mut dyn Any

Downcast to a concrete type (mutable) for type-specific operations.