path: root/engine/src/file_format/wavefront/obj.rs

//! OBJ file format parsing.
//!
//! File format documentation: <https://paulbourke.net/dataformats/obj>

use crate::color::Color;
use crate::file_format::wavefront::common::{
    keyword,
    parse_statement_line,
    ParsingError,
    Triplet,
};
use crate::mesh::Mesh;
use crate::util::try_option;
use crate::vector::{Vec2, Vec3};
use crate::vertex::{Builder as VertexBuilder, Vertex};

/// The output from parsing the content of a Wavefront `.obj` using [`parse`].
#[derive(Debug)]
#[non_exhaustive]
pub struct Obj
{
    pub mesh: Mesh,
}

/// Parses the content of a Wavefront `.obj`.
///
/// # Errors
/// Will return `Err` if the `.obj` content is formatted incorrectly.
pub fn parse(obj_content: &str) -> Result<Obj, Error>
{
    let lines = obj_content
        .lines()
        .enumerate()
        .map(|(line_index, line)| (line_index + 1, line));

    let statements = lines
        .map(|(line_no, line)| (line_no, parse_statement_line::<Keyword>(line, line_no)))
        .filter_map(|(line_no, result)| {
            let opt_statement = match result {
                Ok(opt_statement) => opt_statement,
                Err(err) => {
                    return Some(Err(err));
                }
            };

            Some(Ok((line_no, opt_statement?)))
        })
        .collect::<Result<Vec<_>, _>>()?;

    let vertex_positions = statements
        .iter()
        .filter_map(|(line_no, statement)| {
            if statement.keyword != Keyword::V {
                return None;
            }

            let x = try_option!(statement.get_float_arg(0, *line_no));
            let y = try_option!(statement.get_float_arg(1, *line_no));
            let z = try_option!(statement.get_float_arg(2, *line_no));

            Some(Ok(Vec3 { x, y, z }))
        })
        .collect::<Result<Vec<_>, _>>()?;

    let texture_positions = statements
        .iter()
        .filter_map(|(line_no, statement)| {
            if statement.keyword != Keyword::Vt {
                return None;
            }

            let u = try_option!(statement.get_float_arg(0, *line_no));
            let v = try_option!(statement.get_float_arg(1, *line_no));
            // let w = try_option!(statement.get_float_arg(2, *line_no));

            Some(Ok(Vec2 { x: u, y: v }))
        })
        .collect::<Result<Vec<_>, _>>()?;

    let vertex_normals = statements
        .iter()
        .filter_map(|(line_no, statement)| {
            if statement.keyword != Keyword::Vn {
                return None;
            }

            let i = try_option!(statement.get_float_arg(0, *line_no));
            let j = try_option!(statement.get_float_arg(1, *line_no));
            let k = try_option!(statement.get_float_arg(2, *line_no));

            Some(Ok(Vec3 { x: i, y: j, z: k }))
        })
        .collect::<Result<Vec<_>, _>>()?;

    let faces = statements
        .iter()
        .filter_map(|(line_no, statement)| {
            if statement.keyword != Keyword::F {
                return None;
            }

            let vertex_a = try_option!(statement.get_triplet_arg(0, *line_no)).into();
            let vertex_b = try_option!(statement.get_triplet_arg(1, *line_no)).into();
            let vertex_c = try_option!(statement.get_triplet_arg(2, *line_no)).into();

            Some(Ok([vertex_a, vertex_b, vertex_c]))
        })
        .collect::<Result<Vec<[FaceVertex; 3]>, _>>()?;

    let vertices = faces
        .iter()
        .flatten()
        .map(|face_vertex| {
            face_vertex_to_vertex(
                face_vertex,
                Data {
                    vertex_positions: &vertex_positions,
                    texture_positions: &texture_positions,
                    vertex_normals: &vertex_normals,
                },
            )
        })
        .collect::<Result<Vec<_>, Error>>()?;

    Ok(Obj {
        mesh: Mesh::new(
            vertices,
            Some(
                faces
                    .iter()
                    .flatten()
                    .enumerate()
                    .map(|(index, _)| {
                        u32::try_from(index).map_err(|_| Error::FaceIndexTooBig(index))
                    })
                    .collect::<Result<Vec<_>, _>>()?,
            ),
        ),
    })
}

struct Data<'a>
{
    vertex_positions: &'a [Vec3<f32>],
    texture_positions: &'a [Vec2<f32>],
    vertex_normals: &'a [Vec3<f32>],
}

fn face_vertex_to_vertex(face_vertex: &FaceVertex, data: Data) -> Result<Vertex, Error>
{
    let vertex_pos = *data
        .vertex_positions
        .get(face_vertex.position as usize - 1)
        .ok_or(Error::FaceVertexPositionNotFound {
            vertex_pos_index: face_vertex.position,
        })?;

    let face_vertex_texture = face_vertex
        .texture
        .ok_or(Error::NoFaceVertexTextureNotSupported)?;

    let texture_pos = *data
        .texture_positions
        .get(face_vertex_texture as usize - 1)
        .ok_or(Error::FaceTexturePositionNotFound {
            texture_pos_index: face_vertex_texture,
        })?;

    let face_vertex_normal = face_vertex
        .normal
        .ok_or(Error::NoFaceVertexNormalNotSupported)?;

    let vertex_normal = *data
        .vertex_normals
        .get(face_vertex_normal as usize - 1)
        .ok_or(Error::FaceVertexNormalNotFound {
            vertex_normal_index: face_vertex_normal,
        })?;

    Ok(VertexBuilder::new()
        .pos(vertex_pos)
        .color(Color::WHITE_F32)
        .texture_coords(texture_pos)
        .normal(vertex_normal)
        .build()
        .unwrap())
}

#[derive(Debug, thiserror::Error)]
pub enum Error
{
    #[error(transparent)]
    ParsingError(#[from] ParsingError),

    #[error(
        "Face vertex position with index {vertex_pos_index} (1-based) was not found"
    )]
    FaceVertexPositionNotFound
    {
        vertex_pos_index: u32
    },

    #[error(
        "Face texture position with index {texture_pos_index} (1-based) was not found"
    )]
    FaceTexturePositionNotFound
    {
        texture_pos_index: u32
    },

    #[error(
        "Face vertex normal with index {vertex_normal_index} (1-based) was not found"
    )]
    FaceVertexNormalNotFound
    {
        vertex_normal_index: u32
    },

    #[error("Face index {0} is too big to fit into a 32-bit integer")]
    FaceIndexTooBig(usize),

    #[error("Face vertices without textures are not yet supported")]
    NoFaceVertexTextureNotSupported,

    #[error("Face vertices without normals are not yet supported")]
    NoFaceVertexNormalNotSupported,
}

keyword! {
    #[derive(Debug, PartialEq, Eq, Clone, Copy)]
    enum Keyword {
        #[keyword(rename = "v")]
        V,

        #[keyword(rename = "vn")]
        Vn,

        #[keyword(rename = "vt")]
        Vt,

        #[keyword(rename = "o")]
        O,

        #[keyword(rename = "s")]
        S,

        #[keyword(rename = "f")]
        F,
    }
}

#[derive(Debug)]
struct FaceVertex
{
    position: u32,
    texture: Option<u32>,
    normal: Option<u32>,
}

impl From<Triplet> for FaceVertex
{
    fn from(triplet: Triplet) -> Self
    {
        Self {
            position: triplet.0,
            texture: triplet.1,
            normal: triplet.2,
        }
    }
}