pico_rendering/

_render_pipeline.rs

use core::cmp::min;
use pico_ecs::_component_storage::ComponentStorage;
use pico_ecs::_world::World;
use pico_transform::_pivot::Pivot;
use pico_transform::_position::Position;
use pico_transform::_size::Size;

// ============================================================================
// STRIP-BASED RENDERER SYSTEM
// ============================================================================
// Renders in horizontal strips to manage memory constraints
use pico_engine_hardware::Display;

use crate::components::_render_component::RendererComponent;
use crate::types::_cell::Cell;
use crate::types::_tile::Tile;
use crate::types::_tile_map::TileMap;

/// Render system - draws all entities
pub struct RenderPipeline {
    prev_cam_x: u16,
    prev_cam_y: u16,
    first_frame: bool,
}

impl RenderPipeline {
    pub fn new() -> Self {
        Self {
            prev_cam_x: 0,
            prev_cam_y: 0,
            first_frame: true,
        }
    }

    /// Run the render system - renders full screen
    #[inline]
    pub fn render_direct(
        &mut self,
        world: &World,
        position_storage: &ComponentStorage<Position>,
        renderer_storage: &ComponentStorage<RendererComponent>,
        size_storage: &ComponentStorage<Size>,
        pivot_storage: &ComponentStorage<Pivot>,
        background_tilemap: &'static TileMap,
        foreground_tilemap: &'static TileMap,
        display: &mut impl Display,
    ) {
        // Draw background tiles first
        self.draw_background(
            world,
            position_storage,
            size_storage,
            pivot_storage,
            background_tilemap,
            display,
        );

        // Then render entities
        for (_entity, transform, renderer, size, pivot) in world.query4(
            position_storage,
            renderer_storage,
            size_storage,
            pivot_storage,
        ) {
            // Calculate sprite screen position (accounting for pivot and camera)
            let sprite_x = transform.x as i16 - pivot.x as i16 - world.camera.x as i16;
            let sprite_y = transform.y as i16 - pivot.y as i16 - world.camera.y as i16;

            // Inline sprite drawing to avoid function call overhead
            draw_sprite(
                display,
                &renderer.texture[renderer.sprite.data_start..renderer.sprite.data_end],
                sprite_x,
                sprite_y,
                size.width as usize,
                size.height as usize,
                renderer.sprite.is_opaque,
            );
        }

        // Finally draw foreground tiles (above entities)
        self.draw_foreground(
            world,
            position_storage,
            size_storage,
            pivot_storage,
            foreground_tilemap,
            display,
        );

        // Update camera tracking after all layers are drawn
        self.prev_cam_x = world.camera.x;
        self.prev_cam_y = world.camera.y;
        self.first_frame = false;

        #[cfg(feature = "is_debug")]
        {
            let mut fps = 0;
            if delta_time > 0 {
                fps = 1000 / delta_time;
            }
            // Draw FPS counter on top
            draw_fps(display, fps);
        }
        // Flush to display
        display.display_buffer();
    }

    // Optimized background rendering with buffer shifting for small camera movements
    #[inline(never)]
    fn draw_background(
        &mut self,
        world: &World,
        position_storage: &ComponentStorage<Position>,
        size_storage: &ComponentStorage<Size>,
        pivot_storage: &ComponentStorage<Pivot>,
        tilemap: &'static TileMap,
        display: &mut impl Display,
    ) {
        self.draw_tilemap(
            world,
            position_storage,
            size_storage,
            pivot_storage,
            display,
            tilemap,
            true,  // Allow buffer shifting for background layer
            false, // Background has no offset
        );
    }

    // Optimized foreground rendering with buffer shifting for small camera movements
    #[inline(never)]
    fn draw_foreground(
        &mut self,
        world: &World,
        position_storage: &ComponentStorage<Position>,
        size_storage: &ComponentStorage<Size>,
        pivot_storage: &ComponentStorage<Pivot>,
        tilemap: &'static TileMap,
        display: &mut impl Display,
    ) {
        self.draw_tilemap(
            world,
            position_storage,
            size_storage,
            pivot_storage,
            display,
            tilemap,
            false, // Don't shift buffer for foreground (already shifted by background)
            true,  // Foreground has -32 pixel offset
        );
    }

