1use axiolid_core::{Point3, Vec3};
28use axiolid_mesh::{NormalAttribute, PolygonFace, PolygonMesh, TriMesh};
29use axiolid_model::{GeometryNode, NodeId};
30use ifc_model::EntityId;
31
32use crate::error::GeometryResult;
33use crate::lower::session::LoweringSession;
34use crate::resource::point::CartesianPointList3D;
35use crate::solid::tessellated::{
36 irregular_network, IndexedPolygonalFace, IndexedPolygonalFaceWithVoids, PolygonalFaceSet,
37 TriangulatedFaceSet, TriangulatedIrregularNetwork,
38};
39use crate::transform::Transform;
40
41const KIND: &str = "tessellated face set";
43
44fn positions(
49 session: &mut LoweringSession<'_>,
50 owner: EntityId,
51 coordinates: EntityId,
52 frame: Transform,
53) -> GeometryResult<Vec<Point3>> {
54 let entity = session.entity(owner, coordinates)?;
55 let raw = CartesianPointList3D::new(coordinates, entity).coordinates()?;
56 Ok(raw
57 .into_iter()
58 .map(|point| {
59 let scaled = point.map(|value| session.units().length(value));
60 Point3::from_array(frame.apply(scaled))
61 })
62 .collect())
63}
64
65fn checked_index(
71 session: &LoweringSession<'_>,
72 owner: EntityId,
73 index: usize,
74 vertex_count: usize,
75 field: &str,
76) -> GeometryResult<u32> {
77 if index >= vertex_count {
78 return Err(session.degenerate(
79 owner,
80 KIND,
81 format!(
82 "{field} addresses vertex {} but Coordinates has {vertex_count}",
83 index + 1
84 ),
85 ));
86 }
87 Ok(index as u32)
88}
89
90pub fn lower_triangulated_face_set_node(
95 session: &mut LoweringSession<'_>,
96 id: EntityId,
97 frame: Transform,
98) -> GeometryResult<NodeId> {
99 if let Some(node) = session.memoized(id, KIND, frame) {
100 return Ok(node);
101 }
102 session.enter(id, KIND)?;
103 let result = build_triangulated(session, id, frame);
104 session.exit(id);
105 let node = result?;
106 session.memoize(id, KIND, frame, node);
107 Ok(node)
108}
109
110fn build_triangulated(
111 session: &mut LoweringSession<'_>,
112 id: EntityId,
113 frame: Transform,
114) -> GeometryResult<NodeId> {
115 let entity = session.entity(id, id)?;
116 let view = TriangulatedFaceSet::new(id, entity);
117 let coordinates = view.coordinates()?;
118 let triangles = view.triangles_0based()?;
119 if entity.is_type(irregular_network::TYPE) {
124 TriangulatedIrregularNetwork::new(id, entity).admit(triangles.len())?;
125 }
126 let normals = view.normals();
127 let positions = positions(session, id, coordinates, frame)?;
128
129 let index_count = session.check_aggregate(
132 id,
133 "IFCTRIANGULATEDFACESET",
134 "triangle indices",
135 triangles.len() as u128 * 3,
136 )?;
137 let mut indices = Vec::with_capacity(index_count);
138 for triangle in &triangles {
139 for corner in triangle {
140 indices.push(checked_index(
141 session,
142 id,
143 *corner,
144 positions.len(),
145 "CoordIndex",
146 )?);
147 }
148 }
149
150 let mut mesh = TriMesh::new(positions, indices);
151 if let Some(values) = normals {
155 mesh.normals = Some(NormalAttribute {
156 values: values
157 .into_iter()
158 .map(|normal| Vec3::from_array(frame.apply_direction(normal)))
159 .collect(),
160 indices: None,
161 });
162 }
163 mesh.attributes = texture::channels(session, id, triangles.len())?;
166 session.node_for(id, GeometryNode::TriMesh(mesh))
167}
168
169pub fn lower_polygonal_face_set_node(
171 session: &mut LoweringSession<'_>,
172 id: EntityId,
173 frame: Transform,
174) -> GeometryResult<NodeId> {
175 if let Some(node) = session.memoized(id, KIND, frame) {
176 return Ok(node);
177 }
178 session.enter(id, KIND)?;
179 let result = build_polygonal(session, id, frame);
180 session.exit(id);
181 let node = result?;
182 session.memoize(id, KIND, frame, node);
183 Ok(node)
184}
185
186fn build_polygonal(
187 session: &mut LoweringSession<'_>,
188 id: EntityId,
189 frame: Transform,
190) -> GeometryResult<NodeId> {
191 let entity = session.entity(id, id)?;
192 let view = PolygonalFaceSet::new(id, entity);
193 let coordinates = view.coordinates()?;
194 let face_refs = view.faces()?;
195 let pn = view.pn_index_0based()?;
196 let positions = positions(session, id, coordinates, frame)?;
197
198 let mut faces = Vec::with_capacity(face_refs.len());
199 for face_ref in &face_refs {
200 let face_entity = session.entity(id, *face_ref)?;
201 let face = IndexedPolygonalFace::new(*face_ref, face_entity);
202 let outer = resolve_loop(session, id, &face.outer_loop_0based()?, &pn, &positions)?;
203
204 let holes = if face.has_voids() {
207 IndexedPolygonalFaceWithVoids::new(*face_ref, face_entity)
208 .inner_loops_0based()?
209 .iter()
210 .map(|inner| resolve_loop(session, id, inner, &pn, &positions))
211 .collect::<GeometryResult<Vec<_>>>()?
212 } else {
213 Vec::new()
214 };
215
216 faces.push(PolygonFace { outer, holes });
217 }
218
219 session.node_for(
220 id,
221 GeometryNode::PolygonMesh(PolygonMesh { positions, faces }),
222 )
223}
224
225fn resolve_loop(
231 session: &LoweringSession<'_>,
232 owner: EntityId,
233 authored: &[usize],
234 pn: &Option<Vec<usize>>,
235 positions: &[Point3],
236) -> GeometryResult<Vec<u32>> {
237 authored
238 .iter()
239 .map(|index| {
240 let direct = match pn {
241 Some(map) => *map.get(*index).ok_or_else(|| {
242 session.degenerate(
243 owner,
244 KIND,
245 format!(
246 "CoordIndex {} is past the end of PnIndex ({} entries)",
247 index + 1,
248 map.len()
249 ),
250 )
251 })?,
252 None => *index,
253 };
254 checked_index(session, owner, direct, positions.len(), "CoordIndex")
255 })
256 .collect()
257}
258
259#[cfg(test)]
260mod tests;
261
262mod texture;
263pub use texture::UV_CHANNEL;