ds3 0.1.0

Pure-Rust parser for Autodesk 3D Studio (.3ds) binary files
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

use ds3::{parse, MeshBuffers};
use std::fs;

#[test]
fn parse_simple_cube() {
    let bytes = fs::read("tests/fixtures/simple_cube.3ds").expect("fixture missing");
    let scene = parse(&bytes).expect("parse failed");

    assert_eq!(scene.meshes.len(), 1, "expected one mesh");
    let mesh = &scene.meshes[0];

    assert_eq!(mesh.name, "Cube");
    assert_eq!(mesh.vertices.len(), 8);
    assert_eq!(mesh.faces.len(), 12);
    assert_eq!(mesh.uvs.len(), 8);
    assert_eq!(mesh.smooth_groups.len(), 12);
    assert!(mesh.smooth_groups.iter().all(|&g| g == 1));
    assert_eq!(mesh.material, None); // MSH_MAT_GROUP not present in fixture

    assert_eq!(scene.materials, vec!["Default"]);
}

#[test]
fn flat_buffers_unit_normals() {
    let bytes = fs::read("tests/fixtures/simple_cube.3ds").expect("fixture missing");
    let scene = parse(&bytes).expect("parse failed");
    let mesh = &scene.meshes[0];

    let MeshBuffers {
        positions,
        normals,
        uvs,
        indices,
    } = mesh.to_flat_buffers();

    // Flat shading expands to one vertex per face corner.
    assert_eq!(positions.len(), mesh.faces.len() * 3);
    assert_eq!(normals.len(), mesh.faces.len() * 3);
    assert_eq!(uvs.len(), mesh.faces.len() * 3);
    assert_eq!(indices.len(), mesh.faces.len() * 3);

    for n in &normals {
        let len_sq = n[0] * n[0] + n[1] * n[1] + n[2] * n[2];
        assert!(
            (len_sq - 1.0).abs() < 1e-5,
            "flat normal not unit length: {:?} (len² = {})",
            n,
            len_sq
        );
    }
}

#[test]
fn smooth_buffers_unit_normals() {
    let bytes = fs::read("tests/fixtures/simple_cube.3ds").expect("fixture missing");
    let scene = parse(&bytes).expect("parse failed");
    let mesh = &scene.meshes[0];

    let MeshBuffers {
        positions,
        normals,
        indices,
        ..
    } = mesh.to_smooth_buffers();

    // With all faces in the same smooth group, vertices should be shared.
    assert!(
        positions.len() < mesh.faces.len() * 3,
        "smooth shading should share vertices, got {} positions",
        positions.len()
    );
    assert_eq!(indices.len(), mesh.faces.len() * 3);

    for n in &normals {
        let len_sq = n[0] * n[0] + n[1] * n[1] + n[2] * n[2];
        assert!(
            (len_sq - 1.0).abs() < 1e-5,
            "smooth normal not unit length: {:?} (len² = {})",
            n,
            len_sq
        );
    }
}

#[test]
fn smooth_shares_vertices_across_faces() {
    let bytes = fs::read("tests/fixtures/simple_cube.3ds").expect("fixture missing");
    let scene = parse(&bytes).expect("parse failed");
    let mesh = &scene.meshes[0];

    let flat = mesh.to_flat_buffers();
    let smooth = mesh.to_smooth_buffers();

    // Smooth shading should produce strictly fewer unique vertices than flat.
    assert!(
        smooth.positions.len() < flat.positions.len(),
        "smooth ({}) should have fewer vertices than flat ({})",
        smooth.positions.len(),
        flat.positions.len()
    );
}