1use wasmtime::TypedFunc;
5
6use crate::error::OcctResult;
7use crate::types::{
8 BoundingBox, EdgeData, EvolutionData, LabelInfo, Mesh, MeshBatch, NurbsCurveData,
9 ProjectionData, ShapeHandle,
10};
11
12#[allow(
23 clippy::type_complexity,
24 clippy::redundant_pub_crate,
25 clippy::struct_field_names
26)]
27pub(crate) struct GeneratedFuncs {
28 fn_make_box: TypedFunc<(f64, f64, f64), u32>,
29 fn_make_box_from_corners: TypedFunc<(f64, f64, f64, f64, f64, f64), u32>,
30 fn_make_cylinder: TypedFunc<(f64, f64), u32>,
31 fn_make_sphere: TypedFunc<(f64,), u32>,
32 fn_make_cone: TypedFunc<(f64, f64, f64), u32>,
33 fn_make_torus: TypedFunc<(f64, f64), u32>,
34 fn_make_ellipsoid: TypedFunc<(f64, f64, f64), u32>,
35 fn_make_rectangle: TypedFunc<(f64, f64), u32>,
36 fn_fuse: TypedFunc<(u32, u32), u32>,
37 fn_cut: TypedFunc<(u32, u32), u32>,
38 fn_common: TypedFunc<(u32, u32), u32>,
39 fn_section: TypedFunc<(u32, u32), u32>,
40 fn_intersect: TypedFunc<(u32, u32), u32>,
41 fn_fuse_all: TypedFunc<(i32, i32), u32>,
42 fn_cut_all: TypedFunc<(u32, i32, i32), u32>,
43 fn_boolean_pipeline: TypedFunc<(u32, i32, i32, i32, i32), u32>,
44 fn_split: TypedFunc<(u32, i32, i32), u32>,
45 fn_extrude: TypedFunc<(u32, f64, f64, f64), u32>,
46 fn_revolve: TypedFunc<(u32, f64, f64, f64, f64, f64, f64, f64), u32>,
47 fn_fillet: TypedFunc<(u32, i32, i32, f64), u32>,
48 fn_chamfer: TypedFunc<(u32, i32, i32, f64), u32>,
49 fn_chamfer_dist_angle: TypedFunc<(u32, i32, i32, f64, f64), u32>,
50 fn_shell: TypedFunc<(u32, i32, i32, f64, f64), u32>,
51 fn_offset: TypedFunc<(u32, f64, f64), u32>,
52 fn_draft: TypedFunc<(u32, u32, f64, f64, f64, f64), u32>,
53 fn_thicken: TypedFunc<(u32, f64, f64), u32>,
54 fn_defeature: TypedFunc<(u32, i32, i32, f64), u32>,
55 fn_reverse_shape: TypedFunc<(u32,), u32>,
56 fn_simplify: TypedFunc<(u32,), u32>,
57 fn_fillet_variable: TypedFunc<(u32, u32, f64, f64), u32>,
58 fn_fillet_batch: TypedFunc<(i32, i32, i32, i32, i32, i32, i32, i32), i32>,
59 fn_offset_wire2_d: TypedFunc<(u32, f64, i32), u32>,
60 fn_translate: TypedFunc<(u32, f64, f64, f64), u32>,
61 fn_rotate: TypedFunc<(u32, f64, f64, f64, f64, f64, f64, f64), u32>,
62 fn_scale: TypedFunc<(u32, f64, f64, f64, f64), u32>,
63 fn_mirror: TypedFunc<(u32, f64, f64, f64, f64, f64, f64), u32>,
64 fn_copy: TypedFunc<(u32,), u32>,
65 fn_linear_pattern: TypedFunc<(u32, f64, f64, f64, f64, i32), u32>,
66 fn_circular_pattern: TypedFunc<(u32, f64, f64, f64, f64, f64, f64, f64, i32), u32>,
67 fn_transform: TypedFunc<(u32, i32, i32), u32>,
68 fn_general_transform: TypedFunc<(u32, i32, i32), u32>,
69 fn_translate_batch: TypedFunc<(i32, i32, i32, i32), i32>,
70 fn_compose_transform: TypedFunc<(i32, i32, i32, i32), i32>,
71 fn_transform_batch: TypedFunc<(i32, i32, i32, i32), i32>,
72 fn_rotate_batch: TypedFunc<(i32, i32, i32, i32), i32>,
73 fn_scale_batch: TypedFunc<(i32, i32, i32, i32), i32>,
74 fn_mirror_batch: TypedFunc<(i32, i32, i32, i32), i32>,
75 fn_make_vertex: TypedFunc<(f64, f64, f64), u32>,
76 fn_make_edge: TypedFunc<(u32, u32), u32>,
77 fn_make_wire: TypedFunc<(i32, i32), u32>,
78 fn_make_face: TypedFunc<(u32,), u32>,
79 fn_make_face_on_surface: TypedFunc<(u32, u32), u32>,
80 fn_make_solid: TypedFunc<(u32,), u32>,
81 fn_sew: TypedFunc<(i32, i32, f64), u32>,
82 fn_make_compound: TypedFunc<(i32, i32), u32>,
83 fn_make_line_edge: TypedFunc<(f64, f64, f64, f64, f64, f64), u32>,
84 fn_make_circle_edge: TypedFunc<(f64, f64, f64, f64, f64, f64, f64), u32>,
85 fn_make_circle_arc: TypedFunc<(f64, f64, f64, f64, f64, f64, f64, f64, f64), u32>,
86 fn_make_arc_edge: TypedFunc<(f64, f64, f64, f64, f64, f64, f64, f64, f64), u32>,
87 fn_make_ellipse_edge: TypedFunc<(f64, f64, f64, f64, f64, f64, f64, f64), u32>,
88 fn_make_bezier_edge: TypedFunc<(i32, i32), u32>,
89 fn_make_ellipse_arc: TypedFunc<(f64, f64, f64, f64, f64, f64, f64, f64, f64, f64), u32>,
90 fn_make_helix_wire: TypedFunc<(f64, f64, f64, f64, f64, f64, f64, f64, f64), u32>,
91 fn_make_non_planar_face: TypedFunc<(u32,), u32>,
92 fn_add_holes_in_face: TypedFunc<(u32, i32, i32), u32>,
93 fn_remove_holes_from_face: TypedFunc<(u32, i32, i32), u32>,
94 fn_solid_from_shell: TypedFunc<(u32,), u32>,
95 fn_build_solid_from_faces: TypedFunc<(i32, i32, f64), u32>,
96 fn_sew_and_solidify: TypedFunc<(i32, i32, f64), u32>,
97 fn_build_tri_face: TypedFunc<(f64, f64, f64, f64, f64, f64, f64, f64, f64), u32>,
98 fn_make_tangent_arc: TypedFunc<(f64, f64, f64, f64, f64, f64, f64, f64, f64), u32>,
99 fn_bspline_surface: TypedFunc<(i32, i32, i32, i32), u32>,
100 fn_get_shape_type: TypedFunc<(u32,), i32>,
101 fn_get_sub_shapes: TypedFunc<(u32, i32, i32), i32>,
102 fn_distance_between: TypedFunc<(u32, u32), f64>,
103 fn_is_same: TypedFunc<(u32, u32), i32>,
104 fn_is_equal: TypedFunc<(u32, u32), i32>,
105 fn_is_null: TypedFunc<(u32,), i32>,
106 fn_hash_code: TypedFunc<(u32, i32), i32>,
107 fn_shape_orientation: TypedFunc<(u32,), i32>,
108 fn_iter_shapes: TypedFunc<(u32,), i32>,
109 fn_edge_to_face_map: TypedFunc<(u32, i32), i32>,
110 fn_downcast: TypedFunc<(u32, i32, i32), u32>,
111 fn_adjacent_faces: TypedFunc<(u32, u32), i32>,
112 fn_shared_edges: TypedFunc<(u32, u32), i32>,
113 fn_get_bounding_box: TypedFunc<(u32, i32), i32>,
114 fn_get_volume: TypedFunc<(u32,), f64>,
115 fn_get_surface_area: TypedFunc<(u32,), f64>,
116 fn_get_length: TypedFunc<(u32,), f64>,
117 fn_get_center_of_mass: TypedFunc<(u32,), i32>,
118 fn_get_surface_center_of_mass: TypedFunc<(u32,), i32>,
119 fn_vertex_position: TypedFunc<(u32,), i32>,
120 fn_surface_type: TypedFunc<(u32,), i32>,
121 fn_surface_normal: TypedFunc<(u32, f64, f64), i32>,
122 fn_point_on_surface: TypedFunc<(u32, f64, f64), i32>,
123 fn_outer_wire: TypedFunc<(u32,), u32>,
124 fn_get_linear_center_of_mass: TypedFunc<(u32,), i32>,
125 fn_surface_curvature: TypedFunc<(u32, f64, f64), i32>,
126 fn_uv_bounds: TypedFunc<(u32,), i32>,
127 fn_get_face_cylinder_data: TypedFunc<(u32,), i32>,
128 fn_uv_from_point: TypedFunc<(u32, f64, f64, f64), i32>,
129 fn_project_point_on_face: TypedFunc<(u32, f64, f64, f64), i32>,
130 fn_classify_point_on_face: TypedFunc<(u32, f64, f64), i32>,
131 fn_curve_type: TypedFunc<(u32,), i32>,
132 fn_curve_point_at_param: TypedFunc<(u32, f64), i32>,
133 fn_curve_tangent: TypedFunc<(u32, f64), i32>,
134 fn_curve_parameters: TypedFunc<(u32,), i32>,
135 fn_curve_is_closed: TypedFunc<(u32,), i32>,
136 fn_curve_length: TypedFunc<(u32,), f64>,
137 fn_interpolate_points: TypedFunc<(i32, i32, i32), u32>,
138 fn_curve_is_periodic: TypedFunc<(u32,), i32>,
139 fn_approximate_points: TypedFunc<(i32, i32, f64), u32>,
140 fn_lift_curve2d_to_plane:
141 TypedFunc<(i32, i32, f64, f64, f64, f64, f64, f64, f64, f64, f64), u32>,
142 fn_get_nurbs_curve_data: TypedFunc<(u32,), i32>,
143 fn_has_triangulation: TypedFunc<(u32,), i32>,
144 fn_query_batch: TypedFunc<(i32, i32), i32>,
145 fn_pipe: TypedFunc<(u32, u32), u32>,
146 fn_simple_pipe: TypedFunc<(u32, u32), u32>,
147 fn_revolve_vec: TypedFunc<(u32, f64, f64, f64, f64, f64, f64, f64), u32>,
148 fn_loft: TypedFunc<(i32, i32, i32, i32), u32>,
149 fn_loft_with_vertices: TypedFunc<(i32, i32, i32, i32, u32, u32), u32>,
150 fn_sweep: TypedFunc<(u32, u32, i32), u32>,
151 fn_sweep_pipe_shell: TypedFunc<(u32, u32, i32, i32), u32>,
152 fn_draft_prism: TypedFunc<(u32, f64, f64, f64, f64), u32>,
153 fn_fix_shape: TypedFunc<(u32,), u32>,
154 fn_unify_same_domain: TypedFunc<(u32,), u32>,
155 fn_is_valid: TypedFunc<(u32,), i32>,
156 fn_heal_solid: TypedFunc<(u32, f64), u32>,
157 fn_heal_face: TypedFunc<(u32, f64), u32>,
158 fn_heal_wire: TypedFunc<(u32, f64), u32>,
159 fn_fix_face_orientations: TypedFunc<(u32,), u32>,
160 fn_build_curves3d: TypedFunc<(u32,), i32>,
161 fn_fix_wire_on_face: TypedFunc<(u32, u32, f64), u32>,
162 fn_remove_degenerate_edges: TypedFunc<(u32,), u32>,
163 fn_import_step: TypedFunc<(i32, i32), u32>,
164 fn_export_step: TypedFunc<(u32,), i32>,
165 fn_export_stl: TypedFunc<(u32, f64, i32), i32>,
166 fn_import_stl: TypedFunc<(i32, i32), u32>,
167 fn_to_brep: TypedFunc<(u32,), i32>,
168 fn_from_brep: TypedFunc<(i32, i32), u32>,
169 fn_translate_with_history: TypedFunc<(u32, f64, f64, f64, i32, i32, i32), i32>,
170 fn_fuse_with_history: TypedFunc<(u32, u32, i32, i32, i32), i32>,
171 fn_cut_with_history: TypedFunc<(u32, u32, i32, i32, i32), i32>,
172 fn_fillet_with_history: TypedFunc<(u32, i32, i32, f64, i32, i32, i32), i32>,
173 fn_rotate_with_history: TypedFunc<(u32, f64, f64, f64, f64, f64, f64, f64, i32, i32, i32), i32>,
174 fn_mirror_with_history: TypedFunc<(u32, f64, f64, f64, f64, f64, f64, i32, i32, i32), i32>,
175 fn_scale_with_history: TypedFunc<(u32, f64, f64, f64, f64, i32, i32, i32), i32>,
176 fn_intersect_with_history: TypedFunc<(u32, u32, i32, i32, i32), i32>,
177 fn_chamfer_with_history: TypedFunc<(u32, i32, i32, f64, i32, i32, i32), i32>,
178 fn_shell_with_history: TypedFunc<(u32, i32, i32, f64, f64, i32, i32, i32), i32>,
179 fn_offset_with_history: TypedFunc<(u32, f64, f64, i32, i32, i32), i32>,
180 fn_thicken_with_history: TypedFunc<(u32, f64, f64, i32, i32, i32), i32>,
181 fn_tessellate: TypedFunc<(u32, f64, f64), i32>,
182 fn_mesh_shape: TypedFunc<(u32, f64, f64), i32>,
183 fn_mesh_batch: TypedFunc<(i32, i32, f64, f64), i32>,
184 fn_wireframe: TypedFunc<(u32, f64), i32>,
185 fn_project_edges: TypedFunc<(u32, f64, f64, f64, f64, f64, f64, f64, f64, f64, i32), i32>,
186 fn_release: TypedFunc<(u32,), i32>,
187 fn_release_all: TypedFunc<(), i32>,
188 fn_get_shape_count: TypedFunc<(), u32>,
189 fn_make_null_shape: TypedFunc<(), u32>,
190 fn_xcaf_new_document: TypedFunc<(), u32>,
191 fn_xcaf_close: TypedFunc<(u32,), i32>,
192 fn_xcaf_add_shape: TypedFunc<(u32, u32), i32>,
193 fn_xcaf_add_component: TypedFunc<(u32, i32, u32, f64, f64, f64, f64, f64, f64), i32>,
194 fn_xcaf_set_color: TypedFunc<(u32, i32, f64, f64, f64), i32>,
195 fn_xcaf_set_name: TypedFunc<(u32, i32, i32, i32), i32>,
196 fn_xcaf_get_label_info: TypedFunc<(u32, i32), i32>,
197 fn_xcaf_get_child_labels: TypedFunc<(u32, i32), i32>,
198 fn_xcaf_get_root_labels: TypedFunc<(u32,), i32>,
199 fn_xcaf_export_step: TypedFunc<(u32,), i32>,
200 fn_xcaf_import_step: TypedFunc<(i32, i32), u32>,
201 fn_xcaf_export_gltf: TypedFunc<(u32, f64, f64), i32>,
202}
203
204impl GeneratedFuncs {
205 #[allow(clippy::too_many_lines)]
206 pub(crate) fn resolve(
207 instance: &wasmtime::Instance,
208 mut store: &mut wasmtime::Store<()>,
209 ) -> OcctResult<Self> {
210 Ok(Self {
211 fn_make_box: instance.get_typed_func(&mut store, "occt_make_box")?,
212 fn_make_box_from_corners: instance
213 .get_typed_func(&mut store, "occt_make_box_from_corners")?,
214 fn_make_cylinder: instance.get_typed_func(&mut store, "occt_make_cylinder")?,
215 fn_make_sphere: instance.get_typed_func(&mut store, "occt_make_sphere")?,
216 fn_make_cone: instance.get_typed_func(&mut store, "occt_make_cone")?,
217 fn_make_torus: instance.get_typed_func(&mut store, "occt_make_torus")?,
218 fn_make_ellipsoid: instance.get_typed_func(&mut store, "occt_make_ellipsoid")?,
219 fn_make_rectangle: instance.get_typed_func(&mut store, "occt_make_rectangle")?,
220 fn_fuse: instance.get_typed_func(&mut store, "occt_fuse")?,
221 fn_cut: instance.get_typed_func(&mut store, "occt_cut")?,
222 fn_common: instance.get_typed_func(&mut store, "occt_common")?,
223 fn_section: instance.get_typed_func(&mut store, "occt_section")?,
224 fn_intersect: instance.get_typed_func(&mut store, "occt_intersect")?,
225 fn_fuse_all: instance.get_typed_func(&mut store, "occt_fuse_all")?,
226 fn_cut_all: instance.get_typed_func(&mut store, "occt_cut_all")?,
227 fn_boolean_pipeline: instance.get_typed_func(&mut store, "occt_boolean_pipeline")?,
228 fn_split: instance.get_typed_func(&mut store, "occt_split")?,
229 fn_extrude: instance.get_typed_func(&mut store, "occt_extrude")?,
230 fn_revolve: instance.get_typed_func(&mut store, "occt_revolve")?,
231 fn_fillet: instance.get_typed_func(&mut store, "occt_fillet")?,
232 fn_chamfer: instance.get_typed_func(&mut store, "occt_chamfer")?,
233 fn_chamfer_dist_angle: instance
234 .get_typed_func(&mut store, "occt_chamfer_dist_angle")?,
235 fn_shell: instance.get_typed_func(&mut store, "occt_shell")?,
236 fn_offset: instance.get_typed_func(&mut store, "occt_offset")?,
237 fn_draft: instance.get_typed_func(&mut store, "occt_draft")?,
238 fn_thicken: instance.get_typed_func(&mut store, "occt_thicken")?,
239 fn_defeature: instance.get_typed_func(&mut store, "occt_defeature")?,
240 fn_reverse_shape: instance.get_typed_func(&mut store, "occt_reverse_shape")?,
241 fn_simplify: instance.get_typed_func(&mut store, "occt_simplify")?,
242 fn_fillet_variable: instance.get_typed_func(&mut store, "occt_fillet_variable")?,
243 fn_fillet_batch: instance.get_typed_func(&mut store, "occt_fillet_batch")?,
244 fn_offset_wire2_d: instance.get_typed_func(&mut store, "occt_offset_wire2_d")?,
245 fn_translate: instance.get_typed_func(&mut store, "occt_translate")?,
246 fn_rotate: instance.get_typed_func(&mut store, "occt_rotate")?,
247 fn_scale: instance.get_typed_func(&mut store, "occt_scale")?,
248 fn_mirror: instance.get_typed_func(&mut store, "occt_mirror")?,
249 fn_copy: instance.get_typed_func(&mut store, "occt_copy")?,
250 fn_linear_pattern: instance.get_typed_func(&mut store, "occt_linear_pattern")?,
251 fn_circular_pattern: instance.get_typed_func(&mut store, "occt_circular_pattern")?,
252 fn_transform: instance.get_typed_func(&mut store, "occt_transform")?,
253 fn_general_transform: instance.get_typed_func(&mut store, "occt_general_transform")?,
254 fn_translate_batch: instance.get_typed_func(&mut store, "occt_translate_batch")?,
255 fn_compose_transform: instance.get_typed_func(&mut store, "occt_compose_transform")?,
256 fn_transform_batch: instance.get_typed_func(&mut store, "occt_transform_batch")?,
257 fn_rotate_batch: instance.get_typed_func(&mut store, "occt_rotate_batch")?,
258 fn_scale_batch: instance.get_typed_func(&mut store, "occt_scale_batch")?,
259 fn_mirror_batch: instance.get_typed_func(&mut store, "occt_mirror_batch")?,
260 fn_make_vertex: instance.get_typed_func(&mut store, "occt_make_vertex")?,
261 fn_make_edge: instance.get_typed_func(&mut store, "occt_make_edge")?,
262 fn_make_wire: instance.get_typed_func(&mut store, "occt_make_wire")?,
263 fn_make_face: instance.get_typed_func(&mut store, "occt_make_face")?,
264 fn_make_face_on_surface: instance
265 .get_typed_func(&mut store, "occt_make_face_on_surface")?,
266 fn_make_solid: instance.get_typed_func(&mut store, "occt_make_solid")?,
267 fn_sew: instance.get_typed_func(&mut store, "occt_sew")?,
268 fn_make_compound: instance.get_typed_func(&mut store, "occt_make_compound")?,
269 fn_make_line_edge: instance.get_typed_func(&mut store, "occt_make_line_edge")?,
270 fn_make_circle_edge: instance.get_typed_func(&mut store, "occt_make_circle_edge")?,
271 fn_make_circle_arc: instance.get_typed_func(&mut store, "occt_make_circle_arc")?,
272 fn_make_arc_edge: instance.get_typed_func(&mut store, "occt_make_arc_edge")?,
273 fn_make_ellipse_edge: instance.get_typed_func(&mut store, "occt_make_ellipse_edge")?,
274 fn_make_bezier_edge: instance.get_typed_func(&mut store, "occt_make_bezier_edge")?,
275 fn_make_ellipse_arc: instance.get_typed_func(&mut store, "occt_make_ellipse_arc")?,
276 fn_make_helix_wire: instance.get_typed_func(&mut store, "occt_make_helix_wire")?,
277 fn_make_non_planar_face: instance
278 .get_typed_func(&mut store, "occt_make_non_planar_face")?,
279 fn_add_holes_in_face: instance.get_typed_func(&mut store, "occt_add_holes_in_face")?,
280 fn_remove_holes_from_face: instance
281 .get_typed_func(&mut store, "occt_remove_holes_from_face")?,
282 fn_solid_from_shell: instance.get_typed_func(&mut store, "occt_solid_from_shell")?,
283 fn_build_solid_from_faces: instance
284 .get_typed_func(&mut store, "occt_build_solid_from_faces")?,
285 fn_sew_and_solidify: instance.get_typed_func(&mut store, "occt_sew_and_solidify")?,
286 fn_build_tri_face: instance.get_typed_func(&mut store, "occt_build_tri_face")?,
287 fn_make_tangent_arc: instance.get_typed_func(&mut store, "occt_make_tangent_arc")?,
288 fn_bspline_surface: instance.get_typed_func(&mut store, "occt_bspline_surface")?,
289 fn_get_shape_type: instance.get_typed_func(&mut store, "occt_get_shape_type")?,
290 fn_get_sub_shapes: instance.get_typed_func(&mut store, "occt_get_sub_shapes")?,
291 fn_distance_between: instance.get_typed_func(&mut store, "occt_distance_between")?,
292 fn_is_same: instance.get_typed_func(&mut store, "occt_is_same")?,
293 fn_is_equal: instance.get_typed_func(&mut store, "occt_is_equal")?,
294 fn_is_null: instance.get_typed_func(&mut store, "occt_is_null")?,
295 fn_hash_code: instance.get_typed_func(&mut store, "occt_hash_code")?,
296 fn_shape_orientation: instance.get_typed_func(&mut store, "occt_shape_orientation")?,
297 fn_iter_shapes: instance.get_typed_func(&mut store, "occt_iter_shapes")?,
298 fn_edge_to_face_map: instance.get_typed_func(&mut store, "occt_edge_to_face_map")?,
299 fn_downcast: instance.get_typed_func(&mut store, "occt_downcast")?,
300 fn_adjacent_faces: instance.get_typed_func(&mut store, "occt_adjacent_faces")?,
301 fn_shared_edges: instance.get_typed_func(&mut store, "occt_shared_edges")?,
302 fn_get_bounding_box: instance.get_typed_func(&mut store, "occt_get_bounding_box")?,
303 fn_get_volume: instance.get_typed_func(&mut store, "occt_get_volume")?,
304 fn_get_surface_area: instance.get_typed_func(&mut store, "occt_get_surface_area")?,
305 fn_get_length: instance.get_typed_func(&mut store, "occt_get_length")?,
306 fn_get_center_of_mass: instance
307 .get_typed_func(&mut store, "occt_get_center_of_mass")?,
308 fn_get_surface_center_of_mass: instance
309 .get_typed_func(&mut store, "occt_get_surface_center_of_mass")?,
310 fn_vertex_position: instance.get_typed_func(&mut store, "occt_vertex_position")?,
311 fn_surface_type: instance.get_typed_func(&mut store, "occt_surface_type")?,
312 fn_surface_normal: instance.get_typed_func(&mut store, "occt_surface_normal")?,
313 fn_point_on_surface: instance.get_typed_func(&mut store, "occt_point_on_surface")?,
314 fn_outer_wire: instance.get_typed_func(&mut store, "occt_outer_wire")?,
315 fn_get_linear_center_of_mass: instance
316 .get_typed_func(&mut store, "occt_get_linear_center_of_mass")?,
317 fn_surface_curvature: instance.get_typed_func(&mut store, "occt_surface_curvature")?,
318 fn_uv_bounds: instance.get_typed_func(&mut store, "occt_uv_bounds")?,
319 fn_get_face_cylinder_data: instance
320 .get_typed_func(&mut store, "occt_get_face_cylinder_data")?,
321 fn_uv_from_point: instance.get_typed_func(&mut store, "occt_uv_from_point")?,
322 fn_project_point_on_face: instance
323 .get_typed_func(&mut store, "occt_project_point_on_face")?,
324 fn_classify_point_on_face: instance
325 .get_typed_func(&mut store, "occt_classify_point_on_face")?,
326 fn_curve_type: instance.get_typed_func(&mut store, "occt_curve_type")?,
327 fn_curve_point_at_param: instance
328 .get_typed_func(&mut store, "occt_curve_point_at_param")?,
329 fn_curve_tangent: instance.get_typed_func(&mut store, "occt_curve_tangent")?,
330 fn_curve_parameters: instance.get_typed_func(&mut store, "occt_curve_parameters")?,
331 fn_curve_is_closed: instance.get_typed_func(&mut store, "occt_curve_is_closed")?,
332 fn_curve_length: instance.get_typed_func(&mut store, "occt_curve_length")?,
333 fn_interpolate_points: instance
334 .get_typed_func(&mut store, "occt_interpolate_points")?,
335 fn_curve_is_periodic: instance.get_typed_func(&mut store, "occt_curve_is_periodic")?,
336 fn_approximate_points: instance
337 .get_typed_func(&mut store, "occt_approximate_points")?,
338 fn_lift_curve2d_to_plane: instance
339 .get_typed_func(&mut store, "occt_lift_curve2d_to_plane")?,
340 fn_get_nurbs_curve_data: instance
341 .get_typed_func(&mut store, "occt_get_nurbs_curve_data")?,
342 fn_has_triangulation: instance.get_typed_func(&mut store, "occt_has_triangulation")?,
343 fn_query_batch: instance.get_typed_func(&mut store, "occt_query_batch")?,
344 fn_pipe: instance.get_typed_func(&mut store, "occt_pipe")?,
345 fn_simple_pipe: instance.get_typed_func(&mut store, "occt_simple_pipe")?,
346 fn_revolve_vec: instance.get_typed_func(&mut store, "occt_revolve_vec")?,
347 fn_loft: instance.get_typed_func(&mut store, "occt_loft")?,
348 fn_loft_with_vertices: instance
349 .get_typed_func(&mut store, "occt_loft_with_vertices")?,
350 fn_sweep: instance.get_typed_func(&mut store, "occt_sweep")?,
351 fn_sweep_pipe_shell: instance.get_typed_func(&mut store, "occt_sweep_pipe_shell")?,
352 fn_draft_prism: instance.get_typed_func(&mut store, "occt_draft_prism")?,
353 fn_fix_shape: instance.get_typed_func(&mut store, "occt_fix_shape")?,
354 fn_unify_same_domain: instance.get_typed_func(&mut store, "occt_unify_same_domain")?,
355 fn_is_valid: instance.get_typed_func(&mut store, "occt_is_valid")?,
356 fn_heal_solid: instance.get_typed_func(&mut store, "occt_heal_solid")?,
357 fn_heal_face: instance.get_typed_func(&mut store, "occt_heal_face")?,
358 fn_heal_wire: instance.get_typed_func(&mut store, "occt_heal_wire")?,
359 fn_fix_face_orientations: instance
360 .get_typed_func(&mut store, "occt_fix_face_orientations")?,
361 fn_build_curves3d: instance.get_typed_func(&mut store, "occt_build_curves3d")?,
362 fn_fix_wire_on_face: instance.get_typed_func(&mut store, "occt_fix_wire_on_face")?,
363 fn_remove_degenerate_edges: instance
364 .get_typed_func(&mut store, "occt_remove_degenerate_edges")?,
365 fn_import_step: instance.get_typed_func(&mut store, "occt_import_step")?,
366 fn_export_step: instance.get_typed_func(&mut store, "occt_export_step")?,
367 fn_export_stl: instance.get_typed_func(&mut store, "occt_export_stl")?,
368 fn_import_stl: instance.get_typed_func(&mut store, "occt_import_stl")?,
369 fn_to_brep: instance.get_typed_func(&mut store, "occt_to_brep")?,
370 fn_from_brep: instance.get_typed_func(&mut store, "occt_from_brep")?,
371 fn_translate_with_history: instance
372 .get_typed_func(&mut store, "occt_translate_with_history")?,
373 fn_fuse_with_history: instance.get_typed_func(&mut store, "occt_fuse_with_history")?,
374 fn_cut_with_history: instance.get_typed_func(&mut store, "occt_cut_with_history")?,
375 fn_fillet_with_history: instance
376 .get_typed_func(&mut store, "occt_fillet_with_history")?,
377 fn_rotate_with_history: instance
378 .get_typed_func(&mut store, "occt_rotate_with_history")?,
379 fn_mirror_with_history: instance
380 .get_typed_func(&mut store, "occt_mirror_with_history")?,
381 fn_scale_with_history: instance
382 .get_typed_func(&mut store, "occt_scale_with_history")?,
383 fn_intersect_with_history: instance
384 .get_typed_func(&mut store, "occt_intersect_with_history")?,
385 fn_chamfer_with_history: instance
386 .get_typed_func(&mut store, "occt_chamfer_with_history")?,
387 fn_shell_with_history: instance
388 .get_typed_func(&mut store, "occt_shell_with_history")?,
389 fn_offset_with_history: instance
390 .get_typed_func(&mut store, "occt_offset_with_history")?,
391 fn_thicken_with_history: instance
392 .get_typed_func(&mut store, "occt_thicken_with_history")?,
393 fn_tessellate: instance.get_typed_func(&mut store, "occt_tessellate")?,
394 fn_mesh_shape: instance.get_typed_func(&mut store, "occt_mesh_shape")?,
395 fn_mesh_batch: instance.get_typed_func(&mut store, "occt_mesh_batch")?,
396 fn_wireframe: instance.get_typed_func(&mut store, "occt_wireframe")?,
397 fn_project_edges: instance.get_typed_func(&mut store, "occt_project_edges")?,
398 fn_release: instance.get_typed_func(&mut store, "occt_release")?,
399 fn_release_all: instance.get_typed_func(&mut store, "occt_release_all")?,
400 fn_get_shape_count: instance.get_typed_func(&mut store, "occt_get_shape_count")?,
401 fn_make_null_shape: instance.get_typed_func(&mut store, "occt_make_null_shape")?,
402 fn_xcaf_new_document: instance.get_typed_func(&mut store, "occt_xcaf_new_document")?,
403 fn_xcaf_close: instance.get_typed_func(&mut store, "occt_xcaf_close")?,
404 fn_xcaf_add_shape: instance.get_typed_func(&mut store, "occt_xcaf_add_shape")?,
405 fn_xcaf_add_component: instance
406 .get_typed_func(&mut store, "occt_xcaf_add_component")?,
407 fn_xcaf_set_color: instance.get_typed_func(&mut store, "occt_xcaf_set_color")?,
408 fn_xcaf_set_name: instance.get_typed_func(&mut store, "occt_xcaf_set_name")?,
409 fn_xcaf_get_label_info: instance
410 .get_typed_func(&mut store, "occt_xcaf_get_label_info")?,
411 fn_xcaf_get_child_labels: instance
412 .get_typed_func(&mut store, "occt_xcaf_get_child_labels")?,
413 fn_xcaf_get_root_labels: instance
414 .get_typed_func(&mut store, "occt_xcaf_get_root_labels")?,
415 fn_xcaf_export_step: instance.get_typed_func(&mut store, "occt_xcaf_export_step")?,
416 fn_xcaf_import_step: instance.get_typed_func(&mut store, "occt_xcaf_import_step")?,
417 fn_xcaf_export_gltf: instance.get_typed_func(&mut store, "occt_xcaf_export_gltf")?,
418 })
419 }
420}
421
422#[allow(missing_docs, clippy::too_many_arguments)]
426impl crate::kernel::OcctKernel {
427 pub fn make_box(&mut self, dx: f64, dy: f64, dz: f64) -> OcctResult<ShapeHandle> {
428 let result = self
429 .generated
430 .fn_make_box
431 .call(&mut self.store, (dx, dy, dz))?;
432 self.check_error("make_box")?;
433 if result == 0 {
434 return Err(self.read_last_error("make_box"));
435 }
436 Ok(ShapeHandle(result))
437 }
438
439 pub fn make_box_from_corners(
440 &mut self,
441 x1: f64,
442 y1: f64,
443 z1: f64,
444 x2: f64,
445 y2: f64,
446 z2: f64,
447 ) -> OcctResult<ShapeHandle> {
448 let result = self
449 .generated
450 .fn_make_box_from_corners
451 .call(&mut self.store, (x1, y1, z1, x2, y2, z2))?;
452 self.check_error("make_box_from_corners")?;
453 if result == 0 {
454 return Err(self.read_last_error("make_box_from_corners"));
455 }
456 Ok(ShapeHandle(result))
457 }
458
459 pub fn make_cylinder(&mut self, radius: f64, height: f64) -> OcctResult<ShapeHandle> {
460 let result = self
461 .generated
462 .fn_make_cylinder
463 .call(&mut self.store, (radius, height))?;
464 self.check_error("make_cylinder")?;
465 if result == 0 {
466 return Err(self.read_last_error("make_cylinder"));
467 }
468 Ok(ShapeHandle(result))
469 }
470
471 pub fn make_sphere(&mut self, radius: f64) -> OcctResult<ShapeHandle> {
472 let result = self
473 .generated
474 .fn_make_sphere
475 .call(&mut self.store, (radius,))?;
476 self.check_error("make_sphere")?;
477 if result == 0 {
478 return Err(self.read_last_error("make_sphere"));
479 }
480 Ok(ShapeHandle(result))
481 }
482
483 pub fn make_cone(&mut self, r1: f64, r2: f64, height: f64) -> OcctResult<ShapeHandle> {
484 let result = self
485 .generated
486 .fn_make_cone
487 .call(&mut self.store, (r1, r2, height))?;
488 self.check_error("make_cone")?;
489 if result == 0 {
490 return Err(self.read_last_error("make_cone"));
491 }
492 Ok(ShapeHandle(result))
493 }
494
495 pub fn make_torus(&mut self, major_radius: f64, minor_radius: f64) -> OcctResult<ShapeHandle> {
496 let result = self
497 .generated
498 .fn_make_torus
499 .call(&mut self.store, (major_radius, minor_radius))?;
500 self.check_error("make_torus")?;
501 if result == 0 {
502 return Err(self.read_last_error("make_torus"));
503 }
504 Ok(ShapeHandle(result))
505 }
506
507 pub fn make_ellipsoid(&mut self, rx: f64, ry: f64, rz: f64) -> OcctResult<ShapeHandle> {
508 let result = self
509 .generated
510 .fn_make_ellipsoid
511 .call(&mut self.store, (rx, ry, rz))?;
512 self.check_error("make_ellipsoid")?;
513 if result == 0 {
514 return Err(self.read_last_error("make_ellipsoid"));
515 }
516 Ok(ShapeHandle(result))
517 }
518
519 pub fn make_rectangle(&mut self, width: f64, height: f64) -> OcctResult<ShapeHandle> {
520 let result = self
521 .generated
522 .fn_make_rectangle
523 .call(&mut self.store, (width, height))?;
524 self.check_error("make_rectangle")?;
525 if result == 0 {
526 return Err(self.read_last_error("make_rectangle"));
527 }
528 Ok(ShapeHandle(result))
529 }
530
531 pub fn fuse(&mut self, a: ShapeHandle, b: ShapeHandle) -> OcctResult<ShapeHandle> {
532 let result = self.generated.fn_fuse.call(&mut self.store, (a.0, b.0))?;
533 self.check_error("fuse")?;
534 if result == 0 {
535 return Err(self.read_last_error("fuse"));
536 }
537 Ok(ShapeHandle(result))
538 }
539
540 pub fn cut(&mut self, a: ShapeHandle, b: ShapeHandle) -> OcctResult<ShapeHandle> {
541 let result = self.generated.fn_cut.call(&mut self.store, (a.0, b.0))?;
542 self.check_error("cut")?;
543 if result == 0 {
544 return Err(self.read_last_error("cut"));
545 }
546 Ok(ShapeHandle(result))
547 }
548
549 pub fn common(&mut self, a: ShapeHandle, b: ShapeHandle) -> OcctResult<ShapeHandle> {
550 let result = self.generated.fn_common.call(&mut self.store, (a.0, b.0))?;
551 self.check_error("common")?;
552 if result == 0 {
553 return Err(self.read_last_error("common"));
554 }
555 Ok(ShapeHandle(result))
556 }
557
558 pub fn section(&mut self, a: ShapeHandle, b: ShapeHandle) -> OcctResult<ShapeHandle> {
559 let result = self
560 .generated
561 .fn_section
562 .call(&mut self.store, (a.0, b.0))?;
563 self.check_error("section")?;
564 if result == 0 {
565 return Err(self.read_last_error("section"));
566 }
567 Ok(ShapeHandle(result))
568 }
569
570 pub fn intersect(&mut self, a: ShapeHandle, b: ShapeHandle) -> OcctResult<ShapeHandle> {
571 let result = self
572 .generated
573 .fn_intersect
574 .call(&mut self.store, (a.0, b.0))?;
575 self.check_error("intersect")?;
576 if result == 0 {
577 return Err(self.read_last_error("intersect"));
578 }
579 Ok(ShapeHandle(result))
580 }
581
582 pub fn fuse_all(&mut self, shape_ids: &[ShapeHandle]) -> OcctResult<ShapeHandle> {
583 let shape_ids_bytes: Vec<u8> = shape_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
584 let shape_ids_ptr = self.write_bytes(&shape_ids_bytes)?;
585 let shape_ids_len = shape_ids.len() as u32;
586 let result = self.generated.fn_fuse_all.call(
587 &mut self.store,
588 (shape_ids_ptr as i32, shape_ids_len as i32),
589 );
590 self.free_bytes(shape_ids_ptr)?;
591 let result = result?;
592 self.check_error("fuse_all")?;
593 if result == 0 {
594 return Err(self.read_last_error("fuse_all"));
595 }
596 Ok(ShapeHandle(result))
597 }
598
599 pub fn cut_all(
600 &mut self,
601 shape_id: ShapeHandle,
602 tool_ids: &[ShapeHandle],
603 ) -> OcctResult<ShapeHandle> {
604 let tool_ids_bytes: Vec<u8> = tool_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
605 let tool_ids_ptr = self.write_bytes(&tool_ids_bytes)?;
606 let tool_ids_len = tool_ids.len() as u32;
607 let result = self.generated.fn_cut_all.call(
608 &mut self.store,
609 (shape_id.0, tool_ids_ptr as i32, tool_ids_len as i32),
610 );
611 self.free_bytes(tool_ids_ptr)?;
612 let result = result?;
613 self.check_error("cut_all")?;
614 if result == 0 {
615 return Err(self.read_last_error("cut_all"));
616 }
617 Ok(ShapeHandle(result))
618 }
619
620 pub fn boolean_pipeline(
621 &mut self,
622 base_id: ShapeHandle,
623 op_codes: &[i32],
624 tool_ids: &[ShapeHandle],
625 ) -> OcctResult<ShapeHandle> {
626 let op_codes_bytes: Vec<u8> = op_codes.iter().flat_map(|v| v.to_le_bytes()).collect();
627 let op_codes_ptr = self.write_bytes(&op_codes_bytes)?;
628 let op_codes_len = op_codes.len() as u32;
629 let tool_ids_bytes: Vec<u8> = tool_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
630 let tool_ids_ptr = match self.write_bytes(&tool_ids_bytes) {
631 Ok(ptr) => ptr,
632 Err(e) => {
633 let _ = self.free_bytes(op_codes_ptr);
634 return Err(e);
635 }
636 };
637 let tool_ids_len = tool_ids.len() as u32;
638 let result = self.generated.fn_boolean_pipeline.call(
639 &mut self.store,
640 (
641 base_id.0,
642 op_codes_ptr as i32,
643 op_codes_len as i32,
644 tool_ids_ptr as i32,
645 tool_ids_len as i32,
646 ),
647 );
648 self.free_bytes(op_codes_ptr)?;
649 self.free_bytes(tool_ids_ptr)?;
650 let result = result?;
651 self.check_error("boolean_pipeline")?;
652 if result == 0 {
653 return Err(self.read_last_error("boolean_pipeline"));
654 }
655 Ok(ShapeHandle(result))
656 }
657
658 pub fn split(
659 &mut self,
660 shape_id: ShapeHandle,
661 tool_ids: &[ShapeHandle],
662 ) -> OcctResult<ShapeHandle> {
663 let tool_ids_bytes: Vec<u8> = tool_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
664 let tool_ids_ptr = self.write_bytes(&tool_ids_bytes)?;
665 let tool_ids_len = tool_ids.len() as u32;
666 let result = self.generated.fn_split.call(
667 &mut self.store,
668 (shape_id.0, tool_ids_ptr as i32, tool_ids_len as i32),
669 );
670 self.free_bytes(tool_ids_ptr)?;
671 let result = result?;
672 self.check_error("split")?;
673 if result == 0 {
674 return Err(self.read_last_error("split"));
675 }
676 Ok(ShapeHandle(result))
677 }
678
679 pub fn extrude(
680 &mut self,
681 shape_id: ShapeHandle,
682 dx: f64,
683 dy: f64,
684 dz: f64,
685 ) -> OcctResult<ShapeHandle> {
686 let result = self
687 .generated
688 .fn_extrude
689 .call(&mut self.store, (shape_id.0, dx, dy, dz))?;
690 self.check_error("extrude")?;
691 if result == 0 {
692 return Err(self.read_last_error("extrude"));
693 }
694 Ok(ShapeHandle(result))
695 }
696
697 pub fn revolve(
698 &mut self,
699 shape_id: ShapeHandle,
700 px: f64,
701 py: f64,
702 pz: f64,
703 dx: f64,
704 dy: f64,
705 dz: f64,
706 angle_rad: f64,
707 ) -> OcctResult<ShapeHandle> {
708 let result = self.generated.fn_revolve.call(
709 &mut self.store,
710 (shape_id.0, px, py, pz, dx, dy, dz, angle_rad),
711 )?;
712 self.check_error("revolve")?;
713 if result == 0 {
714 return Err(self.read_last_error("revolve"));
715 }
716 Ok(ShapeHandle(result))
717 }
718
719 pub fn fillet(
720 &mut self,
721 solid_id: ShapeHandle,
722 edge_ids: &[ShapeHandle],
723 radius: f64,
724 ) -> OcctResult<ShapeHandle> {
725 let edge_ids_bytes: Vec<u8> = edge_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
726 let edge_ids_ptr = self.write_bytes(&edge_ids_bytes)?;
727 let edge_ids_len = edge_ids.len() as u32;
728 let result = self.generated.fn_fillet.call(
729 &mut self.store,
730 (solid_id.0, edge_ids_ptr as i32, edge_ids_len as i32, radius),
731 );
732 self.free_bytes(edge_ids_ptr)?;
733 let result = result?;
734 self.check_error("fillet")?;
735 if result == 0 {
736 return Err(self.read_last_error("fillet"));
737 }
738 Ok(ShapeHandle(result))
739 }
740
741 pub fn chamfer(
742 &mut self,
743 solid_id: ShapeHandle,
744 edge_ids: &[ShapeHandle],
745 distance: f64,
746 ) -> OcctResult<ShapeHandle> {
747 let edge_ids_bytes: Vec<u8> = edge_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
748 let edge_ids_ptr = self.write_bytes(&edge_ids_bytes)?;
749 let edge_ids_len = edge_ids.len() as u32;
750 let result = self.generated.fn_chamfer.call(
751 &mut self.store,
752 (
753 solid_id.0,
754 edge_ids_ptr as i32,
755 edge_ids_len as i32,
756 distance,
757 ),
758 );
759 self.free_bytes(edge_ids_ptr)?;
760 let result = result?;
761 self.check_error("chamfer")?;
762 if result == 0 {
763 return Err(self.read_last_error("chamfer"));
764 }
765 Ok(ShapeHandle(result))
766 }
767
768 pub fn chamfer_dist_angle(
769 &mut self,
770 solid_id: ShapeHandle,
771 edge_ids: &[ShapeHandle],
772 distance: f64,
773 angle_deg: f64,
774 ) -> OcctResult<ShapeHandle> {
775 let edge_ids_bytes: Vec<u8> = edge_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
776 let edge_ids_ptr = self.write_bytes(&edge_ids_bytes)?;
777 let edge_ids_len = edge_ids.len() as u32;
778 let result = self.generated.fn_chamfer_dist_angle.call(
779 &mut self.store,
780 (
781 solid_id.0,
782 edge_ids_ptr as i32,
783 edge_ids_len as i32,
784 distance,
785 angle_deg,
786 ),
787 );
788 self.free_bytes(edge_ids_ptr)?;
789 let result = result?;
790 self.check_error("chamfer_dist_angle")?;
791 if result == 0 {
792 return Err(self.read_last_error("chamfer_dist_angle"));
793 }
794 Ok(ShapeHandle(result))
795 }
796
797 pub fn shell(
798 &mut self,
799 solid_id: ShapeHandle,
800 face_ids: &[ShapeHandle],
801 thickness: f64,
802 tolerance: f64,
803 ) -> OcctResult<ShapeHandle> {
804 let face_ids_bytes: Vec<u8> = face_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
805 let face_ids_ptr = self.write_bytes(&face_ids_bytes)?;
806 let face_ids_len = face_ids.len() as u32;
807 let result = self.generated.fn_shell.call(
808 &mut self.store,
809 (
810 solid_id.0,
811 face_ids_ptr as i32,
812 face_ids_len as i32,
813 thickness,
814 tolerance,
815 ),
816 );
817 self.free_bytes(face_ids_ptr)?;
818 let result = result?;
819 self.check_error("shell")?;
820 if result == 0 {
821 return Err(self.read_last_error("shell"));
822 }
823 Ok(ShapeHandle(result))
824 }
825
826 pub fn offset(
827 &mut self,
828 solid_id: ShapeHandle,
829 distance: f64,
830 tolerance: f64,
831 ) -> OcctResult<ShapeHandle> {
832 let result = self
833 .generated
834 .fn_offset
835 .call(&mut self.store, (solid_id.0, distance, tolerance))?;
836 self.check_error("offset")?;
837 if result == 0 {
838 return Err(self.read_last_error("offset"));
839 }
840 Ok(ShapeHandle(result))
841 }
842
843 pub fn draft(
844 &mut self,
845 shape_id: ShapeHandle,
846 face_id: ShapeHandle,
847 angle_rad: f64,
848 dx: f64,
849 dy: f64,
850 dz: f64,
851 ) -> OcctResult<ShapeHandle> {
852 let result = self.generated.fn_draft.call(
853 &mut self.store,
854 (shape_id.0, face_id.0, angle_rad, dx, dy, dz),
855 )?;
856 self.check_error("draft")?;
857 if result == 0 {
858 return Err(self.read_last_error("draft"));
859 }
860 Ok(ShapeHandle(result))
861 }
862
863 pub fn thicken(
864 &mut self,
865 shape_id: ShapeHandle,
866 thickness: f64,
867 tolerance: f64,
868 ) -> OcctResult<ShapeHandle> {
869 let result = self
870 .generated
871 .fn_thicken
872 .call(&mut self.store, (shape_id.0, thickness, tolerance))?;
873 self.check_error("thicken")?;
874 if result == 0 {
875 return Err(self.read_last_error("thicken"));
876 }
877 Ok(ShapeHandle(result))
878 }
879
880 pub fn defeature(
881 &mut self,
882 shape_id: ShapeHandle,
883 face_ids: &[ShapeHandle],
884 tolerance: f64,
885 ) -> OcctResult<ShapeHandle> {
886 let face_ids_bytes: Vec<u8> = face_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
887 let face_ids_ptr = self.write_bytes(&face_ids_bytes)?;
888 let face_ids_len = face_ids.len() as u32;
889 let result = self.generated.fn_defeature.call(
890 &mut self.store,
891 (
892 shape_id.0,
893 face_ids_ptr as i32,
894 face_ids_len as i32,
895 tolerance,
896 ),
897 );
898 self.free_bytes(face_ids_ptr)?;
899 let result = result?;
900 self.check_error("defeature")?;
901 if result == 0 {
902 return Err(self.read_last_error("defeature"));
903 }
904 Ok(ShapeHandle(result))
905 }
906
907 pub fn reverse_shape(&mut self, id: ShapeHandle) -> OcctResult<ShapeHandle> {
908 let result = self
909 .generated
910 .fn_reverse_shape
911 .call(&mut self.store, (id.0,))?;
912 self.check_error("reverse_shape")?;
913 if result == 0 {
914 return Err(self.read_last_error("reverse_shape"));
915 }
916 Ok(ShapeHandle(result))
917 }
918
919 pub fn simplify(&mut self, id: ShapeHandle) -> OcctResult<ShapeHandle> {
920 let result = self.generated.fn_simplify.call(&mut self.store, (id.0,))?;
921 self.check_error("simplify")?;
922 if result == 0 {
923 return Err(self.read_last_error("simplify"));
924 }
925 Ok(ShapeHandle(result))
926 }
927
928 pub fn fillet_variable(
929 &mut self,
930 solid_id: ShapeHandle,
931 edge_id: ShapeHandle,
932 start_radius: f64,
933 end_radius: f64,
934 ) -> OcctResult<ShapeHandle> {
935 let result = self.generated.fn_fillet_variable.call(
936 &mut self.store,
937 (solid_id.0, edge_id.0, start_radius, end_radius),
938 )?;
939 self.check_error("fillet_variable")?;
940 if result == 0 {
941 return Err(self.read_last_error("fillet_variable"));
942 }
943 Ok(ShapeHandle(result))
944 }
945
946 pub fn fillet_batch(
947 &mut self,
948 solid_ids: &[ShapeHandle],
949 edge_counts: &[i32],
950 flat_edge_ids: &[ShapeHandle],
951 radii: &[f64],
952 ) -> OcctResult<Vec<u32>> {
953 let solid_ids_bytes: Vec<u8> = solid_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
954 let solid_ids_ptr = self.write_bytes(&solid_ids_bytes)?;
955 let solid_ids_len = solid_ids.len() as u32;
956 let edge_counts_bytes: Vec<u8> = edge_counts.iter().flat_map(|v| v.to_le_bytes()).collect();
957 let edge_counts_ptr = match self.write_bytes(&edge_counts_bytes) {
958 Ok(ptr) => ptr,
959 Err(e) => {
960 let _ = self.free_bytes(solid_ids_ptr);
961 return Err(e);
962 }
963 };
964 let edge_counts_len = edge_counts.len() as u32;
965 let flat_edge_ids_bytes: Vec<u8> = flat_edge_ids
966 .iter()
967 .flat_map(|h| h.0.to_le_bytes())
968 .collect();
969 let flat_edge_ids_ptr = match self.write_bytes(&flat_edge_ids_bytes) {
970 Ok(ptr) => ptr,
971 Err(e) => {
972 let _ = self.free_bytes(solid_ids_ptr);
973 let _ = self.free_bytes(edge_counts_ptr);
974 return Err(e);
975 }
976 };
977 let flat_edge_ids_len = flat_edge_ids.len() as u32;
978 let radii_bytes: Vec<u8> = radii.iter().flat_map(|v| v.to_le_bytes()).collect();
979 let radii_ptr = match self.write_bytes(&radii_bytes) {
980 Ok(ptr) => ptr,
981 Err(e) => {
982 let _ = self.free_bytes(solid_ids_ptr);
983 let _ = self.free_bytes(edge_counts_ptr);
984 let _ = self.free_bytes(flat_edge_ids_ptr);
985 return Err(e);
986 }
987 };
988 let radii_len = radii.len() as u32;
989 let len = self.generated.fn_fillet_batch.call(
990 &mut self.store,
991 (
992 solid_ids_ptr as i32,
993 solid_ids_len as i32,
994 edge_counts_ptr as i32,
995 edge_counts_len as i32,
996 flat_edge_ids_ptr as i32,
997 flat_edge_ids_len as i32,
998 radii_ptr as i32,
999 radii_len as i32,
1000 ),
1001 );
1002 self.free_bytes(solid_ids_ptr)?;
1003 self.free_bytes(edge_counts_ptr)?;
1004 self.free_bytes(flat_edge_ids_ptr)?;
1005 self.free_bytes(radii_ptr)?;
1006 let len = len?;
1007 if len < 0 {
1008 return Err(self.read_last_error("fillet_batch"));
1009 }
1010 self.read_vec_u32_result()
1011 }
1012
1013 pub fn offset_wire2_d(
1014 &mut self,
1015 wire_id: ShapeHandle,
1016 offset: f64,
1017 join_type: i32,
1018 ) -> OcctResult<ShapeHandle> {
1019 let result = self
1020 .generated
1021 .fn_offset_wire2_d
1022 .call(&mut self.store, (wire_id.0, offset, join_type))?;
1023 self.check_error("offset_wire2_d")?;
1024 if result == 0 {
1025 return Err(self.read_last_error("offset_wire2_d"));
1026 }
1027 Ok(ShapeHandle(result))
1028 }
1029
1030 pub fn translate(
1031 &mut self,
1032 id: ShapeHandle,
1033 dx: f64,
1034 dy: f64,
1035 dz: f64,
1036 ) -> OcctResult<ShapeHandle> {
1037 let result = self
1038 .generated
1039 .fn_translate
1040 .call(&mut self.store, (id.0, dx, dy, dz))?;
1041 self.check_error("translate")?;
1042 if result == 0 {
1043 return Err(self.read_last_error("translate"));
1044 }
1045 Ok(ShapeHandle(result))
1046 }
1047
1048 pub fn rotate(
1049 &mut self,
1050 id: ShapeHandle,
1051 px: f64,
1052 py: f64,
1053 pz: f64,
1054 dx: f64,
1055 dy: f64,
1056 dz: f64,
1057 angle_rad: f64,
1058 ) -> OcctResult<ShapeHandle> {
1059 let result = self
1060 .generated
1061 .fn_rotate
1062 .call(&mut self.store, (id.0, px, py, pz, dx, dy, dz, angle_rad))?;
1063 self.check_error("rotate")?;
1064 if result == 0 {
1065 return Err(self.read_last_error("rotate"));
1066 }
1067 Ok(ShapeHandle(result))
1068 }
1069
1070 pub fn scale(
1071 &mut self,
1072 id: ShapeHandle,
1073 px: f64,
1074 py: f64,
1075 pz: f64,
1076 factor: f64,
1077 ) -> OcctResult<ShapeHandle> {
1078 let result = self
1079 .generated
1080 .fn_scale
1081 .call(&mut self.store, (id.0, px, py, pz, factor))?;
1082 self.check_error("scale")?;
1083 if result == 0 {
1084 return Err(self.read_last_error("scale"));
1085 }
1086 Ok(ShapeHandle(result))
1087 }
1088
1089 pub fn mirror(
1090 &mut self,
1091 id: ShapeHandle,
1092 px: f64,
1093 py: f64,
1094 pz: f64,
1095 nx: f64,
1096 ny: f64,
1097 nz: f64,
1098 ) -> OcctResult<ShapeHandle> {
1099 let result = self
1100 .generated
1101 .fn_mirror
1102 .call(&mut self.store, (id.0, px, py, pz, nx, ny, nz))?;
1103 self.check_error("mirror")?;
1104 if result == 0 {
1105 return Err(self.read_last_error("mirror"));
1106 }
1107 Ok(ShapeHandle(result))
1108 }
1109
1110 pub fn copy(&mut self, id: ShapeHandle) -> OcctResult<ShapeHandle> {
1111 let result = self.generated.fn_copy.call(&mut self.store, (id.0,))?;
1112 self.check_error("copy")?;
1113 if result == 0 {
1114 return Err(self.read_last_error("copy"));
1115 }
1116 Ok(ShapeHandle(result))
1117 }
1118
1119 pub fn linear_pattern(
1120 &mut self,
1121 id: ShapeHandle,
1122 dx: f64,
1123 dy: f64,
1124 dz: f64,
1125 spacing: f64,
1126 count: i32,
1127 ) -> OcctResult<ShapeHandle> {
1128 let result = self
1129 .generated
1130 .fn_linear_pattern
1131 .call(&mut self.store, (id.0, dx, dy, dz, spacing, count))?;
1132 self.check_error("linear_pattern")?;
1133 if result == 0 {
1134 return Err(self.read_last_error("linear_pattern"));
1135 }
1136 Ok(ShapeHandle(result))
1137 }
1138
1139 pub fn circular_pattern(
1140 &mut self,
1141 id: ShapeHandle,
1142 cx: f64,
1143 cy: f64,
1144 cz: f64,
1145 ax: f64,
1146 ay: f64,
1147 az: f64,
1148 angle: f64,
1149 count: i32,
1150 ) -> OcctResult<ShapeHandle> {
1151 let result = self.generated.fn_circular_pattern.call(
1152 &mut self.store,
1153 (id.0, cx, cy, cz, ax, ay, az, angle, count),
1154 )?;
1155 self.check_error("circular_pattern")?;
1156 if result == 0 {
1157 return Err(self.read_last_error("circular_pattern"));
1158 }
1159 Ok(ShapeHandle(result))
1160 }
1161
1162 pub fn transform(&mut self, id: ShapeHandle, matrix: &[f64]) -> OcctResult<ShapeHandle> {
1163 let matrix_bytes: Vec<u8> = matrix.iter().flat_map(|v| v.to_le_bytes()).collect();
1164 let matrix_ptr = self.write_bytes(&matrix_bytes)?;
1165 let matrix_len = matrix.len() as u32;
1166 let result = self.generated.fn_transform.call(
1167 &mut self.store,
1168 (id.0, matrix_ptr as i32, matrix_len as i32),
1169 );
1170 self.free_bytes(matrix_ptr)?;
1171 let result = result?;
1172 self.check_error("transform")?;
1173 if result == 0 {
1174 return Err(self.read_last_error("transform"));
1175 }
1176 Ok(ShapeHandle(result))
1177 }
1178
1179 pub fn general_transform(
1180 &mut self,
1181 id: ShapeHandle,
1182 matrix: &[f64],
1183 ) -> OcctResult<ShapeHandle> {
1184 let matrix_bytes: Vec<u8> = matrix.iter().flat_map(|v| v.to_le_bytes()).collect();
1185 let matrix_ptr = self.write_bytes(&matrix_bytes)?;
1186 let matrix_len = matrix.len() as u32;
1187 let result = self.generated.fn_general_transform.call(
1188 &mut self.store,
1189 (id.0, matrix_ptr as i32, matrix_len as i32),
1190 );
1191 self.free_bytes(matrix_ptr)?;
1192 let result = result?;
1193 self.check_error("general_transform")?;
1194 if result == 0 {
1195 return Err(self.read_last_error("general_transform"));
1196 }
1197 Ok(ShapeHandle(result))
1198 }
1199
1200 pub fn translate_batch(
1201 &mut self,
1202 ids: &[ShapeHandle],
1203 offsets: &[f64],
1204 ) -> OcctResult<Vec<u32>> {
1205 let ids_bytes: Vec<u8> = ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
1206 let ids_ptr = self.write_bytes(&ids_bytes)?;
1207 let ids_len = ids.len() as u32;
1208 let offsets_bytes: Vec<u8> = offsets.iter().flat_map(|v| v.to_le_bytes()).collect();
1209 let offsets_ptr = match self.write_bytes(&offsets_bytes) {
1210 Ok(ptr) => ptr,
1211 Err(e) => {
1212 let _ = self.free_bytes(ids_ptr);
1213 return Err(e);
1214 }
1215 };
1216 let offsets_len = offsets.len() as u32;
1217 let len = self.generated.fn_translate_batch.call(
1218 &mut self.store,
1219 (
1220 ids_ptr as i32,
1221 ids_len as i32,
1222 offsets_ptr as i32,
1223 offsets_len as i32,
1224 ),
1225 );
1226 self.free_bytes(ids_ptr)?;
1227 self.free_bytes(offsets_ptr)?;
1228 let len = len?;
1229 if len < 0 {
1230 return Err(self.read_last_error("translate_batch"));
1231 }
1232 self.read_vec_u32_result()
1233 }
1234
1235 pub fn compose_transform(&mut self, m1: &[f64], m2: &[f64]) -> OcctResult<Vec<f64>> {
1236 let m1_bytes: Vec<u8> = m1.iter().flat_map(|v| v.to_le_bytes()).collect();
1237 let m1_ptr = self.write_bytes(&m1_bytes)?;
1238 let m1_len = m1.len() as u32;
1239 let m2_bytes: Vec<u8> = m2.iter().flat_map(|v| v.to_le_bytes()).collect();
1240 let m2_ptr = match self.write_bytes(&m2_bytes) {
1241 Ok(ptr) => ptr,
1242 Err(e) => {
1243 let _ = self.free_bytes(m1_ptr);
1244 return Err(e);
1245 }
1246 };
1247 let m2_len = m2.len() as u32;
1248 let len = self.generated.fn_compose_transform.call(
1249 &mut self.store,
1250 (m1_ptr as i32, m1_len as i32, m2_ptr as i32, m2_len as i32),
1251 );
1252 self.free_bytes(m1_ptr)?;
1253 self.free_bytes(m2_ptr)?;
1254 let len = len?;
1255 if len < 0 {
1256 return Err(self.read_last_error("compose_transform"));
1257 }
1258 self.read_vec_f64_result()
1259 }
1260
1261 pub fn transform_batch(
1262 &mut self,
1263 ids: &[ShapeHandle],
1264 matrices: &[f64],
1265 ) -> OcctResult<Vec<u32>> {
1266 let ids_bytes: Vec<u8> = ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
1267 let ids_ptr = self.write_bytes(&ids_bytes)?;
1268 let ids_len = ids.len() as u32;
1269 let matrices_bytes: Vec<u8> = matrices.iter().flat_map(|v| v.to_le_bytes()).collect();
1270 let matrices_ptr = match self.write_bytes(&matrices_bytes) {
1271 Ok(ptr) => ptr,
1272 Err(e) => {
1273 let _ = self.free_bytes(ids_ptr);
1274 return Err(e);
1275 }
1276 };
1277 let matrices_len = matrices.len() as u32;
1278 let len = self.generated.fn_transform_batch.call(
1279 &mut self.store,
1280 (
1281 ids_ptr as i32,
1282 ids_len as i32,
1283 matrices_ptr as i32,
1284 matrices_len as i32,
1285 ),
1286 );
1287 self.free_bytes(ids_ptr)?;
1288 self.free_bytes(matrices_ptr)?;
1289 let len = len?;
1290 if len < 0 {
1291 return Err(self.read_last_error("transform_batch"));
1292 }
1293 self.read_vec_u32_result()
1294 }
1295
1296 pub fn rotate_batch(&mut self, ids: &[ShapeHandle], params: &[f64]) -> OcctResult<Vec<u32>> {
1297 let ids_bytes: Vec<u8> = ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
1298 let ids_ptr = self.write_bytes(&ids_bytes)?;
1299 let ids_len = ids.len() as u32;
1300 let params_bytes: Vec<u8> = params.iter().flat_map(|v| v.to_le_bytes()).collect();
1301 let params_ptr = match self.write_bytes(¶ms_bytes) {
1302 Ok(ptr) => ptr,
1303 Err(e) => {
1304 let _ = self.free_bytes(ids_ptr);
1305 return Err(e);
1306 }
1307 };
1308 let params_len = params.len() as u32;
1309 let len = self.generated.fn_rotate_batch.call(
1310 &mut self.store,
1311 (
1312 ids_ptr as i32,
1313 ids_len as i32,
1314 params_ptr as i32,
1315 params_len as i32,
1316 ),
1317 );
1318 self.free_bytes(ids_ptr)?;
1319 self.free_bytes(params_ptr)?;
1320 let len = len?;
1321 if len < 0 {
1322 return Err(self.read_last_error("rotate_batch"));
1323 }
1324 self.read_vec_u32_result()
1325 }
1326
1327 pub fn scale_batch(&mut self, ids: &[ShapeHandle], params: &[f64]) -> OcctResult<Vec<u32>> {
1328 let ids_bytes: Vec<u8> = ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
1329 let ids_ptr = self.write_bytes(&ids_bytes)?;
1330 let ids_len = ids.len() as u32;
1331 let params_bytes: Vec<u8> = params.iter().flat_map(|v| v.to_le_bytes()).collect();
1332 let params_ptr = match self.write_bytes(¶ms_bytes) {
1333 Ok(ptr) => ptr,
1334 Err(e) => {
1335 let _ = self.free_bytes(ids_ptr);
1336 return Err(e);
1337 }
1338 };
1339 let params_len = params.len() as u32;
1340 let len = self.generated.fn_scale_batch.call(
1341 &mut self.store,
1342 (
1343 ids_ptr as i32,
1344 ids_len as i32,
1345 params_ptr as i32,
1346 params_len as i32,
1347 ),
1348 );
1349 self.free_bytes(ids_ptr)?;
1350 self.free_bytes(params_ptr)?;
1351 let len = len?;
1352 if len < 0 {
1353 return Err(self.read_last_error("scale_batch"));
1354 }
1355 self.read_vec_u32_result()
1356 }
1357
1358 pub fn mirror_batch(&mut self, ids: &[ShapeHandle], params: &[f64]) -> OcctResult<Vec<u32>> {
1359 let ids_bytes: Vec<u8> = ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
1360 let ids_ptr = self.write_bytes(&ids_bytes)?;
1361 let ids_len = ids.len() as u32;
1362 let params_bytes: Vec<u8> = params.iter().flat_map(|v| v.to_le_bytes()).collect();
1363 let params_ptr = match self.write_bytes(¶ms_bytes) {
1364 Ok(ptr) => ptr,
1365 Err(e) => {
1366 let _ = self.free_bytes(ids_ptr);
1367 return Err(e);
1368 }
1369 };
1370 let params_len = params.len() as u32;
1371 let len = self.generated.fn_mirror_batch.call(
1372 &mut self.store,
1373 (
1374 ids_ptr as i32,
1375 ids_len as i32,
1376 params_ptr as i32,
1377 params_len as i32,
1378 ),
1379 );
1380 self.free_bytes(ids_ptr)?;
1381 self.free_bytes(params_ptr)?;
1382 let len = len?;
1383 if len < 0 {
1384 return Err(self.read_last_error("mirror_batch"));
1385 }
1386 self.read_vec_u32_result()
1387 }
1388
1389 pub fn make_vertex(&mut self, x: f64, y: f64, z: f64) -> OcctResult<ShapeHandle> {
1390 let result = self
1391 .generated
1392 .fn_make_vertex
1393 .call(&mut self.store, (x, y, z))?;
1394 self.check_error("make_vertex")?;
1395 if result == 0 {
1396 return Err(self.read_last_error("make_vertex"));
1397 }
1398 Ok(ShapeHandle(result))
1399 }
1400
1401 pub fn make_edge(&mut self, v1: ShapeHandle, v2: ShapeHandle) -> OcctResult<ShapeHandle> {
1402 let result = self
1403 .generated
1404 .fn_make_edge
1405 .call(&mut self.store, (v1.0, v2.0))?;
1406 self.check_error("make_edge")?;
1407 if result == 0 {
1408 return Err(self.read_last_error("make_edge"));
1409 }
1410 Ok(ShapeHandle(result))
1411 }
1412
1413 pub fn make_wire(&mut self, edge_ids: &[ShapeHandle]) -> OcctResult<ShapeHandle> {
1414 let edge_ids_bytes: Vec<u8> = edge_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
1415 let edge_ids_ptr = self.write_bytes(&edge_ids_bytes)?;
1416 let edge_ids_len = edge_ids.len() as u32;
1417 let result = self
1418 .generated
1419 .fn_make_wire
1420 .call(&mut self.store, (edge_ids_ptr as i32, edge_ids_len as i32));
1421 self.free_bytes(edge_ids_ptr)?;
1422 let result = result?;
1423 self.check_error("make_wire")?;
1424 if result == 0 {
1425 return Err(self.read_last_error("make_wire"));
1426 }
1427 Ok(ShapeHandle(result))
1428 }
1429
1430 pub fn make_face(&mut self, wire_id: ShapeHandle) -> OcctResult<ShapeHandle> {
1431 let result = self
1432 .generated
1433 .fn_make_face
1434 .call(&mut self.store, (wire_id.0,))?;
1435 self.check_error("make_face")?;
1436 if result == 0 {
1437 return Err(self.read_last_error("make_face"));
1438 }
1439 Ok(ShapeHandle(result))
1440 }
1441
1442 pub fn make_face_on_surface(
1443 &mut self,
1444 face_id: ShapeHandle,
1445 wire_id: ShapeHandle,
1446 ) -> OcctResult<ShapeHandle> {
1447 let result = self
1448 .generated
1449 .fn_make_face_on_surface
1450 .call(&mut self.store, (face_id.0, wire_id.0))?;
1451 self.check_error("make_face_on_surface")?;
1452 if result == 0 {
1453 return Err(self.read_last_error("make_face_on_surface"));
1454 }
1455 Ok(ShapeHandle(result))
1456 }
1457
1458 pub fn make_solid(&mut self, shell_id: ShapeHandle) -> OcctResult<ShapeHandle> {
1459 let result = self
1460 .generated
1461 .fn_make_solid
1462 .call(&mut self.store, (shell_id.0,))?;
1463 self.check_error("make_solid")?;
1464 if result == 0 {
1465 return Err(self.read_last_error("make_solid"));
1466 }
1467 Ok(ShapeHandle(result))
1468 }
1469
1470 pub fn sew(&mut self, shape_ids: &[ShapeHandle], tolerance: f64) -> OcctResult<ShapeHandle> {
1471 let shape_ids_bytes: Vec<u8> = shape_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
1472 let shape_ids_ptr = self.write_bytes(&shape_ids_bytes)?;
1473 let shape_ids_len = shape_ids.len() as u32;
1474 let result = self.generated.fn_sew.call(
1475 &mut self.store,
1476 (shape_ids_ptr as i32, shape_ids_len as i32, tolerance),
1477 );
1478 self.free_bytes(shape_ids_ptr)?;
1479 let result = result?;
1480 self.check_error("sew")?;
1481 if result == 0 {
1482 return Err(self.read_last_error("sew"));
1483 }
1484 Ok(ShapeHandle(result))
1485 }
1486
1487 pub fn make_compound(&mut self, shape_ids: &[ShapeHandle]) -> OcctResult<ShapeHandle> {
1488 let shape_ids_bytes: Vec<u8> = shape_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
1489 let shape_ids_ptr = self.write_bytes(&shape_ids_bytes)?;
1490 let shape_ids_len = shape_ids.len() as u32;
1491 let result = self.generated.fn_make_compound.call(
1492 &mut self.store,
1493 (shape_ids_ptr as i32, shape_ids_len as i32),
1494 );
1495 self.free_bytes(shape_ids_ptr)?;
1496 let result = result?;
1497 self.check_error("make_compound")?;
1498 if result == 0 {
1499 return Err(self.read_last_error("make_compound"));
1500 }
1501 Ok(ShapeHandle(result))
1502 }
1503
1504 pub fn make_line_edge(
1505 &mut self,
1506 x1: f64,
1507 y1: f64,
1508 z1: f64,
1509 x2: f64,
1510 y2: f64,
1511 z2: f64,
1512 ) -> OcctResult<ShapeHandle> {
1513 let result = self
1514 .generated
1515 .fn_make_line_edge
1516 .call(&mut self.store, (x1, y1, z1, x2, y2, z2))?;
1517 self.check_error("make_line_edge")?;
1518 if result == 0 {
1519 return Err(self.read_last_error("make_line_edge"));
1520 }
1521 Ok(ShapeHandle(result))
1522 }
1523
1524 pub fn make_circle_edge(
1525 &mut self,
1526 cx: f64,
1527 cy: f64,
1528 cz: f64,
1529 nx: f64,
1530 ny: f64,
1531 nz: f64,
1532 radius: f64,
1533 ) -> OcctResult<ShapeHandle> {
1534 let result = self
1535 .generated
1536 .fn_make_circle_edge
1537 .call(&mut self.store, (cx, cy, cz, nx, ny, nz, radius))?;
1538 self.check_error("make_circle_edge")?;
1539 if result == 0 {
1540 return Err(self.read_last_error("make_circle_edge"));
1541 }
1542 Ok(ShapeHandle(result))
1543 }
1544
1545 pub fn make_circle_arc(
1546 &mut self,
1547 cx: f64,
1548 cy: f64,
1549 cz: f64,
1550 nx: f64,
1551 ny: f64,
1552 nz: f64,
1553 radius: f64,
1554 start_angle: f64,
1555 end_angle: f64,
1556 ) -> OcctResult<ShapeHandle> {
1557 let result = self.generated.fn_make_circle_arc.call(
1558 &mut self.store,
1559 (cx, cy, cz, nx, ny, nz, radius, start_angle, end_angle),
1560 )?;
1561 self.check_error("make_circle_arc")?;
1562 if result == 0 {
1563 return Err(self.read_last_error("make_circle_arc"));
1564 }
1565 Ok(ShapeHandle(result))
1566 }
1567
1568 pub fn make_arc_edge(
1569 &mut self,
1570 x1: f64,
1571 y1: f64,
1572 z1: f64,
1573 x2: f64,
1574 y2: f64,
1575 z2: f64,
1576 x3: f64,
1577 y3: f64,
1578 z3: f64,
1579 ) -> OcctResult<ShapeHandle> {
1580 let result = self
1581 .generated
1582 .fn_make_arc_edge
1583 .call(&mut self.store, (x1, y1, z1, x2, y2, z2, x3, y3, z3))?;
1584 self.check_error("make_arc_edge")?;
1585 if result == 0 {
1586 return Err(self.read_last_error("make_arc_edge"));
1587 }
1588 Ok(ShapeHandle(result))
1589 }
1590
1591 pub fn make_ellipse_edge(
1592 &mut self,
1593 cx: f64,
1594 cy: f64,
1595 cz: f64,
1596 nx: f64,
1597 ny: f64,
1598 nz: f64,
1599 major_radius: f64,
1600 minor_radius: f64,
1601 ) -> OcctResult<ShapeHandle> {
1602 let result = self.generated.fn_make_ellipse_edge.call(
1603 &mut self.store,
1604 (cx, cy, cz, nx, ny, nz, major_radius, minor_radius),
1605 )?;
1606 self.check_error("make_ellipse_edge")?;
1607 if result == 0 {
1608 return Err(self.read_last_error("make_ellipse_edge"));
1609 }
1610 Ok(ShapeHandle(result))
1611 }
1612
1613 pub fn make_bezier_edge(&mut self, flat_points: &[f64]) -> OcctResult<ShapeHandle> {
1614 let flat_points_bytes: Vec<u8> = flat_points.iter().flat_map(|v| v.to_le_bytes()).collect();
1615 let flat_points_ptr = self.write_bytes(&flat_points_bytes)?;
1616 let flat_points_len = flat_points.len() as u32;
1617 let result = self.generated.fn_make_bezier_edge.call(
1618 &mut self.store,
1619 (flat_points_ptr as i32, flat_points_len as i32),
1620 );
1621 self.free_bytes(flat_points_ptr)?;
1622 let result = result?;
1623 self.check_error("make_bezier_edge")?;
1624 if result == 0 {
1625 return Err(self.read_last_error("make_bezier_edge"));
1626 }
1627 Ok(ShapeHandle(result))
1628 }
1629
1630 pub fn make_ellipse_arc(
1631 &mut self,
1632 cx: f64,
1633 cy: f64,
1634 cz: f64,
1635 nx: f64,
1636 ny: f64,
1637 nz: f64,
1638 major_radius: f64,
1639 minor_radius: f64,
1640 start_angle: f64,
1641 end_angle: f64,
1642 ) -> OcctResult<ShapeHandle> {
1643 let result = self.generated.fn_make_ellipse_arc.call(
1644 &mut self.store,
1645 (
1646 cx,
1647 cy,
1648 cz,
1649 nx,
1650 ny,
1651 nz,
1652 major_radius,
1653 minor_radius,
1654 start_angle,
1655 end_angle,
1656 ),
1657 )?;
1658 self.check_error("make_ellipse_arc")?;
1659 if result == 0 {
1660 return Err(self.read_last_error("make_ellipse_arc"));
1661 }
1662 Ok(ShapeHandle(result))
1663 }
1664
1665 pub fn make_helix_wire(
1666 &mut self,
1667 px: f64,
1668 py: f64,
1669 pz: f64,
1670 dx: f64,
1671 dy: f64,
1672 dz: f64,
1673 pitch: f64,
1674 height: f64,
1675 radius: f64,
1676 ) -> OcctResult<ShapeHandle> {
1677 let result = self.generated.fn_make_helix_wire.call(
1678 &mut self.store,
1679 (px, py, pz, dx, dy, dz, pitch, height, radius),
1680 )?;
1681 self.check_error("make_helix_wire")?;
1682 if result == 0 {
1683 return Err(self.read_last_error("make_helix_wire"));
1684 }
1685 Ok(ShapeHandle(result))
1686 }
1687
1688 pub fn make_non_planar_face(&mut self, wire_id: ShapeHandle) -> OcctResult<ShapeHandle> {
1689 let result = self
1690 .generated
1691 .fn_make_non_planar_face
1692 .call(&mut self.store, (wire_id.0,))?;
1693 self.check_error("make_non_planar_face")?;
1694 if result == 0 {
1695 return Err(self.read_last_error("make_non_planar_face"));
1696 }
1697 Ok(ShapeHandle(result))
1698 }
1699
1700 pub fn add_holes_in_face(
1701 &mut self,
1702 face_id: ShapeHandle,
1703 hole_wire_ids: &[ShapeHandle],
1704 ) -> OcctResult<ShapeHandle> {
1705 let hole_wire_ids_bytes: Vec<u8> = hole_wire_ids
1706 .iter()
1707 .flat_map(|h| h.0.to_le_bytes())
1708 .collect();
1709 let hole_wire_ids_ptr = self.write_bytes(&hole_wire_ids_bytes)?;
1710 let hole_wire_ids_len = hole_wire_ids.len() as u32;
1711 let result = self.generated.fn_add_holes_in_face.call(
1712 &mut self.store,
1713 (
1714 face_id.0,
1715 hole_wire_ids_ptr as i32,
1716 hole_wire_ids_len as i32,
1717 ),
1718 );
1719 self.free_bytes(hole_wire_ids_ptr)?;
1720 let result = result?;
1721 self.check_error("add_holes_in_face")?;
1722 if result == 0 {
1723 return Err(self.read_last_error("add_holes_in_face"));
1724 }
1725 Ok(ShapeHandle(result))
1726 }
1727
1728 pub fn remove_holes_from_face(
1729 &mut self,
1730 face_id: ShapeHandle,
1731 hole_indices: &[i32],
1732 ) -> OcctResult<ShapeHandle> {
1733 let hole_indices_bytes: Vec<u8> =
1734 hole_indices.iter().flat_map(|v| v.to_le_bytes()).collect();
1735 let hole_indices_ptr = self.write_bytes(&hole_indices_bytes)?;
1736 let hole_indices_len = hole_indices.len() as u32;
1737 let result = self.generated.fn_remove_holes_from_face.call(
1738 &mut self.store,
1739 (face_id.0, hole_indices_ptr as i32, hole_indices_len as i32),
1740 );
1741 self.free_bytes(hole_indices_ptr)?;
1742 let result = result?;
1743 self.check_error("remove_holes_from_face")?;
1744 if result == 0 {
1745 return Err(self.read_last_error("remove_holes_from_face"));
1746 }
1747 Ok(ShapeHandle(result))
1748 }
1749
1750 pub fn solid_from_shell(&mut self, shell_id: ShapeHandle) -> OcctResult<ShapeHandle> {
1751 let result = self
1752 .generated
1753 .fn_solid_from_shell
1754 .call(&mut self.store, (shell_id.0,))?;
1755 self.check_error("solid_from_shell")?;
1756 if result == 0 {
1757 return Err(self.read_last_error("solid_from_shell"));
1758 }
1759 Ok(ShapeHandle(result))
1760 }
1761
1762 pub fn build_solid_from_faces(
1763 &mut self,
1764 face_ids: &[ShapeHandle],
1765 tolerance: f64,
1766 ) -> OcctResult<ShapeHandle> {
1767 let face_ids_bytes: Vec<u8> = face_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
1768 let face_ids_ptr = self.write_bytes(&face_ids_bytes)?;
1769 let face_ids_len = face_ids.len() as u32;
1770 let result = self.generated.fn_build_solid_from_faces.call(
1771 &mut self.store,
1772 (face_ids_ptr as i32, face_ids_len as i32, tolerance),
1773 );
1774 self.free_bytes(face_ids_ptr)?;
1775 let result = result?;
1776 self.check_error("build_solid_from_faces")?;
1777 if result == 0 {
1778 return Err(self.read_last_error("build_solid_from_faces"));
1779 }
1780 Ok(ShapeHandle(result))
1781 }
1782
1783 pub fn sew_and_solidify(
1784 &mut self,
1785 face_ids: &[ShapeHandle],
1786 tolerance: f64,
1787 ) -> OcctResult<ShapeHandle> {
1788 let face_ids_bytes: Vec<u8> = face_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
1789 let face_ids_ptr = self.write_bytes(&face_ids_bytes)?;
1790 let face_ids_len = face_ids.len() as u32;
1791 let result = self.generated.fn_sew_and_solidify.call(
1792 &mut self.store,
1793 (face_ids_ptr as i32, face_ids_len as i32, tolerance),
1794 );
1795 self.free_bytes(face_ids_ptr)?;
1796 let result = result?;
1797 self.check_error("sew_and_solidify")?;
1798 if result == 0 {
1799 return Err(self.read_last_error("sew_and_solidify"));
1800 }
1801 Ok(ShapeHandle(result))
1802 }
1803
1804 pub fn build_tri_face(
1805 &mut self,
1806 ax: f64,
1807 ay: f64,
1808 az: f64,
1809 bx: f64,
1810 by: f64,
1811 bz: f64,
1812 cx2: f64,
1813 cy2: f64,
1814 cz2: f64,
1815 ) -> OcctResult<ShapeHandle> {
1816 let result = self
1817 .generated
1818 .fn_build_tri_face
1819 .call(&mut self.store, (ax, ay, az, bx, by, bz, cx2, cy2, cz2))?;
1820 self.check_error("build_tri_face")?;
1821 if result == 0 {
1822 return Err(self.read_last_error("build_tri_face"));
1823 }
1824 Ok(ShapeHandle(result))
1825 }
1826
1827 pub fn make_tangent_arc(
1828 &mut self,
1829 x1: f64,
1830 y1: f64,
1831 z1: f64,
1832 tx: f64,
1833 ty: f64,
1834 tz: f64,
1835 x2: f64,
1836 y2: f64,
1837 z2: f64,
1838 ) -> OcctResult<ShapeHandle> {
1839 let result = self
1840 .generated
1841 .fn_make_tangent_arc
1842 .call(&mut self.store, (x1, y1, z1, tx, ty, tz, x2, y2, z2))?;
1843 self.check_error("make_tangent_arc")?;
1844 if result == 0 {
1845 return Err(self.read_last_error("make_tangent_arc"));
1846 }
1847 Ok(ShapeHandle(result))
1848 }
1849
1850 pub fn bspline_surface(
1851 &mut self,
1852 flat_points: &[f64],
1853 rows: i32,
1854 cols: i32,
1855 ) -> OcctResult<ShapeHandle> {
1856 let flat_points_bytes: Vec<u8> = flat_points.iter().flat_map(|v| v.to_le_bytes()).collect();
1857 let flat_points_ptr = self.write_bytes(&flat_points_bytes)?;
1858 let flat_points_len = flat_points.len() as u32;
1859 let result = self.generated.fn_bspline_surface.call(
1860 &mut self.store,
1861 (flat_points_ptr as i32, flat_points_len as i32, rows, cols),
1862 );
1863 self.free_bytes(flat_points_ptr)?;
1864 let result = result?;
1865 self.check_error("bspline_surface")?;
1866 if result == 0 {
1867 return Err(self.read_last_error("bspline_surface"));
1868 }
1869 Ok(ShapeHandle(result))
1870 }
1871
1872 pub fn get_shape_type(&mut self, id: ShapeHandle) -> OcctResult<String> {
1873 let len = self
1874 .generated
1875 .fn_get_shape_type
1876 .call(&mut self.store, (id.0,))?;
1877 if len < 0 {
1878 return Err(self.read_last_error("get_shape_type"));
1879 }
1880 self.read_string_result()
1881 }
1882
1883 pub fn get_sub_shapes(&mut self, id: ShapeHandle, shape_type: &str) -> OcctResult<Vec<u32>> {
1884 let shape_type_ptr = self.write_bytes(shape_type.as_bytes())?;
1885 let shape_type_len = shape_type.len() as u32;
1886 let len = self.generated.fn_get_sub_shapes.call(
1887 &mut self.store,
1888 (id.0, shape_type_ptr as i32, shape_type_len as i32),
1889 );
1890 self.free_bytes(shape_type_ptr)?;
1891 let len = len?;
1892 if len < 0 {
1893 return Err(self.read_last_error("get_sub_shapes"));
1894 }
1895 self.read_vec_u32_result()
1896 }
1897
1898 pub fn distance_between(&mut self, a: ShapeHandle, b: ShapeHandle) -> OcctResult<f64> {
1899 let result = self
1900 .generated
1901 .fn_distance_between
1902 .call(&mut self.store, (a.0, b.0))?;
1903 self.check_error("distance_between")?;
1904 Ok(result)
1905 }
1906
1907 pub fn is_same(&mut self, a: ShapeHandle, b: ShapeHandle) -> OcctResult<bool> {
1908 let result = self
1909 .generated
1910 .fn_is_same
1911 .call(&mut self.store, (a.0, b.0))?;
1912 if result < 0 {
1913 return Err(self.read_last_error("is_same"));
1914 }
1915 Ok(result != 0)
1916 }
1917
1918 pub fn is_equal(&mut self, a: ShapeHandle, b: ShapeHandle) -> OcctResult<bool> {
1919 let result = self
1920 .generated
1921 .fn_is_equal
1922 .call(&mut self.store, (a.0, b.0))?;
1923 if result < 0 {
1924 return Err(self.read_last_error("is_equal"));
1925 }
1926 Ok(result != 0)
1927 }
1928
1929 pub fn is_null(&mut self, id: ShapeHandle) -> OcctResult<bool> {
1930 let result = self.generated.fn_is_null.call(&mut self.store, (id.0,))?;
1931 if result < 0 {
1932 return Err(self.read_last_error("is_null"));
1933 }
1934 Ok(result != 0)
1935 }
1936
1937 pub fn hash_code(&mut self, id: ShapeHandle, upper_bound: i32) -> OcctResult<i32> {
1938 let result = self
1939 .generated
1940 .fn_hash_code
1941 .call(&mut self.store, (id.0, upper_bound))?;
1942 self.check_error("hash_code")?;
1943 Ok(result)
1944 }
1945
1946 pub fn shape_orientation(&mut self, id: ShapeHandle) -> OcctResult<String> {
1947 let len = self
1948 .generated
1949 .fn_shape_orientation
1950 .call(&mut self.store, (id.0,))?;
1951 if len < 0 {
1952 return Err(self.read_last_error("shape_orientation"));
1953 }
1954 self.read_string_result()
1955 }
1956
1957 pub fn iter_shapes(&mut self, id: ShapeHandle) -> OcctResult<Vec<u32>> {
1958 let len = self
1959 .generated
1960 .fn_iter_shapes
1961 .call(&mut self.store, (id.0,))?;
1962 if len < 0 {
1963 return Err(self.read_last_error("iter_shapes"));
1964 }
1965 self.read_vec_u32_result()
1966 }
1967
1968 pub fn edge_to_face_map(
1969 &mut self,
1970 id: ShapeHandle,
1971 hash_upper_bound: i32,
1972 ) -> OcctResult<Vec<i32>> {
1973 let len = self
1974 .generated
1975 .fn_edge_to_face_map
1976 .call(&mut self.store, (id.0, hash_upper_bound))?;
1977 if len < 0 {
1978 return Err(self.read_last_error("edge_to_face_map"));
1979 }
1980 self.read_vec_i32_result()
1981 }
1982
1983 pub fn downcast(&mut self, id: ShapeHandle, target_type: &str) -> OcctResult<ShapeHandle> {
1984 let target_type_ptr = self.write_bytes(target_type.as_bytes())?;
1985 let target_type_len = target_type.len() as u32;
1986 let result = self.generated.fn_downcast.call(
1987 &mut self.store,
1988 (id.0, target_type_ptr as i32, target_type_len as i32),
1989 );
1990 self.free_bytes(target_type_ptr)?;
1991 let result = result?;
1992 self.check_error("downcast")?;
1993 if result == 0 {
1994 return Err(self.read_last_error("downcast"));
1995 }
1996 Ok(ShapeHandle(result))
1997 }
1998
1999 pub fn adjacent_faces(
2000 &mut self,
2001 shape_id: ShapeHandle,
2002 face_id: ShapeHandle,
2003 ) -> OcctResult<Vec<u32>> {
2004 let len = self
2005 .generated
2006 .fn_adjacent_faces
2007 .call(&mut self.store, (shape_id.0, face_id.0))?;
2008 if len < 0 {
2009 return Err(self.read_last_error("adjacent_faces"));
2010 }
2011 self.read_vec_u32_result()
2012 }
2013
2014 pub fn shared_edges(
2015 &mut self,
2016 face_a: ShapeHandle,
2017 face_b: ShapeHandle,
2018 ) -> OcctResult<Vec<u32>> {
2019 let len = self
2020 .generated
2021 .fn_shared_edges
2022 .call(&mut self.store, (face_a.0, face_b.0))?;
2023 if len < 0 {
2024 return Err(self.read_last_error("shared_edges"));
2025 }
2026 self.read_vec_u32_result()
2027 }
2028
2029 pub fn get_bounding_box(
2030 &mut self,
2031 id: ShapeHandle,
2032 use_triangulation: bool,
2033 ) -> OcctResult<BoundingBox> {
2034 let status = self
2035 .generated
2036 .fn_get_bounding_box
2037 .call(&mut self.store, (id.0, i32::from(use_triangulation)))?;
2038 if status < 0 {
2039 return Err(self.read_last_error("get_bounding_box"));
2040 }
2041 self.read_bbox_result()
2042 }
2043
2044 pub fn get_volume(&mut self, id: ShapeHandle) -> OcctResult<f64> {
2045 let result = self
2046 .generated
2047 .fn_get_volume
2048 .call(&mut self.store, (id.0,))?;
2049 self.check_error("get_volume")?;
2050 Ok(result)
2051 }
2052
2053 pub fn get_surface_area(&mut self, id: ShapeHandle) -> OcctResult<f64> {
2054 let result = self
2055 .generated
2056 .fn_get_surface_area
2057 .call(&mut self.store, (id.0,))?;
2058 self.check_error("get_surface_area")?;
2059 Ok(result)
2060 }
2061
2062 pub fn get_length(&mut self, id: ShapeHandle) -> OcctResult<f64> {
2063 let result = self
2064 .generated
2065 .fn_get_length
2066 .call(&mut self.store, (id.0,))?;
2067 self.check_error("get_length")?;
2068 Ok(result)
2069 }
2070
2071 pub fn get_center_of_mass(&mut self, id: ShapeHandle) -> OcctResult<Vec<f64>> {
2072 let len = self
2073 .generated
2074 .fn_get_center_of_mass
2075 .call(&mut self.store, (id.0,))?;
2076 if len < 0 {
2077 return Err(self.read_last_error("get_center_of_mass"));
2078 }
2079 self.read_vec_f64_result()
2080 }
2081
2082 pub fn get_surface_center_of_mass(&mut self, face_id: ShapeHandle) -> OcctResult<Vec<f64>> {
2083 let len = self
2084 .generated
2085 .fn_get_surface_center_of_mass
2086 .call(&mut self.store, (face_id.0,))?;
2087 if len < 0 {
2088 return Err(self.read_last_error("get_surface_center_of_mass"));
2089 }
2090 self.read_vec_f64_result()
2091 }
2092
2093 pub fn vertex_position(&mut self, vertex_id: ShapeHandle) -> OcctResult<Vec<f64>> {
2094 let len = self
2095 .generated
2096 .fn_vertex_position
2097 .call(&mut self.store, (vertex_id.0,))?;
2098 if len < 0 {
2099 return Err(self.read_last_error("vertex_position"));
2100 }
2101 self.read_vec_f64_result()
2102 }
2103
2104 pub fn surface_type(&mut self, face_id: ShapeHandle) -> OcctResult<String> {
2105 let len = self
2106 .generated
2107 .fn_surface_type
2108 .call(&mut self.store, (face_id.0,))?;
2109 if len < 0 {
2110 return Err(self.read_last_error("surface_type"));
2111 }
2112 self.read_string_result()
2113 }
2114
2115 pub fn surface_normal(&mut self, face_id: ShapeHandle, u: f64, v: f64) -> OcctResult<Vec<f64>> {
2116 let len = self
2117 .generated
2118 .fn_surface_normal
2119 .call(&mut self.store, (face_id.0, u, v))?;
2120 if len < 0 {
2121 return Err(self.read_last_error("surface_normal"));
2122 }
2123 self.read_vec_f64_result()
2124 }
2125
2126 pub fn point_on_surface(
2127 &mut self,
2128 face_id: ShapeHandle,
2129 u: f64,
2130 v: f64,
2131 ) -> OcctResult<Vec<f64>> {
2132 let len = self
2133 .generated
2134 .fn_point_on_surface
2135 .call(&mut self.store, (face_id.0, u, v))?;
2136 if len < 0 {
2137 return Err(self.read_last_error("point_on_surface"));
2138 }
2139 self.read_vec_f64_result()
2140 }
2141
2142 pub fn outer_wire(&mut self, face_id: ShapeHandle) -> OcctResult<ShapeHandle> {
2143 let result = self
2144 .generated
2145 .fn_outer_wire
2146 .call(&mut self.store, (face_id.0,))?;
2147 self.check_error("outer_wire")?;
2148 if result == 0 {
2149 return Err(self.read_last_error("outer_wire"));
2150 }
2151 Ok(ShapeHandle(result))
2152 }
2153
2154 pub fn get_linear_center_of_mass(&mut self, id: ShapeHandle) -> OcctResult<Vec<f64>> {
2155 let len = self
2156 .generated
2157 .fn_get_linear_center_of_mass
2158 .call(&mut self.store, (id.0,))?;
2159 if len < 0 {
2160 return Err(self.read_last_error("get_linear_center_of_mass"));
2161 }
2162 self.read_vec_f64_result()
2163 }
2164
2165 pub fn surface_curvature(
2166 &mut self,
2167 face_id: ShapeHandle,
2168 u: f64,
2169 v: f64,
2170 ) -> OcctResult<Vec<f64>> {
2171 let len = self
2172 .generated
2173 .fn_surface_curvature
2174 .call(&mut self.store, (face_id.0, u, v))?;
2175 if len < 0 {
2176 return Err(self.read_last_error("surface_curvature"));
2177 }
2178 self.read_vec_f64_result()
2179 }
2180
2181 pub fn uv_bounds(&mut self, face_id: ShapeHandle) -> OcctResult<Vec<f64>> {
2182 let len = self
2183 .generated
2184 .fn_uv_bounds
2185 .call(&mut self.store, (face_id.0,))?;
2186 if len < 0 {
2187 return Err(self.read_last_error("uv_bounds"));
2188 }
2189 self.read_vec_f64_result()
2190 }
2191
2192 pub fn get_face_cylinder_data(&mut self, face_id: ShapeHandle) -> OcctResult<Vec<f64>> {
2193 let len = self
2194 .generated
2195 .fn_get_face_cylinder_data
2196 .call(&mut self.store, (face_id.0,))?;
2197 if len < 0 {
2198 return Err(self.read_last_error("get_face_cylinder_data"));
2199 }
2200 self.read_vec_f64_result()
2201 }
2202
2203 pub fn uv_from_point(
2204 &mut self,
2205 face_id: ShapeHandle,
2206 x: f64,
2207 y: f64,
2208 z: f64,
2209 ) -> OcctResult<Vec<f64>> {
2210 let len = self
2211 .generated
2212 .fn_uv_from_point
2213 .call(&mut self.store, (face_id.0, x, y, z))?;
2214 if len < 0 {
2215 return Err(self.read_last_error("uv_from_point"));
2216 }
2217 self.read_vec_f64_result()
2218 }
2219
2220 pub fn project_point_on_face(
2221 &mut self,
2222 face_id: ShapeHandle,
2223 x: f64,
2224 y: f64,
2225 z: f64,
2226 ) -> OcctResult<Vec<f64>> {
2227 let len = self
2228 .generated
2229 .fn_project_point_on_face
2230 .call(&mut self.store, (face_id.0, x, y, z))?;
2231 if len < 0 {
2232 return Err(self.read_last_error("project_point_on_face"));
2233 }
2234 self.read_vec_f64_result()
2235 }
2236
2237 pub fn classify_point_on_face(
2238 &mut self,
2239 face_id: ShapeHandle,
2240 u: f64,
2241 v: f64,
2242 ) -> OcctResult<String> {
2243 let len = self
2244 .generated
2245 .fn_classify_point_on_face
2246 .call(&mut self.store, (face_id.0, u, v))?;
2247 if len < 0 {
2248 return Err(self.read_last_error("classify_point_on_face"));
2249 }
2250 self.read_string_result()
2251 }
2252
2253 pub fn curve_type(&mut self, id: ShapeHandle) -> OcctResult<String> {
2254 let len = self
2255 .generated
2256 .fn_curve_type
2257 .call(&mut self.store, (id.0,))?;
2258 if len < 0 {
2259 return Err(self.read_last_error("curve_type"));
2260 }
2261 self.read_string_result()
2262 }
2263
2264 pub fn curve_point_at_param(&mut self, id: ShapeHandle, param: f64) -> OcctResult<Vec<f64>> {
2265 let len = self
2266 .generated
2267 .fn_curve_point_at_param
2268 .call(&mut self.store, (id.0, param))?;
2269 if len < 0 {
2270 return Err(self.read_last_error("curve_point_at_param"));
2271 }
2272 self.read_vec_f64_result()
2273 }
2274
2275 pub fn curve_tangent(&mut self, id: ShapeHandle, param: f64) -> OcctResult<Vec<f64>> {
2276 let len = self
2277 .generated
2278 .fn_curve_tangent
2279 .call(&mut self.store, (id.0, param))?;
2280 if len < 0 {
2281 return Err(self.read_last_error("curve_tangent"));
2282 }
2283 self.read_vec_f64_result()
2284 }
2285
2286 pub fn curve_parameters(&mut self, id: ShapeHandle) -> OcctResult<Vec<f64>> {
2287 let len = self
2288 .generated
2289 .fn_curve_parameters
2290 .call(&mut self.store, (id.0,))?;
2291 if len < 0 {
2292 return Err(self.read_last_error("curve_parameters"));
2293 }
2294 self.read_vec_f64_result()
2295 }
2296
2297 pub fn curve_is_closed(&mut self, id: ShapeHandle) -> OcctResult<bool> {
2298 let result = self
2299 .generated
2300 .fn_curve_is_closed
2301 .call(&mut self.store, (id.0,))?;
2302 if result < 0 {
2303 return Err(self.read_last_error("curve_is_closed"));
2304 }
2305 Ok(result != 0)
2306 }
2307
2308 pub fn curve_length(&mut self, id: ShapeHandle) -> OcctResult<f64> {
2309 let result = self
2310 .generated
2311 .fn_curve_length
2312 .call(&mut self.store, (id.0,))?;
2313 self.check_error("curve_length")?;
2314 Ok(result)
2315 }
2316
2317 pub fn interpolate_points(
2318 &mut self,
2319 flat_points: &[f64],
2320 periodic: bool,
2321 ) -> OcctResult<ShapeHandle> {
2322 let flat_points_bytes: Vec<u8> = flat_points.iter().flat_map(|v| v.to_le_bytes()).collect();
2323 let flat_points_ptr = self.write_bytes(&flat_points_bytes)?;
2324 let flat_points_len = flat_points.len() as u32;
2325 let result = self.generated.fn_interpolate_points.call(
2326 &mut self.store,
2327 (
2328 flat_points_ptr as i32,
2329 flat_points_len as i32,
2330 i32::from(periodic),
2331 ),
2332 );
2333 self.free_bytes(flat_points_ptr)?;
2334 let result = result?;
2335 self.check_error("interpolate_points")?;
2336 if result == 0 {
2337 return Err(self.read_last_error("interpolate_points"));
2338 }
2339 Ok(ShapeHandle(result))
2340 }
2341
2342 pub fn curve_is_periodic(&mut self, id: ShapeHandle) -> OcctResult<bool> {
2343 let result = self
2344 .generated
2345 .fn_curve_is_periodic
2346 .call(&mut self.store, (id.0,))?;
2347 if result < 0 {
2348 return Err(self.read_last_error("curve_is_periodic"));
2349 }
2350 Ok(result != 0)
2351 }
2352
2353 pub fn approximate_points(
2354 &mut self,
2355 flat_points: &[f64],
2356 tolerance: f64,
2357 ) -> OcctResult<ShapeHandle> {
2358 let flat_points_bytes: Vec<u8> = flat_points.iter().flat_map(|v| v.to_le_bytes()).collect();
2359 let flat_points_ptr = self.write_bytes(&flat_points_bytes)?;
2360 let flat_points_len = flat_points.len() as u32;
2361 let result = self.generated.fn_approximate_points.call(
2362 &mut self.store,
2363 (flat_points_ptr as i32, flat_points_len as i32, tolerance),
2364 );
2365 self.free_bytes(flat_points_ptr)?;
2366 let result = result?;
2367 self.check_error("approximate_points")?;
2368 if result == 0 {
2369 return Err(self.read_last_error("approximate_points"));
2370 }
2371 Ok(ShapeHandle(result))
2372 }
2373
2374 pub fn lift_curve2d_to_plane(
2375 &mut self,
2376 flat_points2d: &[f64],
2377 plane_ox: f64,
2378 plane_oy: f64,
2379 plane_oz: f64,
2380 plane_zx: f64,
2381 plane_zy: f64,
2382 plane_zz: f64,
2383 plane_xx: f64,
2384 plane_xy: f64,
2385 plane_xz: f64,
2386 ) -> OcctResult<ShapeHandle> {
2387 let flat_points2d_bytes: Vec<u8> =
2388 flat_points2d.iter().flat_map(|v| v.to_le_bytes()).collect();
2389 let flat_points2d_ptr = self.write_bytes(&flat_points2d_bytes)?;
2390 let flat_points2d_len = flat_points2d.len() as u32;
2391 let result = self.generated.fn_lift_curve2d_to_plane.call(
2392 &mut self.store,
2393 (
2394 flat_points2d_ptr as i32,
2395 flat_points2d_len as i32,
2396 plane_ox,
2397 plane_oy,
2398 plane_oz,
2399 plane_zx,
2400 plane_zy,
2401 plane_zz,
2402 plane_xx,
2403 plane_xy,
2404 plane_xz,
2405 ),
2406 );
2407 self.free_bytes(flat_points2d_ptr)?;
2408 let result = result?;
2409 self.check_error("lift_curve2d_to_plane")?;
2410 if result == 0 {
2411 return Err(self.read_last_error("lift_curve2d_to_plane"));
2412 }
2413 Ok(ShapeHandle(result))
2414 }
2415
2416 pub fn get_nurbs_curve_data(&mut self, edge_id: ShapeHandle) -> OcctResult<NurbsCurveData> {
2417 let status = self
2418 .generated
2419 .fn_get_nurbs_curve_data
2420 .call(&mut self.store, (edge_id.0,))?;
2421 if status < 0 {
2422 return Err(self.read_last_error("get_nurbs_curve_data"));
2423 }
2424 self.read_nurbs_result()
2425 }
2426
2427 pub fn has_triangulation(&mut self, id: ShapeHandle) -> OcctResult<bool> {
2428 let result = self
2429 .generated
2430 .fn_has_triangulation
2431 .call(&mut self.store, (id.0,))?;
2432 if result < 0 {
2433 return Err(self.read_last_error("has_triangulation"));
2434 }
2435 Ok(result != 0)
2436 }
2437
2438 pub fn query_batch(&mut self, ids: &[ShapeHandle]) -> OcctResult<Vec<f64>> {
2439 let ids_bytes: Vec<u8> = ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
2440 let ids_ptr = self.write_bytes(&ids_bytes)?;
2441 let ids_len = ids.len() as u32;
2442 let len = self
2443 .generated
2444 .fn_query_batch
2445 .call(&mut self.store, (ids_ptr as i32, ids_len as i32));
2446 self.free_bytes(ids_ptr)?;
2447 let len = len?;
2448 if len < 0 {
2449 return Err(self.read_last_error("query_batch"));
2450 }
2451 self.read_vec_f64_result()
2452 }
2453
2454 pub fn pipe(
2455 &mut self,
2456 profile_id: ShapeHandle,
2457 spine_id: ShapeHandle,
2458 ) -> OcctResult<ShapeHandle> {
2459 let result = self
2460 .generated
2461 .fn_pipe
2462 .call(&mut self.store, (profile_id.0, spine_id.0))?;
2463 self.check_error("pipe")?;
2464 if result == 0 {
2465 return Err(self.read_last_error("pipe"));
2466 }
2467 Ok(ShapeHandle(result))
2468 }
2469
2470 pub fn simple_pipe(
2471 &mut self,
2472 profile_id: ShapeHandle,
2473 spine_id: ShapeHandle,
2474 ) -> OcctResult<ShapeHandle> {
2475 let result = self
2476 .generated
2477 .fn_simple_pipe
2478 .call(&mut self.store, (profile_id.0, spine_id.0))?;
2479 self.check_error("simple_pipe")?;
2480 if result == 0 {
2481 return Err(self.read_last_error("simple_pipe"));
2482 }
2483 Ok(ShapeHandle(result))
2484 }
2485
2486 pub fn revolve_vec(
2487 &mut self,
2488 shape_id: ShapeHandle,
2489 cx: f64,
2490 cy: f64,
2491 cz: f64,
2492 dx: f64,
2493 dy: f64,
2494 dz: f64,
2495 angle: f64,
2496 ) -> OcctResult<ShapeHandle> {
2497 let result = self
2498 .generated
2499 .fn_revolve_vec
2500 .call(&mut self.store, (shape_id.0, cx, cy, cz, dx, dy, dz, angle))?;
2501 self.check_error("revolve_vec")?;
2502 if result == 0 {
2503 return Err(self.read_last_error("revolve_vec"));
2504 }
2505 Ok(ShapeHandle(result))
2506 }
2507
2508 pub fn loft(
2509 &mut self,
2510 wire_ids: &[ShapeHandle],
2511 is_solid: bool,
2512 ruled: bool,
2513 ) -> OcctResult<ShapeHandle> {
2514 let wire_ids_bytes: Vec<u8> = wire_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
2515 let wire_ids_ptr = self.write_bytes(&wire_ids_bytes)?;
2516 let wire_ids_len = wire_ids.len() as u32;
2517 let result = self.generated.fn_loft.call(
2518 &mut self.store,
2519 (
2520 wire_ids_ptr as i32,
2521 wire_ids_len as i32,
2522 i32::from(is_solid),
2523 i32::from(ruled),
2524 ),
2525 );
2526 self.free_bytes(wire_ids_ptr)?;
2527 let result = result?;
2528 self.check_error("loft")?;
2529 if result == 0 {
2530 return Err(self.read_last_error("loft"));
2531 }
2532 Ok(ShapeHandle(result))
2533 }
2534
2535 pub fn loft_with_vertices(
2536 &mut self,
2537 wire_ids: &[ShapeHandle],
2538 is_solid: bool,
2539 ruled: bool,
2540 start_vertex_id: ShapeHandle,
2541 end_vertex_id: ShapeHandle,
2542 ) -> OcctResult<ShapeHandle> {
2543 let wire_ids_bytes: Vec<u8> = wire_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
2544 let wire_ids_ptr = self.write_bytes(&wire_ids_bytes)?;
2545 let wire_ids_len = wire_ids.len() as u32;
2546 let result = self.generated.fn_loft_with_vertices.call(
2547 &mut self.store,
2548 (
2549 wire_ids_ptr as i32,
2550 wire_ids_len as i32,
2551 i32::from(is_solid),
2552 i32::from(ruled),
2553 start_vertex_id.0,
2554 end_vertex_id.0,
2555 ),
2556 );
2557 self.free_bytes(wire_ids_ptr)?;
2558 let result = result?;
2559 self.check_error("loft_with_vertices")?;
2560 if result == 0 {
2561 return Err(self.read_last_error("loft_with_vertices"));
2562 }
2563 Ok(ShapeHandle(result))
2564 }
2565
2566 pub fn sweep(
2567 &mut self,
2568 wire_id: ShapeHandle,
2569 spine_id: ShapeHandle,
2570 transition_mode: i32,
2571 ) -> OcctResult<ShapeHandle> {
2572 let result = self
2573 .generated
2574 .fn_sweep
2575 .call(&mut self.store, (wire_id.0, spine_id.0, transition_mode))?;
2576 self.check_error("sweep")?;
2577 if result == 0 {
2578 return Err(self.read_last_error("sweep"));
2579 }
2580 Ok(ShapeHandle(result))
2581 }
2582
2583 pub fn sweep_pipe_shell(
2584 &mut self,
2585 profile_id: ShapeHandle,
2586 spine_id: ShapeHandle,
2587 freenet: bool,
2588 smooth: bool,
2589 ) -> OcctResult<ShapeHandle> {
2590 let result = self.generated.fn_sweep_pipe_shell.call(
2591 &mut self.store,
2592 (
2593 profile_id.0,
2594 spine_id.0,
2595 i32::from(freenet),
2596 i32::from(smooth),
2597 ),
2598 )?;
2599 self.check_error("sweep_pipe_shell")?;
2600 if result == 0 {
2601 return Err(self.read_last_error("sweep_pipe_shell"));
2602 }
2603 Ok(ShapeHandle(result))
2604 }
2605
2606 pub fn draft_prism(
2607 &mut self,
2608 shape_id: ShapeHandle,
2609 dx: f64,
2610 dy: f64,
2611 dz: f64,
2612 angle_deg: f64,
2613 ) -> OcctResult<ShapeHandle> {
2614 let result = self
2615 .generated
2616 .fn_draft_prism
2617 .call(&mut self.store, (shape_id.0, dx, dy, dz, angle_deg))?;
2618 self.check_error("draft_prism")?;
2619 if result == 0 {
2620 return Err(self.read_last_error("draft_prism"));
2621 }
2622 Ok(ShapeHandle(result))
2623 }
2624
2625 pub fn fix_shape(&mut self, id: ShapeHandle) -> OcctResult<ShapeHandle> {
2626 let result = self.generated.fn_fix_shape.call(&mut self.store, (id.0,))?;
2627 self.check_error("fix_shape")?;
2628 if result == 0 {
2629 return Err(self.read_last_error("fix_shape"));
2630 }
2631 Ok(ShapeHandle(result))
2632 }
2633
2634 pub fn unify_same_domain(&mut self, id: ShapeHandle) -> OcctResult<ShapeHandle> {
2635 let result = self
2636 .generated
2637 .fn_unify_same_domain
2638 .call(&mut self.store, (id.0,))?;
2639 self.check_error("unify_same_domain")?;
2640 if result == 0 {
2641 return Err(self.read_last_error("unify_same_domain"));
2642 }
2643 Ok(ShapeHandle(result))
2644 }
2645
2646 pub fn is_valid(&mut self, id: ShapeHandle) -> OcctResult<bool> {
2647 let result = self.generated.fn_is_valid.call(&mut self.store, (id.0,))?;
2648 if result < 0 {
2649 return Err(self.read_last_error("is_valid"));
2650 }
2651 Ok(result != 0)
2652 }
2653
2654 pub fn heal_solid(&mut self, id: ShapeHandle, tolerance: f64) -> OcctResult<ShapeHandle> {
2655 let result = self
2656 .generated
2657 .fn_heal_solid
2658 .call(&mut self.store, (id.0, tolerance))?;
2659 self.check_error("heal_solid")?;
2660 if result == 0 {
2661 return Err(self.read_last_error("heal_solid"));
2662 }
2663 Ok(ShapeHandle(result))
2664 }
2665
2666 pub fn heal_face(&mut self, id: ShapeHandle, tolerance: f64) -> OcctResult<ShapeHandle> {
2667 let result = self
2668 .generated
2669 .fn_heal_face
2670 .call(&mut self.store, (id.0, tolerance))?;
2671 self.check_error("heal_face")?;
2672 if result == 0 {
2673 return Err(self.read_last_error("heal_face"));
2674 }
2675 Ok(ShapeHandle(result))
2676 }
2677
2678 pub fn heal_wire(&mut self, id: ShapeHandle, tolerance: f64) -> OcctResult<ShapeHandle> {
2679 let result = self
2680 .generated
2681 .fn_heal_wire
2682 .call(&mut self.store, (id.0, tolerance))?;
2683 self.check_error("heal_wire")?;
2684 if result == 0 {
2685 return Err(self.read_last_error("heal_wire"));
2686 }
2687 Ok(ShapeHandle(result))
2688 }
2689
2690 pub fn fix_face_orientations(&mut self, id: ShapeHandle) -> OcctResult<ShapeHandle> {
2691 let result = self
2692 .generated
2693 .fn_fix_face_orientations
2694 .call(&mut self.store, (id.0,))?;
2695 self.check_error("fix_face_orientations")?;
2696 if result == 0 {
2697 return Err(self.read_last_error("fix_face_orientations"));
2698 }
2699 Ok(ShapeHandle(result))
2700 }
2701
2702 pub fn build_curves3d(&mut self, wire_id: ShapeHandle) -> OcctResult<()> {
2703 let result = self
2704 .generated
2705 .fn_build_curves3d
2706 .call(&mut self.store, (wire_id.0,))?;
2707 if result < 0 {
2708 return Err(self.read_last_error("build_curves3d"));
2709 }
2710 Ok(())
2711 }
2712
2713 pub fn fix_wire_on_face(
2714 &mut self,
2715 wire_id: ShapeHandle,
2716 face_id: ShapeHandle,
2717 tolerance: f64,
2718 ) -> OcctResult<ShapeHandle> {
2719 let result = self
2720 .generated
2721 .fn_fix_wire_on_face
2722 .call(&mut self.store, (wire_id.0, face_id.0, tolerance))?;
2723 self.check_error("fix_wire_on_face")?;
2724 if result == 0 {
2725 return Err(self.read_last_error("fix_wire_on_face"));
2726 }
2727 Ok(ShapeHandle(result))
2728 }
2729
2730 pub fn remove_degenerate_edges(&mut self, id: ShapeHandle) -> OcctResult<ShapeHandle> {
2731 let result = self
2732 .generated
2733 .fn_remove_degenerate_edges
2734 .call(&mut self.store, (id.0,))?;
2735 self.check_error("remove_degenerate_edges")?;
2736 if result == 0 {
2737 return Err(self.read_last_error("remove_degenerate_edges"));
2738 }
2739 Ok(ShapeHandle(result))
2740 }
2741
2742 pub fn import_step(&mut self, data: &str) -> OcctResult<ShapeHandle> {
2743 let data_ptr = self.write_bytes(data.as_bytes())?;
2744 let data_len = data.len() as u32;
2745 let result = self
2746 .generated
2747 .fn_import_step
2748 .call(&mut self.store, (data_ptr as i32, data_len as i32));
2749 self.free_bytes(data_ptr)?;
2750 let result = result?;
2751 self.check_error("import_step")?;
2752 if result == 0 {
2753 return Err(self.read_last_error("import_step"));
2754 }
2755 Ok(ShapeHandle(result))
2756 }
2757
2758 pub fn export_step(&mut self, id: ShapeHandle) -> OcctResult<String> {
2759 let len = self
2760 .generated
2761 .fn_export_step
2762 .call(&mut self.store, (id.0,))?;
2763 if len < 0 {
2764 return Err(self.read_last_error("export_step"));
2765 }
2766 self.read_string_result()
2767 }
2768
2769 pub fn export_stl(
2770 &mut self,
2771 id: ShapeHandle,
2772 linear_deflection: f64,
2773 ascii: bool,
2774 ) -> OcctResult<String> {
2775 let len = self
2776 .generated
2777 .fn_export_stl
2778 .call(&mut self.store, (id.0, linear_deflection, i32::from(ascii)))?;
2779 if len < 0 {
2780 return Err(self.read_last_error("export_stl"));
2781 }
2782 self.read_string_result()
2783 }
2784
2785 pub fn import_stl(&mut self, data: &str) -> OcctResult<ShapeHandle> {
2786 let data_ptr = self.write_bytes(data.as_bytes())?;
2787 let data_len = data.len() as u32;
2788 let result = self
2789 .generated
2790 .fn_import_stl
2791 .call(&mut self.store, (data_ptr as i32, data_len as i32));
2792 self.free_bytes(data_ptr)?;
2793 let result = result?;
2794 self.check_error("import_stl")?;
2795 if result == 0 {
2796 return Err(self.read_last_error("import_stl"));
2797 }
2798 Ok(ShapeHandle(result))
2799 }
2800
2801 pub fn to_brep(&mut self, id: ShapeHandle) -> OcctResult<String> {
2802 let len = self.generated.fn_to_brep.call(&mut self.store, (id.0,))?;
2803 if len < 0 {
2804 return Err(self.read_last_error("to_brep"));
2805 }
2806 self.read_string_result()
2807 }
2808
2809 pub fn from_brep(&mut self, data: &str) -> OcctResult<ShapeHandle> {
2810 let data_ptr = self.write_bytes(data.as_bytes())?;
2811 let data_len = data.len() as u32;
2812 let result = self
2813 .generated
2814 .fn_from_brep
2815 .call(&mut self.store, (data_ptr as i32, data_len as i32));
2816 self.free_bytes(data_ptr)?;
2817 let result = result?;
2818 self.check_error("from_brep")?;
2819 if result == 0 {
2820 return Err(self.read_last_error("from_brep"));
2821 }
2822 Ok(ShapeHandle(result))
2823 }
2824
2825 pub fn translate_with_history(
2826 &mut self,
2827 id: ShapeHandle,
2828 dx: f64,
2829 dy: f64,
2830 dz: f64,
2831 input_face_hashes: &[i32],
2832 hash_upper_bound: i32,
2833 ) -> OcctResult<EvolutionData> {
2834 let input_face_hashes_bytes: Vec<u8> = input_face_hashes
2835 .iter()
2836 .flat_map(|v| v.to_le_bytes())
2837 .collect();
2838 let input_face_hashes_ptr = self.write_bytes(&input_face_hashes_bytes)?;
2839 let input_face_hashes_len = input_face_hashes.len() as u32;
2840 let status = self.generated.fn_translate_with_history.call(
2841 &mut self.store,
2842 (
2843 id.0,
2844 dx,
2845 dy,
2846 dz,
2847 input_face_hashes_ptr as i32,
2848 input_face_hashes_len as i32,
2849 hash_upper_bound,
2850 ),
2851 );
2852 self.free_bytes(input_face_hashes_ptr)?;
2853 let status = status?;
2854 if status < 0 {
2855 return Err(self.read_last_error("translate_with_history"));
2856 }
2857 self.read_evolution_result()
2858 }
2859
2860 pub fn fuse_with_history(
2861 &mut self,
2862 a: ShapeHandle,
2863 b: ShapeHandle,
2864 input_face_hashes: &[i32],
2865 hash_upper_bound: i32,
2866 ) -> OcctResult<EvolutionData> {
2867 let input_face_hashes_bytes: Vec<u8> = input_face_hashes
2868 .iter()
2869 .flat_map(|v| v.to_le_bytes())
2870 .collect();
2871 let input_face_hashes_ptr = self.write_bytes(&input_face_hashes_bytes)?;
2872 let input_face_hashes_len = input_face_hashes.len() as u32;
2873 let status = self.generated.fn_fuse_with_history.call(
2874 &mut self.store,
2875 (
2876 a.0,
2877 b.0,
2878 input_face_hashes_ptr as i32,
2879 input_face_hashes_len as i32,
2880 hash_upper_bound,
2881 ),
2882 );
2883 self.free_bytes(input_face_hashes_ptr)?;
2884 let status = status?;
2885 if status < 0 {
2886 return Err(self.read_last_error("fuse_with_history"));
2887 }
2888 self.read_evolution_result()
2889 }
2890
2891 pub fn cut_with_history(
2892 &mut self,
2893 a: ShapeHandle,
2894 b: ShapeHandle,
2895 input_face_hashes: &[i32],
2896 hash_upper_bound: i32,
2897 ) -> OcctResult<EvolutionData> {
2898 let input_face_hashes_bytes: Vec<u8> = input_face_hashes
2899 .iter()
2900 .flat_map(|v| v.to_le_bytes())
2901 .collect();
2902 let input_face_hashes_ptr = self.write_bytes(&input_face_hashes_bytes)?;
2903 let input_face_hashes_len = input_face_hashes.len() as u32;
2904 let status = self.generated.fn_cut_with_history.call(
2905 &mut self.store,
2906 (
2907 a.0,
2908 b.0,
2909 input_face_hashes_ptr as i32,
2910 input_face_hashes_len as i32,
2911 hash_upper_bound,
2912 ),
2913 );
2914 self.free_bytes(input_face_hashes_ptr)?;
2915 let status = status?;
2916 if status < 0 {
2917 return Err(self.read_last_error("cut_with_history"));
2918 }
2919 self.read_evolution_result()
2920 }
2921
2922 pub fn fillet_with_history(
2923 &mut self,
2924 solid_id: ShapeHandle,
2925 edge_ids: &[ShapeHandle],
2926 radius: f64,
2927 input_face_hashes: &[i32],
2928 hash_upper_bound: i32,
2929 ) -> OcctResult<EvolutionData> {
2930 let edge_ids_bytes: Vec<u8> = edge_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
2931 let edge_ids_ptr = self.write_bytes(&edge_ids_bytes)?;
2932 let edge_ids_len = edge_ids.len() as u32;
2933 let input_face_hashes_bytes: Vec<u8> = input_face_hashes
2934 .iter()
2935 .flat_map(|v| v.to_le_bytes())
2936 .collect();
2937 let input_face_hashes_ptr = match self.write_bytes(&input_face_hashes_bytes) {
2938 Ok(ptr) => ptr,
2939 Err(e) => {
2940 let _ = self.free_bytes(edge_ids_ptr);
2941 return Err(e);
2942 }
2943 };
2944 let input_face_hashes_len = input_face_hashes.len() as u32;
2945 let status = self.generated.fn_fillet_with_history.call(
2946 &mut self.store,
2947 (
2948 solid_id.0,
2949 edge_ids_ptr as i32,
2950 edge_ids_len as i32,
2951 radius,
2952 input_face_hashes_ptr as i32,
2953 input_face_hashes_len as i32,
2954 hash_upper_bound,
2955 ),
2956 );
2957 self.free_bytes(edge_ids_ptr)?;
2958 self.free_bytes(input_face_hashes_ptr)?;
2959 let status = status?;
2960 if status < 0 {
2961 return Err(self.read_last_error("fillet_with_history"));
2962 }
2963 self.read_evolution_result()
2964 }
2965
2966 pub fn rotate_with_history(
2967 &mut self,
2968 id: ShapeHandle,
2969 px: f64,
2970 py: f64,
2971 pz: f64,
2972 dx: f64,
2973 dy: f64,
2974 dz: f64,
2975 angle: f64,
2976 input_face_hashes: &[i32],
2977 hash_upper_bound: i32,
2978 ) -> OcctResult<EvolutionData> {
2979 let input_face_hashes_bytes: Vec<u8> = input_face_hashes
2980 .iter()
2981 .flat_map(|v| v.to_le_bytes())
2982 .collect();
2983 let input_face_hashes_ptr = self.write_bytes(&input_face_hashes_bytes)?;
2984 let input_face_hashes_len = input_face_hashes.len() as u32;
2985 let status = self.generated.fn_rotate_with_history.call(
2986 &mut self.store,
2987 (
2988 id.0,
2989 px,
2990 py,
2991 pz,
2992 dx,
2993 dy,
2994 dz,
2995 angle,
2996 input_face_hashes_ptr as i32,
2997 input_face_hashes_len as i32,
2998 hash_upper_bound,
2999 ),
3000 );
3001 self.free_bytes(input_face_hashes_ptr)?;
3002 let status = status?;
3003 if status < 0 {
3004 return Err(self.read_last_error("rotate_with_history"));
3005 }
3006 self.read_evolution_result()
3007 }
3008
3009 pub fn mirror_with_history(
3010 &mut self,
3011 id: ShapeHandle,
3012 px: f64,
3013 py: f64,
3014 pz: f64,
3015 nx: f64,
3016 ny: f64,
3017 nz: f64,
3018 input_face_hashes: &[i32],
3019 hash_upper_bound: i32,
3020 ) -> OcctResult<EvolutionData> {
3021 let input_face_hashes_bytes: Vec<u8> = input_face_hashes
3022 .iter()
3023 .flat_map(|v| v.to_le_bytes())
3024 .collect();
3025 let input_face_hashes_ptr = self.write_bytes(&input_face_hashes_bytes)?;
3026 let input_face_hashes_len = input_face_hashes.len() as u32;
3027 let status = self.generated.fn_mirror_with_history.call(
3028 &mut self.store,
3029 (
3030 id.0,
3031 px,
3032 py,
3033 pz,
3034 nx,
3035 ny,
3036 nz,
3037 input_face_hashes_ptr as i32,
3038 input_face_hashes_len as i32,
3039 hash_upper_bound,
3040 ),
3041 );
3042 self.free_bytes(input_face_hashes_ptr)?;
3043 let status = status?;
3044 if status < 0 {
3045 return Err(self.read_last_error("mirror_with_history"));
3046 }
3047 self.read_evolution_result()
3048 }
3049
3050 pub fn scale_with_history(
3051 &mut self,
3052 id: ShapeHandle,
3053 cx: f64,
3054 cy: f64,
3055 cz: f64,
3056 factor: f64,
3057 input_face_hashes: &[i32],
3058 hash_upper_bound: i32,
3059 ) -> OcctResult<EvolutionData> {
3060 let input_face_hashes_bytes: Vec<u8> = input_face_hashes
3061 .iter()
3062 .flat_map(|v| v.to_le_bytes())
3063 .collect();
3064 let input_face_hashes_ptr = self.write_bytes(&input_face_hashes_bytes)?;
3065 let input_face_hashes_len = input_face_hashes.len() as u32;
3066 let status = self.generated.fn_scale_with_history.call(
3067 &mut self.store,
3068 (
3069 id.0,
3070 cx,
3071 cy,
3072 cz,
3073 factor,
3074 input_face_hashes_ptr as i32,
3075 input_face_hashes_len as i32,
3076 hash_upper_bound,
3077 ),
3078 );
3079 self.free_bytes(input_face_hashes_ptr)?;
3080 let status = status?;
3081 if status < 0 {
3082 return Err(self.read_last_error("scale_with_history"));
3083 }
3084 self.read_evolution_result()
3085 }
3086
3087 pub fn intersect_with_history(
3088 &mut self,
3089 a: ShapeHandle,
3090 b: ShapeHandle,
3091 input_face_hashes: &[i32],
3092 hash_upper_bound: i32,
3093 ) -> OcctResult<EvolutionData> {
3094 let input_face_hashes_bytes: Vec<u8> = input_face_hashes
3095 .iter()
3096 .flat_map(|v| v.to_le_bytes())
3097 .collect();
3098 let input_face_hashes_ptr = self.write_bytes(&input_face_hashes_bytes)?;
3099 let input_face_hashes_len = input_face_hashes.len() as u32;
3100 let status = self.generated.fn_intersect_with_history.call(
3101 &mut self.store,
3102 (
3103 a.0,
3104 b.0,
3105 input_face_hashes_ptr as i32,
3106 input_face_hashes_len as i32,
3107 hash_upper_bound,
3108 ),
3109 );
3110 self.free_bytes(input_face_hashes_ptr)?;
3111 let status = status?;
3112 if status < 0 {
3113 return Err(self.read_last_error("intersect_with_history"));
3114 }
3115 self.read_evolution_result()
3116 }
3117
3118 pub fn chamfer_with_history(
3119 &mut self,
3120 solid_id: ShapeHandle,
3121 edge_ids: &[ShapeHandle],
3122 distance: f64,
3123 input_face_hashes: &[i32],
3124 hash_upper_bound: i32,
3125 ) -> OcctResult<EvolutionData> {
3126 let edge_ids_bytes: Vec<u8> = edge_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
3127 let edge_ids_ptr = self.write_bytes(&edge_ids_bytes)?;
3128 let edge_ids_len = edge_ids.len() as u32;
3129 let input_face_hashes_bytes: Vec<u8> = input_face_hashes
3130 .iter()
3131 .flat_map(|v| v.to_le_bytes())
3132 .collect();
3133 let input_face_hashes_ptr = match self.write_bytes(&input_face_hashes_bytes) {
3134 Ok(ptr) => ptr,
3135 Err(e) => {
3136 let _ = self.free_bytes(edge_ids_ptr);
3137 return Err(e);
3138 }
3139 };
3140 let input_face_hashes_len = input_face_hashes.len() as u32;
3141 let status = self.generated.fn_chamfer_with_history.call(
3142 &mut self.store,
3143 (
3144 solid_id.0,
3145 edge_ids_ptr as i32,
3146 edge_ids_len as i32,
3147 distance,
3148 input_face_hashes_ptr as i32,
3149 input_face_hashes_len as i32,
3150 hash_upper_bound,
3151 ),
3152 );
3153 self.free_bytes(edge_ids_ptr)?;
3154 self.free_bytes(input_face_hashes_ptr)?;
3155 let status = status?;
3156 if status < 0 {
3157 return Err(self.read_last_error("chamfer_with_history"));
3158 }
3159 self.read_evolution_result()
3160 }
3161
3162 pub fn shell_with_history(
3163 &mut self,
3164 solid_id: ShapeHandle,
3165 face_ids: &[ShapeHandle],
3166 thickness: f64,
3167 tolerance: f64,
3168 input_face_hashes: &[i32],
3169 hash_upper_bound: i32,
3170 ) -> OcctResult<EvolutionData> {
3171 let face_ids_bytes: Vec<u8> = face_ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
3172 let face_ids_ptr = self.write_bytes(&face_ids_bytes)?;
3173 let face_ids_len = face_ids.len() as u32;
3174 let input_face_hashes_bytes: Vec<u8> = input_face_hashes
3175 .iter()
3176 .flat_map(|v| v.to_le_bytes())
3177 .collect();
3178 let input_face_hashes_ptr = match self.write_bytes(&input_face_hashes_bytes) {
3179 Ok(ptr) => ptr,
3180 Err(e) => {
3181 let _ = self.free_bytes(face_ids_ptr);
3182 return Err(e);
3183 }
3184 };
3185 let input_face_hashes_len = input_face_hashes.len() as u32;
3186 let status = self.generated.fn_shell_with_history.call(
3187 &mut self.store,
3188 (
3189 solid_id.0,
3190 face_ids_ptr as i32,
3191 face_ids_len as i32,
3192 thickness,
3193 tolerance,
3194 input_face_hashes_ptr as i32,
3195 input_face_hashes_len as i32,
3196 hash_upper_bound,
3197 ),
3198 );
3199 self.free_bytes(face_ids_ptr)?;
3200 self.free_bytes(input_face_hashes_ptr)?;
3201 let status = status?;
3202 if status < 0 {
3203 return Err(self.read_last_error("shell_with_history"));
3204 }
3205 self.read_evolution_result()
3206 }
3207
3208 pub fn offset_with_history(
3209 &mut self,
3210 solid_id: ShapeHandle,
3211 distance: f64,
3212 tolerance: f64,
3213 input_face_hashes: &[i32],
3214 hash_upper_bound: i32,
3215 ) -> OcctResult<EvolutionData> {
3216 let input_face_hashes_bytes: Vec<u8> = input_face_hashes
3217 .iter()
3218 .flat_map(|v| v.to_le_bytes())
3219 .collect();
3220 let input_face_hashes_ptr = self.write_bytes(&input_face_hashes_bytes)?;
3221 let input_face_hashes_len = input_face_hashes.len() as u32;
3222 let status = self.generated.fn_offset_with_history.call(
3223 &mut self.store,
3224 (
3225 solid_id.0,
3226 distance,
3227 tolerance,
3228 input_face_hashes_ptr as i32,
3229 input_face_hashes_len as i32,
3230 hash_upper_bound,
3231 ),
3232 );
3233 self.free_bytes(input_face_hashes_ptr)?;
3234 let status = status?;
3235 if status < 0 {
3236 return Err(self.read_last_error("offset_with_history"));
3237 }
3238 self.read_evolution_result()
3239 }
3240
3241 pub fn thicken_with_history(
3242 &mut self,
3243 shape_id: ShapeHandle,
3244 thickness: f64,
3245 tolerance: f64,
3246 input_face_hashes: &[i32],
3247 hash_upper_bound: i32,
3248 ) -> OcctResult<EvolutionData> {
3249 let input_face_hashes_bytes: Vec<u8> = input_face_hashes
3250 .iter()
3251 .flat_map(|v| v.to_le_bytes())
3252 .collect();
3253 let input_face_hashes_ptr = self.write_bytes(&input_face_hashes_bytes)?;
3254 let input_face_hashes_len = input_face_hashes.len() as u32;
3255 let status = self.generated.fn_thicken_with_history.call(
3256 &mut self.store,
3257 (
3258 shape_id.0,
3259 thickness,
3260 tolerance,
3261 input_face_hashes_ptr as i32,
3262 input_face_hashes_len as i32,
3263 hash_upper_bound,
3264 ),
3265 );
3266 self.free_bytes(input_face_hashes_ptr)?;
3267 let status = status?;
3268 if status < 0 {
3269 return Err(self.read_last_error("thicken_with_history"));
3270 }
3271 self.read_evolution_result()
3272 }
3273
3274 pub fn tessellate(
3275 &mut self,
3276 id: ShapeHandle,
3277 linear_deflection: f64,
3278 angular_deflection: f64,
3279 ) -> OcctResult<Mesh> {
3280 let status = self.generated.fn_tessellate.call(
3281 &mut self.store,
3282 (id.0, linear_deflection, angular_deflection),
3283 )?;
3284 if status < 0 {
3285 return Err(self.read_last_error("tessellate"));
3286 }
3287 self.read_mesh_result()
3288 }
3289
3290 pub fn mesh_shape(
3291 &mut self,
3292 id: ShapeHandle,
3293 linear_deflection: f64,
3294 angular_deflection: f64,
3295 ) -> OcctResult<Mesh> {
3296 let status = self.generated.fn_mesh_shape.call(
3297 &mut self.store,
3298 (id.0, linear_deflection, angular_deflection),
3299 )?;
3300 if status < 0 {
3301 return Err(self.read_last_error("mesh_shape"));
3302 }
3303 self.read_mesh_result()
3304 }
3305
3306 pub fn mesh_batch(
3307 &mut self,
3308 ids: &[ShapeHandle],
3309 linear_deflection: f64,
3310 angular_deflection: f64,
3311 ) -> OcctResult<MeshBatch> {
3312 let ids_bytes: Vec<u8> = ids.iter().flat_map(|h| h.0.to_le_bytes()).collect();
3313 let ids_ptr = self.write_bytes(&ids_bytes)?;
3314 let ids_len = ids.len() as u32;
3315 let status = self.generated.fn_mesh_batch.call(
3316 &mut self.store,
3317 (
3318 ids_ptr as i32,
3319 ids_len as i32,
3320 linear_deflection,
3321 angular_deflection,
3322 ),
3323 );
3324 self.free_bytes(ids_ptr)?;
3325 let status = status?;
3326 if status < 0 {
3327 return Err(self.read_last_error("mesh_batch"));
3328 }
3329 self.read_mesh_batch_result()
3330 }
3331
3332 pub fn wireframe(&mut self, id: ShapeHandle, deflection: f64) -> OcctResult<EdgeData> {
3333 let status = self
3334 .generated
3335 .fn_wireframe
3336 .call(&mut self.store, (id.0, deflection))?;
3337 if status < 0 {
3338 return Err(self.read_last_error("wireframe"));
3339 }
3340 self.read_edge_result()
3341 }
3342
3343 pub fn project_edges(
3344 &mut self,
3345 shape_id: ShapeHandle,
3346 ox: f64,
3347 oy: f64,
3348 oz: f64,
3349 dx: f64,
3350 dy: f64,
3351 dz: f64,
3352 xx: f64,
3353 xy: f64,
3354 xz: f64,
3355 has_x_axis: bool,
3356 ) -> OcctResult<ProjectionData> {
3357 let status = self.generated.fn_project_edges.call(
3358 &mut self.store,
3359 (
3360 shape_id.0,
3361 ox,
3362 oy,
3363 oz,
3364 dx,
3365 dy,
3366 dz,
3367 xx,
3368 xy,
3369 xz,
3370 i32::from(has_x_axis),
3371 ),
3372 )?;
3373 if status < 0 {
3374 return Err(self.read_last_error("project_edges"));
3375 }
3376 self.read_projection_result()
3377 }
3378
3379 pub fn release(&mut self, id: ShapeHandle) -> OcctResult<()> {
3380 let result = self.generated.fn_release.call(&mut self.store, (id.0,))?;
3381 if result < 0 {
3382 return Err(self.read_last_error("release"));
3383 }
3384 Ok(())
3385 }
3386
3387 pub fn release_all(&mut self) -> OcctResult<()> {
3388 let result = self.generated.fn_release_all.call(&mut self.store, ())?;
3389 if result < 0 {
3390 return Err(self.read_last_error("release_all"));
3391 }
3392 Ok(())
3393 }
3394
3395 pub fn get_shape_count(&mut self) -> OcctResult<u32> {
3396 let result = self
3397 .generated
3398 .fn_get_shape_count
3399 .call(&mut self.store, ())?;
3400 self.check_error("get_shape_count")?;
3401 Ok(result)
3402 }
3403
3404 pub fn make_null_shape(&mut self) -> OcctResult<ShapeHandle> {
3405 let result = self
3406 .generated
3407 .fn_make_null_shape
3408 .call(&mut self.store, ())?;
3409 self.check_error("make_null_shape")?;
3410 if result == 0 {
3411 return Err(self.read_last_error("make_null_shape"));
3412 }
3413 Ok(ShapeHandle(result))
3414 }
3415
3416 pub fn xcaf_new_document(&mut self) -> OcctResult<u32> {
3417 let result = self
3418 .generated
3419 .fn_xcaf_new_document
3420 .call(&mut self.store, ())?;
3421 self.check_error("xcaf_new_document")?;
3422 Ok(result)
3423 }
3424
3425 pub fn xcaf_close(&mut self, doc_id: ShapeHandle) -> OcctResult<()> {
3426 let result = self
3427 .generated
3428 .fn_xcaf_close
3429 .call(&mut self.store, (doc_id.0,))?;
3430 if result < 0 {
3431 return Err(self.read_last_error("xcaf_close"));
3432 }
3433 Ok(())
3434 }
3435
3436 pub fn xcaf_add_shape(
3437 &mut self,
3438 doc_id: ShapeHandle,
3439 shape_id: ShapeHandle,
3440 ) -> OcctResult<i32> {
3441 let result = self
3442 .generated
3443 .fn_xcaf_add_shape
3444 .call(&mut self.store, (doc_id.0, shape_id.0))?;
3445 self.check_error("xcaf_add_shape")?;
3446 Ok(result)
3447 }
3448
3449 pub fn xcaf_add_component(
3450 &mut self,
3451 doc_id: ShapeHandle,
3452 parent_label_id: i32,
3453 shape_id: ShapeHandle,
3454 tx: f64,
3455 ty: f64,
3456 tz: f64,
3457 rx: f64,
3458 ry: f64,
3459 rz: f64,
3460 ) -> OcctResult<i32> {
3461 let result = self.generated.fn_xcaf_add_component.call(
3462 &mut self.store,
3463 (
3464 doc_id.0,
3465 parent_label_id,
3466 shape_id.0,
3467 tx,
3468 ty,
3469 tz,
3470 rx,
3471 ry,
3472 rz,
3473 ),
3474 )?;
3475 self.check_error("xcaf_add_component")?;
3476 Ok(result)
3477 }
3478
3479 pub fn xcaf_set_color(
3480 &mut self,
3481 doc_id: ShapeHandle,
3482 label_id: i32,
3483 r: f64,
3484 g: f64,
3485 b: f64,
3486 ) -> OcctResult<()> {
3487 let result = self
3488 .generated
3489 .fn_xcaf_set_color
3490 .call(&mut self.store, (doc_id.0, label_id, r, g, b))?;
3491 if result < 0 {
3492 return Err(self.read_last_error("xcaf_set_color"));
3493 }
3494 Ok(())
3495 }
3496
3497 pub fn xcaf_set_name(
3498 &mut self,
3499 doc_id: ShapeHandle,
3500 label_id: i32,
3501 name: &str,
3502 ) -> OcctResult<()> {
3503 let name_ptr = self.write_bytes(name.as_bytes())?;
3504 let name_len = name.len() as u32;
3505 let result = self.generated.fn_xcaf_set_name.call(
3506 &mut self.store,
3507 (doc_id.0, label_id, name_ptr as i32, name_len as i32),
3508 );
3509 self.free_bytes(name_ptr)?;
3510 let result = result?;
3511 if result < 0 {
3512 return Err(self.read_last_error("xcaf_set_name"));
3513 }
3514 Ok(())
3515 }
3516
3517 pub fn xcaf_get_label_info(
3518 &mut self,
3519 doc_id: ShapeHandle,
3520 label_id: i32,
3521 ) -> OcctResult<LabelInfo> {
3522 let status = self
3523 .generated
3524 .fn_xcaf_get_label_info
3525 .call(&mut self.store, (doc_id.0, label_id))?;
3526 if status < 0 {
3527 return Err(self.read_last_error("xcaf_get_label_info"));
3528 }
3529 self.read_label_info_result()
3530 }
3531
3532 pub fn xcaf_get_child_labels(
3533 &mut self,
3534 doc_id: ShapeHandle,
3535 parent_label_id: i32,
3536 ) -> OcctResult<Vec<i32>> {
3537 let len = self
3538 .generated
3539 .fn_xcaf_get_child_labels
3540 .call(&mut self.store, (doc_id.0, parent_label_id))?;
3541 if len < 0 {
3542 return Err(self.read_last_error("xcaf_get_child_labels"));
3543 }
3544 self.read_vec_i32_result()
3545 }
3546
3547 pub fn xcaf_get_root_labels(&mut self, doc_id: ShapeHandle) -> OcctResult<Vec<i32>> {
3548 let len = self
3549 .generated
3550 .fn_xcaf_get_root_labels
3551 .call(&mut self.store, (doc_id.0,))?;
3552 if len < 0 {
3553 return Err(self.read_last_error("xcaf_get_root_labels"));
3554 }
3555 self.read_vec_i32_result()
3556 }
3557
3558 pub fn xcaf_export_step(&mut self, doc_id: ShapeHandle) -> OcctResult<String> {
3559 let len = self
3560 .generated
3561 .fn_xcaf_export_step
3562 .call(&mut self.store, (doc_id.0,))?;
3563 if len < 0 {
3564 return Err(self.read_last_error("xcaf_export_step"));
3565 }
3566 self.read_string_result()
3567 }
3568
3569 pub fn xcaf_import_step(&mut self, step_data: &str) -> OcctResult<u32> {
3570 let step_data_ptr = self.write_bytes(step_data.as_bytes())?;
3571 let step_data_len = step_data.len() as u32;
3572 let result = self.generated.fn_xcaf_import_step.call(
3573 &mut self.store,
3574 (step_data_ptr as i32, step_data_len as i32),
3575 );
3576 self.free_bytes(step_data_ptr)?;
3577 let result = result?;
3578 self.check_error("xcaf_import_step")?;
3579 Ok(result)
3580 }
3581
3582 pub fn xcaf_export_gltf(
3583 &mut self,
3584 doc_id: ShapeHandle,
3585 lin_deflection: f64,
3586 ang_deflection: f64,
3587 ) -> OcctResult<String> {
3588 let len = self
3589 .generated
3590 .fn_xcaf_export_gltf
3591 .call(&mut self.store, (doc_id.0, lin_deflection, ang_deflection))?;
3592 if len < 0 {
3593 return Err(self.read_last_error("xcaf_export_gltf"));
3594 }
3595 self.read_string_result()
3596 }
3597}