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;
use pico_engine_hardware::Display;

use crate::components::_render_component::RendererComponent;
use crate::types::_tile_map::TileMap;

// ============================================================================
// RENDER PIPELINE - OPTIMIZED TILE & SPRITE RENDERER
// ============================================================================
// This renderer uses several optimizations for embedded systems:
// 1. Buffer shifting for small camera movements (avoids full redraws)
// 2. Selective tile redrawing under moving entities
// 3. Strip-encoded sprite format for transparency
// 4. Unsafe pointer operations for maximum performance

const TILE_SIZE: u16 = 16;
const SCREEN_WIDTH_TILES: u16 = 20;  // 320px / 16px
const SCREEN_HEIGHT_TILES: u16 = 15; // 240px / 16px
const MAX_TILEMAP_SIZE: u16 = 30;

/// Render system - manages all rendering operations
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,
        }
    }

    // ========================================================================
    // PUBLIC API
    // ========================================================================

    /// Main render function - orchestrates the entire rendering process
    /// 
    /// Order of operations:
    /// 1. Draw background tilemap
    /// 2. Draw all entities (sprites)
    /// 3. Draw foreground tilemap
    /// 4. Draw debug info (if enabled)
    /// 5. Flush to display
    #[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,
    ) {
        // Layer 1: Background tiles
        self.render_tilemap_layer(
            world,
            position_storage,
            size_storage,
            pivot_storage,
            background_tilemap,
            display,
            true,  // Allow buffer shifting
            false, // Not foreground
        );

        // Layer 2: Entities (sprites)
        self.render_entities(
            world,
            position_storage,
            renderer_storage,
            size_storage,
            pivot_storage,
            display,
        );

        // Layer 3: Foreground tiles
        self.render_tilemap_layer(
            world,
            position_storage,
            size_storage,
            pivot_storage,
            foreground_tilemap,
            display,
            false, // Don't shift again (background already shifted)
            true,  // Is foreground
        );

        // Update camera tracking
        self.prev_cam_x = world.camera.x;
        self.prev_cam_y = world.camera.y;
        self.first_frame = false;

        // Debug overlay
        #[cfg(feature = "is_debug")]
        {
            // Note: delta_time not available in current signature
            // draw_fps(display, fps);
        }

        // Flush frame buffer to display
        display.display_buffer();
    }

    // ========================================================================
    // ENTITY RENDERING
    // ========================================================================

    /// Renders all visible entities (sprites)
    #[inline]
    fn render_entities(
        &self,
        world: &World,
        position_storage: &ComponentStorage<Position>,
        renderer_storage: &ComponentStorage<RendererComponent>,
        size_storage: &ComponentStorage<Size>,
        pivot_storage: &ComponentStorage<Pivot>,
        display: &mut impl Display,
    ) {
        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;

            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,
            );
        }
    }

    // ========================================================================
    // TILEMAP RENDERING
    // ========================================================================

    /// Renders a complete tilemap layer with optimizations
    /// 
    /// Optimization strategies:
    /// - Static camera: Only redraw tiles under moving entities
    /// - Small movement (<= 2 pixels): Shift buffer and draw edge tiles
    /// - Large movement: Full redraw of visible area
    #[inline(never)]
    fn render_tilemap_layer(
        &mut self,
        world: &World,
        position_storage: &ComponentStorage<Position>,
        size_storage: &ComponentStorage<Size>,
        pivot_storage: &ComponentStorage<Pivot>,
        tilemap: &'static TileMap,
        display: &mut impl Display,
        allow_buffer_shift: bool,
        is_foreground: bool,
    ) {
        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;

        // Strategy 1: Camera not moving - minimal redraw
        if delta_x == 0 && delta_y == 0 && !self.first_frame {
            self.redraw_tiles_under_entities(
                world,
                position_storage,
                size_storage,
                pivot_storage,
                tilemap,
                display,
                cam_x,
                cam_y,
                is_foreground,
            );
            return;
        }

        // Strategy 2: Small camera movement - optimize with buffer shift
        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);
            
            self.redraw_edge_tiles_after_shift(
                world,
                tilemap,
                display,
                cam_x,
                cam_y,
                delta_x,
                delta_y,
                is_foreground,
            );
            
            // Also redraw tiles under entities
            self.redraw_tiles_under_entities(
                world,
                position_storage,
                size_storage,
                pivot_storage,
                tilemap,
                display,
                cam_x,
                cam_y,
                is_foreground,
            );
            return;
        }

        // Strategy 3: Large movement or first frame - full redraw
        self.redraw_visible_tilemap(tilemap, display, cam_x, cam_y, is_foreground);
    }

    /// Redraws only tiles that are underneath moving entities
    /// This prevents sprite trails when entities move but camera doesn't
    #[inline(never)]
    fn redraw_tiles_under_entities(
        &self,
        world: &World,
        position_storage: &ComponentStorage<Position>,
        size_storage: &ComponentStorage<Size>,
        pivot_storage: &ComponentStorage<Pivot>,
        tilemap: &'static TileMap,
        display: &mut impl Display,
        cam_x: u16,
        cam_y: u16,
        is_foreground: bool,
    ) {
        for (_entity, transform, size, pivot) in
            world.query3(position_storage, size_storage, pivot_storage)
        {
            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;

            // Calculate tile range overlapping with entity
            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, MAX_TILEMAP_SIZE);
            let tile_end_y = min(
                (entity_bottom + if is_foreground { TILE_SIZE } else { 0 } + TILE_SIZE - 1) / TILE_SIZE,
                MAX_TILEMAP_SIZE,
            );

            // Redraw affected tiles
            for ty in tile_start_y..tile_end_y {
                for tx in tile_start_x..tile_end_x {
                    self.draw_tile_at(
                        tx, ty,
                        cam_x as i16,
                        cam_y as i16,
                        tilemap,
                        display,
                        is_foreground,
                    );
                }
            }
        }
    }

    /// Redraws edge tiles after buffer shift
    /// When the buffer is shifted, edge tiles need to be redrawn to fill gaps
    #[inline(never)]
    fn redraw_edge_tiles_after_shift(
        &self,
        _world: &World,
        tilemap: &'static TileMap,
        display: &mut impl Display,
        cam_x: u16,
        cam_y: u16,
        delta_x: i16,
        delta_y: i16,
        is_foreground: bool,
    ) {
        let start_x = cam_x / TILE_SIZE;
        let start_y = cam_y / TILE_SIZE;
        let end_x = min((cam_x + 320) / TILE_SIZE + 1, MAX_TILEMAP_SIZE);
        let end_y = min((cam_y + 240) / TILE_SIZE + 1, MAX_TILEMAP_SIZE);

        // Redraw horizontal edges (left/right)
        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_at(end_x - 1, y, cam_x as i16, cam_y as i16, tilemap, display, is_foreground);
                }
                if end_x > 1 {
                    self.draw_tile_at(end_x - 2, y, cam_x as i16, cam_y as i16, tilemap, display, 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_at(start_x, y, cam_x as i16, cam_y as i16, tilemap, display, is_foreground);
                if start_x + 1 < MAX_TILEMAP_SIZE {
                    self.draw_tile_at(start_x + 1, y, cam_x as i16, cam_y as i16, tilemap, display, is_foreground);
                }
            }
        }

        // Redraw vertical edges (top/bottom)
        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_at(x, end_y - 1, cam_x as i16, cam_y as i16, tilemap, display, is_foreground);
                }
                if end_y > 1 {
                    self.draw_tile_at(x, end_y - 2, cam_x as i16, cam_y as i16, tilemap, display, 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_at(x, start_y, cam_x as i16, cam_y as i16, tilemap, display, is_foreground);
                if start_y + 1 < MAX_TILEMAP_SIZE {
                    self.draw_tile_at(x, start_y + 1, cam_x as i16, cam_y as i16, tilemap, display, is_foreground);
                }
            }
        }
    }

    /// Full redraw of all visible tiles
    /// Used for large camera movements or first frame
    #[inline(never)]
    fn redraw_visible_tilemap(
        &self,
        tilemap: &'static TileMap,
        display: &mut impl Display,
        cam_x: u16,
        cam_y: u16,
        is_foreground: bool,
    ) {
        let start_x = cam_x / TILE_SIZE;
        let start_y = cam_y / TILE_SIZE;
        let end_x = min(start_x + SCREEN_WIDTH_TILES + 1, MAX_TILEMAP_SIZE);
        let end_y = min(start_y + SCREEN_HEIGHT_TILES + 2, MAX_TILEMAP_SIZE);

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

    /// Draws a single tile at the given grid position
    /// 
    /// This function:
    /// 1. Looks up the cell in the 2D array
    /// 2. Gets all tiles for that cell
    /// 3. Draws each tile sprite
    #[inline]
    fn draw_tile_at(
        &self,
        x: u16,
        y: u16,
        cam_x: i16,
        cam_y: i16,
        tilemap: &'static TileMap,
        display: &mut impl Display,
        is_foreground: bool,
    ) {
        // Bounds check
        if x >= tilemap.width || y >= tilemap.height {
            return;
        }

        // Access 2D array: cells[x][y]
        let cell = &tilemap.cells[x as usize][y as usize];
        let cell_tiles = &tilemap.tiles[cell.start..cell.end];

        // Draw all tiles in this cell
        for tile in cell_tiles {
            let sprite = tile.sprite;
            
            // Calculate screen position
            // For foreground, adjust Y by -16 to compensate for data generation coordinate inversion
            let pos_x = (x * TILE_SIZE) as i16 - cam_x;
            let pos_y = (y * TILE_SIZE) as i16 - cam_y - if is_foreground { 16 } else { 0 };

            draw_sprite(
                display,
                &tilemap.texture[sprite.data_start..sprite.data_end],
                pos_x,
                pos_y,
                TILE_SIZE as usize,
                TILE_SIZE as usize,
                sprite.is_opaque,
            );
        }
    }
}

// ============================================================================
// LEGACY WRAPPER FUNCTIONS (Deprecated)
// ============================================================================



// ============================================================================
// SPRITE RENDERING UTILITIES
// ============================================================================

/// Draw sprite into frame buffer
/// Dispatches to optimized rendering path based on sprite type
#[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,
                    );
                }
            }
        }
    }
}