Struct Renderer 

pub struct Renderer {
    pub window: Arc<Window>,
    pub post_process: PostProcessStack,
    /* private fields */
}

Fields

window: Arc<Window>

post_process: PostProcessStack

Post-processing stack for “juice” effects.

Implementations

impl Renderer

pub async fn new( window: Arc<Window>, png_bytes: &[u8], tile_w: u32, tile_h: u32, use_scanlines: bool, ) -> Self

pub fn load_sprite_folder(&mut self, path: &str, tile_w: u32, tile_h: u32)

Load all .png files from path (recursively) into the sprite atlas.

pub fn get_sprite_data(&self, name: &str) -> Option<SpriteData>

Returns the metadata (UVs, spans) for a named sprite if it exists.

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

pub fn update_camera(&mut self, uniform: &CameraUniform)

Upload a new camera view-projection matrix to the GPU.

pub fn update_entity_offsets(&mut self, offsets: &[[f32; 4]])

Upload an array of [f32; 4] offsets for entity animation.

pub fn surface_format(&self) -> TextureFormat

pub fn set_mtsdf_distance_range(&mut self, range: f32)

Update the MTSDF distance range used by the text shader.

Call this once after registering a font via TextLayer::set_font, passing font.distance_range from the loaded Font. The atlas dimensions are taken from the actual GPU texture and do not need to be supplied again.

Examples found in repository

examples/pathfinding.rs (line 123)

    fn on_enter(&mut self, engine: &mut jEngine) {
        if let Ok(font) = Font::from_mtsdf_json(DEFAULT_FONT_METADATA) {
            engine.renderer.set_mtsdf_distance_range(font.distance_range);
            engine.ui.text.set_font(font);
        }
        
        // Load sound effects
        engine.audio.load_sound("move", "resources/audio/UI_selection.wav");
        engine.audio.load_sound("toggle", "resources/audio/UI_click.wav");
    }

examples/stress_test.rs (line 152)

    fn render(&mut self, engine: &mut jEngine) {
        if !self.font_loaded {
            if let Ok(font) = jengine::renderer::text::Font::from_mtsdf_json(DEFAULT_FONT_METADATA) {
                engine.renderer.set_mtsdf_distance_range(font.distance_range);
                engine.ui.text.set_font(font);
            }
            self.font_loaded = true;
        }

        engine.clear();

        // ── Draw Entities (as small circles for speed) ──
        for (_e, (_m, pos)) in self.world.query_multi::<(EntityMarker, Position)>() {
            engine.draw_particle(pos.x, pos.y, Color([0.4, 0.7, 1.0, 1.0]), 4.0);
        }

        // ── Draw Particles ──
        for (_e, (_l, pos)) in self.world.query_multi::<(Life, Position)>() {
            engine.draw_particle(pos.x, pos.y, Color([1.0, 0.5, 0.2, 0.8]), 2.0);
        }

        // ── Stats UI ──
        let th = engine.tile_height() as f32;
        
        engine.ui.ui_rect(0.0, 0.0, 350.0, th * 8.0, Color([0.0, 0.0, 0.0, 0.7]));
        
        let mut y = 10.0;
        let lines = [
            format!("STRESS TEST - [Space] for Nova"),
            format!("Entities:  {} (Q/W to adj)", self.entity_target_count),
            format!("P-Rate:    {} / frame (A/S to adj)", self.particle_spawn_rate),
            format!("Total ECS: {}", self.world.entity_count()),
            format!("FPS:       {:.1}", 1.0 / engine.dt().max(0.001)),
        ];

        for line in lines {
            engine.ui.ui_text(10.0, y, &line, Color::WHITE, Color::TRANSPARENT, None);
            y += th;
        }
    }

examples/particles.rs (line 266)

    fn render(&mut self, engine: &mut jEngine) {
        if !self.font_loaded {
            if let Ok(font) = jengine::renderer::text::Font::from_mtsdf_json(DEFAULT_FONT_METADATA) {
                engine.renderer.set_mtsdf_distance_range(font.distance_range);
                engine.ui.text.set_font(font);
            }
            self.font_loaded = true;
        }

        engine.clear();

        let sw = engine.renderer.window.inner_size().width as f32;
        let sh = engine.renderer.window.inner_size().height as f32;

        // Set dark navy background using the tile grid (Pass 1)
        // This ensures particles (Pass 3) are drawn ON TOP of the background.
        for y in 0..engine.grid_height() {
            for x in 0..engine.grid_width() {
                engine.set_background(x, y, Color([0.01, 0.01, 0.02, 1.0]));
            }
        }

        // --- Render System ---
        for (_e, (pos, life, p)) in self.world.query_multi::<(Position, Life, Particle)>() {
            let t = (life.current / life.max).clamp(0.0, 1.0);
            
            // Lerp color
            let mut c = [0.0; 4];
            for i in 0..4 {
                c[i] = p.color_end[i] + (p.color_start[i] - p.color_end[i]) * t;
            }
            
            // Lerp size
            let size = p.size_end + (p.size_start - p.size_end) * t;
            
            engine.draw_particle(pos.x, pos.y, Color(c), size);
        }

        // --- UI ---
        let tw = engine.tile_width() as f32;
        let th = engine.tile_height() as f32;
        
        engine.ui.ui_text(tw, th, "PARTICLE SHOWCASE", Color::WHITE, Color::TRANSPARENT, Some(48.0));
        
        let mut y = th * 4.0;
        let help = [
            "MOUSE LCLICK : Spawn Explosion",
            "[S] KEY      : Spawn Slash (at mouse)",
            "[G] KEY      : Spawn Glitch (at mouse)",
            "CONTINUOUS   : Fire & Smoke (bottom)",
            "[ESC]        : Quit demo"
        ];
        
        for line in help {
            engine.ui.ui_text(tw, y, line, Color([0.6, 0.7, 0.7, 1.0]), Color::TRANSPARENT, None);
            y += th * 1.2;
        }

        y += th;
        let pp_help = [
            format!("[1] Scanlines: {}", if self.pp.scanlines { "ON" } else { "OFF" }),
            format!("[2] Vignette:  {}", if self.pp.vignette  { "ON" } else { "OFF" }),
            format!("[3] Chromatic: {}", if self.pp.chromatic { "ON" } else { "OFF" }),
            format!("[4] Bloom:     {}", if self.pp.bloom     { "ON" } else { "OFF" }),
        ];
        for line in pp_help {
            engine.ui.ui_text(tw, y, &line, Color([0.4, 0.9, 0.6, 1.0]), Color::TRANSPARENT, None);
            y += th * 1.2;
        }
        
        let count = self.world.entity_count();
        engine.ui.ui_text(sw - tw * 18.0, sh - th * 2.5, &format!("Active Entities: {}", count), Color::CYAN, Color::TRANSPARENT, Some(20.0));
    }

pub fn render( &mut self, char_verts: &[TileVertex], sprite_verts: &[TileVertex], particle_verts: &[ParticleVertex], ui_verts: &[UIVertex], text_verts: &[TextVertex], text_indices: &[u16], ) -> Result<(), SurfaceError>

Render one frame.

Draw order within the single render pass:

1. char_verts — character tile atlas (bg fills + char glyphs) [camera]
2. sprite_verts — sprite atlas (static and animated sprites) [camera]
3. particle_verts — particle pipeline [camera]
4. ui_verts — UI solid fills (TileVertex, Layer 2) [screen]
5. text_verts — MTSDF text (Labels + ui_char_at) [screen]

Passes 1–3 use the camera bind group (scroll/zoom). Passes 4–5 use the plain projection bind group (screen-fixed).