uvunwrap 0.2.0

Pure-Rust automatic UV unwrapping: chart segmentation, LSCM parameterization and atlas packing (lightmap UVs, baking)
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Input validation: every documented requirement on [`Options`] and
//! [`MeshInput`], reported as an [`Error`] naming the offending option,
//! array or instance.

use crate::{Density, Error, MeshInput, Options};

/// Checks the options against their documented ranges.
pub(crate) fn options(o: &Options) -> Result<(), Error> {
    let invalid = |option, requirement| {
        Err(Error::InvalidOption {
            option,
            requirement,
        })
    };
    if !(o.max_chart_angle > 0.0 && o.max_chart_angle < 90.0) {
        return invalid("max_chart_angle", "in (0, 90)");
    }
    if !(o.max_area_distortion >= 1.0 && o.max_area_distortion.is_finite()) {
        return invalid("max_area_distortion", "finite and >= 1");
    }
    let page_size = match o.density {
        Density::Auto { page_size } => Some(page_size),
        Density::Fixed {
            texels_per_unit,
            page_size,
        } => {
            if !(texels_per_unit > 0.0 && texels_per_unit.is_finite()) {
                return invalid("density.texels_per_unit", "finite and > 0");
            }
            page_size
        }
    };
    if let Some(size) = page_size {
        if size <= o.padding.saturating_mul(2) {
            return invalid("density.page_size", "greater than 2 × padding");
        }
        if o.block_align && size % 4 != 0 {
            return invalid("density.page_size", "a multiple of 4 with block_align");
        }
    }
    Ok(())
}

/// Checks mesh `mi` against its documented requirements.
pub(crate) fn mesh(mi: usize, m: &MeshInput<'_>) -> Result<(), Error> {
    if m.indices.len() % 3 != 0 {
        return Err(Error::InvalidIndexCount {
            mesh: mi,
            count: m.indices.len(),
        });
    }
    if let Some(&index) = m.indices.iter().find(|&&i| i as usize >= m.positions.len()) {
        return Err(Error::IndexOutOfRange {
            mesh: mi,
            index,
            vertex_count: m.positions.len(),
        });
    }
    if let Some(vertex) = m
        .positions
        .iter()
        .position(|p| p.iter().any(|c| !c.is_finite()))
    {
        return Err(Error::NonFinitePosition { mesh: mi, vertex });
    }
    let face_count = m.indices.len() / 3;
    let per_face = [
        ("face_materials", m.face_materials.map(<[_]>::len)),
        ("ignored_faces", m.ignored_faces.map(<[_]>::len)),
        ("polygons", m.polygons.map(<[_]>::len)),
    ];
    for (field, len) in per_face {
        if let Some(len) = len.filter(|&l| l != face_count) {
            return Err(Error::FaceDataLength {
                mesh: mi,
                field,
                len,
                face_count,
            });
        }
    }
    if let Some(polygons) = m.polygons {
        // Triangles grouped by polygon: neighbours in this order with the
        // same id belong to one polygon and must agree.
        let mut order: Vec<usize> = (0..face_count).collect();
        order.sort_unstable_by_key(|&f| (polygons[f], f));
        for pair in order.windows(2) {
            let (a, b) = (pair[0], pair[1]);
            if polygons[a] != polygons[b] {
                continue;
            }
            let mixed = |field| Error::MixedPolygon {
                mesh: mi,
                polygon: polygons[a],
                field,
            };
            if m.face_materials.is_some_and(|fm| fm[a] != fm[b]) {
                return Err(mixed("face_materials"));
            }
            if m.ignored_faces.is_some_and(|ig| ig[a] != ig[b]) {
                return Err(mixed("ignored_faces"));
            }
        }
    }
    if let Some(uvs) = m.existing_uvs {
        if uvs.len() != m.positions.len() {
            return Err(Error::UvCount {
                mesh: mi,
                len: uvs.len(),
                vertex_count: m.positions.len(),
            });
        }
        if let Some(vertex) = uvs.iter().position(|p| p.iter().any(|c| !c.is_finite())) {
            return Err(Error::NonFiniteUv { mesh: mi, vertex });
        }
    }
    let valid = |k: f32| k > 0.0 && k.is_finite();
    if !valid(m.scale) {
        return Err(Error::InvalidScale {
            mesh: mi,
            instance: None,
        });
    }
    if let Some(i) = m.instance_scales.iter().position(|&k| !valid(k)) {
        return Err(Error::InvalidScale {
            mesh: mi,
            instance: Some(i),
        });
    }
    Ok(())
}