pxl8/pxl8d/src/procgen.rs

extern crate alloc;

use alloc::vec;
use alloc::vec::Vec;
use libm::sqrtf;

use crate::bsp::{Bsp, BspVertex, BspEdge, BspFace, BspPlane, BspNode, BspLeaf, BspPortal, BspCellPortals};
use crate::math::Vec3;

pub const CELL_SIZE: f32 = 64.0;
pub const WALL_HEIGHT: f32 = 128.0;
pub const PVS_MAX_DEPTH: u32 = 64;

#[derive(Clone, Copy)]
pub struct LightSource {
    pub position: Vec3,
    pub intensity: f32,
    pub radius: f32,
}

#[derive(Clone, Copy)]
pub struct ProcgenParams {
    pub width: i32,
    pub height: i32,
    pub seed: u32,
    pub min_room_size: i32,
    pub max_room_size: i32,
    pub num_rooms: i32,
}

impl Default for ProcgenParams {
    fn default() -> Self {
        Self {
            width: 16,
            height: 16,
            seed: 12345,
            min_room_size: 3,
            max_room_size: 6,
            num_rooms: 8,
        }
    }
}

struct RoomGrid {
    cells: Vec<u8>,
    width: i32,
    height: i32,
}

impl RoomGrid {
    fn new(width: i32, height: i32) -> Self {
        Self {
            cells: vec![0; (width * height) as usize],
            width,
            height,
        }
    }

    fn get(&self, x: i32, y: i32) -> u8 {
        if x < 0 || x >= self.width || y < 0 || y >= self.height {
            return 1;
        }
        self.cells[(y * self.width + x) as usize]
    }

    fn set(&mut self, x: i32, y: i32, value: u8) {
        if x >= 0 && x < self.width && y >= 0 && y < self.height {
            self.cells[(y * self.width + x) as usize] = value;
        }
    }

    fn fill(&mut self, value: u8) {
        for cell in &mut self.cells {
            *cell = value;
        }
    }
}

struct Rng {
    state: u32,
}

impl Rng {
    fn new(seed: u32) -> Self {
        Self { state: seed }
    }

    fn next(&mut self) -> u32 {
        self.state = self.state.wrapping_mul(1103515245).wrapping_add(12345);
        (self.state >> 16) & 0x7FFF
    }
}

#[derive(Clone, Copy)]
struct Bounds {
    x: i32,
    y: i32,
    w: i32,
    h: i32,
}

impl Bounds {
    fn intersects(&self, other: &Bounds) -> bool {
        !(self.x + self.w <= other.x || other.x + other.w <= self.x ||
          self.y + self.h <= other.y || other.y + other.h <= self.y)
    }
}

struct BspBuildContext<'a> {
    bsp: &'a mut Bsp,
    grid: &'a RoomGrid,
    node_count: u32,
    plane_offset: u32,
}

fn carve_corridor_h(grid: &mut RoomGrid, x1: i32, x2: i32, y: i32) {
    let start = x1.min(x2);
    let end = x1.max(x2);
    for x in start..=end {
        grid.set(x, y, 0);
        grid.set(x, y - 1, 0);
        grid.set(x, y + 1, 0);
    }
}

fn carve_corridor_v(grid: &mut RoomGrid, y1: i32, y2: i32, x: i32) {
    let start = y1.min(y2);
    let end = y1.max(y2);
    for y in start..=end {
        grid.set(x, y, 0);
        grid.set(x - 1, y, 0);
        grid.set(x + 1, y, 0);
    }
}

fn compute_face_aabb(face: &mut BspFace, verts: &[BspVertex], vert_idx: usize) {
    face.aabb_min = Vec3::new(1e30, 1e30, 1e30);
    face.aabb_max = Vec3::new(-1e30, -1e30, -1e30);

    for i in 0..4 {
        let v = verts[vert_idx + i].position;
        if v.x < face.aabb_min.x { face.aabb_min.x = v.x; }
        if v.x > face.aabb_max.x { face.aabb_max.x = v.x; }
        if v.y < face.aabb_min.y { face.aabb_min.y = v.y; }
        if v.y > face.aabb_max.y { face.aabb_max.y = v.y; }
        if v.z < face.aabb_min.z { face.aabb_min.z = v.z; }
        if v.z > face.aabb_max.z { face.aabb_max.z = v.z; }
    }
}

