extern crate byteorder;
use byteorder::{LittleEndian, ReadBytesExt};
use std::io::*;
#[derive(Debug)]
pub struct Header {
pub i: char,
pub b: char,
pub s: char,
pub p: char,
}
fn read_header(cursor: &mut Cursor<&[u8]>) -> Result<Header> {
let i = cursor.read_u8()? as char;
let b = cursor.read_u8()? as char;
let s = cursor.read_u8()? as char;
let p = cursor.read_u8()? as char;
Ok(Header {
i: i,
b: b,
s: s,
p: p,
})
}
fn read_version(cursor: &mut Cursor<&[u8]>) -> Result<i32> {
cursor.read_i32::<LittleEndian>()
}
#[derive(Debug)]
pub struct DirEntry {
pub offset: i32,
pub length: i32,
}
fn read_directories(cursor: &mut Cursor<&[u8]>) -> Result<Vec<DirEntry>> {
let mut dir_entries = Vec::new();
for _ in 0..17 {
let offset = cursor.read_i32::<LittleEndian>()?;
let length = cursor.read_i32::<LittleEndian>()?;
dir_entries.push(DirEntry {
offset: offset,
length: length,
});
}
Ok(dir_entries)
}
#[derive(Debug)]
pub struct Entity {
pub entities: String,
}
fn read_entities(cursor: &mut Cursor<&[u8]>, dir_entry: &DirEntry) -> Result<Entity> {
let mut entities = Vec::with_capacity(dir_entry.length as usize);
cursor.set_position(dir_entry.offset as u64);
for _ in 0..dir_entry.length {
let data = cursor.read_u8()?;
entities.push(data);
}
let entities = String::from_utf8(entities).unwrap();
Ok(Entity { entities: entities })
}
fn read_entry<F, T>(cursor: &mut Cursor<&[u8]>, dir_entry: &DirEntry, mut f: F) -> Result<Vec<T>>
where F: FnMut(&mut Cursor<&[u8]>) -> Result<T>
{
let mut entries = Vec::new();
cursor.set_position(dir_entry.offset as u64);
let end_pos = (dir_entry.offset + dir_entry.length) as u64;
while cursor.position() < end_pos {
let entry = f(cursor)?;
entries.push(entry);
}
Ok(entries)
}
#[derive(Debug)]
pub struct Texture {
pub name: String,
pub flags: i32,
pub contents: i32,
}
fn read_texture(cursor: &mut Cursor<&[u8]>) -> Result<Texture> {
let mut texture = Vec::new();
for _ in 0..64 {
let data = cursor.read_u8()?;
if data != 0u8 {
texture.push(data);
}
}
let texture_name = String::from_utf8(texture).unwrap();
let flags = cursor.read_i32::<LittleEndian>()?;
let contents = cursor.read_i32::<LittleEndian>()?;
Ok(Texture {
name: texture_name,
flags: flags,
contents: contents,
})
}
#[derive(Debug)]
pub struct Plane {
pub normal: [f32; 3],
pub dist: f32,
}
fn read_plane(cursor: &mut Cursor<&[u8]>) -> Result<Plane> {
let x = cursor.read_f32::<LittleEndian>()?;
let y = cursor.read_f32::<LittleEndian>()?;
let z = cursor.read_f32::<LittleEndian>()?;
let dist = cursor.read_f32::<LittleEndian>()?;
let plane = Plane {
normal: [x, y, z],
dist: dist,
};
Ok(plane)
}
#[derive(Debug)]
pub struct Node {
pub plane: i32,
pub children: [i32; 2],
pub mins: [i32; 3],
pub maxs: [i32; 3],
}
fn read_node(cursor: &mut Cursor<&[u8]>) -> Result<Node> {
let plane = cursor.read_i32::<LittleEndian>()?;
let children = [cursor.read_i32::<LittleEndian>()?, cursor.read_i32::<LittleEndian>()?];
let mins = [cursor.read_i32::<LittleEndian>()?,
cursor.read_i32::<LittleEndian>()?,
cursor.read_i32::<LittleEndian>()?];
let maxs = [cursor.read_i32::<LittleEndian>()?,
cursor.read_i32::<LittleEndian>()?,
cursor.read_i32::<LittleEndian>()?];
let node = Node {
plane: plane,
children: children,
mins: mins,
maxs: maxs,
};
Ok(node)
}
#[derive(Debug)]
pub struct Leaf {
pub cluster: i32,
pub area: i32,
pub mins: [i32; 3],
pub maxs: [i32; 3],
pub leaf_face: i32,
pub num_leaf_faces: i32,
pub leaf_brush: i32,
pub num_leaf_brushes: i32,
}
fn read_leaf(cursor: &mut Cursor<&[u8]>) -> Result<Leaf> {
let cluster = cursor.read_i32::<LittleEndian>()?;
let area = cursor.read_i32::<LittleEndian>()?;
let mins = [cursor.read_i32::<LittleEndian>()?,
cursor.read_i32::<LittleEndian>()?,
cursor.read_i32::<LittleEndian>()?];
let maxs = [cursor.read_i32::<LittleEndian>()?,
cursor.read_i32::<LittleEndian>()?,
cursor.read_i32::<LittleEndian>()?];
let leaf_face = cursor.read_i32::<LittleEndian>()?;
let num_leaf_faces = cursor.read_i32::<LittleEndian>()?;
let leaf_brush = cursor.read_i32::<LittleEndian>()?;
let num_leaf_brushes = cursor.read_i32::<LittleEndian>()?;
let leaf = Leaf {
cluster: cluster,
area: area,
mins: mins,
maxs: maxs,
leaf_face: leaf_face,
num_leaf_faces: num_leaf_faces,
leaf_brush: leaf_brush,
num_leaf_brushes: num_leaf_brushes,
};
Ok(leaf)
}
#[derive(Debug)]
pub struct LeafFace {
pub face: i32,
}
fn read_leaf_face(cursor: &mut Cursor<&[u8]>) -> Result<LeafFace> {
let face = cursor.read_i32::<LittleEndian>()?;
let leaf_face = LeafFace { face: face };
Ok(leaf_face)
}
#[derive(Debug)]
pub struct LeafBrush {
pub brush: i32,
}
fn read_leaf_brush(cursor: &mut Cursor<&[u8]>) -> Result<LeafBrush> {
let brush = cursor.read_i32::<LittleEndian>()?;
let leaf_brush = LeafBrush { brush: brush };
Ok(leaf_brush)
}
#[derive(Debug)]
pub struct Model {
pub mins: [f32; 3],
pub maxs: [f32; 3],
pub face: i32,
pub num_faces: i32,
pub brush: i32,
pub num_brushes: i32,
}
fn read_model(cursor: &mut Cursor<&[u8]>) -> Result<Model> {
let mins = [cursor.read_f32::<LittleEndian>()?,
cursor.read_f32::<LittleEndian>()?,
cursor.read_f32::<LittleEndian>()?];
let maxs = [cursor.read_f32::<LittleEndian>()?,
cursor.read_f32::<LittleEndian>()?,
cursor.read_f32::<LittleEndian>()?];
let face = cursor.read_i32::<LittleEndian>()?;
let num_faces = cursor.read_i32::<LittleEndian>()?;
let brush = cursor.read_i32::<LittleEndian>()?;
let num_brushes = cursor.read_i32::<LittleEndian>()?;
let model = Model {
mins: mins,
maxs: maxs,
face: face,
num_faces: num_faces,
brush: brush,
num_brushes: num_brushes,
};
Ok(model)
}
#[derive(Debug)]
pub struct Brush {
pub brush_side: i32,
pub num_brush_sides: i32,
pub texture: i32,
}
fn read_brush(cursor: &mut Cursor<&[u8]>) -> Result<Brush> {
let brush_side = cursor.read_i32::<LittleEndian>()?;
let num_brush_sides = cursor.read_i32::<LittleEndian>()?;
let texture = cursor.read_i32::<LittleEndian>()?;
let brush = Brush {
brush_side: brush_side,
num_brush_sides: num_brush_sides,
texture: texture,
};
Ok(brush)
}
#[derive(Debug)]
pub struct BrushSide {
pub plane: i32,
pub texture: i32,
}
fn read_brush_side(cursor: &mut Cursor<&[u8]>) -> Result<BrushSide> {
let plane = cursor.read_i32::<LittleEndian>()?;
let texture = cursor.read_i32::<LittleEndian>()?;
let brush_side = BrushSide {
plane: plane,
texture: texture,
};
Ok(brush_side)
}
#[derive(Debug)]
pub struct Vertex {
pub position: [f32; 3],
pub tex_coord1: [f32; 2],
pub tex_coord2: [f32; 2],
pub normal: [f32; 3],
pub color: [u8; 4],
}
fn read_vertex(cursor: &mut Cursor<&[u8]>) -> Result<Vertex> {
let position = [cursor.read_f32::<LittleEndian>()?,
cursor.read_f32::<LittleEndian>()?,
cursor.read_f32::<LittleEndian>()?];
let tex_coord1 = [cursor.read_f32::<LittleEndian>()?, cursor.read_f32::<LittleEndian>()?];
let tex_coord2 = [cursor.read_f32::<LittleEndian>()?, cursor.read_f32::<LittleEndian>()?];
let normal = [cursor.read_f32::<LittleEndian>()?,
cursor.read_f32::<LittleEndian>()?,
cursor.read_f32::<LittleEndian>()?];
let color = [cursor.read_u8()?, cursor.read_u8()?, cursor.read_u8()?, cursor.read_u8()?];
let vertex = Vertex {
position: position,
tex_coord1: tex_coord1,
tex_coord2: tex_coord2,
normal: normal,
color: color,
};
Ok(vertex)
}
#[derive(Debug)]
pub struct MeshVert {
pub offset: i32,
}
fn read_mesh_vert(cursor: &mut Cursor<&[u8]>) -> Result<MeshVert> {
let offset = cursor.read_i32::<LittleEndian>()?;
let mesh_vert = MeshVert { offset: offset };
Ok(mesh_vert)
}
#[derive(Debug)]
pub struct Effect {
pub name: String,
pub brush: i32,
pub unk: i32,
}
fn read_effect(cursor: &mut Cursor<&[u8]>) -> Result<Effect> {
let mut name = Vec::new();
for _ in 0..64 {
let data = cursor.read_u8()?;
if data != 0u8 {
name.push(data);
}
}
let name = String::from_utf8(name).unwrap();
let brush = cursor.read_i32::<LittleEndian>()?;
let unk = cursor.read_i32::<LittleEndian>()?;
Ok(Effect {
name: name,
brush: brush,
unk: unk,
})
}
#[derive(Debug)]
pub struct Face {
pub texture: usize,
pub effect: i32,
pub face_type: i32,
pub vertex: i32,
pub num_vertexes: i32,
pub mesh_vert: usize,
pub num_mesh_verts: usize,
pub lm_index: i32,
pub lm_start: [i32; 2],
pub lm_size: [i32; 2],
pub lm_origin: [f32; 3],
pub lm_vecs: [[f32; 3]; 2],
pub normal: [f32; 3],
pub size: [i32; 2],
}
fn read_face(cursor: &mut Cursor<&[u8]>) -> Result<Face> {
let texture = cursor.read_i32::<LittleEndian>()? as usize;
let effect = cursor.read_i32::<LittleEndian>()?;
let face_type = cursor.read_i32::<LittleEndian>()?;
let vertex = cursor.read_i32::<LittleEndian>()?;
let num_vertexes = cursor.read_i32::<LittleEndian>()?;
let mesh_vert = cursor.read_i32::<LittleEndian>()? as usize;
let num_mesh_verts = cursor.read_i32::<LittleEndian>()? as usize;
let lm_index = cursor.read_i32::<LittleEndian>()?;
let lm_start = [cursor.read_i32::<LittleEndian>()?, cursor.read_i32::<LittleEndian>()?];
let lm_size = [cursor.read_i32::<LittleEndian>()?, cursor.read_i32::<LittleEndian>()?];
let lm_origin = [cursor.read_f32::<LittleEndian>()?,
cursor.read_f32::<LittleEndian>()?,
cursor.read_f32::<LittleEndian>()?];
let lm_vec1 = [cursor.read_f32::<LittleEndian>()?,
cursor.read_f32::<LittleEndian>()?,
cursor.read_f32::<LittleEndian>()?];
let lm_vec2 = [cursor.read_f32::<LittleEndian>()?,
cursor.read_f32::<LittleEndian>()?,
cursor.read_f32::<LittleEndian>()?];
let lm_vecs = [lm_vec1, lm_vec2];
let normal = [cursor.read_f32::<LittleEndian>()?,
cursor.read_f32::<LittleEndian>()?,
cursor.read_f32::<LittleEndian>()?];
let size = [cursor.read_i32::<LittleEndian>()?, cursor.read_i32::<LittleEndian>()?];
let face = Face {
texture: texture,
effect: effect,
face_type: face_type,
vertex: vertex,
num_vertexes: num_vertexes,
mesh_vert: mesh_vert,
num_mesh_verts: num_mesh_verts,
lm_index: lm_index,
lm_start: lm_start,
lm_size: lm_size,
lm_origin: lm_origin,
lm_vecs: lm_vecs,
normal: normal,
size: size,
};
Ok(face)
}
#[derive(Debug)]
pub struct VisData {
pub n_vecs : i32, pub sz_vecs : i32, pub vecs : Vec<u8> }
fn read_visdata(cursor: &mut Cursor<&[u8]>) -> Result<VisData> {
let n_vecs = cursor.read_i32::<LittleEndian>()?;
let sz_vecs = cursor.read_i32::<LittleEndian>()?;
let mut vecs = Vec::new();
for _ in 0..(n_vecs * sz_vecs) {
let v = cursor.read_u8()?;
vecs.push(v);
}
let vis_data = VisData {
n_vecs: n_vecs,
sz_vecs : sz_vecs,
vecs : vecs
};
Ok(vis_data)
}
#[derive(Debug)]
pub struct BSP {
pub header: Header,
pub dir_entries: Vec<DirEntry>,
pub entities: Entity,
pub textures: Vec<Texture>,
pub planes: Vec<Plane>,
pub nodes: Vec<Node>,
pub leafs: Vec<Leaf>,
pub leaf_faces: Vec<LeafFace>,
pub leaf_brushes: Vec<LeafBrush>,
pub models: Vec<Model>,
pub brushes: Vec<Brush>,
pub brush_sides: Vec<BrushSide>,
pub vertexes: Vec<Vertex>,
pub mesh_verts: Vec<MeshVert>,
pub effects: Vec<Effect>,
pub faces: Vec<Face>,
pub vis_data : VisData,
}
pub fn read_bsp(bytes: &[u8]) -> Result<BSP> {
let mut cursor = Cursor::new(bytes);
let header = read_header(&mut cursor)?;
let version = read_version(&mut cursor)?;
assert_eq!(version, 0x2e);
let dir_entries = read_directories(&mut cursor)?;
let entities = read_entities(&mut cursor, &dir_entries[0])?;
let textures = read_entry(&mut cursor, &dir_entries[1], read_texture)?;
let planes = read_entry(&mut cursor, &dir_entries[2], read_plane)?;
let nodes = read_entry(&mut cursor, &dir_entries[3], read_node)?;
let leafs = read_entry(&mut cursor, &dir_entries[4], read_leaf)?;
let leaf_faces = read_entry(&mut cursor, &dir_entries[5], read_leaf_face)?;
let leaf_brushes = read_entry(&mut cursor, &dir_entries[6], read_leaf_brush)?;
let models = read_entry(&mut cursor, &dir_entries[7], read_model)?;
let brushes = read_entry(&mut cursor, &dir_entries[8], read_brush)?;
let brush_sides = read_entry(&mut cursor, &dir_entries[9], read_brush_side)?;
let vertexes = read_entry(&mut cursor, &dir_entries[10], read_vertex)?;
let mesh_verts = read_entry(&mut cursor, &dir_entries[11], read_mesh_vert)?;
let effects = read_entry(&mut cursor, &dir_entries[12], read_effect)?;
let faces = read_entry(&mut cursor, &dir_entries[13], read_face)?;
cursor.set_position(dir_entries[16].offset as u64);
let vis_data = read_visdata(&mut cursor)?;
Ok({
BSP {
header: header,
dir_entries: dir_entries,
entities: entities,
textures: textures,
planes: planes,
nodes: nodes,
leafs: leafs,
leaf_faces: leaf_faces,
leaf_brushes: leaf_brushes,
models: models,
brushes: brushes,
brush_sides: brush_sides,
vertexes: vertexes,
mesh_verts: mesh_verts,
effects: effects,
faces: faces,
vis_data: vis_data
}
})
}