pico_rendering/render_pipeline/

_sprite_renderer.rs

use pico_engine_hardware::Display;

/// 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 with aligned memory copy
#[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
/// Strip encoding format: u16 header (low byte = transparent count, high byte = opaque count)
#[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;
                }
            }
        }
    }
}

/// Shift frame buffer for small camera movements
/// 
/// Delta represents camera movement, buffer shifts in opposite direction
/// For example, when camera moves right (delta_x > 0), buffer shifts left
#[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,
                    );
                }
            }
        }
    }
}