ifc_geometry/compile/
layers.rs1use axiolid_contracts::ExecutionOptions;
5use axiolid_mesh_compile_contract::MeshCompiler;
6use axiolid_model::GeometryNode;
7use ifc_model::{EntityId, Model};
8
9use super::{attribute_net_refusal, refused, MeshClosure, Tolerance, TriMesh};
10use crate::error::{GeometryError, GeometryResult};
11use crate::lower::{lower_product_layers, LayerBody, LayerCut, LoweringSession};
12use crate::units;
13
14#[derive(Debug, Clone)]
16#[non_exhaustive]
17pub struct LayerMesh {
18 pub mesh: TriMesh,
21 pub closure: MeshClosure,
23}
24
25#[derive(Debug, Clone)]
27#[non_exhaustive]
28pub struct LayerMeshes {
29 pub parts: Vec<Option<LayerMesh>>,
32 pub openings: Vec<EntityId>,
34 pub taken_as_applied: Vec<EntityId>,
37}
38
39#[cfg(feature = "compile-reference-backend")]
48pub fn compile_product_layer_meshes(
49 model: &Model,
50 product: EntityId,
51 cut: &LayerCut,
52 body: LayerBody,
53 tolerance: Tolerance,
54) -> GeometryResult<Option<LayerMeshes>> {
55 compile_product_layer_meshes_with(
56 &super::default_backend(),
57 model,
58 product,
59 cut,
60 body,
61 tolerance,
62 )
63}
64
65pub fn compile_product_layer_meshes_with<B: MeshCompiler>(
88 backend: &B,
89 model: &Model,
90 product: EntityId,
91 cut: &LayerCut,
92 body: LayerBody,
93 tolerance: Tolerance,
94) -> GeometryResult<Option<LayerMeshes>> {
95 let scale = units::resolve(model)?;
96 let mut session = LoweringSession::new(model, &scale);
97 let Some(layered) = lower_product_layers(&mut session, product, cut, body)? else {
98 return Ok(None);
99 };
100 let present: Vec<_> = layered.parts.iter().flatten().copied().collect();
101 let root = session.node_for(product, GeometryNode::Collection(present))?;
102 let lowered = session.finish(root)?;
103 let options = ExecutionOptions::new(tolerance);
104
105 let mut parts = Vec::with_capacity(layered.parts.len());
106 for (layer, part) in layered.parts.iter().enumerate() {
107 let Some(part) = part else {
108 parts.push(None);
109 continue;
110 };
111 match backend.compile_mesh_reported(&lowered.graph, *part, &options) {
112 Ok(outcome) => parts.push(Some(LayerMesh {
113 mesh: outcome.mesh,
114 closure: outcome.closure,
115 })),
116 Err(error) => {
117 let body_error = match &layered.net {
119 Some(net) => backend
120 .compile_mesh_reported(&lowered.graph, net.root, &options)
121 .err()
122 .map(|_| {
123 attribute_net_refusal(
124 backend,
125 &lowered,
126 net,
127 &options,
128 product,
129 error.clone(),
130 )
131 }),
132 None => backend
133 .compile_mesh_reported(&lowered.graph, layered.body, &options)
134 .err()
135 .map(|body| refused(product, body, &lowered.provenance)),
136 };
137 return Err(body_error.unwrap_or_else(|| GeometryError::LayerNotSplit {
138 product,
139 layer,
140 cause: Box::new(refused(product, error, &lowered.provenance)),
141 }));
142 }
143 }
144 }
145 let (openings, taken_as_applied) = layered.net.as_ref().map_or_else(
146 || (Vec::new(), Vec::new()),
147 |net| {
148 (
149 net.openings(),
150 net.taken_as_applied.iter().map(|a| a.opening).collect(),
151 )
152 },
153 );
154 Ok(Some(LayerMeshes {
155 parts,
156 openings,
157 taken_as_applied,
158 }))
159}