fn build_bsp_node(ctx: &mut BspBuildContext, x0: i32, y0: i32, x1: i32, y1: i32, depth: i32) -> i32 {
    if x1 - x0 == 1 && y1 - y0 == 1 {
        let leaf_idx = y0 * ctx.grid.width + x0;
        return -(leaf_idx + 1);
    }

    let node_idx = ctx.node_count;
    ctx.node_count += 1;

    let plane_idx = ctx.plane_offset;
    ctx.plane_offset += 1;

    if depth % 2 == 0 {
        let mid_x = (x0 + x1) / 2;
        let split_pos = mid_x as f32 * CELL_SIZE;

        ctx.bsp.planes[plane_idx as usize] = BspPlane {
            normal: Vec3::new(1.0, 0.0, 0.0),
            dist: split_pos,
            plane_type: 0,
        };

        let child0 = build_bsp_node(ctx, mid_x, y0, x1, y1, depth + 1);
        let child1 = build_bsp_node(ctx, x0, y0, mid_x, y1, depth + 1);

        ctx.bsp.nodes[node_idx as usize] = BspNode {
            plane_id: plane_idx,
            children: [child0, child1],
            ..Default::default()
        };
    } else {
        let mid_y = (y0 + y1) / 2;
        let split_pos = mid_y as f32 * CELL_SIZE;

        ctx.bsp.planes[plane_idx as usize] = BspPlane {
            normal: Vec3::new(0.0, 0.0, 1.0),
            dist: split_pos,
            plane_type: 0,
        };

        let child0 = build_bsp_node(ctx, x0, mid_y, x1, y1, depth + 1);
        let child1 = build_bsp_node(ctx, x0, y0, x1, mid_y, depth + 1);

        ctx.bsp.nodes[node_idx as usize] = BspNode {
            plane_id: plane_idx,
            children: [child0, child1],
            ..Default::default()
        };
    }

    node_idx as i32
}

fn build_cell_portals(grid: &RoomGrid) -> Vec<BspCellPortals> {
    let total_cells = (grid.width * grid.height) as usize;
    let mut portals = vec![BspCellPortals::default(); total_cells];

    for y in 0..grid.height {
        for x in 0..grid.width {
            if grid.get(x, y) != 0 {
                continue;
            }

            let c = (y * grid.width + x) as usize;
            let cx = x as f32 * CELL_SIZE;
            let cz = y as f32 * CELL_SIZE;

            if x > 0 && grid.get(x - 1, y) == 0 {
                let p = &mut portals[c];
                let idx = p.num_portals as usize;
                p.portals[idx] = BspPortal {
                    x0: cx,
                    z0: cz,
                    x1: cx,
                    z1: cz + CELL_SIZE,
                    target_leaf: (y * grid.width + (x - 1)) as u32,
                };
                p.num_portals += 1;
            }
            if x < grid.width - 1 && grid.get(x + 1, y) == 0 {
                let p = &mut portals[c];
                let idx = p.num_portals as usize;
                p.portals[idx] = BspPortal {
                    x0: cx + CELL_SIZE,
                    z0: cz + CELL_SIZE,
                    x1: cx + CELL_SIZE,
                    z1: cz,
                    target_leaf: (y * grid.width + (x + 1)) as u32,
                };
                p.num_portals += 1;
            }
            if y > 0 && grid.get(x, y - 1) == 0 {
                let p = &mut portals[c];
                let idx = p.num_portals as usize;
                p.portals[idx] = BspPortal {
                    x0: cx + CELL_SIZE,
                    z0: cz,
                    x1: cx,
                    z1: cz,
                    target_leaf: ((y - 1) * grid.width + x) as u32,
                };
                p.num_portals += 1;
            }
            if y < grid.height - 1 && grid.get(x, y + 1) == 0 {
                let p = &mut portals[c];
                let idx = p.num_portals as usize;
                p.portals[idx] = BspPortal {
                    x0: cx,
                    z0: cz + CELL_SIZE,
                    x1: cx + CELL_SIZE,
                    z1: cz + CELL_SIZE,
                    target_leaf: ((y + 1) * grid.width + x) as u32,
                };
                p.num_portals += 1;
            }
        }
    }

    portals
}