    // Generic tilemap rendering with buffer shifting for small camera movements
    #[inline(never)]
    fn draw_tilemap(
        &mut self,
        world: &World,
        position_storage: &ComponentStorage<Position>,
        size_storage: &ComponentStorage<Size>,
        pivot_storage: &ComponentStorage<Pivot>,
        display: &mut impl Display,
        tilemap: &'static TileMap,
        allow_buffer_shift: bool,
        is_foreground: bool,
    ) {
        const TILE_SIZE: u16 = 16;
        const HORIZONTAL_TILES: u16 = 20;
        const VERTICAL_TILES: u16 = 15;

        let cam_x = world.camera.x;
        let cam_y = world.camera.y;
        let delta_x = cam_x as i16 - self.prev_cam_x as i16;
        let delta_y = cam_y as i16 - self.prev_cam_y as i16;

        // Camera not moving: only redraw tiles under entities
        if delta_x == 0 && delta_y == 0 && !self.first_frame {
            // Redraw tiles that intersect with entities to clear trails from movement
            for (_entity, transform, size, pivot) in
                world.query3(position_storage, size_storage, pivot_storage)
            {
                // Calculate entity bounding box in world coordinates
                let entity_left = transform.x - pivot.x as u16;
                let entity_top = transform.y - pivot.y as u16;
                let entity_right = entity_left + size.width;
                let entity_bottom = entity_top + size.height;

                // Find tiles whose rendered area overlaps with entity
                // Foreground tiles render from (y*16-16) to (y*16), so adjust calculation
                let tile_start_x = entity_left / TILE_SIZE;
                let tile_start_y = if is_foreground {
                    if entity_top >= TILE_SIZE {
                        (entity_top + TILE_SIZE - 1) / TILE_SIZE
                    } else {
                        0
                    }
                } else {
                    entity_top / TILE_SIZE
                };
                let tile_end_x = min((entity_right + TILE_SIZE - 1) / TILE_SIZE, 30);
                let tile_end_y = min(
                    (entity_bottom + if is_foreground { TILE_SIZE } else { 0 } + TILE_SIZE - 1)
                        / TILE_SIZE,
                    30,
                );

                // Redraw overlapping tiles
                for ty in tile_start_y..tile_end_y {
                    for tx in tile_start_x..tile_end_x {
                        self.draw_tile_column(
                            tx,
                            ty,
                            cam_x as i16,
                            cam_y as i16,
                            display,
                            tilemap.cells,
                            tilemap.tiles,
                            tilemap.texture,
                            is_foreground,
                        );
                    }
                }
            }
            return;
        }

        // Small scroll optimization: shift buffer and only draw new tiles
        if allow_buffer_shift
            && delta_x.abs() <= 2
            && delta_y.abs() <= 2
            && (delta_x != 0 || delta_y != 0)
        {
            shift_buffer(display, delta_x, delta_y);

            // Calculate visible tile range - tiles that overlap with the screen
            // Account for camera offset within tiles by expanding range by 1 in each direction
            let start_x = cam_x / TILE_SIZE;
            let start_y = cam_y / TILE_SIZE;
            let end_x = min((cam_x + 320) / TILE_SIZE + 1, 30);
            let end_y = min((cam_y + 240) / TILE_SIZE + 1, 30);

            // Always redraw edge tiles after shifting to fill gaps from sub-tile positioning
            if delta_x > 0 {
                // Camera moved right -> redraw RIGHT edge (2 columns)
                for y in start_y..end_y {
                    if end_x > 0 {
                        self.draw_tile_column(
                            end_x - 1,
                            y,
                            cam_x as i16,
                            cam_y as i16,
                            display,
                            tilemap.cells,
                            tilemap.tiles,
                            tilemap.texture,
                            is_foreground,
                        );
                    }
                    if end_x > 1 {
                        self.draw_tile_column(
                            end_x - 2,
                            y,
                            cam_x as i16,
                            cam_y as i16,
                            display,
                            tilemap.cells,
                            tilemap.tiles,
                            tilemap.texture,
                            is_foreground,
                        );
                    }
                }
            } else if delta_x < 0 {
                // Camera moved left -> redraw LEFT edge (2 columns)
                for y in start_y..end_y {
                    self.draw_tile_column(
                        start_x,
                        y,
                        cam_x as i16,
                        cam_y as i16,
                        display,
                        tilemap.cells,
                        tilemap.tiles,
                        tilemap.texture,
                        is_foreground,
                    );
                    if start_x + 1 < 30 {
                        self.draw_tile_column(
                            start_x + 1,
                            y,
                            cam_x as i16,
                            cam_y as i16,
                            display,
                            tilemap.cells,
                            tilemap.tiles,
                            tilemap.texture,
                            is_foreground,
                        );
                    }
                }
            }

            // Always redraw edge tiles after shifting
            if delta_y > 0 {
                // Camera moved down -> redraw BOTTOM edge (2 rows)
                for x in start_x..end_x {
                    if end_y > 0 {
                        self.draw_tile_column(
                            x,
                            end_y - 1,
                            cam_x as i16,
                            cam_y as i16,
                            display,
                            tilemap.cells,
                            tilemap.tiles,
                            tilemap.texture,
                            is_foreground,
                        );
                    }
                    if end_y > 1 {
                        self.draw_tile_column(
                            x,
                            end_y - 2,
                            cam_x as i16,
                            cam_y as i16,
                            display,
                            tilemap.cells,
                            tilemap.tiles,
                            tilemap.texture,
                            is_foreground,
                        );
                    }
                }
            } else if delta_y < 0 {
                // Camera moved up -> redraw TOP edge (2 rows)
                for x in start_x..end_x {
                    self.draw_tile_column(
                        x,
                        start_y,
                        cam_x as i16,
                        cam_y as i16,
                        display,
                        tilemap.cells,
                        tilemap.tiles,
                        tilemap.texture,
                        is_foreground,
                    );
                    if start_y + 1 < 30 {
                        self.draw_tile_column(
                            x,
                            start_y + 1,
                            cam_x as i16,
                            cam_y as i16,
                            display,
                            tilemap.cells,
                            tilemap.tiles,
                            tilemap.texture,
                            is_foreground,
                        );
                    }
                }
            }

            // Redraw tiles that intersect with entities to clear trails
            for (_entity, transform, size, pivot) in
                world.query3(position_storage, size_storage, pivot_storage)
            {
                // Calculate entity bounding box in world coordinates
                let entity_left = transform.x - pivot.x as u16;
                let entity_top = transform.y - pivot.y as u16;
                let entity_right = entity_left + size.width;
                let entity_bottom = entity_top + size.height;

                // Find tiles whose rendered area overlaps with entity
                // Foreground tiles render from (y*16-16) to (y*16), so adjust calculation
                let tile_start_x = entity_left / TILE_SIZE;
                let tile_start_y = if is_foreground {
                    if entity_top >= TILE_SIZE {
                        (entity_top + TILE_SIZE - 1) / TILE_SIZE
                    } else {
                        0
                    }
                } else {
                    entity_top / TILE_SIZE
                };
                let tile_end_x = min((entity_right + TILE_SIZE - 1) / TILE_SIZE, 30);
                let tile_end_y = min(
                    (entity_bottom + if is_foreground { TILE_SIZE } else { 0 } + TILE_SIZE - 1)
                        / TILE_SIZE,
                    30,
                );

                // Redraw overlapping tiles
                for ty in tile_start_y..tile_end_y {
                    for tx in tile_start_x..tile_end_x {
                        self.draw_tile_column(
                            tx,
                            ty,
                            cam_x as i16,
                            cam_y as i16,
                            display,
                            tilemap.cells,
                            tilemap.tiles,
                            tilemap.texture,
                            is_foreground,
                        );
                    }
                }
            }
        } else {
            // Large movement or first frame - draw everything
            let start_x = cam_x / TILE_SIZE;
            let start_y = cam_y / TILE_SIZE;
            let end_x = min(start_x + HORIZONTAL_TILES + 1, 30);
            let end_y = min(start_y + VERTICAL_TILES + 2, 30);

            for y in start_y..end_y {
                for x in start_x..end_x {
                    self.draw_tile_column(
                        x,
                        y,
                        cam_x as i16,
                        cam_y as i16,
                        display,
                        tilemap.cells,
                        tilemap.tiles,
                        tilemap.texture,
                        is_foreground,
                    );
                }
            }
        }
    }

