Struct K3dengine 

pub struct K3dengine {
    pub camera: Camera,
    /* private fields */
}

Fields

camera: Camera

Implementations

impl K3dengine

pub fn record_bsp<const MAX: usize>( &self, world: &BspWorld<'_>, scratch: &mut BspScratch<'_>, commands: &mut CommandBuffer<MAX>, telemetry: Option<&mut BspTelemetry>, ) -> Result<(), RenderError>

Record BSP world geometry into a command buffer for later execution.

Produces DrawPrimitive::TexturedTriangleWithDepth commands for faces without lightmaps and DrawPrimitive::LightmappedTriangle for faces with face.lightmap_id != 0xFFFF.

Execute the resulting buffer with K3dengine::execute_bsp_textured.

pub fn record_bsp_with_sector_lights<const MAX: usize>( &self, world: &BspWorld<'_>, scratch: &mut BspScratch<'_>, commands: &mut CommandBuffer<MAX>, sector_lights: Option<&[SectorLight]>, time_seconds: f32, telemetry: Option<&mut BspTelemetry>, ) -> Result<(), RenderError>

Record BSP geometry while applying optional animated sector lights.

pub fn execute_bsp_textured<D, const MAX: usize, const N: usize>( &self, fb: &mut D, frame: &mut FrameCtx<'_>, commands: &CommandBuffer<MAX>, texture_manager: &TextureManager<N>, telemetry: Option<&mut ExecuteTelemetry>, ) -> Result<Option<DirtyRegion>, RenderError>

where D: DrawTarget<Color = Rgb565> + OriginDimensions, D::Error: Debug,

Execute a BSP command buffer with texture support.

Handles both DrawPrimitive::TexturedTriangleWithDepth and DrawPrimitive::LightmappedTriangle using texture_manager.

pub fn render_bsp_direct<D, const N: usize>( &self, world: &BspWorld<'_>, scratch: &mut BspScratch<'_>, texture_manager: &TextureManager<N>, fb: &mut D, frame: &mut FrameCtx<'_>, telemetry: Option<&mut BspTelemetry>, ) -> Result<(), RenderError>

where D: DrawTarget<Color = Rgb565> + OriginDimensions, D::Error: Debug,

One-shot BSP render: traverse + rasterize without an intermediate command buffer.

Lower overhead than record+execute for world geometry that must be re-traversed every frame (camera always moves).

pub fn render_bsp_coverage<D, const N: usize>( &self, world: &BspWorld<'_>, scratch: &mut BspScratch<'_>, texture_manager: &TextureManager<N>, fb: &mut D, coverage: &mut CoverageBuffer<'_>, telemetry: Option<&mut BspTelemetry>, ) -> Result<(), RenderError>

where D: DrawTarget<Color = Rgb565> + OriginDimensions, D::Error: Debug,

M5: One-shot BSP render using a coverage bitmap instead of a z-buffer.

Requires frame was created with a valid zbuffer (the zbuffer is not used for depth testing — the coverage buffer takes its role). The zbuffer slice is only needed to satisfy the FrameCtx API; pass a zero-length slice and skip frame.validate() if RAM is tight, or supply a 1-element dummy.

Front-to-back traversal guarantees correctness without depth testing.

impl K3dengine

pub fn render_painters_algorithm<'a, MS, F>( &self, meshes: MS, triangles: &mut Vec<DepthSortedTriangle>, callback: F, ) -> usize

where MS: IntoIterator<Item = &'a K3dMesh<'a>>, F: FnMut(DrawPrimitive),

Render using Painter’s Algorithm (back-to-front sorting, no Z-buffer)

Collects all triangles, sorts them by depth, and renders back-to-front. This eliminates the need for a Z-buffer, saving significant memory.

Arguments

• meshes - Iterator of meshes to render
• triangles - Buffer to store sorted triangles (must be large enough!)
• callback - Drawing callback for each primitive

Returns

Number of triangles rendered

impl K3dengine

pub fn new(width: u16, height: u16) -> K3dengine

pub fn set_fog(&mut self, fog: FogConfig)

Enable depth-based fog for subsequent execute calls.

pub fn clear_fog(&mut self)

Disable fog (default state).

pub fn set_dither(&mut self, dither: DitherConfig)

Enable ordered dithering for subsequent execute passes.

pub fn clear_dither(&mut self)

Disable ordered dithering.

pub fn set_vertex_snap_bits(&mut self, bits: u8)

Set NDC vertex snap precision. 0 disables snapping.

pub fn set_texture_mapping(&mut self, mapping: TextureMapping)

Select texture interpolation mode.

pub fn set_light_levels(&mut self, levels: LightLevels)

Select sector light quantization model.

pub fn set_stipple_mode(&mut self, mode: StippleMode)

Set stipple mode used by textured/lightmapped raster paths.

pub fn set_screen_tint(&mut self, tint: ScreenTint)

Set an optional full-screen tint.

pub fn clear_screen_tint(&mut self)

Disable full-screen tint.

pub fn set_palette_mode(&mut self, mode: PaletteMode)

Set output palette quantization mode.

pub fn set_sky(&mut self, sky: SkyConfig)

Set procedural sky rendering parameters.

pub fn clear_sky(&mut self)

Disable procedural sky rendering.

pub fn apply_retro_style(&mut self, style: RetroStyle)

Apply a coarse retro visual preset.

pub fn add_point_light(&mut self, light: PointLight) -> bool

Add a dynamic point light. Returns false when the 16-light limit is reached.

pub fn clear_point_lights(&mut self)

Remove all dynamic point lights.

pub fn set_caps(&mut self, caps: ProfileCaps)

pub fn clear_caps(&mut self)

pub fn set_quality_tier(&mut self, tier: QualityTier)

pub fn set_material_profile(&mut self, profile: MaterialProfile)

pub fn apply_render_defaults(&mut self, defaults: RenderDefaults)

pub fn transform_points<const N: usize>( &self, indices: &[usize; N], vertices: &[[f32; 3]], model_matrix: Matrix4<f32>, ) -> Option<[Point3<i32>; N]>

pub fn transform_points_with_w<const N: usize>( &self, indices: &[usize; N], vertices: &[[f32; 3]], model_matrix: Matrix4<f32>, ) -> Option<([Point3<i32>; N], [f32; N])>

Like transform_points but also returns clip-space W values for perspective-correct UV.

pub fn record<'a, MS, const MAX: usize>( &self, meshes: MS, commands: &mut CommandBuffer<MAX>, telemetry: Option<&mut RecordTelemetry>, ) -> Result<(), RenderError>

where MS: IntoIterator<Item = &'a K3dMesh<'a>>,

pub fn record_with_fallback<'a, MS, FS, const MAX: usize>( &self, primary: MS, fallback: FS, commands: &mut CommandBuffer<MAX>, telemetry: Option<&mut RecordTelemetry>, ) -> Result<BudgetFallbackOutcome, RenderError>

where MS: IntoIterator<Item = &'a K3dMesh<'a>>, FS: IntoIterator<Item = &'a K3dMesh<'a>>,

pub fn record_with_degradation<'a, const MAX: usize>( &mut self, meshes: &[&'a K3dMesh<'a>], commands: &mut CommandBuffer<MAX>, policy: DegradationPolicy<'_>, telemetry: Option<&mut RecordTelemetry>, ) -> Result<DegradationOutcome, RenderError>

pub fn execute<D, const MAX: usize>( &self, fb: &mut D, frame: &mut FrameCtx<'_>, commands: &CommandBuffer<MAX>, telemetry: Option<&mut ExecuteTelemetry>, ) -> Result<Option<DirtyRegion>, RenderError>

where D: DrawTarget<Color = Rgb565> + OriginDimensions, <D as DrawTarget>::Error: Debug,

pub fn execute_with_textures<D, const MAX: usize, const N: usize>( &self, fb: &mut D, frame: &mut FrameCtx<'_>, commands: &CommandBuffer<MAX>, texture_manager: &TextureManager<N>, telemetry: Option<&mut ExecuteTelemetry>, ) -> Result<Option<DirtyRegion>, RenderError>

where D: DrawTarget<Color = Rgb565> + OriginDimensions, <D as DrawTarget>::Error: Debug,

Like Self::execute, but resolves RenderMode::Textured meshes’ DrawPrimitive::TexturedTriangleWithDepth/LightmappedTriangle primitives via texture_manager instead of silently dropping them.

record() doesn’t need a texture manager (it only transforms geometry into primitives, it doesn’t sample pixels), so a scene mixing textured and flat-colored/lit meshes still goes through one record() call – only execute() needs to change to execute_with_textures() once any mesh in the batch uses RenderMode::Textured.

pub fn execute_tiled<D, const MAX: usize, const BIN_CAP: usize>( &self, fb: &mut D, frame: &mut FrameCtx<'_>, commands: &CommandBuffer<MAX>, tile: TileConfig, ) -> Result<TileBinStats, RenderError>

where D: DrawTarget<Color = Rgb565> + OriginDimensions, <D as DrawTarget>::Error: Debug,