#[derive(Clone, Copy)]
struct FloodEntry {
    leaf: u32,
    depth: u32,
}

fn portal_flood_bfs(
    start_leaf: u32,
    portals: &[BspCellPortals],
    leafs: &[BspLeaf],
    pvs: &mut [u8],
    num_leafs: u32,
) {
    let pvs_bytes = ((num_leafs + 7) / 8) as usize;
    let mut visited = vec![0u8; pvs_bytes];
    let mut queue = Vec::with_capacity(num_leafs as usize);

    pvs[(start_leaf >> 3) as usize] |= 1 << (start_leaf & 7);
    visited[(start_leaf >> 3) as usize] |= 1 << (start_leaf & 7);
    queue.push(FloodEntry { leaf: start_leaf, depth: 0 });

    let mut head = 0;
    while head < queue.len() {
        let e = queue[head];
        head += 1;

        if e.depth >= PVS_MAX_DEPTH {
            continue;
        }
        if leafs[e.leaf as usize].contents == -1 {
            continue;
        }

        let cp = &portals[e.leaf as usize];
        for i in 0..cp.num_portals {
            let target = cp.portals[i as usize].target_leaf;
            let byte = (target >> 3) as usize;
            let bit = target & 7;

            if visited[byte] & (1 << bit) != 0 {
                continue;
            }
            visited[byte] |= 1 << bit;

            if leafs[target as usize].contents == -1 {
                continue;
            }

            pvs[byte] |= 1 << bit;
            queue.push(FloodEntry { leaf: target, depth: e.depth + 1 });
        }
    }
}

fn compute_leaf_pvs(
    start_leaf: u32,
    portals: &[BspCellPortals],
    leafs: &[BspLeaf],
    num_leafs: u32,
) -> Vec<u8> {
    let pvs_bytes = ((num_leafs + 7) / 8) as usize;
    let mut pvs = vec![0u8; pvs_bytes];
    portal_flood_bfs(start_leaf, portals, leafs, &mut pvs, num_leafs);
    pvs
}

fn rle_compress_pvs(pvs: &[u8]) -> Vec<u8> {
    let mut out = Vec::new();
    let mut i = 0;

    while i < pvs.len() {
        if pvs[i] != 0 {
            out.push(pvs[i]);
            i += 1;
        } else {
            let mut count = 0u8;
            while i < pvs.len() && pvs[i] == 0 && count < 255 {
                count += 1;
                i += 1;
            }
            out.push(0);
            out.push(count);
        }
    }

    out
}

fn build_pvs_data(bsp: &mut Bsp, portals: &[BspCellPortals]) {
    let num_leafs = bsp.leafs.len() as u32;
    let mut visdata = Vec::new();

    for leaf in 0..num_leafs {
        if bsp.leafs[leaf as usize].contents == -1 {
            bsp.leafs[leaf as usize].visofs = -1;
            continue;
        }

        let pvs = compute_leaf_pvs(leaf, portals, &bsp.leafs, num_leafs);
        let compressed = rle_compress_pvs(&pvs);

        bsp.leafs[leaf as usize].visofs = visdata.len() as i32;
        visdata.extend_from_slice(&compressed);
    }

    bsp.visdata = visdata;
}

fn compute_vertex_light(
    pos: Vec3,
    normal: Vec3,
    lights: &[LightSource],
    ambient: f32,
) -> f32 {
    let mut total = ambient;

    for light in lights {
        let to_light = Vec3::new(
            light.position.x - pos.x,
            light.position.y - pos.y,
            light.position.z - pos.z,
        );

        let dist_sq = to_light.x * to_light.x + to_light.y * to_light.y + to_light.z * to_light.z;
        let dist = sqrtf(dist_sq).max(1.0);

        if dist > light.radius {
            continue;
        }

        let inv_dist = 1.0 / dist;
        let light_dir = Vec3::new(
            to_light.x * inv_dist,
            to_light.y * inv_dist,
            to_light.z * inv_dist,
        );

        let ndotl = (normal.x * light_dir.x + normal.y * light_dir.y + normal.z * light_dir.z).max(0.0);

        let attenuation = (1.0 - dist / light.radius).max(0.0);
        let attenuation = attenuation * attenuation;

        total += light.intensity * ndotl * attenuation;
    }

    total.min(1.0)
}

