procedural_modelling 0.4.2

A framework-agnostic Procedural Modelling crate.
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

use crate::{
    halfedge::{
        HalfEdgeFaceImpl, HalfEdgeImpl, HalfEdgeImplMeshType, HalfEdgeMeshImpl, HalfEdgeVertexImpl,
    },
    mesh::{
        EmptyEdgePayload, EmptyFacePayload, EmptyMeshPayload, EuclideanMeshType, MeshType,
        MeshType3D, MeshTypeHalfEdge,
    },
};

use super::{NdAffine, NdRotate, Polygon2d, VecN, VertexPayloadPNU};

/// A mesh type for nalgebra with
/// - nd vertices,
/// - usize indices,
/// - no face or edge payload,
/// - f64 vertex positions, normals, and uv coordinates
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
pub struct MeshTypeNd64PNU<const D: usize>;

/// 2d variant of MeshTypeNd64PNU
pub type MeshType2d64PNU = MeshTypeNd64PNU<2>;
/// 3d variant of MeshTypeNd64PNU
pub type MeshType3d64PNU = MeshTypeNd64PNU<3>;
/// 4d variant of MeshTypeNd64PNU
pub type MeshType4d64PNU = MeshTypeNd64PNU<4>;

impl<const D: usize> MeshType for MeshTypeNd64PNU<D> {
    type E = usize;
    type V = usize;
    type F = usize;
    type EP = EmptyEdgePayload<Self>;
    type VP = VertexPayloadPNU<f64, D>;
    type FP = EmptyFacePayload<Self>;
    type MP = EmptyMeshPayload<Self>;
    type Mesh = MeshNd64<D>;
    type Face = HalfEdgeFaceImpl<Self>;
    type Edge = HalfEdgeImpl<Self>;
    type Vertex = HalfEdgeVertexImpl<Self>;
}
impl<const D: usize> EuclideanMeshType<D> for MeshTypeNd64PNU<D> {
    type S = f64;
    type Vec = VecN<f64, D>;
    type Vec2 = VecN<f64, 2>;
    type Trans = NdAffine<f64, D>;
    type Rot = NdRotate<f64, D>;
    type Poly = Polygon2d<f64>;
}
impl<const D: usize> HalfEdgeImplMeshType for MeshTypeNd64PNU<D> {}
impl<const D: usize> MeshTypeHalfEdge for MeshTypeNd64PNU<D> {}
impl MeshType3D for MeshTypeNd64PNU<3> {}

/// A mesh with
/// - nalgebra nd vertices,
/// - usize indices,
/// - f64 positions, normals, and uv coordinates
pub type MeshNd64<const D: usize> = HalfEdgeMeshImpl<MeshTypeNd64PNU<D>>;
/// 2d variant of MeshNd64
pub type Mesh2d64 = MeshNd64<2>;
/// 3d variant of MeshNd64
pub type Mesh3d64 = MeshNd64<3>;
/// 4d variant of MeshNd64
pub type Mesh4d64 = MeshNd64<4>;

/// 64-bit 3d variant of the half-edge vertex
pub type Mesh3d64Vertex = HalfEdgeVertexImpl<MeshTypeNd64PNU<3>>;

/// 64-bit 3d variant of the half-edge edge
pub type Mesh3d64Edge = HalfEdgeImpl<MeshTypeNd64PNU<3>>;

/// 64-bit 3d variant of the half-edge face
pub type Mesh3d64Face = HalfEdgeFaceImpl<MeshTypeNd64PNU<3>>;