diff options
Diffstat (limited to 'stockton-levels/src')
40 files changed, 317 insertions, 1847 deletions
diff --git a/stockton-levels/src/coords.rs b/stockton-levels/src/coords.rs deleted file mode 100644 index 1b1fa55..0000000 --- a/stockton-levels/src/coords.rs +++ /dev/null @@ -1,41 +0,0 @@ -// This program is free software: you can redistribute it and/or modify it -// under the terms of the GNU General Public License as published by the Free -// Software Foundation, either version 3 of the License, or (at your option) -// any later version. - -// This program is distributed in the hope that it will be useful, but WITHOUT -// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for -// more details. - -// You should have received a copy of the GNU General Public License along -// with this program. If not, see <http://www.gnu.org/licenses/>. -//! Marker traits for different co-ordinate systems, and functions to swizzle between them - -use na::base::Scalar; -use na::Vector3; -use std::ops::Neg; - -pub trait CoordSystem {} - -/// X points East, Y points South, Z points downwards -pub struct Q3System; -impl CoordSystem for Q3System {} - -/// X points east, Y points downwards, Z points inwards -pub struct VulkanSystem; -impl CoordSystem for VulkanSystem {} - -pub struct Swizzler; - -pub trait SwizzleFromTo<F: CoordSystem, T: CoordSystem> { - fn swizzle<U: Scalar + Copy + Neg<Output = U>>(vec: &mut Vector3<U>); -} - -impl SwizzleFromTo<Q3System, VulkanSystem> for Swizzler { - fn swizzle<U: Scalar + Copy + Neg<Output = U>>(vec: &mut Vector3<U>) { - let temp = vec.y; - vec.y = vec.z; - vec.z = -temp; - } -} diff --git a/stockton-levels/src/features.rs b/stockton-levels/src/features.rs index 9b05772..f748bd0 100644 --- a/stockton-levels/src/features.rs +++ b/stockton-levels/src/features.rs @@ -12,8 +12,7 @@ // with this program. If not, see <http://www.gnu.org/licenses/>. //! Marker traits for different feature sets -use crate::coords::CoordSystem; -use crate::traits::*; +use crate::parts::*; -pub trait MinBspFeatures<S: CoordSystem>: HasBspTree<S> + Send + Sync {} -impl<T, S: CoordSystem> MinBspFeatures<S> for T where T: HasBspTree<S> + Send + Sync {} +pub trait MinRenderFeatures: HasFaces + HasTextures + Send + Sync {} +impl<T> MinRenderFeatures for T where T: HasFaces + HasTextures + Send + Sync {} diff --git a/stockton-levels/src/helpers.rs b/stockton-levels/src/helpers.rs deleted file mode 100644 index 0fe3e96..0000000 --- a/stockton-levels/src/helpers.rs +++ /dev/null @@ -1,54 +0,0 @@ -//! Helper functions for parsing - -use na::{Vector2, Vector3}; -use std::convert::TryInto; - -/// Turn a slice into a le i32, the int datatype in a bsp file. -/// # Panics -/// If slice is not 4 bytes long -pub fn slice_to_i32(slice: &[u8]) -> i32 { - i32::from_le_bytes(slice.try_into().unwrap()) -} - -/// Turn a slice into a le u32, used for some bitflags. -/// # Panics -/// If slice is not 4 bytes long. -pub fn slice_to_u32(slice: &[u8]) -> u32 { - u32::from_le_bytes(slice.try_into().unwrap()) -} - -/// Turn a slice into a le f32, the float datatype in a bsp file. -/// # Panics -/// If slice is not 4 bytes long -pub fn slice_to_f32(slice: &[u8]) -> f32 { - f32::from_bits(u32::from_le_bytes(slice.try_into().unwrap())) -} - -/// Turn a slice of floats into a 3D vector -/// # Panics -/// If slice isn't 12 bytes long. -pub fn slice_to_vec3(slice: &[u8]) -> Vector3<f32> { - Vector3::new( - slice_to_f32(&slice[0..4]), - slice_to_f32(&slice[4..8]), - slice_to_f32(&slice[8..12]), - ) -} - -/// Turn a slice of i32s into a 3D vector -/// # Panics -/// If slice isn't 12 bytes long. -pub fn slice_to_vec3i(slice: &[u8]) -> Vector3<i32> { - Vector3::new( - slice_to_i32(&slice[0..4]), - slice_to_i32(&slice[4..8]), - slice_to_i32(&slice[8..12]), - ) -} - -/// Turn a slice of u32s into a 2D vector -/// # Panics -/// If slice isn't 8 bytes long. -pub fn slice_to_vec2ui(slice: &[u8]) -> Vector2<u32> { - Vector2::new(slice_to_u32(&slice[0..4]), slice_to_u32(&slice[4..8])) -} diff --git a/stockton-levels/src/lib.rs b/stockton-levels/src/lib.rs index a71d8e2..49609c2 100644 --- a/stockton-levels/src/lib.rs +++ b/stockton-levels/src/lib.rs @@ -10,18 +10,11 @@ // You should have received a copy of the GNU General Public License along // with this program. If not, see <http://www.gnu.org/licenses/>. -//! Parses common features from many BSP file formats. -#![allow(incomplete_features)] -#![feature(generic_associated_types)] +//! Interfaces & Data structures stockton expects when rendering a level. extern crate nalgebra as na; -#[macro_use] -extern crate bitflags; -pub mod coords; pub mod features; -mod helpers; +pub mod parts; pub mod prelude; -pub mod q3; -pub mod traits; pub mod types; diff --git a/stockton-levels/src/parts/entities.rs b/stockton-levels/src/parts/entities.rs new file mode 100644 index 0000000..7a5ac74 --- /dev/null +++ b/stockton-levels/src/parts/entities.rs @@ -0,0 +1,36 @@ +use std::iter::Iterator; + +pub type EntityRef = u32; + +/// A game entity +pub trait IsEntity<C: HasEntities + ?Sized> { + fn get_attr(&self, container: &C) -> Option<&str>; +} + +pub trait HasEntities { + type Entity: IsEntity<Self>; + + fn get_entity(&self, idx: EntityRef) -> Option<&Self::Entity>; + fn iter_entities(&self) -> Entities<Self> { + Entities { + next: 0, + container: self, + } + } +} + +#[derive(Debug, Clone, Copy)] +pub struct Entities<'a, T: HasEntities + ?Sized> { + next: EntityRef, + container: &'a T, +} + +impl<'a, T: HasEntities> Iterator for Entities<'a, T> { + type Item = &'a T::Entity; + + fn next(&mut self) -> Option<Self::Item> { + let res = self.container.get_entity(self.next); + self.next += 1; + res + } +} diff --git a/stockton-levels/src/parts/faces.rs b/stockton-levels/src/parts/faces.rs new file mode 100644 index 0000000..0168cd8 --- /dev/null +++ b/stockton-levels/src/parts/faces.rs @@ -0,0 +1,43 @@ +use super::{textures::TextureRef, vertices::Vertex}; +use serde::{Deserialize, Serialize}; + +pub type FaceRef = u32; + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum Geometry { + Vertices(Vertex, Vertex, Vertex), +} + +pub trait IsFace<C: HasFaces + ?Sized> { + fn index(&self, container: &C) -> FaceRef; + fn geometry(&self, container: &C) -> Geometry; + fn texture_idx(&self, container: &C) -> TextureRef; +} + +pub trait HasFaces { + type Face: IsFace<Self>; + + fn get_face(&self, index: FaceRef) -> Option<&Self::Face>; + fn iter_faces(&self) -> Faces<Self> { + Faces { + next: 0, + container: self, + } + } +} + +#[derive(Debug, Clone, Copy)] +pub struct Faces<'a, T: HasFaces + ?Sized> { + next: FaceRef, + container: &'a T, +} + +impl<'a, T: HasFaces> Iterator for Faces<'a, T> { + type Item = &'a T::Face; + + fn next(&mut self) -> Option<Self::Item> { + let res = self.container.get_face(self.next); + self.next += 1; + res + } +} diff --git a/stockton-levels/src/parts/mod.rs b/stockton-levels/src/parts/mod.rs new file mode 100644 index 0000000..05697f0 --- /dev/null +++ b/stockton-levels/src/parts/mod.rs @@ -0,0 +1,17 @@ +mod entities; +mod faces; +mod textures; +mod vertices; +mod visdata; + +pub mod data { + pub use super::entities::{Entities, EntityRef}; + pub use super::faces::{FaceRef, Faces, Geometry}; + pub use super::textures::{TextureRef, Textures}; + pub use super::vertices::{Vertex, VertexRef}; +} + +pub use entities::{HasEntities, IsEntity}; +pub use faces::{HasFaces, IsFace}; +pub use textures::{HasTextures, IsTexture}; +pub use visdata::HasVisData; diff --git a/stockton-levels/src/parts/textures.rs b/stockton-levels/src/parts/textures.rs new file mode 100644 index 0000000..8e6cb9a --- /dev/null +++ b/stockton-levels/src/parts/textures.rs @@ -0,0 +1,48 @@ +// This program is free software: you can redistribute it and/or modify it +// under the terms of the GNU General Public License as published by the Free +// Software Foundation, either version 3 of the License, or (at your option) +// any later version. + +// This program is distributed in the hope that it will be useful, but WITHOUT +// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +// more details. + +// You should have received a copy of the GNU General Public License along +// with this program. If not, see <http://www.gnu.org/licenses/>. + +use std::iter::Iterator; + +pub type TextureRef = u32; + +pub trait IsTexture { + fn name(&self) -> &str; +} + +pub trait HasTextures { + type Texture: IsTexture; + + fn get_texture(&self, idx: TextureRef) -> Option<&Self::Texture>; + fn iter_textures(&self) -> Textures<Self> { + Textures { + next: 0, + container: self, + } + } +} + +#[derive(Debug, Clone, Copy)] +pub struct Textures<'a, T: HasTextures + ?Sized> { + next: TextureRef, + container: &'a T, +} + +impl<'a, T: HasTextures> Iterator for Textures<'a, T> { + type Item = &'a T::Texture; + + fn next(&mut self) -> Option<Self::Item> { + let res = self.container.get_texture(self.next); + self.next += 1; + res + } +} diff --git a/stockton-levels/src/parts/vertices.rs b/stockton-levels/src/parts/vertices.rs new file mode 100644 index 0000000..0b7dfd6 --- /dev/null +++ b/stockton-levels/src/parts/vertices.rs @@ -0,0 +1,156 @@ +use crate::types::Rgba; +use na::{Vector2, Vector3}; +use serde::de; +use serde::de::{Deserializer, MapAccess, SeqAccess, Visitor}; +use serde::ser::{Serialize, SerializeStruct, Serializer}; +use serde::Deserialize; +use std::fmt; + +pub type VertexRef = u32; + +/// A vertex, used to describe a face. +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct Vertex { + pub position: Vector3<f32>, + pub tex: Vector2<f32>, + pub color: Rgba, +} + +impl Serialize for Vertex { + fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { + let mut state = serializer.serialize_struct("Vertex", 5)?; + state.serialize_field("pos_x", &self.position.x)?; + state.serialize_field("pos_y", &self.position.y)?; + state.serialize_field("pos_z", &self.position.z)?; + state.serialize_field("tex_u", &self.tex.x)?; + state.serialize_field("tex_v", &self.tex.y)?; + state.serialize_field("color", &self.color)?; + + state.end() + } +} + +impl<'de> Deserialize<'de> for Vertex { + fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { + #[derive(Deserialize)] + #[serde(field_identifier, rename_all = "snake_case")] + enum Field { + PosX, + PosY, + PosZ, + TexU, + TexV, + Color, + } + const FIELDS: &'static [&'static str] = + &["pos_x", "pos_y", "pos_z", "tex_x", "tex_y", "color"]; + + struct VertexVisitor; + + impl<'de> Visitor<'de> for VertexVisitor { + type Value = Vertex; + + fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + formatter.write_str("struct Vertex") + } + + fn visit_seq<V>(self, mut seq: V) -> Result<Vertex, V::Error> + where + V: SeqAccess<'de>, + { + let pos_x = seq + .next_element()? + .ok_or_else(|| de::Error::invalid_length(0, &self))?; + let pos_y = seq + .next_element()? + .ok_or_else(|| de::Error::invalid_length(1, &self))?; + let pos_z = seq + .next_element()? + .ok_or_else(|| de::Error::invalid_length(2, &self))?; + let tex_u = seq + .next_element()? + .ok_or_else(|| de::Error::invalid_length(3, &self))?; + let tex_v = seq + .next_element()? + .ok_or_else(|| de::Error::invalid_length(4, &self))?; + let color = seq + .next_element()? + .ok_or_else(|| de::Error::invalid_length(5, &self))?; + Ok(Vertex { + position: Vector3::new(pos_x, pos_y, pos_z), + tex: Vector2::new(tex_u, tex_v), + color, + }) + } + + fn visit_map<V>(self, mut map: V) -> Result<Vertex, V::Error> + where + V: MapAccess<'de>, + { + let mut pos_x = None; + let mut pos_y = None; + let mut pos_z = None; + let mut tex_u = None; + let mut tex_v = None; + let mut color = None; + while let Some(key) = map.next_key()? { + match key { + Field::PosX => { + if pos_x.is_some() { + return Err(de::Error::duplicate_field("pos_x")); + } + pos_x = Some(map.next_value()?); + } + Field::PosY => { + if pos_y.is_some() { + return Err(de::Error::duplicate_field("pos_y")); + } + pos_y = Some(map.next_value()?); + } + Field::PosZ => { + if pos_z.is_some() { + return Err(de::Error::duplicate_field("pos_z")); + } + pos_z = Some(map.next_value()?); + } + Field::TexU => { + if tex_u.is_some() { + return Err(de::Error::duplicate_field("tex_u")); + } + tex_u = Some(map.next_value()?); + } + Field::TexV => { + if tex_v.is_some() { + return Err(de::Error::duplicate_field("tex_v")); + } + tex_v = Some(map.next_value()?); + } + Field::Color => { + if color.is_some() { + return Err(de::Error::duplicate_field("color")); + } + color = Some(map.next_value()?); + } + } + } + let position = Vector3::new( + pos_x.ok_or_else(|| de::Error::missing_field("pos_x"))?, + pos_y.ok_or_else(|| de::Error::missing_field("pos_y"))?, + pos_z.ok_or_else(|| de::Error::missing_field("pos_z"))?, + ); + let tex = Vector2::new( + tex_u.ok_or_else(|| de::Error::missing_field("tex_u"))?, + tex_v.ok_or_else(|| de::Error::missing_field("tex_v"))?, + ); + let color = color.ok_or_else(|| de::Error::missing_field("nanos"))?; + Ok(Vertex { + position, + tex, + color, + }) + } + } + + deserializer.deserialize_struct("Vertex", FIELDS, VertexVisitor) + } +} diff --git a/stockton-levels/src/parts/visdata.rs b/stockton-levels/src/parts/visdata.rs new file mode 100644 index 0000000..f311bf7 --- /dev/null +++ b/stockton-levels/src/parts/visdata.rs @@ -0,0 +1,8 @@ +use super::faces::FaceRef; +use na::Vector3; +use std::iter::Iterator; + +pub trait HasVisData { + type Faces: Iterator<Item = FaceRef>; + fn get_visible(pos: Vector3<f32>, rot: Vector3<f32>) -> Self::Faces; +} diff --git a/stockton-levels/src/prelude.rs b/stockton-levels/src/prelude.rs index 2d09252..0da890b 100644 --- a/stockton-levels/src/prelude.rs +++ b/stockton-levels/src/prelude.rs @@ -12,6 +12,5 @@ // with this program. If not, see <http://www.gnu.org/licenses/>. //! Common traits, etc. -pub use crate::coords::*; pub use crate::features::*; -pub use crate::traits::*; +pub use crate::parts::*; diff --git a/stockton-levels/src/q3/brushes.rs b/stockton-levels/src/q3/brushes.rs deleted file mode 100644 index 9cb0d8e..0000000 --- a/stockton-levels/src/q3/brushes.rs +++ /dev/null @@ -1,100 +0,0 @@ -//! Parses the brushes & brushsides lumps from a bsp file - -/// The size of one brush record. -const BRUSH_SIZE: usize = 4 * 3; - -/// The size of one brushsize record -const SIDE_SIZE: usize = 4 * 2; - -use super::Q3BspFile; -use crate::coords::CoordSystem; -use crate::helpers::slice_to_i32; -use crate::traits::brushes::*; -use crate::types::{ParseError, Result}; - -/// Parse the brushes & brushsides lump from a bsp file. -pub fn from_data( - brushes_data: &[u8], - sides_data: &[u8], - n_textures: u32, - n_planes: u32, -) -> Result<Box<[Brush]>> { - if brushes_data.len() % BRUSH_SIZE != 0 || sides_data.len() % SIDE_SIZE != 0 { - return Err(ParseError::Invalid); - } - let length = brushes_data.len() / BRUSH_SIZE; - - let mut brushes = Vec::with_capacity(length as usize); - for n in 0..length { - let offset = n * BRUSH_SIZE; - let brush = &brushes_data[offset..offset + BRUSH_SIZE]; - - let texture_idx = slice_to_i32(&brush[8..12]) as usize; - if texture_idx >= n_textures as usize { - return Err(ParseError::Invalid); - } - - brushes.push(Brush { - sides: get_sides( - sides_data, - slice_to_i32(&brush[0..4]), - slice_to_i32(&brush[4..8]), - n_textures as usize, - n_planes as usize, - )?, - texture_idx, - }); - } - - Ok(brushes.into_boxed_slice()) -} - -/// Internal function to get the relevant brushsides for a brush from the data in the brush lump. -fn get_sides( - sides_data: &[u8], - start: i32, - length: i32, - n_textures: usize, - n_planes: usize, -) -> Result<Box<[BrushSide]>> { - let mut sides = Vec::with_capacity(length as usize); - - if length > 0 { - for n in start..start + length { - let offset = n as usize * SIDE_SIZE; - let brush = &sides_data[offset..offset + SIDE_SIZE]; - - let plane_idx = slice_to_i32(&brush[0..4]) as usize; - if plane_idx / 2 >= n_planes { - return Err(ParseError::Invalid); - } - - let is_opposing = plane_idx % 2 != 0; - - let texture_idx = slice_to_i32(&brush[4..8]) as usize; - if texture_idx >= n_textures { - return Err(ParseError::Invalid); - } - - sides.push(BrushSide { - plane_idx, - texture_idx, - is_opposing, - }); - } - } - - Ok(sides.into_boxed_slice()) -} - -impl<T: CoordSystem> HasBrushes<T> for Q3BspFile<T> { - type BrushesIter<'a> = std::slice::Iter<'a, Brush>; - - fn brushes_iter(&self) -> Self::BrushesIter<'_> { - self.brushes.iter() - } - - fn get_brush(&self, index: u32) -> &Brush { - &self.brushes[index as usize] - } -} diff --git a/stockton-levels/src/q3/effects.rs b/stockton-levels/src/q3/effects.rs deleted file mode 100644 index 369ed80..0000000 --- a/stockton-levels/src/q3/effects.rs +++ /dev/null @@ -1,48 +0,0 @@ -use std::str; - -use super::Q3BspFile; -use crate::coords::CoordSystem; -use crate::helpers::slice_to_u32; -use crate::traits::effects::*; -use crate::types::{ParseError, Result}; - -/// The size of one effect definition -const EFFECT_SIZE: usize = 64 + 4 + 4; - -pub fn from_data(data: &[u8], n_brushes: u32) -> Result<Box<[Effect]>> { - if data.len() % EFFECT_SIZE != 0 { - return Err(ParseError::Invalid); - } - let length = data.len() / EFFECT_SIZE; - - let mut effects = Vec::with_capacity(length); - for n in 0..length { - let raw = &data[n * EFFECT_SIZE..(n + 1) * EFFECT_SIZE]; - - let brush_idx = slice_to_u32(&raw[64..68]); - if brush_idx >= n_brushes { - return Err(ParseError::Invalid); - } - - effects.push(Effect { - name: str::from_utf8(&raw[..64]) - .map_err(|_| ParseError::Invalid)? - .to_owned(), - brush_idx, - }); - } - - Ok(effects.into_boxed_slice()) -} - -impl<T: CoordSystem> HasEffects<T> for Q3BspFile<T> { - type EffectsIter<'a> = std::slice::Iter<'a, Effect>; - - fn effects_iter(&self) -> Self::EffectsIter<'_> { - self.effects.iter() - } - - fn get_effect(&self, index: u32) -> &Effect { - &self.effects[index as usize] - } -} diff --git a/stockton-levels/src/q3/entities.rs b/stockton-levels/src/q3/entities.rs deleted file mode 100644 index d36eb37..0000000 --- a/stockton-levels/src/q3/entities.rs +++ /dev/null @@ -1,95 +0,0 @@ -use std::collections::HashMap; -use std::str; - -use super::Q3BspFile; -use crate::coords::CoordSystem; -use crate::traits::entities::*; -use crate::types::{ParseError, Result}; - -const QUOTE: u8 = b'"'; -const END_BRACKET: u8 = b'}'; -const START_BRACKET: u8 = b'{'; - -/// Internal enum to parse through the entities string. -#[derive(PartialEq, Eq)] -enum ParseState { - InKey, - InValue, - AfterKey, - InsideEntity, - OutsideEntity, -} - -/// Parse the given data as an Entities lump -pub fn from_data(data: &[u8]) -> Result<Box<[Entity]>> { - use self::ParseState::*; - - let string = str::from_utf8(data).unwrap(); - - let mut attrs = HashMap::new(); - let mut entities = Vec::new(); - - let mut state = ParseState::OutsideEntity; - - let mut key_start = 0; - let mut key_end = 0; - let mut val_start = 0; - let mut val_end; - - for (i, chr) in string.bytes().enumerate() { - match chr { - QUOTE => match state { - InsideEntity => { - state = ParseState::InKey; - key_start = i + 1; - } - InKey => { - state = ParseState::AfterKey; - key_end = i; - } - AfterKey => { - state = ParseState::InValue; - val_start = i + 1; - } - InValue => { - state = ParseState::InsideEntity; - val_end = i; - - attrs.insert( - string[key_start..key_end].to_owned(), - string[val_start..val_end].to_owned(), - ); - } - _ => { - return Err(ParseError::Invalid); - } - }, - END_BRACKET => { - if state != InsideEntity { - return Err(ParseError::Invalid); - } - - state = OutsideEntity; - - entities.push(Entity { attributes: attrs }); - attrs = HashMap::new(); - } - START_BRACKET => { - if state != OutsideEntity { - return Err(ParseError::Invalid); - } - state = InsideEntity; - } - _ => {} - } - } - Ok(entities.into_boxed_slice()) -} - -impl<T: CoordSystem> HasEntities for Q3BspFile<T> { - type EntitiesIter<'a> = std::slice::Iter<'a, Entity>; - - fn entities_iter(&self) -> Self::EntitiesIter<'_> { - self.entities.iter() - } -} diff --git a/stockton-levels/src/q3/faces.rs b/stockton-levels/src/q3/faces.rs deleted file mode 100644 index 95467bb..0000000 --- a/stockton-levels/src/q3/faces.rs +++ /dev/null @@ -1,148 +0,0 @@ -use super::Q3BspFile; -use crate::coords::CoordSystem; -use crate::helpers::{slice_to_i32, slice_to_u32, slice_to_vec2ui, slice_to_vec3}; -use crate::traits::faces::*; -use crate::types::{ParseError, Result}; -use na::Vector3; - -const FACE_SIZE: usize = (4 * 8) + (4 * 2) + (4 * 2) + (4 * 3) + ((4 * 2) * 3) + (4 * 3) + (4 * 2); - -pub fn from_data( - data: &[u8], - n_textures: u32, - n_effects: u32, - n_vertices: u32, - n_meshverts: u32, - n_lightmaps: u32, -) -> Result<Box<[Face]>> { - if data.len() % FACE_SIZE != 0 { - return Err(ParseError::Invalid); - } - let length = data.len() / FACE_SIZE; - - let mut faces = Vec::with_capacity(length); - for n in 0..length { - faces.push(face_from_slice( - &data[n * FACE_SIZE..(n + 1) * FACE_SIZE], - n_textures, - n_effects, - n_vertices, - n_meshverts, - n_lightmaps, - )?); - } - - Ok(faces.into_boxed_slice()) -} - -fn face_from_slice( - data: &[u8], - n_textures: u32, - n_effects: u32, - n_vertices: u32, - n_meshverts: u32, - n_lightmaps: u32, -) -> Result<Face> { - if data.len() != FACE_SIZE { - panic!("tried to call face.from_slice with invalid slice size"); - } - - // texture - let texture_idx = slice_to_u32(&data[0..4]); - if texture_idx >= n_textures { - return Err(ParseError::Invalid); - } - - // effects - let effect_idx = slice_to_u32(&data[4..8]); - let effect_idx = if effect_idx < 0xffffffff { - if effect_idx >= n_effects { - return Err(ParseError::Invalid); - } - - Some(effect_idx) - } else { - None - }; - - // face type - // TODO - let face_type: FaceType = unsafe { ::std::mem::transmute(slice_to_u32(&data[8..12])) }; - - // vertices - let vertex_offset = slice_to_u32(&data[12..16]); - let vertex_n = slice_to_u32(&data[16..20]); - if (vertex_offset + vertex_n) > n_vertices { - return Err(ParseError::Invalid); - } - - let vertices_idx = vertex_offset..vertex_offset + vertex_n; - - // meshverts - let meshverts_offset = slice_to_u32(&data[20..24]); - let meshverts_n = slice_to_u32(&data[24..28]); - if (meshverts_offset + meshverts_n) > n_meshverts { - return Err(ParseError::Invalid); - } - - let meshverts_idx = meshverts_offset..meshverts_offset + meshverts_n; - - // lightmap - let lightmap_idx = slice_to_i32(&data[28..32]); - let lightmap_idx = if lightmap_idx > 0 { - if lightmap_idx as u32 >= n_lightmaps { - return Err(ParseError::Invalid); - } - - Some(lightmap_idx as u32) - } else { - None - }; - - // map properties - let map_start = slice_to_vec2ui(&data[32..40]); - let map_size = slice_to_vec2ui(&data[40..48]); - let map_origin = slice_to_vec3(&data[48..60]); - - // map_vecs - let mut map_vecs = [Vector3::new(0.0, 0.0, 0.0); 2]; - for (n, map_vec) in map_vecs.iter_mut().enumerate() { - let offset = 60 + (n * 3 * 4); - *map_vec = slice_to_vec3(&data[offset..offset + 12]); - } - - // normal & size - let normal = slice_to_vec3(&data[84..96]); - let size = slice_to_vec2ui(&data[96..104]); - - Ok(Face { - face_type, - texture_idx, - effect_idx, - vertices_idx, - meshverts_idx, - lightmap_idx, - map_start, - map_size, - map_origin, - map_vecs, - normal, - size, - }) -} - -impl<T: CoordSystem> HasFaces<T> for Q3BspFile<T> { - type FacesIter<'a> = std::slice::Iter<'a, Face>; - - fn faces_iter(&self) -> Self::FacesIter<'_> { - self.faces.iter() - } - - fn faces_len(&self) -> u32 { - self.faces.len() as u32 - } - - fn get_face(&self, index: u32) -> &Face { - &self.faces[index as usize] - } -} diff --git a/stockton-levels/src/q3/file.rs b/stockton-levels/src/q3/file.rs deleted file mode 100644 index f577fb0..0000000 --- a/stockton-levels/src/q3/file.rs +++ /dev/null @@ -1,147 +0,0 @@ -//! A complete BSP file - -// Trait implementations are stored in their own files. - -use bitvec::prelude::*; -use std::marker::PhantomData; - -use self::header::Header; -use crate::coords::*; -use crate::types::Result; - -use super::*; -use crate::traits::brushes::Brush; -use crate::traits::effects::Effect; -use crate::traits::entities::Entity; -use crate::traits::faces::Face; -use crate::traits::light_maps::LightMap; -use crate::traits::light_vols::LightVol; -use crate::traits::models::Model; -use crate::traits::planes::Plane; -use crate::traits::textures::Texture; -use crate::traits::tree::BspNode; -use crate::traits::vertices::{MeshVert, Vertex}; - -/// A parsed Quake 3 BSP File. -pub struct Q3BspFile<T: CoordSystem> { - pub(crate) visdata: Box<[BitBox<Local, u8>]>, - pub(crate) textures: Box<[Texture]>, - pub(crate) entities: Box<[Entity]>, - pub(crate) planes: Box<[Plane]>, - pub(crate) vertices: Box<[Vertex]>, - pub(crate) meshverts: Box<[MeshVert]>, - pub(crate) light_maps: Box<[LightMap]>, - pub(crate) light_vols: Box<[LightVol]>, - pub(crate) brushes: Box<[Brush]>, - pub(crate) effects: Box<[Effect]>, - pub(crate) faces: Box<[Face]>, - pub(crate) models: Box<[Model]>, - pub(crate) tree_root: BspNode, - _phantom: PhantomData<T>, -} - -impl Q3BspFile<Q3System> { - /// Parse `data` as a quake 3 bsp file. - pub fn parse_file(data: &[u8]) -> Result<Q3BspFile<Q3System>> { - let header = Header::from(data)?; - - let entities = entities::from_data(header.get_lump(&data, 0))?; - let textures = textures::from_data(header.get_lump(&data, 1))?; - let planes = planes::from_data(header.get_lump(&data, 2))?; - let vertices = vertices::verts_from_data(header.get_lump(&data, 10))?; - let meshverts = vertices::meshverts_from_data(header.get_lump(&data, 11))?; - let light_maps = light_maps::from_data(header.get_lump(&data, 14))?; - let light_vols = light_vols::from_data(header.get_lump(&data, 15))?; - let visdata = visdata::from_data(header.get_lump(&data, 16))?; - let brushes = brushes::from_data( - header.get_lump(&data, 8), - header.get_lump(&data, 9), - textures.len() as u32, - planes.len() as u32, - )?; - let effects = effects::from_data(header.get_lump(&data, 12), brushes.len() as u32)?; - let faces = faces::from_data( - header.get_lump(&data, 13), - textures.len() as u32, - effects.len() as u32, - vertices.len() as u32, - meshverts.len() as u32, - light_maps.len() as u32, - )?; - - let tree_root = tree::from_data( - header.get_lump(&data, 3), - header.get_lump(&data, 4), - header.get_lump(&data, 5), - header.get_lump(&data, 6), - faces.len() as u32, - brushes.len() as u32, - )?; - - let models = models::from_data( - header.get_lump(&data, 7), - faces.len() as u32, - brushes.len() as u32, - )?; - - Ok(Q3BspFile { - visdata, - textures, - entities, - planes, - vertices, - meshverts, - light_maps, - light_vols, - brushes, - effects, - faces, - tree_root, - models, - _phantom: PhantomData, - }) - } -} - -impl<T: CoordSystem> Q3BspFile<T> { - pub fn swizzle_to<D: CoordSystem>(mut self) -> Q3BspFile<D> - where - Swizzler: SwizzleFromTo<T, D>, - { - for vertex in self.vertices.iter_mut() { - Swizzler::swizzle(&mut vertex.normal); - Swizzler::swizzle(&mut vertex.position); - } - - for model in self.models.iter_mut() { - Swizzler::swizzle(&mut model.mins); - Swizzler::swizzle(&mut model.maxs); - } - - for face in self.faces.iter_mut() { - Swizzler::swizzle(&mut face.normal); - } - - for plane in self.planes.iter_mut() { - Swizzler::swizzle(&mut plane.normal); - } - - // TODO: Possibly don't need to move? - Q3BspFile { - visdata: self.visdata, - textures: self.textures, - entities: self.entities, - planes: self.planes, - vertices: self.vertices, - meshverts: self.meshverts, - light_maps: self.light_maps, - light_vols: self.light_vols, - brushes: self.brushes, - effects: self.effects, - faces: self.faces, - tree_root: self.tree_root, - models: self.models, - _phantom: PhantomData, - } - } -} diff --git a/stockton-levels/src/q3/header.rs b/stockton-levels/src/q3/header.rs deleted file mode 100644 index 45478e0..0000000 --- a/stockton-levels/src/q3/header.rs +++ /dev/null @@ -1,68 +0,0 @@ -use crate::types::{ParseError, Result}; -use std::convert::TryInto; - -const MAGIC_HEADER: &[u8] = &[0x49, 0x42, 0x53, 0x50]; -const HEADER_LEN: usize = 4 + 4 + (17 * 4 * 2); - -/// The header found at the start of a (Q3) bsp file -#[derive(Clone, Copy, Debug)] -pub struct Header { - pub version: u32, - pub dir_entries: [DirEntry; 17], -} - -/// A directory entry, pointing to a lump in the file -#[derive(Clone, Copy, Debug)] -pub struct DirEntry { - /// Offset from beginning of file to start of lump - pub offset: u32, - - /// Length of lump, multiple of 4. - pub length: u32, -} - -impl Header { - /// Deserialise from buffer. - /// # Format - /// string[4] magic Magic number. Always "IBSP". - /// int version Version number. 0x2e for the BSP files distributed with Quake 3. - /// direntry[17] direntries Lump directory, seventeen entries. - pub fn from(v: &[u8]) -> Result<Header> { - if v.len() < HEADER_LEN { - return Err(ParseError::Invalid); - } - let magic = &v[0..4]; - - if magic != MAGIC_HEADER { - return Err(ParseError::Invalid); - } - - let version: &[u8; 4] = v[4..8].try_into().unwrap(); - - let entries: &[u8] = &v[8..144]; - let mut dir_entries: [DirEntry; 17] = [DirEntry { - offset: 0, - length: 0, - }; 17]; - - for n in 0..17 { - let base = &entries[(n * 8)..(n * 8) + 8]; - dir_entries[n] = DirEntry { - offset: u32::from_le_bytes(base[0..4].try_into().unwrap()), - length: u32::from_le_bytes(base[4..8].try_into().unwrap()), - } - } - - Ok(Header { - version: u32::from_le_bytes(*version), - dir_entries, - }) - } - - /// Get the lump at given index from the buffer, with offset & length based on this directory. - pub fn get_lump<'l>(&self, buf: &'l [u8], index: usize) -> &'l [u8] { - let entry = self.dir_entries[index]; - - &buf[entry.offset as usize..entry.offset as usize + entry.length as usize] - } -} diff --git a/stockton-levels/src/q3/light_maps.rs b/stockton-levels/src/q3/light_maps.rs deleted file mode 100644 index 377fea5..0000000 --- a/stockton-levels/src/q3/light_maps.rs +++ /dev/null @@ -1,43 +0,0 @@ -use super::Q3BspFile; -use crate::coords::CoordSystem; -use crate::traits::light_maps::*; -use crate::types::{ParseError, Result, Rgb}; - -/// The size of one LightMap -const LIGHTMAP_SIZE: usize = 128 * 128 * 3; - -/// Parse the LightMap data from a bsp file. -pub fn from_data(data: &[u8]) -> Result<Box<[LightMap]>> { - if data.len() % LIGHTMAP_SIZE != 0 { - return Err(ParseError::Invalid); - } - let length = data.len() / LIGHTMAP_SIZE; - - let mut maps = Vec::with_capacity(length as usize); - for n in 0..length { - let raw = &data[n * LIGHTMAP_SIZE..(n + 1) * LIGHTMAP_SIZE]; - let mut map: [[Rgb; 128]; 128] = [[Rgb::white(); 128]; 128]; - - for (x, outer) in map.iter_mut().enumerate() { - for (y, inner) in outer.iter_mut().enumerate() { - let offset = (x * 128 * 3) + (y * 3); - *inner = Rgb::from_slice(&raw[offset..offset + 3]); - } - } - maps.push(LightMap { map }) - } - - Ok(maps.into_boxed_slice()) -} - -impl<T: CoordSystem> HasLightMaps for Q3BspFile<T> { - type LightMapsIter<'a> = std::slice::Iter<'a, LightMap>; - - fn lightmaps_iter(&self) -> Self::LightMapsIter<'_> { - self.light_maps.iter() - } - - fn get_lightmap(&self, index: u32) -> &LightMap { - &self.light_maps[index as usize] - } -} diff --git a/stockton-levels/src/q3/light_vols.rs b/stockton-levels/src/q3/light_vols.rs deleted file mode 100644 index 46f2557..0000000 --- a/stockton-levels/src/q3/light_vols.rs +++ /dev/null @@ -1,39 +0,0 @@ -use std::convert::TryInto; - -use super::Q3BspFile; -use crate::coords::CoordSystem; -use crate::traits::light_vols::*; -use crate::types::{ParseError, Result, Rgb}; - -const VOL_LENGTH: usize = (3 * 2) + 2; - -pub fn from_data(data: &[u8]) -> Result<Box<[LightVol]>> { - if data.len() % VOL_LENGTH != 0 { - return Err(ParseError::Invalid); - } - let length = data.len() / VOL_LENGTH; - - let mut vols = Vec::with_capacity(length); - for n in 0..length { - let data = &data[n * VOL_LENGTH..(n + 1) * VOL_LENGTH]; - vols.push(LightVol { - ambient: Rgb::from_slice(&data[0..3]), - directional: Rgb::from_slice(&data[3..6]), - dir: data[6..8].try_into().unwrap(), - }); - } - - Ok(vols.into_boxed_slice()) -} - -impl<T: CoordSystem> HasLightVols for Q3BspFile<T> { - type LightVolsIter<'a> = std::slice::Iter<'a, LightVol>; - - fn lightvols_iter(&self) -> Self::LightVolsIter<'_> { - self.light_vols.iter() - } - - fn get_lightvol(&self, index: u32) -> &LightVol { - &self.light_vols[index as usize] - } -} diff --git a/stockton-levels/src/q3/mod.rs b/stockton-levels/src/q3/mod.rs deleted file mode 100644 index 44d5159..0000000 --- a/stockton-levels/src/q3/mod.rs +++ /dev/null @@ -1,18 +0,0 @@ -//! Parsing data from Q3 and similar BSPs - -mod brushes; -mod effects; -mod entities; -mod faces; -pub mod file; -mod header; -mod light_maps; -mod light_vols; -mod models; -mod planes; -mod textures; -mod tree; -mod vertices; -mod visdata; - -pub use self::file::Q3BspFile; diff --git a/stockton-levels/src/q3/models.rs b/stockton-levels/src/q3/models.rs deleted file mode 100644 index a3de54a..0000000 --- a/stockton-levels/src/q3/models.rs +++ /dev/null @@ -1,65 +0,0 @@ -use super::Q3BspFile; -use crate::coords::CoordSystem; -use crate::helpers::{slice_to_u32, slice_to_vec3}; -use crate::traits::models::*; -use crate::types::{ParseError, Result}; - -const MODEL_SIZE: usize = (4 * 3 * 2) + (4 * 4); - -pub fn from_data(data: &[u8], n_faces: u32, n_brushes: u32) -> Result<Box<[Model]>> { - if data.len() % MODEL_SIZE != 0 { - return Err(ParseError::Invalid); - } - let n_models = data.len() / MODEL_SIZE; - - let mut models = Vec::with_capacity(n_models); - for n in 0..n_models { - let raw = &data[n * MODEL_SIZE..(n + 1) * MODEL_SIZE]; - - let mins = slice_to_vec3(&raw[0..12]); - let maxs = slice_to_vec3(&raw[12..24]); - - let faces_idx = { - let start = slice_to_u32(&raw[24..28]); - let n = slice_to_u32(&raw[28..32]); - - if start + n > n_faces { - return Err(ParseError::Invalid); - } - - start..start + n - }; - - let brushes_idx = { - let start = slice_to_u32(&raw[32..36]); - let n = slice_to_u32(&raw[36..40]); - - if start + n > n_brushes { - return Err(ParseError::Invalid); - } - - start..start + n - }; - - models.push(Model { - mins, - maxs, - faces_idx, - brushes_idx, - }) - } - - Ok(models.into_boxed_slice()) -} - -impl<T: CoordSystem> HasModels<T> for Q3BspFile<T> { - type ModelsIter<'a> = std::slice::Iter<'a, Model>; - - fn models_iter(&self) -> Self::ModelsIter<'_> { - self.models.iter() - } - - fn get_model(&self, index: u32) -> &Model { - &self.models[index as usize] - } -} diff --git a/stockton-levels/src/q3/planes.rs b/stockton-levels/src/q3/planes.rs deleted file mode 100644 index b4d3217..0000000 --- a/stockton-levels/src/q3/planes.rs +++ /dev/null @@ -1,40 +0,0 @@ -const PLANE_SIZE: usize = (4 * 3) + 4; - -use super::Q3BspFile; -use crate::coords::CoordSystem; -use crate::helpers::{slice_to_f32, slice_to_vec3}; -use crate::traits::planes::*; -use crate::types::{ParseError, Result}; - -/// Parse a lump of planes. -/// A lump is (data length / plane size) planes long -pub fn from_data(data: &[u8]) -> Result<Box<[Plane]>> { - let length = data.len() / PLANE_SIZE; - if data.is_empty() || data.len() % PLANE_SIZE != 0 || length % 2 != 0 { - return Err(ParseError::Invalid); - } - - let mut planes = Vec::with_capacity(length / 2); - for n in 0..length { - let offset = n * PLANE_SIZE; - let plane = &data[offset..offset + PLANE_SIZE]; - planes.push(Plane { - normal: slice_to_vec3(&plane[0..12]), - dist: slice_to_f32(&plane[12..16]), - }); - } - - Ok(planes.into_boxed_slice()) -} - -impl<T: CoordSystem> HasPlanes<T> for Q3BspFile<T> { - type PlanesIter<'a> = std::slice::Iter<'a, Plane>; - - fn planes_iter(&self) -> Self::PlanesIter<'_> { - self.planes.iter() - } - - fn get_plane(&self, idx: u32) -> &Plane { - &self.planes[idx as usize] - } -} diff --git a/stockton-levels/src/q3/textures.rs b/stockton-levels/src/q3/textures.rs deleted file mode 100644 index 98c2fe4..0000000 --- a/stockton-levels/src/q3/textures.rs +++ /dev/null @@ -1,137 +0,0 @@ -use std::str; - -use super::Q3BspFile; -use crate::coords::CoordSystem; -use crate::helpers::slice_to_u32; -use crate::traits::textures::*; -use crate::types::{ParseError, Result}; - -const TEXTURE_LUMP_SIZE: usize = 64 + 4 + 4; - -/// Try to parse the given buffer as an entities lump. -/// # Format -/// Each entity is: -/// string[64] name Texture name. -/// int flags Surface flags. -/// int contents Content flags. -/// Length of entities is total lump size / TEXTURE_LUMP_SIZE (64 + 4 + 4) -pub fn from_data(lump: &[u8]) -> Result<Box<[Texture]>> { - if lump.is_empty() || lump.len() % TEXTURE_LUMP_SIZE != 0 { - return Err(ParseError::Invalid); - } - let length = lump.len() / TEXTURE_LUMP_SIZE; - - let mut textures = Vec::with_capacity(length); - for n in 0..length { - let offset = n * TEXTURE_LUMP_SIZE; - textures.push(Texture { - name: str::from_utf8(&lump[offset..offset + 64]) - .map_err(|_| ParseError::Invalid)? - .trim_matches('\0') - .to_owned(), - surface: SurfaceFlags::from_bits_truncate(slice_to_u32( - &lump[offset + 64..offset + 68], - )), - contents: ContentsFlags::from_bits_truncate(slice_to_u32( - &lump[offset + 68..offset + 72], - )), - }); - } - - Ok(textures.into_boxed_slice()) -} - -impl<T: CoordSystem> HasTextures for Q3BspFile<T> { - type TexturesIter<'a> = std::slice::Iter<'a, Texture>; - - fn textures_iter(&self) -> Self::TexturesIter<'_> { - self.textures.iter() - } - - fn get_texture(&self, idx: u32) -> Option<&Texture> { - if idx >= self.textures.len() as u32 { - None - } else { - Some(&self.textures[idx as usize]) - } - } -} - -#[test] -fn textures_single_texture() { - let buf: &[u8] = &[ - b'T', b'E', b'S', b'T', b' ', b'T', b'E', b'X', b'T', b'U', b'R', b'E', 0x00, 0x00, 0x00, - 0x00, // name (padded to 64 bytes) - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x43, 0x00, 0x04, 0x00, // surface flags - 0x09, 0x00, 0x00, 0x00, // contents flags - ]; - - let lump = from_data(buf).unwrap(); - - assert_eq!(lump.len(), 1); - - assert_eq!(lump[0].name, "TEST TEXTURE"); - assert_eq!( - lump[0].surface, - SurfaceFlags::NO_DAMAGE | SurfaceFlags::SLICK | SurfaceFlags::FLESH | SurfaceFlags::DUST - ); - assert_eq!(lump[0].contents, ContentsFlags::SOLID | ContentsFlags::LAVA); -} - -#[test] -fn textures_multiple_textures() { - let buf: &[u8] = &[ - b'T', b'E', b'S', b'T', b' ', b'T', b'E', b'X', b'T', b'U', b'R', b'E', b'1', 0x00, 0x00, - 0x00, // name (padded to 64 bytes) - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x43, 0x00, 0x04, 0x00, // surface flags - 0x09, 0x00, 0x00, 0x00, // contents flags - b'T', b'E', b'S', b'T', b' ', b'T', b'E', b'X', b'T', b'U', b'R', b'E', b'2', 0x00, 0x00, - 0x00, // name (padded to 64 bytes) - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x2c, 0x10, 0x00, 0x00, // surface flags - 0x01, 0x00, 0x00, 0x00, // contents flags - b'T', b'E', b'S', b'T', b' ', b'T', b'E', b'X', b'T', b'U', b'R', b'E', b'3', 0x00, 0x00, - 0x00, // name (padded to 64 bytes) - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, // surface flags - 0x41, 0x00, 0x00, 0x00, // contents flags - ]; - - let lump = from_data(buf).unwrap(); - - assert_eq!(lump.len(), 3); - - assert_eq!(lump[0].name, "TEST TEXTURE1"); - assert_eq!(lump[1].name, "TEST TEXTURE2"); - assert_eq!(lump[2].name, "TEST TEXTURE3"); - - assert_eq!( - lump[0].surface, - SurfaceFlags::NO_DAMAGE | SurfaceFlags::SLICK | SurfaceFlags::FLESH | SurfaceFlags::DUST - ); - assert_eq!( - lump[1].surface, - SurfaceFlags::METAL_STEPS - | SurfaceFlags::NO_MARKS - | SurfaceFlags::LADDER - | SurfaceFlags::SKY - ); - assert_eq!( - lump[2].surface, - SurfaceFlags::POINT_LIGHT | SurfaceFlags::SKIP - ); - - assert_eq!(lump[0].contents, ContentsFlags::SOLID | ContentsFlags::LAVA); - assert_eq!(lump[1].contents, ContentsFlags::SOLID); - assert_eq!(lump[2].contents, ContentsFlags::SOLID | ContentsFlags::FOG); -} diff --git a/stockton-levels/src/q3/tree.rs b/stockton-levels/src/q3/tree.rs deleted file mode 100644 index 05f1531..0000000 --- a/stockton-levels/src/q3/tree.rs +++ /dev/null @@ -1,151 +0,0 @@ -//! Parses the BSP tree into a usable format - -use super::Q3BspFile; -use crate::coords::CoordSystem; -use crate::helpers::{slice_to_i32, slice_to_u32, slice_to_vec3i}; -use crate::traits::tree::*; -use crate::types::{ParseError, Result}; - -const NODE_SIZE: usize = 4 + (4 * 2) + (4 * 3) + (4 * 3); -const LEAF_SIZE: usize = 4 * 6 + (4 * 3 * 2); - -pub fn from_data( - nodes: &[u8], - leaves: &[u8], - leaf_faces: &[u8], - leaf_brushes: &[u8], - n_faces: u32, - n_brushes: u32, -) -> Result<BspNode> { - if nodes.len() % NODE_SIZE != 0 || leaves.len() % LEAF_SIZE != 0 { - return Err(ParseError::Invalid); - } - - compile_node( - 0, - nodes, - leaves, - leaf_faces, - leaf_brushes, - n_faces, - n_brushes, - ) -} - -/// Internal function. Visits given node and all its children. Used to recursively build tree. -fn compile_node( - i: i32, - nodes: &[u8], - leaves: &[u8], - leaf_faces: &[u8], - leaf_brushes: &[u8], - n_faces: u32, - n_brushes: u32, -) -> Result<BspNode> { - if i < 0 { - // Leaf. - let i = i.abs() - 1; - - let raw = &leaves[i as usize * LEAF_SIZE..(i as usize * LEAF_SIZE) + LEAF_SIZE]; - - let faces_idx = { - let start = slice_to_u32(&raw[32..36]) as usize; - let n = slice_to_u32(&raw[36..40]) as usize; - - let mut faces = Vec::with_capacity(n); - if n > 0 { - if start + n > leaf_faces.len() / 4 { - return Err(ParseError::Invalid); - } - - for i in start..start + n { - let face_idx = slice_to_u32(&leaf_faces[i * 4..(i + 1) * 4]); - if face_idx >= n_faces { - return Err(ParseError::Invalid); - } - - faces.push(face_idx); - } - } - - faces.into_boxed_slice() - }; - - let brushes_idx = { - let start = slice_to_u32(&raw[40..44]) as usize; - let n = slice_to_u32(&raw[44..48]) as usize; - let mut brushes = Vec::with_capacity(n); - - if n > 0 { - if start + n > leaf_brushes.len() / 4 { - return Err(ParseError::Invalid); - } - - for i in start..start + n { - let brush_idx = slice_to_u32(&leaf_brushes[i * 4..(i + 1) * 4]); - if brush_idx >= n_brushes { - return Err(ParseError::Invalid); - } - - brushes.push(brush_idx); - } - } - - brushes.into_boxed_slice() - }; - - let leaf = BspLeaf { - cluster_id: slice_to_u32(&raw[0..4]), - area: slice_to_i32(&raw[4..8]), - // 8..20 = min - // 20..32 = max - faces_idx, - brushes_idx, - }; - - Ok(BspNode { - plane_idx: 0, - min: slice_to_vec3i(&raw[8..20]), - max: slice_to_vec3i(&raw[20..32]), - value: BspNodeValue::Leaf(leaf), - }) - } else { - // Node. - let raw = &nodes[i as usize * NODE_SIZE..(i as usize * NODE_SIZE) + NODE_SIZE]; - - let plane_idx = slice_to_u32(&raw[0..4]); - let child_one = compile_node( - slice_to_i32(&raw[4..8]), - nodes, - leaves, - leaf_faces, - leaf_brushes, - n_faces, - n_brushes, - )?; - let child_two = compile_node( - slice_to_i32(&raw[8..12]), - nodes, - leaves, - leaf_faces, - leaf_brushes, - n_faces, - n_brushes, - )?; - let min = slice_to_vec3i(&raw[12..24]); - let max = slice_to_vec3i(&raw[24..36]); - - Ok(BspNode { - plane_idx, - value: BspNodeValue::Children(Box::new(child_one), Box::new(child_two)), - min, - max, - }) - } -} - -impl<T: CoordSystem> HasBspTree<T> for Q3BspFile<T> { - fn get_bsp_root(&self) -> &BspNode { - &self.tree_root - } -} diff --git a/stockton-levels/src/q3/vertices.rs b/stockton-levels/src/q3/vertices.rs deleted file mode 100644 index 77ff667..0000000 --- a/stockton-levels/src/q3/vertices.rs +++ /dev/null @@ -1,72 +0,0 @@ -use std::convert::TryInto; - -use super::Q3BspFile; -use crate::coords::CoordSystem; -use crate::helpers::{slice_to_u32, slice_to_vec3}; -use crate::traits::vertices::*; -use crate::types::{ParseError, Result, Rgba}; - -/// The size of one vertex -const VERTEX_SIZE: usize = (4 * 3) + (2 * 2 * 4) + (4 * 3) + 4; - -/// Parse a Vertices data from the data in a BSP file. -pub fn verts_from_data(data: &[u8]) -> Result<Box<[Vertex]>> { - if data.len() % VERTEX_SIZE != 0 { - return Err(ParseError::Invalid); - } - let length = data.len() / VERTEX_SIZE; - - let mut vertices = Vec::with_capacity(length as usize); - for n in 0..length { - let offset = n * VERTEX_SIZE; - let vertex = &data[offset..offset + VERTEX_SIZE]; - - vertices.push(Vertex { - position: slice_to_vec3(&vertex[0..12]), - tex: TexCoord::from_bytes(&vertex[12..28].try_into().unwrap()), - normal: slice_to_vec3(&vertex[28..40]), - color: Rgba::from_slice(&vertex[40..44]), - }) - } - - Ok(vertices.into_boxed_slice()) -} - -/// Parse the given data as a list of MeshVerts. -pub fn meshverts_from_data(data: &[u8]) -> Result<Box<[MeshVert]>> { - if data.len() % 4 != 0 { - return Err(ParseError::Invalid); - } - let length = data.len() / 4; - - let mut meshverts = Vec::with_capacity(length as usize); - for n in 0..length { - meshverts.push(slice_to_u32(&data[n * 4..(n + 1) * 4])) - } - - Ok(meshverts.into_boxed_slice()) -} - -impl<T: CoordSystem> HasVertices<T> for Q3BspFile<T> { - type VerticesIter<'a> = std::slice::Iter<'a, Vertex>; - - fn vertices_iter(&self) -> Self::VerticesIter<'_> { - self.vertices.iter() - } - - fn get_vertex(&self, index: u32) -> &Vertex { - &self.vertices[index as usize] - } -} - -impl<T: CoordSystem> HasMeshVerts<T> for Q3BspFile<T> { - type MeshVertsIter<'a> = std::slice::Iter<'a, MeshVert>; - - fn meshverts_iter(&self) -> Self::MeshVertsIter<'_> { - self.meshverts.iter() - } - - fn get_meshvert<'a>(&self, index: u32) -> MeshVert { - self.meshverts[index as usize] - } -} diff --git a/stockton-levels/src/q3/visdata.rs b/stockton-levels/src/q3/visdata.rs deleted file mode 100644 index d3cc532..0000000 --- a/stockton-levels/src/q3/visdata.rs +++ /dev/null @@ -1,53 +0,0 @@ -//! Parses visdata from Q3 BSPs. - -use bitvec::prelude::*; -use std::vec::IntoIter; - -use super::file::Q3BspFile; -use crate::coords::CoordSystem; -use crate::helpers::slice_to_i32; -use crate::traits::visdata::*; -use crate::types::{ParseError, Result}; - -/// Stores cluster-to-cluster visibility information. -pub fn from_data(data: &[u8]) -> Result<Box<[BitBox<Local, u8>]>> { - if data.len() < 8 { - return Err(ParseError::Invalid); - } - - let n_vecs = slice_to_i32(&data[0..4]) as usize; - let size_vecs = slice_to_i32(&data[4..8]) as usize; - - if data.len() - 8 != (n_vecs * size_vecs) { - return Err(ParseError::Invalid); - } - - let mut vecs = Vec::with_capacity(n_vecs); - for n in 0..n_vecs { - let offset = 8 + (n * size_vecs); - let slice = &data[offset..offset + size_vecs]; - vecs.push(BitBox::from_slice(slice)); - } - - Ok(vecs.into_boxed_slice()) -} - -impl<T: CoordSystem> HasVisData for Q3BspFile<T> { - type VisibleIterator = IntoIter<ClusterId>; - - fn all_visible_from(&self, from: ClusterId) -> Self::VisibleIterator { - let mut visible = vec![]; - - for (idx, val) in self.visdata[from as usize].iter().enumerate() { - if *val { - visible.push(idx as u32); - } - } - - visible.into_iter() - } - - fn cluster_visible_from(&self, from: ClusterId, dest: ClusterId) -> bool { - self.visdata[from as usize][dest as usize] - } -} diff --git a/stockton-levels/src/traits/brushes.rs b/stockton-levels/src/traits/brushes.rs deleted file mode 100644 index 911d068..0000000 --- a/stockton-levels/src/traits/brushes.rs +++ /dev/null @@ -1,27 +0,0 @@ -//! Parses the brushes & brushsides lumps from a bsp file - -use super::HasPlanes; -use crate::coords::CoordSystem; - -/// One brush record. Used for collision detection. -/// "Each brush describes a convex volume as defined by its surrounding surfaces." -#[derive(Debug, Clone, PartialEq)] -pub struct Brush { - pub sides: Box<[BrushSide]>, - pub texture_idx: usize, -} - -/// Bounding surface for brush. -#[derive(Debug, Clone, PartialEq)] -pub struct BrushSide { - pub plane_idx: usize, - pub texture_idx: usize, - pub is_opposing: bool, -} - -pub trait HasBrushes<S: CoordSystem>: HasPlanes<S> { - type BrushesIter<'a>: Iterator<Item = &'a Brush>; - - fn brushes_iter(&self) -> Self::BrushesIter<'_>; - fn get_brush(&self, index: u32) -> &Brush; -} diff --git a/stockton-levels/src/traits/effects.rs b/stockton-levels/src/traits/effects.rs deleted file mode 100644 index 75e696e..0000000 --- a/stockton-levels/src/traits/effects.rs +++ /dev/null @@ -1,19 +0,0 @@ -use super::HasBrushes; -use crate::coords::CoordSystem; - -/// One effect definition -#[derive(Debug, Clone, PartialEq)] -pub struct Effect { - /// The name of the effect - always 64 characters long - pub name: String, - - /// The brush used for this effect - pub brush_idx: u32, // todo: unknown: i32 -} - -pub trait HasEffects<S: CoordSystem>: HasBrushes<S> { - type EffectsIter<'a>: Iterator<Item = &'a Effect>; - - fn effects_iter(&self) -> Self::EffectsIter<'_>; - fn get_effect(&self, index: u32) -> &Effect; -} diff --git a/stockton-levels/src/traits/entities.rs b/stockton-levels/src/traits/entities.rs deleted file mode 100644 index 330ef35..0000000 --- a/stockton-levels/src/traits/entities.rs +++ /dev/null @@ -1,14 +0,0 @@ -use std::collections::HashMap; -use std::iter::Iterator; - -#[derive(Debug, Clone, PartialEq)] -/// A game entity -pub struct Entity { - pub attributes: HashMap<String, String>, -} - -pub trait HasEntities { - type EntitiesIter<'a>: Iterator<Item = &'a Entity>; - - fn entities_iter(&self) -> Self::EntitiesIter<'_>; -} diff --git a/stockton-levels/src/traits/faces.rs b/stockton-levels/src/traits/faces.rs deleted file mode 100644 index 00addc4..0000000 --- a/stockton-levels/src/traits/faces.rs +++ /dev/null @@ -1,42 +0,0 @@ -use na::{Vector2, Vector3}; -use std::ops::Range; - -use super::{HasEffects, HasLightMaps, HasMeshVerts, HasTextures}; -use crate::coords::CoordSystem; - -#[derive(Debug, Clone, Copy, PartialEq)] -#[repr(i32)] -pub enum FaceType { - Polygon = 1, - Patch = 2, - Mesh = 3, - Billboard = 4, -} - -#[derive(Debug, Clone, PartialEq)] -pub struct Face { - pub face_type: FaceType, - pub texture_idx: u32, - pub effect_idx: Option<u32>, - pub lightmap_idx: Option<u32>, - pub vertices_idx: Range<u32>, - pub meshverts_idx: Range<u32>, - - pub map_start: Vector2<u32>, - pub map_size: Vector2<u32>, - pub map_origin: Vector3<f32>, - pub map_vecs: [Vector3<f32>; 2], - - pub normal: Vector3<f32>, - pub size: Vector2<u32>, -} - -pub trait HasFaces<S: CoordSystem>: - HasTextures + HasEffects<S> + HasLightMaps + HasMeshVerts<S> -{ - type FacesIter<'a>: Iterator<Item = &'a Face>; - - fn faces_iter(&self) -> Self::FacesIter<'_>; - fn faces_len(&self) -> u32; - fn get_face(&self, index: u32) -> &Face; -} diff --git a/stockton-levels/src/traits/light_maps.rs b/stockton-levels/src/traits/light_maps.rs deleted file mode 100644 index 0ee468a..0000000 --- a/stockton-levels/src/traits/light_maps.rs +++ /dev/null @@ -1,45 +0,0 @@ -use std::fmt; - -use crate::types::Rgb; - -/// Stores light map textures that help make surface lighting more realistic -#[derive(Clone)] -pub struct LightMap { - pub map: [[Rgb; 128]; 128], -} - -impl PartialEq for LightMap { - fn eq(&self, other: &LightMap) -> bool { - for x in 0..128 { - for y in 0..128 { - if self.map[x][y] != other.map[x][y] { - return false; - } - } - } - true - } -} - -impl fmt::Debug for LightMap { - // rust can't derive debug for 3d arrays so done manually - // \_( )_/ - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "LightMap {{ map: [")?; - for c in self.map.iter() { - write!(f, "[")?; - for x in c.iter() { - write!(f, "{:?}, ", x)?; - } - write!(f, "], ")?; - } - write!(f, "}}") - } -} - -pub trait HasLightMaps { - type LightMapsIter<'a>: Iterator<Item = &'a LightMap>; - - fn lightmaps_iter(&self) -> Self::LightMapsIter<'_>; - fn get_lightmap(&self, index: u32) -> &LightMap; -} diff --git a/stockton-levels/src/traits/light_vols.rs b/stockton-levels/src/traits/light_vols.rs deleted file mode 100644 index 2014fad..0000000 --- a/stockton-levels/src/traits/light_vols.rs +++ /dev/null @@ -1,15 +0,0 @@ -use crate::types::Rgb; - -#[derive(Debug, Clone, Copy)] -pub struct LightVol { - pub ambient: Rgb, - pub directional: Rgb, - pub dir: [u8; 2], -} - -pub trait HasLightVols { - type LightVolsIter<'a>: Iterator<Item = &'a LightVol>; - - fn lightvols_iter(&self) -> Self::LightVolsIter<'_>; - fn get_lightvol(&self, index: u32) -> &LightVol; -} diff --git a/stockton-levels/src/traits/mod.rs b/stockton-levels/src/traits/mod.rs deleted file mode 100644 index 84fa7eb..0000000 --- a/stockton-levels/src/traits/mod.rs +++ /dev/null @@ -1,27 +0,0 @@ -//! Traits for parts of files that can exist - -pub mod brushes; -pub mod effects; -pub mod entities; -pub mod faces; -pub mod light_maps; -pub mod light_vols; -pub mod models; -pub mod planes; -pub mod textures; -pub mod tree; -pub mod vertices; -pub mod visdata; - -pub use self::brushes::HasBrushes; -pub use self::effects::HasEffects; -pub use self::entities::HasEntities; -pub use self::faces::HasFaces; -pub use self::light_maps::HasLightMaps; -pub use self::light_vols::HasLightVols; -pub use self::models::HasModels; -pub use self::planes::HasPlanes; -pub use self::textures::HasTextures; -pub use self::tree::HasBspTree; -pub use self::vertices::{HasMeshVerts, HasVertices}; -pub use self::visdata::HasVisData; diff --git a/stockton-levels/src/traits/models.rs b/stockton-levels/src/traits/models.rs deleted file mode 100644 index 58b5f74..0000000 --- a/stockton-levels/src/traits/models.rs +++ /dev/null @@ -1,20 +0,0 @@ -use na::Vector3; -use std::ops::Range; - -use super::{HasBrushes, HasFaces}; -use crate::coords::CoordSystem; - -#[derive(Debug, Clone)] -pub struct Model { - pub mins: Vector3<f32>, - pub maxs: Vector3<f32>, - pub faces_idx: Range<u32>, - pub brushes_idx: Range<u32>, -} - -pub trait HasModels<S: CoordSystem>: HasFaces<S> + HasBrushes<S> { - type ModelsIter<'a>: Iterator<Item = &'a Model>; - - fn models_iter(&self) -> Self::ModelsIter<'_>; - fn get_model(&self, index: u32) -> &Model; -} diff --git a/stockton-levels/src/traits/planes.rs b/stockton-levels/src/traits/planes.rs deleted file mode 100644 index ed48c63..0000000 --- a/stockton-levels/src/traits/planes.rs +++ /dev/null @@ -1,27 +0,0 @@ -use crate::coords::CoordSystem; -use na::Vector3; -use std::iter::Iterator; - -/// The planes lump from a BSP file. -/// Found at lump index 2 in a q3 bsp. -#[derive(Debug, Clone)] -pub struct PlanesLump { - pub planes: Box<[Plane]>, -} - -/// Generic plane, referenced by nodes & brushsizes -#[derive(Debug, Clone, Copy, PartialEq)] -pub struct Plane { - /// Plane normal - pub normal: Vector3<f32>, - - /// Distance from origin to plane along normal - pub dist: f32, -} - -pub trait HasPlanes<S: CoordSystem> { - type PlanesIter<'a>: Iterator<Item = &'a Plane>; - - fn planes_iter(&self) -> Self::PlanesIter<'_>; - fn get_plane(&self, idx: u32) -> &Plane; -} diff --git a/stockton-levels/src/traits/textures.rs b/stockton-levels/src/traits/textures.rs deleted file mode 100644 index 75764b6..0000000 --- a/stockton-levels/src/traits/textures.rs +++ /dev/null @@ -1,147 +0,0 @@ -// This program is free software: you can redistribute it and/or modify it -// under the terms of the GNU General Public License as published by the Free -// Software Foundation, either version 3 of the License, or (at your option) -// any later version. - -// This program is distributed in the hope that it will be useful, but WITHOUT -// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for -// more details. - -// You should have received a copy of the GNU General Public License along -// with this program. If not, see <http://www.gnu.org/licenses/>. - -use std::iter::Iterator; - -#[derive(Debug, Clone, PartialEq)] -/// A texture from a BSP File. -pub struct Texture { - pub name: String, - pub surface: SurfaceFlags, - pub contents: ContentsFlags, -} - -bitflags!( - /// Extracted from the Q3 arena engine code. - /// https://github.com/id-Software/Quake-III-Arena/blob/master/code/game/surfaceflags.h - pub struct SurfaceFlags: u32 { - /// never give falling damage - const NO_DAMAGE = 0x1; - - /// affects game physics - const SLICK = 0x2; - - /// lighting from environment map - const SKY = 0x4; - - /// don't make missile explosions - const NO_IMPACT = 0x10; - - /// function as a ladder - const LADDER = 0x8; - - /// don't leave missile marks - const NO_MARKS = 0x20; - - /// make flesh sounds and effects - const FLESH = 0x40; - - /// don't generate a drawsurface at all - const NODRAW = 0x80; - - /// make a primary bsp splitter - const HINT = 0x01_00; - - /// completely ignore, allowing non-closed brushes - const SKIP = 0x02_00; - - /// surface doesn't need a lightmap - const NO_LIGHT_MAP = 0x04_00; - - /// generate lighting info at vertexes - const POINT_LIGHT = 0x08_00; - - /// clanking footsteps - const METAL_STEPS = 0x10_00; - - /// no footstep sounds - const NO_STEPS = 0x20_00; - - /// don't collide against curves with this set - const NON_SOLID = 0x40_00; - - /// act as a light filter during q3map -light - const LIGHT_FILTER = 0x80_00; - - /// do per-pixel light shadow casting in q3map - const ALPHA_SHADOW = 0x01_00_00; - - /// don't dlight even if solid (solid lava, skies) - const NO_DLIGHT = 0x02_00_00; - - /// leave a dust trail when walking on this surface - const DUST = 0x04_00_00; - } -); - -bitflags!( - /// Extracted from the Q3 arena engine code. Less documented than `SurfaceFlags`. - /// https://github.com/id-Software/Quake-III-Arena/blob/master/code/game/surfaceflags.h - pub struct ContentsFlags: u32 { - // an eye is never valid in a solid - const SOLID = 0x1; - const LAVA = 0x8; - const SLIME = 0x10; - const WATER = 0x20; - const FOG = 0x40; - - const NOT_TEAM1 = 0x00_80; - const NOT_TEAM2 = 0x01_00; - const NOT_BOT_CLIP = 0x02_00; - - const AREA_PORTAL = 0x80_00; - - /// bot specific contents type - const PLAYER_CLIP = 0x01_00_00; - - /// bot specific contents type - const MONSTER_CLIP = 0x02_00_00; - - const TELEPORTER = 0x04_00_00; - const JUMP_PAD = 0x08_00_00; - const CLUSTER_PORTAL = 0x10_00_00; - const DO_NOT_ENTER = 0x20_00_00; - const BOT_CLIP = 0x40_00_00; - const MOVER = 0x80_00_00; - - // removed before bsping an entity - const ORIGIN = 0x01_00_00_00; - - // should never be on a brush, only in game - const BODY = 0x02_00_00_00; - - /// brush not used for the bsp - const DETAIL = 0x08_00_00_00; - - /// brush not used for the bsp - const CORPSE = 0x04_00_00_00; - - /// brushes used for the bsp - const STRUCTURAL = 0x10_00_00_00; - - /// don't consume surface fragments inside - const TRANSLUCENT = 0x20_00_00_00; - - const TRIGGER = 0x40_00_00_00; - - /// don't leave bodies or items (death fog, lava) - const NODROP = 0x80_00_00_00; - } -); - -pub trait HasTextures { - type TexturesIter<'a>: Iterator<Item = &'a Texture>; - - fn textures_iter(&self) -> Self::TexturesIter<'_>; - fn get_texture(&self, idx: u32) -> Option<&Texture>; -} diff --git a/stockton-levels/src/traits/tree.rs b/stockton-levels/src/traits/tree.rs deleted file mode 100644 index f22be2c..0000000 --- a/stockton-levels/src/traits/tree.rs +++ /dev/null @@ -1,35 +0,0 @@ -//! Parses the BSP tree into a usable format - -use super::{HasBrushes, HasFaces, HasVisData}; -use crate::coords::CoordSystem; -use na::Vector3; - -/// A node in a BSP tree. -/// Either has two children *or* a leaf entry. -#[derive(Debug, Clone)] -pub struct BspNode { - pub plane_idx: u32, - pub min: Vector3<i32>, - pub max: Vector3<i32>, - pub value: BspNodeValue, -} - -#[derive(Debug, Clone)] -pub enum BspNodeValue { - Leaf(BspLeaf), - Children(Box<BspNode>, Box<BspNode>), -} - -/// A leaf in a BSP tree. -/// Will be under a `BSPNode`, min and max values are stored there. -#[derive(Debug, Clone)] -pub struct BspLeaf { - pub cluster_id: u32, - pub area: i32, - pub faces_idx: Box<[u32]>, - pub brushes_idx: Box<[u32]>, -} - -pub trait HasBspTree<S: CoordSystem>: HasFaces<S> + HasBrushes<S> + HasVisData { - fn get_bsp_root(&self) -> &BspNode; -} diff --git a/stockton-levels/src/traits/vertices.rs b/stockton-levels/src/traits/vertices.rs deleted file mode 100644 index 11cd681..0000000 --- a/stockton-levels/src/traits/vertices.rs +++ /dev/null @@ -1,52 +0,0 @@ -use crate::coords::CoordSystem; -use crate::helpers::slice_to_f32; -use crate::types::Rgba; -use na::Vector3; - -/// A vertex, used to describe a face. -#[derive(Debug, Clone, Copy, PartialEq)] -pub struct Vertex { - pub position: Vector3<f32>, - pub tex: TexCoord, - pub normal: Vector3<f32>, - pub color: Rgba, -} - -/// Represents a TexCoord. 0 = surface, 1= lightmap. -/// This could also be written as [[f32; 2]; 2] -#[derive(Debug, Clone, Copy, PartialEq)] -pub struct TexCoord { - pub u: [f32; 2], - pub v: [f32; 2], -} - -impl TexCoord { - /// Internal function. Converts a slice to a TexCoord. - pub fn from_bytes(bytes: &[u8; 16]) -> TexCoord { - TexCoord { - u: [slice_to_f32(&bytes[0..4]), slice_to_f32(&bytes[8..12])], - v: [slice_to_f32(&bytes[4..8]), slice_to_f32(&bytes[12..16])], - } - } -} - -/// A vertex offset, used to describe generalised triangle meshes -pub type MeshVert = u32; - -pub trait HasVertices<S: CoordSystem> { - type VerticesIter<'a>: Iterator<Item = &'a Vertex>; - - fn vertices_iter(&self) -> Self::VerticesIter<'_>; - fn get_vertex(&self, index: u32) -> &Vertex; -} - -pub trait HasMeshVerts<S: CoordSystem>: HasVertices<S> { - type MeshVertsIter<'a>: Iterator<Item = &'a MeshVert>; - - fn meshverts_iter(&self) -> Self::MeshVertsIter<'_>; - fn get_meshvert(&self, index: u32) -> MeshVert; - - fn resolve_meshvert(&self, index: u32, base: u32) -> &Vertex { - self.get_vertex(self.get_meshvert(index) + base) - } -} diff --git a/stockton-levels/src/traits/visdata.rs b/stockton-levels/src/traits/visdata.rs deleted file mode 100644 index 7cd4d20..0000000 --- a/stockton-levels/src/traits/visdata.rs +++ /dev/null @@ -1,27 +0,0 @@ -// This program is free software: you can redistribute it and/or modify it -// under the terms of the GNU General Public License as published by the Free -// Software Foundation, either version 3 of the License, or (at your option) -// any later version. - -// This program is distributed in the hope that it will be useful, but WITHOUT -// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or -// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for -// more details. - -// You should have received a copy of the GNU General Public License along -// with this program. If not, see <http://www.gnu.org/licenses/>. - -use std::iter::Iterator; - -pub type ClusterId = u32; - -pub trait HasVisData { - /// The iterator returned from all_visible_from - type VisibleIterator: Iterator<Item = ClusterId>; - - /// Returns an iterator of all clusters visible from the given Cluster ID - fn all_visible_from(&self, from: ClusterId) -> Self::VisibleIterator; - - /// Returns true if `dest` is visible from `from`. - fn cluster_visible_from(&self, from: ClusterId, dest: ClusterId) -> bool; -} diff --git a/stockton-levels/src/types.rs b/stockton-levels/src/types.rs index dd42a5e..dad824c 100644 --- a/stockton-levels/src/types.rs +++ b/stockton-levels/src/types.rs @@ -1,10 +1,10 @@ //! Various types used in parsed BSP files. +use serde::{Deserialize, Serialize}; use std::convert::TryInto; -use thiserror::Error; /// RGBA Colour (0-255) -#[derive(Debug, Clone, Copy, PartialEq)] +#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)] pub struct Rgba { pub r: u8, pub g: u8, @@ -32,7 +32,7 @@ impl Rgba { } /// RGB Colour (0-255) -#[derive(Debug, Clone, Copy, PartialEq)] +#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)] pub struct Rgb { pub r: u8, pub g: u8, @@ -65,16 +65,3 @@ impl Rgb { Rgb::from_bytes(slice.try_into().unwrap()) } } - -#[derive(Error, Debug)] -/// An error encountered while parsing. -pub enum ParseError { - #[error("Unsupported format")] - Unsupported, - - #[error("Invalid file")] - Invalid, -} - -/// Standard result type. -pub type Result<T> = std::result::Result<T, ParseError>; |