    #[inline]
    fn draw_tile_column(
        &self,
        x: u16,
        y: u16,
        cam_x: i16,
        cam_y: i16,
        display: &mut impl Display,
        cells: &'static [Cell],
        tiles: &'static [Tile],
        texture: &'static [u16],
        is_foreground: bool,
    ) {
        let cell_idx = (y as usize * 30) + x as usize;
        if cell_idx >= cells.len() {
            return;
        }
        let cell = &cells[cell_idx];
        let cell_tiles = &tiles[cell.start..cell.end];

        for tile in cell_tiles {
            let sprite = tile.sprite;
            // Tiles use grid positioning
            // For foreground, adjust Y by -16 to compensate for data generation coordinate inversion
            let pos_x = (x * 16) as i16 - cam_x;
            let pos_y = (y * 16) as i16 - cam_y - if is_foreground { 16 } else { 0 };

            draw_sprite(
                display,
                &texture[sprite.data_start..sprite.data_end],
                pos_x,
                pos_y,
                16,
                16,
                sprite.is_opaque,
            );
        }
    }
}

// Draw sprite into frame buffer
#[inline]
pub fn draw_sprite(
    display: &mut impl Display,
    data: &[u16],
    x: i16,
    y: i16,
    width: usize,
    height: usize,
    is_opaque: bool,
) {
    // Early exit for completely off-screen sprites
    if x >= display.get_screen_width() as i16
        || y >= display.get_screen_height() as i16
        || x + width as i16 <= 0
        || y + height as i16 <= 0
    {
        return;
    }

    if is_opaque {
        draw_sprite_opaque(display, data, x, y, width, height);
    } else {
        draw_sprite_strip_encoded(display, data, x, y, width, height);
    }
}