fn compute_bsp_vertex_lighting(bsp: &mut Bsp, lights: &[LightSource], ambient: f32) {
    if bsp.vertices.is_empty() {
        return;
    }

    bsp.vertex_lights = vec![0u32; bsp.vertices.len()];

    for f in 0..bsp.faces.len() {
        let face = &bsp.faces[f];
        let normal = if (face.plane_id as usize) < bsp.planes.len() {
            bsp.planes[face.plane_id as usize].normal
        } else {
            Vec3::new(0.0, 1.0, 0.0)
        };

        for e in 0..face.num_edges {
            let surfedge_idx = (face.first_edge + e as u32) as usize;
            if surfedge_idx >= bsp.surfedges.len() {
                continue;
            }

            let edge_idx = bsp.surfedges[surfedge_idx];
            let vert_idx = if edge_idx >= 0 {
                let ei = edge_idx as usize;
                if ei >= bsp.edges.len() { continue; }
                bsp.edges[ei].vertex[0] as usize
            } else {
                let ei = (-edge_idx) as usize;
                if ei >= bsp.edges.len() { continue; }
                bsp.edges[ei].vertex[1] as usize
            };

            if vert_idx >= bsp.vertices.len() {
                continue;
            }

            let pos = bsp.vertices[vert_idx].position;
            let light = compute_vertex_light(pos, normal, lights, ambient);

            let light_byte = (light * 255.0) as u8;
            bsp.vertex_lights[vert_idx] = ((light_byte as u32) << 24) | 0x00FFFFFF;
        }
    }
}

