Struct Pipeline 

pub struct Pipeline {
    pub width: u32,
    pub height: u32,
    pub stats: FrameStats,
    pub svogi: CascadedSvogi,
    pub fog: VolumetricFogPipeline,
    pub raw_window_events: Vec<WindowEvent>,
    /* private fields */
}

The main render pipeline.

Created once by ProofEngine::new() and kept alive for the duration of the game. Owns the window, OpenGL context, shader programs, font atlas, glyph VAO, and the post-processing pipeline.

Fields

width: u32

height: u32

stats: FrameStats

svogi: CascadedSvogi

fog: VolumetricFogPipeline

raw_window_events: Vec<WindowEvent>

Raw winit WindowEvents collected during poll_events, drained by consumers.

Implementations

impl Pipeline

pub fn init(config: &EngineConfig) -> Self

Initialize window, OpenGL 3.3 Core context, shader programs, font atlas, and PostFxPipeline.

pub fn set_density_entities( &mut self, entities: &[GpuDensityEntityData], budget: u32, )

Hand over this frame’s GPU density entities and the particle budget each is drawn with. They are drawn into the scene after the glyph pass, so they bloom and grade with everything else.

pub fn update_render_config(&mut self, config: &RenderConfig)

Update the render config used by the PostFx pipeline this frame. Call from ProofEngine::run() whenever the config changes.

pub fn poll_events(&mut self, input: &mut InputState) -> bool

Poll window events and update InputState. Returns false on quit.

pub fn render(&mut self, scene: &Scene, camera: &ProofCamera)

Collect all visible glyphs + particles from the scene, upload to the GPU, and execute the full multi-pass rendering pipeline.

pub fn render_frame( &mut self, scene: &Scene, camera: &ProofCamera, ui: Option<&UiLayer>, fx: &ScreenFx, )

Render the scene, the UI layer’s world pass, and post-processing.

With ui given, its world-pass commands are painted into the HDR scene buffer after the 3D glyphs and before post-processing, so they bloom, grade and shake with the scene; its HUD-pass commands are built here and painted by render_ui afterwards. fx supplies the frame’s shockwaves, flash and light-shaft source.

pub fn render_ui(&mut self, ui: &UiLayer)

Paint a screen-space UI layer on top of the finished frame.

Runs after post-processing and writes straight to the default framebuffer, so panels and text are not smeared by bloom, chromatic aberration or grain — a HUD has to stay readable.

Call once per frame, after render, before swap.

pub fn swap(&mut self) -> bool

Swap back buffer to screen. Returns false on window close.

pub fn gl(&self) -> &Context

Get a reference to the raw glow OpenGL context. Used by egui-glow to render UI on top of the scene.

pub fn window(&self) -> &Window

Get the window reference (for egui-winit event processing).

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

The framebuffer size the viewport is actually set to.

This is what screen-space passes must project against. On a scaled display it can differ from the window’s logical size, and projecting against the wrong one magnifies the whole UI.

pub fn read_frame(&self) -> (u32, u32, Vec<u8>)

Read the frame that is currently on screen back off the GPU.

Returns (width, height, rgba) with the bottom row first, which is how OpenGL stores it. Call this after everything for the frame has been drawn and before the buffers are swapped, or the read comes back empty.

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

Get the current window size.