// Optimized opaque sprite rendering
#[inline]
fn draw_sprite_opaque(
    display: &mut impl Display,
    data: &[u16],
    x: i16,
    y: i16,
    width: usize,
    height: usize,
) {
    // Calculate clipping boundaries once
    let start_y = if y < 0 { -y } else { 0 };
    let end_y = ((y + height as i16).min(display.get_screen_height() as i16) - y).max(0) as usize;
    let start_x = if x < 0 { -x } else { 0 };
    let end_x = ((x + width as i16).min(display.get_screen_width() as i16) - x).max(0) as usize;

    // Fast path: fully visible sprite with aligned copy
    if start_y == 0 && end_y == height && start_x == 0 && end_x == width {
        for row in 0..height {
            let screen_y = (y + row as i16) as usize;
            let dst_start = screen_y * display.get_screen_width() + x as usize;
            let src_start = row * width;
            unsafe {
                core::ptr::copy_nonoverlapping(
                    data.as_ptr().add(src_start),
                    display.frame_buffer().as_mut_ptr().add(dst_start),
                    width,
                );
            }
        }
    } else {
        // Clipped sprite - row by row copy
        for row in start_y as usize..end_y {
            let screen_y = (y + row as i16) as usize;
            let dst_start = screen_y * display.get_screen_width() + (x + start_x) as usize;
            let src_start = row * width + start_x as usize;
            let copy_len = end_x - start_x as usize;

            unsafe {
                core::ptr::copy_nonoverlapping(
                    data.as_ptr().add(src_start),
                    display.frame_buffer().as_mut_ptr().add(dst_start),
                    copy_len,
                );
            }
        }
    }
}