fn grid_to_bsp(bsp: &mut Bsp, grid: &RoomGrid) {
    let mut face_count = 0;
    let mut floor_ceiling_count = 0;

    for y in 0..grid.height {
        for x in 0..grid.width {
            if grid.get(x, y) == 0 {
                if grid.get(x - 1, y) == 1 { face_count += 1; }
                if grid.get(x + 1, y) == 1 { face_count += 1; }
                if grid.get(x, y - 1) == 1 { face_count += 1; }
                if grid.get(x, y + 1) == 1 { face_count += 1; }
                floor_ceiling_count += 1;
            }
        }
    }

    face_count += floor_ceiling_count;
    let vertex_count = face_count * 4;

    let total_cells = (grid.width * grid.height) as usize;
    let max_nodes = 2 * total_cells;
    let total_planes = face_count + max_nodes;

    bsp.vertices = vec![BspVertex::default(); vertex_count];
    bsp.faces = vec![BspFace::default(); face_count];
    bsp.planes = vec![BspPlane::default(); total_planes];
    bsp.edges = vec![BspEdge::default(); vertex_count];
    bsp.surfedges = vec![0i32; vertex_count];
    bsp.nodes = vec![BspNode::default(); max_nodes];

    let mut face_cell = vec![0u32; face_count];

    let mut vert_idx = 0usize;
    let mut face_idx = 0usize;
    let mut edge_idx = 0usize;

    for y in 0..grid.height {
        for x in 0..grid.width {
            if grid.get(x, y) == 0 {
                let fx = x as f32 * CELL_SIZE;
                let fy = y as f32 * CELL_SIZE;
                let cell_idx = (y * grid.width + x) as u32;

                if grid.get(x - 1, y) == 1 {
                    bsp.vertices[vert_idx + 0].position = Vec3::new(fx, 0.0, fy);
                    bsp.vertices[vert_idx + 1].position = Vec3::new(fx, WALL_HEIGHT, fy);
                    bsp.vertices[vert_idx + 2].position = Vec3::new(fx, WALL_HEIGHT, fy + CELL_SIZE);
                    bsp.vertices[vert_idx + 3].position = Vec3::new(fx, 0.0, fy + CELL_SIZE);

                    bsp.planes[face_idx].normal = Vec3::new(1.0, 0.0, 0.0);
                    bsp.planes[face_idx].dist = fx;

                    bsp.faces[face_idx].plane_id = face_idx as u16;
                    bsp.faces[face_idx].num_edges = 4;
                    bsp.faces[face_idx].first_edge = edge_idx as u32;
                    bsp.faces[face_idx].material_id = 0;

                    for i in 0..4 {
                        bsp.edges[edge_idx + i].vertex[0] = (vert_idx + i) as u16;
                        bsp.edges[edge_idx + i].vertex[1] = (vert_idx + ((i + 1) % 4)) as u16;
                        bsp.surfedges[edge_idx + i] = (edge_idx + i) as i32;
                    }

                    compute_face_aabb(&mut bsp.faces[face_idx], &bsp.vertices, vert_idx);
                    face_cell[face_idx] = cell_idx;

                    vert_idx += 4;
                    edge_idx += 4;
                    face_idx += 1;
                }

                if grid.get(x + 1, y) == 1 {
                    bsp.vertices[vert_idx + 0].position = Vec3::new(fx + CELL_SIZE, 0.0, fy);
                    bsp.vertices[vert_idx + 1].position = Vec3::new(fx + CELL_SIZE, 0.0, fy + CELL_SIZE);
                    bsp.vertices[vert_idx + 2].position = Vec3::new(fx + CELL_SIZE, WALL_HEIGHT, fy + CELL_SIZE);
                    bsp.vertices[vert_idx + 3].position = Vec3::new(fx + CELL_SIZE, WALL_HEIGHT, fy);

                    bsp.planes[face_idx].normal = Vec3::new(-1.0, 0.0, 0.0);
                    bsp.planes[face_idx].dist = -(fx + CELL_SIZE);

                    bsp.faces[face_idx].plane_id = face_idx as u16;
                    bsp.faces[face_idx].num_edges = 4;
                    bsp.faces[face_idx].first_edge = edge_idx as u32;
                    bsp.faces[face_idx].material_id = 0;

                    for i in 0..4 {
                        bsp.edges[edge_idx + i].vertex[0] = (vert_idx + i) as u16;
                        bsp.edges[edge_idx + i].vertex[1] = (vert_idx + ((i + 1) % 4)) as u16;
                        bsp.surfedges[edge_idx + i] = (edge_idx + i) as i32;
                    }

                    compute_face_aabb(&mut bsp.faces[face_idx], &bsp.vertices, vert_idx);
                    face_cell[face_idx] = cell_idx;

                    vert_idx += 4;
                    edge_idx += 4;
                    face_idx += 1;
                }

                if grid.get(x, y - 1) == 1 {
                    bsp.vertices[vert_idx + 0].position = Vec3::new(fx, 0.0, fy);
                    bsp.vertices[vert_idx + 1].position = Vec3::new(fx + CELL_SIZE, 0.0, fy);
                    bsp.vertices[vert_idx + 2].position = Vec3::new(fx + CELL_SIZE, WALL_HEIGHT, fy);
                    bsp.vertices[vert_idx + 3].position = Vec3::new(fx, WALL_HEIGHT, fy);

                    bsp.planes[face_idx].normal = Vec3::new(0.0, 0.0, 1.0);
                    bsp.planes[face_idx].dist = fy;

                    bsp.faces[face_idx].plane_id = face_idx as u16;
                    bsp.faces[face_idx].num_edges = 4;
                    bsp.faces[face_idx].first_edge = edge_idx as u32;
                    bsp.faces[face_idx].material_id = 0;

                    for i in 0..4 {
                        bsp.edges[edge_idx + i].vertex[0] = (vert_idx + i) as u16;
                        bsp.edges[edge_idx + i].vertex[1] = (vert_idx + ((i + 1) % 4)) as u16;
                        bsp.surfedges[edge_idx + i] = (edge_idx + i) as i32;
                    }

                    compute_face_aabb(&mut bsp.faces[face_idx], &bsp.vertices, vert_idx);
                    face_cell[face_idx] = cell_idx;

                    vert_idx += 4;
                    edge_idx += 4;
                    face_idx += 1;
                }

                if grid.get(x, y + 1) == 1 {
                    bsp.vertices[vert_idx + 0].position = Vec3::new(fx, 0.0, fy + CELL_SIZE);
                    bsp.vertices[vert_idx + 1].position = Vec3::new(fx, WALL_HEIGHT, fy + CELL_SIZE);
                    bsp.vertices[vert_idx + 2].position = Vec3::new(fx + CELL_SIZE, WALL_HEIGHT, fy + CELL_SIZE);
                    bsp.vertices[vert_idx + 3].position = Vec3::new(fx + CELL_SIZE, 0.0, fy + CELL_SIZE);

                    bsp.planes[face_idx].normal = Vec3::new(0.0, 0.0, -1.0);
                    bsp.planes[face_idx].dist = -(fy + CELL_SIZE);

                    bsp.faces[face_idx].plane_id = face_idx as u16;
                    bsp.faces[face_idx].num_edges = 4;
                    bsp.faces[face_idx].first_edge = edge_idx as u32;
                    bsp.faces[face_idx].material_id = 0;

                    for i in 0..4 {
                        bsp.edges[edge_idx + i].vertex[0] = (vert_idx + i) as u16;
                        bsp.edges[edge_idx + i].vertex[1] = (vert_idx + ((i + 1) % 4)) as u16;
                        bsp.surfedges[edge_idx + i] = (edge_idx + i) as i32;
                    }

                    compute_face_aabb(&mut bsp.faces[face_idx], &bsp.vertices, vert_idx);
                    face_cell[face_idx] = cell_idx;

                    vert_idx += 4;
                    edge_idx += 4;
                    face_idx += 1;
                }
            }
        }
    }

    for y in 0..grid.height {
        for x in 0..grid.width {
            if grid.get(x, y) == 0 {
                let fx = x as f32 * CELL_SIZE;
                let fy = y as f32 * CELL_SIZE;
                let cell_idx = (y * grid.width + x) as u32;

                bsp.vertices[vert_idx + 0].position = Vec3::new(fx, 0.0, fy);
                bsp.vertices[vert_idx + 1].position = Vec3::new(fx, 0.0, fy + CELL_SIZE);
                bsp.vertices[vert_idx + 2].position = Vec3::new(fx + CELL_SIZE, 0.0, fy + CELL_SIZE);
                bsp.vertices[vert_idx + 3].position = Vec3::new(fx + CELL_SIZE, 0.0, fy);

                bsp.planes[face_idx].normal = Vec3::new(0.0, 1.0, 0.0);
                bsp.planes[face_idx].dist = 0.0;

                bsp.faces[face_idx].plane_id = face_idx as u16;
                bsp.faces[face_idx].num_edges = 4;
                bsp.faces[face_idx].first_edge = edge_idx as u32;
                bsp.faces[face_idx].material_id = 0;

                for i in 0..4 {
                    bsp.edges[edge_idx + i].vertex[0] = (vert_idx + i) as u16;
                    bsp.edges[edge_idx + i].vertex[1] = (vert_idx + ((i + 1) % 4)) as u16;
                    bsp.surfedges[edge_idx + i] = (edge_idx + i) as i32;
                }

                compute_face_aabb(&mut bsp.faces[face_idx], &bsp.vertices, vert_idx);
                face_cell[face_idx] = cell_idx;

                vert_idx += 4;
                edge_idx += 4;
                face_idx += 1;
            }
        }
    }

    bsp.vertices.truncate(vert_idx);
    bsp.faces.truncate(face_idx);
    bsp.edges.truncate(edge_idx);
    bsp.surfedges.truncate(edge_idx);

    bsp.leafs = vec![BspLeaf::default(); total_cells];
    bsp.marksurfaces = vec![0u16; face_idx];

    let mut faces_per_cell = vec![0u32; total_cells];
    let mut cell_offset = vec![0u32; total_cells];
    let mut cell_cursor = vec![0u32; total_cells];

    for i in 0..face_idx {
        faces_per_cell[face_cell[i] as usize] += 1;
    }

    let mut offset = 0u32;
    for c in 0..total_cells {
        cell_offset[c] = offset;
        offset += faces_per_cell[c];
    }

    for i in 0..face_idx {
        let c = face_cell[i] as usize;
        bsp.marksurfaces[(cell_offset[c] + cell_cursor[c]) as usize] = i as u16;
        cell_cursor[c] += 1;
    }

    for y in 0..grid.height {
        for x in 0..grid.width {
            let c = (y * grid.width + x) as usize;
            let leaf = &mut bsp.leafs[c];

            let fx = x as f32 * CELL_SIZE;
            let fz = y as f32 * CELL_SIZE;

            leaf.mins[0] = fx as i16;
            leaf.mins[1] = 0;
            leaf.mins[2] = fz as i16;
            leaf.maxs[0] = (fx + CELL_SIZE) as i16;
            leaf.maxs[1] = WALL_HEIGHT as i16;
            leaf.maxs[2] = (fz + CELL_SIZE) as i16;

            if grid.get(x, y) == 0 {
                leaf.contents = -2;
                leaf.first_marksurface = cell_offset[c] as u16;
                leaf.num_marksurfaces = faces_per_cell[c] as u16;
            } else {
                leaf.contents = -1;
                leaf.first_marksurface = 0;
                leaf.num_marksurfaces = 0;
            }
            leaf.visofs = -1;
        }
    }

    let face_count_final = face_idx;
    let mut ctx = BspBuildContext {
        bsp,
        grid,
        node_count: 0,
        plane_offset: face_count_final as u32,
    };

    build_bsp_node(&mut ctx, 0, 0, grid.width, grid.height, 0);

    let node_count = ctx.node_count as usize;
    let plane_count = ctx.plane_offset as usize;
    ctx.bsp.nodes.truncate(node_count);
    ctx.bsp.planes.truncate(plane_count);

    let portals = build_cell_portals(grid);
    build_pvs_data(ctx.bsp, &portals);
    ctx.bsp.cell_portals = portals;
}

