spottedcat 0.9.0

Rusty SpottedCat simple game engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use crate::model::Vertex;

/// Loads a simple OBJ file from a byte slice.
/// Supports only triangular faces (f v1/vt1/vn1 v2/vt2/vn2 v3/vt3/vn3).
/// Parses OBJ data into raw vertex and index buffers.
pub fn parse_obj_data(data: &[u8]) -> anyhow::Result<(Vec<Vertex>, Vec<u32>)> {
    let text = std::str::from_utf8(data)?;
    let mut positions = Vec::new();
    let mut uvs = Vec::new();
    let mut normals = Vec::new();
    let mut vertices = Vec::new();
    let mut indices = Vec::new();
    let mut vertex_cache = std::collections::HashMap::new();

    for line in text.lines() {
        let line = line.trim();
        if line.is_empty() || line.starts_with('#') {
            continue;
        }

        let parts: Vec<&str> = line.split_whitespace().collect();
        if parts.is_empty() {
            continue;
        }

        match parts[0] {
            "v" => {
                if parts.len() >= 4 {
                    positions.push([
                        parts[1].parse::<f32>()?,
                        parts[2].parse::<f32>()?,
                        parts[3].parse::<f32>()?,
                    ]);
                }
            }
            "vt" => {
                if parts.len() >= 3 {
                    uvs.push([
                        parts[1].parse::<f32>()?,
                        1.0 - parts[2].parse::<f32>()?, // Flip Y for wgpu
                    ]);
                }
            }
            "vn" => {
                if parts.len() >= 4 {
                    normals.push([
                        parts[1].parse::<f32>()?,
                        parts[2].parse::<f32>()?,
                        parts[3].parse::<f32>()?,
                    ]);
                }
            }
            "f" => {
                // Support up to quads by triangulating (triangle fan)
                let face_indices: Vec<(usize, Option<usize>, Option<usize>)> = parts[1..]
                    .iter()
                    .map(|p| {
                        let sub: Vec<&str> = p.split('/').collect();
                        let v = sub[0].parse::<usize>().unwrap_or(1) - 1;
                        let vt = if sub.len() > 1 && !sub[1].is_empty() {
                            Some(sub[1].parse::<usize>().unwrap_or(1) - 1)
                        } else {
                            None
                        };
                        let vn = if sub.len() > 2 && !sub[2].is_empty() {
                            Some(sub[2].parse::<usize>().unwrap_or(1) - 1)
                        } else {
                            None
                        };
                        (v, vt, vn)
                    })
                    .collect();

                for i in 1..face_indices.len() - 1 {
                    let tris = [face_indices[0], face_indices[i], face_indices[i + 1]];
                    for key in tris {
                        if let Some(&idx) = vertex_cache.get(&key) {
                            indices.push(idx);
                        } else {
                            let idx = vertices.len() as u32;
                            vertices.push(Vertex {
                                pos: positions[key.0],
                                uv: key.1.map(|u| uvs[u]).unwrap_or([0.0, 0.0]),
                                normal: key.2.map(|n| normals[n]).unwrap_or([0.0, 1.0, 0.0]),
                                tangent: [0.0, 0.0, 0.0],
                                joint_indices: [0; 4],
                                joint_weights: [0.0; 4],
                                ..Default::default()
                            });
                            vertex_cache.insert(key, idx);
                            indices.push(idx);
                        }
                    }
                }
            }
            _ => {}
        }
    }

    Ok((vertices, indices))
}

/// Loads a simple OBJ file from a byte slice into a Model.
pub fn load_obj_from_bytes(
    ctx: &mut crate::Context,
    data: &[u8],
) -> anyhow::Result<crate::model::Model> {
    let (vertices, indices) = parse_obj_data(data)?;
    crate::model::Model::new(ctx, &vertices, &indices)
}