// Optimized strip-encoded sprite decoder with memcpy for contiguous runs
#[inline(never)]
fn draw_sprite_strip_encoded(
    display: &mut impl Display,
    data: &[u16],
    x: i16,
    y: i16,
    width: usize,
    height: usize,
) {
    let mut data_idx = 0;
    let mut row = 0;
    let mut col = 0;
    let data_len = data.len();
    let fb_ptr = display.frame_buffer().as_mut_ptr();
    let data_ptr = data.as_ptr();

    unsafe {
        while data_idx < data_len {
            // Read strip header
            let header = *data_ptr.add(data_idx);
            data_idx += 1;

            let transparent_count = (header & 0xFF) as usize;
            let opaque_count = ((header >> 8) & 0xFF) as usize;

            // Skip transparent pixels - update row/col without division
            let mut skip = transparent_count;
            while skip > 0 {
                let available = width - col;
                if skip >= available {
                    skip -= available;
                    col = 0;
                    row += 1;
                    if row >= height {
                        return;
                    }
                } else {
                    col += skip;
                    break;
                }
            }

            // Process opaque pixels in row-aligned batches
            let mut remaining = opaque_count;

            while remaining > 0 && row < height {
                let pixels_in_row = width - col;
                let batch_size = remaining.min(pixels_in_row);

                let screen_x = x + col as i16;
                let screen_y = y + row as i16;

                // Check if entire batch is on screen
                if screen_y >= 0
                    && screen_y < display.get_screen_height() as i16
                    && screen_x >= 0
                    && screen_x + batch_size as i16 <= display.get_screen_width() as i16
                {
                    // Fast path: memcpy entire batch
                    let fb_idx = screen_y as usize * display.get_screen_width() + screen_x as usize;
                    core::ptr::copy_nonoverlapping(
                        data_ptr.add(data_idx),
                        fb_ptr.add(fb_idx),
                        batch_size,
                    );
                } else if screen_y >= 0 && screen_y < display.get_screen_height() as i16 {
                    // Partial on-screen: per-pixel bounds check
                    for i in 0..batch_size {
                        let px = screen_x + i as i16;
                        if px >= 0 && px < display.get_screen_width() as i16 {
                            let fb_idx =
                                screen_y as usize * display.get_screen_width() + px as usize;
                            *fb_ptr.add(fb_idx) = *data_ptr.add(data_idx + i);
                        }
                    }
                }

                data_idx += batch_size;
                col += batch_size;
                remaining -= batch_size;

                if col >= width {
                    col = 0;
                    row += 1;
                }
            }
        }
    }
}