pub fn generate_rooms(params: &ProcgenParams) -> Bsp {
    let mut rng = Rng::new(params.seed);

    let mut grid = RoomGrid::new(params.width, params.height);
    grid.fill(1);

    let mut rooms: Vec<Bounds> = Vec::new();
    let max_attempts = params.num_rooms * 10;

    for _ in 0..max_attempts {
        if rooms.len() >= params.num_rooms as usize {
            break;
        }

        let w = params.min_room_size + (rng.next() % (params.max_room_size - params.min_room_size + 1) as u32) as i32;
        let h = params.min_room_size + (rng.next() % (params.max_room_size - params.min_room_size + 1) as u32) as i32;
        let x = 1 + (rng.next() % (params.width - w - 2) as u32) as i32;
        let y = 1 + (rng.next() % (params.height - h - 2) as u32) as i32;

        let new_room = Bounds { x, y, w, h };

        let overlaps = rooms.iter().any(|r| new_room.intersects(r));

        if !overlaps {
            for ry in y..(y + h) {
                for rx in x..(x + w) {
                    grid.set(rx, ry, 0);
                }
            }

            if !rooms.is_empty() {
                let prev = rooms.last().unwrap();
                let new_cx = x + w / 2;
                let new_cy = y + h / 2;
                let prev_cx = prev.x + prev.w / 2;
                let prev_cy = prev.y + prev.h / 2;

                if rng.next() % 2 == 0 {
                    carve_corridor_h(&mut grid, prev_cx, new_cx, prev_cy);
                    carve_corridor_v(&mut grid, prev_cy, new_cy, new_cx);
                } else {
                    carve_corridor_v(&mut grid, prev_cy, new_cy, prev_cx);
                    carve_corridor_h(&mut grid, prev_cx, new_cx, new_cy);
                }
            }

            rooms.push(new_room);
        }
    }

    let mut bsp = Bsp::new();
    grid_to_bsp(&mut bsp, &grid);

    let light_height = 80.0;
    let lights: Vec<LightSource> = rooms.iter().map(|room| {
        let cx = (room.x as f32 + room.w as f32 / 2.0) * CELL_SIZE;
        let cy = (room.y as f32 + room.h as f32 / 2.0) * CELL_SIZE;
        LightSource {
            position: Vec3::new(cx, light_height, cy),
            intensity: 0.8,
            radius: 300.0,
        }
    }).collect();

    compute_bsp_vertex_lighting(&mut bsp, &lights, 0.1);

    bsp
}

pub fn generate(params: &ProcgenParams) -> Bsp {
    generate_rooms(params)
}