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