// Draw FPS counter in top-left corner
pub fn draw_fps(display: &mut impl Display, fps: u32) {
    // Simple 3x5 digit font data (0-9)
    const DIGIT_WIDTH: usize = 4;
    const DIGIT_HEIGHT: usize = 7;
    const DIGITS: [[u8; DIGIT_HEIGHT]; 10] = [
        [0b1110, 0b1010, 0b1010, 0b1010, 0b1010, 0b1010, 0b1110], // 0
        [0b0100, 0b1100, 0b0100, 0b0100, 0b0100, 0b0100, 0b1110], // 1
        [0b1110, 0b0010, 0b0010, 0b1110, 0b1000, 0b1000, 0b1110], // 2
        [0b1110, 0b0010, 0b0010, 0b1110, 0b0010, 0b0010, 0b1110], // 3
        [0b1010, 0b1010, 0b1010, 0b1110, 0b0010, 0b0010, 0b0010], // 4
        [0b1110, 0b1000, 0b1000, 0b1110, 0b0010, 0b0010, 0b1110], // 5
        [0b1110, 0b1000, 0b1000, 0b1110, 0b1010, 0b1010, 0b1110], // 6
        [0b1110, 0b0010, 0b0010, 0b0010, 0b0010, 0b0010, 0b0010], // 7
        [0b1110, 0b1010, 0b1010, 0b1110, 0b1010, 0b1010, 0b1110], // 8
        [0b1110, 0b1010, 0b1010, 0b1110, 0b0010, 0b0010, 0b1110], // 9
    ];

    const FG_COLOR: u16 = 0xFFFF; // White
    const BG_COLOR: u16 = 0x0000; // Black
    const START_X: usize = 4;
    const START_Y: usize = 4;
    const PADDING: usize = 2;

    // Calculate background dimensions
    const BG_WIDTH: usize = 3 * DIGIT_WIDTH + 2 + PADDING * 2; // 3 digits + 2 gaps + padding
    const BG_HEIGHT: usize = DIGIT_HEIGHT + PADDING * 2;

    // Draw dark background
    for y in 0..BG_HEIGHT {
        for x in 0..BG_WIDTH {
            let fb_x = START_X + x;
            let fb_y = START_Y + y;
            if fb_x < display.get_screen_width() && fb_y < display.get_screen_height() {
                let fb_idx = fb_y * display.get_screen_width() + fb_x;
                display.frame_buffer()[fb_idx] = BG_COLOR;
            }
        }
    }

    // Extract digits from FPS value
    let mut digits = [0u8; 3];
    let mut temp = fps.min(999); // Cap at 999
    digits[2] = (temp % 10) as u8;
    temp /= 10;
    digits[1] = (temp % 10) as u8;
    temp /= 10;
    digits[0] = (temp % 10) as u8;

    // Draw each digit
    for (digit_idx, &digit) in digits.iter().enumerate() {
        let x_offset = START_X + PADDING + digit_idx * (DIGIT_WIDTH + 1);

        for y in 0..DIGIT_HEIGHT {
            let row_data = DIGITS[digit as usize][y];
            for x in 0..DIGIT_WIDTH {
                if (row_data >> (DIGIT_WIDTH - 1 - x)) & 1 == 1 {
                    let fb_x = x_offset + x;
                    let fb_y = START_Y + PADDING + y;
                    if fb_x < display.get_screen_width() && fb_y < display.get_screen_height() {
                        let fb_idx = fb_y * display.get_screen_width() + fb_x;
                        display.frame_buffer()[fb_idx] = FG_COLOR;
                    }
                }
            }
        }
    }
}
// Shift frame buffer for small camera movements
// delta represents camera movement, buffer shifts in opposite direction
#[inline(never)]
pub fn shift_buffer(display: &mut impl Display, delta_x: i16, delta_y: i16) {
    if delta_x == 0 && delta_y == 0 {
        return;
    }

    let fb_ptr = display.frame_buffer().as_mut_ptr();

    unsafe {
        if delta_y != 0 {
            // Camera moves down -> buffer shifts up (content moves up on screen)
            // Camera moves up -> buffer shifts down (content moves down on screen)
            let shift_amount = delta_y.abs() as usize;
            if delta_y > 0 {
                // Camera down: shift buffer UP
                for y in 0..(display.get_screen_height() - shift_amount) {
                    let src_idx = (y + shift_amount) * display.get_screen_width();
                    let dst_idx = y * display.get_screen_width();
                    core::ptr::copy(
                        fb_ptr.add(src_idx),
                        fb_ptr.add(dst_idx),
                        display.get_screen_width(),
                    );
                }
            } else {
                // Camera up: shift buffer DOWN
                for y in (shift_amount..display.get_screen_height()).rev() {
                    let src_idx = (y - shift_amount) * display.get_screen_width();
                    let dst_idx = y * display.get_screen_width();
                    core::ptr::copy(
                        fb_ptr.add(src_idx),
                        fb_ptr.add(dst_idx),
                        display.get_screen_width(),
                    );
                }
            }
        }

        if delta_x != 0 {
            // Camera moves right -> buffer shifts left (content moves left on screen)
            // Camera moves left -> buffer shifts right (content moves right on screen)
            let shift_amount = delta_x.abs() as usize;
            if delta_x > 0 {
                // Camera right: shift buffer LEFT
                for y in 0..display.get_screen_height() {
                    let row_start = y * display.get_screen_width();
                    core::ptr::copy(
                        fb_ptr.add(row_start + shift_amount),
                        fb_ptr.add(row_start),
                        display.get_screen_width() - shift_amount,
                    );
                }
            } else {
                // Camera left: shift buffer RIGHT
                for y in 0..display.get_screen_height() {
                    let row_start = y * display.get_screen_width();
                    core::ptr::copy(
                        fb_ptr.add(row_start),
                        fb_ptr.add(row_start + shift_amount),
                        display.get_screen_width() - shift_amount,
                    );
                }
            }
        }
    }
}