1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
|
// pybind 11 related includes
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
namespace py = pybind11;
// Standard Handle
#include <Standard_Handle.hxx>
// user-defined inclusion per module before includes
// includes to resolve forward declarations
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Graphic3d_Structure.hxx>
#include <Graphic3d_TransformPers.hxx>
#include <SelectMgr_Selection.hxx>
#include <gp_Trsf.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <SelectMgr_EntityOwner.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Graphic3d_Camera.hxx>
#include <SelectMgr_FrustumBuilder.hxx>
#include <SelectMgr_ViewClipRange.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <V3d_Viewer.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <SelectMgr_EntityOwner.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <SelectMgr_EntityOwner.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <SelectMgr_EntityOwner.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <SelectMgr_EntityOwner.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <SelectMgr_ViewerSelector.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <SelectMgr_EntityOwner.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <gp_Ax1.hxx>
#include <Graphic3d_SequenceOfHClipPlane.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <SelectMgr_SensitiveEntitySet.hxx>
#include <V3d_View.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
// module includes
#include <SelectMgr.hxx>
#include <SelectMgr_AndFilter.hxx>
#include <SelectMgr_AndOrFilter.hxx>
#include <SelectMgr_AxisIntersector.hxx>
#include <SelectMgr_BaseFrustum.hxx>
#include <SelectMgr_BaseIntersector.hxx>
#include <SelectMgr_BVHThreadPool.hxx>
#include <SelectMgr_CompositionFilter.hxx>
#include <SelectMgr_EntityOwner.hxx>
#include <SelectMgr_Filter.hxx>
#include <SelectMgr_FilterType.hxx>
#include <SelectMgr_Frustum.hxx>
#include <SelectMgr_FrustumBuilder.hxx>
#include <SelectMgr_IndexedDataMapOfOwnerCriterion.hxx>
#include <SelectMgr_IndexedMapOfOwner.hxx>
#include <SelectMgr_ListIteratorOfListOfFilter.hxx>
#include <SelectMgr_ListOfFilter.hxx>
#include <SelectMgr_OrFilter.hxx>
#include <SelectMgr_PickingStrategy.hxx>
#include <SelectMgr_RectangularFrustum.hxx>
#include <SelectMgr_SelectableObject.hxx>
#include <SelectMgr_SelectableObjectSet.hxx>
#include <SelectMgr_SelectingVolumeManager.hxx>
#include <SelectMgr_Selection.hxx>
#include <SelectMgr_SelectionImageFiller.hxx>
#include <SelectMgr_SelectionManager.hxx>
#include <SelectMgr_SelectionType.hxx>
#include <SelectMgr_SensitiveEntity.hxx>
#include <SelectMgr_SensitiveEntitySet.hxx>
#include <SelectMgr_SequenceOfOwner.hxx>
#include <SelectMgr_SequenceOfSelection.hxx>
#include <SelectMgr_SortCriterion.hxx>
#include <SelectMgr_StateOfSelection.hxx>
#include <SelectMgr_ToleranceMap.hxx>
#include <SelectMgr_TriangularFrustum.hxx>
#include <SelectMgr_TriangularFrustumSet.hxx>
#include <SelectMgr_TypeOfBVHUpdate.hxx>
#include <SelectMgr_TypeOfDepthTolerance.hxx>
#include <SelectMgr_TypeOfUpdate.hxx>
#include <SelectMgr_VectorTypes.hxx>
#include <SelectMgr_ViewClipRange.hxx>
#include <SelectMgr_ViewerSelector.hxx>
#include <SelectMgr_ViewerSelector3d.hxx>
// template related includes
#include "NCollection_tmpl.hxx"
#include "NCollection_tmpl.hxx"
#include "NCollection_tmpl.hxx"
#include "NCollection_tmpl.hxx"
#include "NCollection_tmpl.hxx"
#include "NCollection_tmpl.hxx"
#include "NCollection_tmpl.hxx"
// user-defined pre
#include "OCP_specific.inc"
// user-defined inclusion per module
// Module definiiton
void register_SelectMgr_enums(py::module &main_module) {
py::module m = main_module.def_submodule("SelectMgr", R"#()#");
// user-defined inclusion per module in the body
// enums
py::enum_<SelectMgr_FilterType>(m, "SelectMgr_FilterType",R"#(Enumeration defines the filter type.)#")
.value("SelectMgr_FilterType_AND",SelectMgr_FilterType::SelectMgr_FilterType_AND)
.value("SelectMgr_FilterType_OR",SelectMgr_FilterType::SelectMgr_FilterType_OR).export_values();
py::enum_<SelectMgr_TypeOfDepthTolerance>(m, "SelectMgr_TypeOfDepthTolerance",R"#(Define the type of depth tolerance for considering picked entities to lie on the same depth (distance from eye to entity).)#")
.value("SelectMgr_TypeOfDepthTolerance_Uniform",SelectMgr_TypeOfDepthTolerance::SelectMgr_TypeOfDepthTolerance_Uniform)
.value("SelectMgr_TypeOfDepthTolerance_UniformPixels",SelectMgr_TypeOfDepthTolerance::SelectMgr_TypeOfDepthTolerance_UniformPixels)
.value("SelectMgr_TypeOfDepthTolerance_SensitivityFactor",SelectMgr_TypeOfDepthTolerance::SelectMgr_TypeOfDepthTolerance_SensitivityFactor).export_values();
py::enum_<SelectMgr_PickingStrategy>(m, "SelectMgr_PickingStrategy",R"#(Enumeration defines picking strategy - which entities detected by picking line will be accepted, considering selection filters.)#")
.value("SelectMgr_PickingStrategy_FirstAcceptable",SelectMgr_PickingStrategy::SelectMgr_PickingStrategy_FirstAcceptable)
.value("SelectMgr_PickingStrategy_OnlyTopmost",SelectMgr_PickingStrategy::SelectMgr_PickingStrategy_OnlyTopmost).export_values();
py::enum_<SelectMgr_StateOfSelection>(m, "SelectMgr_StateOfSelection",R"#(different state of a Selection in a ViewerSelector...)#")
.value("SelectMgr_SOS_Any",SelectMgr_StateOfSelection::SelectMgr_SOS_Any)
.value("SelectMgr_SOS_Unknown",SelectMgr_StateOfSelection::SelectMgr_SOS_Unknown)
.value("SelectMgr_SOS_Deactivated",SelectMgr_StateOfSelection::SelectMgr_SOS_Deactivated)
.value("SelectMgr_SOS_Activated",SelectMgr_StateOfSelection::SelectMgr_SOS_Activated).export_values();
py::enum_<SelectMgr_TypeOfUpdate>(m, "SelectMgr_TypeOfUpdate",R"#(Provides values for types of update, including - full - partial - none.)#")
.value("SelectMgr_TOU_Full",SelectMgr_TypeOfUpdate::SelectMgr_TOU_Full)
.value("SelectMgr_TOU_Partial",SelectMgr_TypeOfUpdate::SelectMgr_TOU_Partial)
.value("SelectMgr_TOU_None",SelectMgr_TypeOfUpdate::SelectMgr_TOU_None).export_values();
py::enum_<SelectMgr_TypeOfBVHUpdate>(m, "SelectMgr_TypeOfBVHUpdate",R"#(Keeps track for BVH update state for each SelectMgr_Selection entity in a following way: - Add : 2nd level BVH does not contain any of the selection's sensitive entities and they must be added; - Remove : all sensitive entities of the selection must be removed from 2nd level BVH; - Renew : 2nd level BVH already contains sensitives of the selection, but the its complete update and removal is required. Therefore, sensitives of the selection with this type of update must be removed from 2nd level BVH and added after recomputation. - Invalidate : the 2nd level BVH needs to be rebuilt; - None : entities of the selection are up to date.)#")
.value("SelectMgr_TBU_Add",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_Add)
.value("SelectMgr_TBU_Remove",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_Remove)
.value("SelectMgr_TBU_Renew",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_Renew)
.value("SelectMgr_TBU_Invalidate",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_Invalidate)
.value("SelectMgr_TBU_None",SelectMgr_TypeOfBVHUpdate::SelectMgr_TBU_None).export_values();
py::enum_<SelectMgr_SelectionType>(m, "SelectMgr_SelectionType",R"#(Possible selection types)#")
.value("SelectMgr_SelectionType_Unknown",SelectMgr_SelectionType::SelectMgr_SelectionType_Unknown)
.value("SelectMgr_SelectionType_Point",SelectMgr_SelectionType::SelectMgr_SelectionType_Point)
.value("SelectMgr_SelectionType_Box",SelectMgr_SelectionType::SelectMgr_SelectionType_Box)
.value("SelectMgr_SelectionType_Polyline",SelectMgr_SelectionType::SelectMgr_SelectionType_Polyline).export_values();
//Python trampoline classes
class Py_SelectMgr_BaseIntersector : public SelectMgr_BaseIntersector{
public:
using SelectMgr_BaseIntersector::SelectMgr_BaseIntersector;
// public pure virtual
void Build() override { PYBIND11_OVERLOAD_PURE(void,SelectMgr_BaseIntersector,Build,) };
Standard_Boolean IsScalable() const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,IsScalable,) };
opencascade::handle<SelectMgr_BaseIntersector> ScaleAndTransform(const Standard_Integer theScaleFactor,const gp_GTrsf & theTrsf,const opencascade::handle<SelectMgr_FrustumBuilder> & theBuilder) const override { PYBIND11_OVERLOAD_PURE(opencascade::handle<SelectMgr_BaseIntersector>,SelectMgr_BaseIntersector,ScaleAndTransform,theScaleFactor,theTrsf,theBuilder) };
Standard_Boolean OverlapsBox( const NCollection_Vec3<Standard_Real> & theBoxMin, const NCollection_Vec3<Standard_Real> & theBoxMax,const SelectMgr_ViewClipRange & theClipRange,SelectBasics_PickResult & thePickResult) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsBox,theBoxMin,theBoxMax,theClipRange,thePickResult) };
Standard_Boolean OverlapsBox( const NCollection_Vec3<Standard_Real> & theBoxMin, const NCollection_Vec3<Standard_Real> & theBoxMax,Standard_Boolean * theInside) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsBox,theBoxMin,theBoxMax,theInside) };
Standard_Boolean OverlapsPoint(const gp_Pnt & thePnt,const SelectMgr_ViewClipRange & theClipRange,SelectBasics_PickResult & thePickResult) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsPoint,thePnt,theClipRange,thePickResult) };
Standard_Boolean OverlapsPoint(const gp_Pnt & thePnt) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsPoint,thePnt) };
Standard_Boolean OverlapsPolygon( const NCollection_Array1<gp_Pnt> & theArrayOfPnts,Select3D_TypeOfSensitivity theSensType,const SelectMgr_ViewClipRange & theClipRange,SelectBasics_PickResult & thePickResult) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsPolygon,theArrayOfPnts,theSensType,theClipRange,thePickResult) };
Standard_Boolean OverlapsSegment(const gp_Pnt & thePnt1,const gp_Pnt & thePnt2,const SelectMgr_ViewClipRange & theClipRange,SelectBasics_PickResult & thePickResult) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsSegment,thePnt1,thePnt2,theClipRange,thePickResult) };
Standard_Boolean OverlapsTriangle(const gp_Pnt & thePnt1,const gp_Pnt & thePnt2,const gp_Pnt & thePnt3,Select3D_TypeOfSensitivity theSensType,const SelectMgr_ViewClipRange & theClipRange,SelectBasics_PickResult & thePickResult) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsTriangle,thePnt1,thePnt2,thePnt3,theSensType,theClipRange,thePickResult) };
Standard_Boolean OverlapsSphere(const gp_Pnt & theCenter,const Standard_Real theRadius,Standard_Boolean * theInside) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsSphere,theCenter,theRadius,theInside) };
Standard_Boolean OverlapsSphere(const gp_Pnt & theCenter,const Standard_Real theRadius,const SelectMgr_ViewClipRange & theClipRange,SelectBasics_PickResult & thePickResult) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsSphere,theCenter,theRadius,theClipRange,thePickResult) };
Standard_Boolean OverlapsCylinder(const Standard_Real theBottomRad,const Standard_Real theTopRad,const Standard_Real theHeight,const gp_Trsf & theTrsf,const Standard_Boolean theIsHollow,const SelectMgr_ViewClipRange & theClipRange,SelectBasics_PickResult & thePickResult) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsCylinder,theBottomRad,theTopRad,theHeight,theTrsf,theIsHollow,theClipRange,thePickResult) };
Standard_Boolean OverlapsCylinder(const Standard_Real theBottomRad,const Standard_Real theTopRad,const Standard_Real theHeight,const gp_Trsf & theTrsf,const Standard_Boolean theIsHollow,Standard_Boolean * theInside) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsCylinder,theBottomRad,theTopRad,theHeight,theTrsf,theIsHollow,theInside) };
Standard_Boolean OverlapsCircle(const Standard_Real theBottomRad,const gp_Trsf & theTrsf,const Standard_Boolean theIsFilled,const SelectMgr_ViewClipRange & theClipRange,SelectBasics_PickResult & thePickResult) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsCircle,theBottomRad,theTrsf,theIsFilled,theClipRange,thePickResult) };
Standard_Boolean OverlapsCircle(const Standard_Real theBottomRad,const gp_Trsf & theTrsf,const Standard_Boolean theIsFilled,Standard_Boolean * theInside) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsCircle,theBottomRad,theTrsf,theIsFilled,theInside) };
// protected pure virtual
// private pure virtual
};
class Py_SelectMgr_Filter : public SelectMgr_Filter{
public:
using SelectMgr_Filter::SelectMgr_Filter;
// public pure virtual
Standard_Boolean IsOk(const opencascade::handle<SelectMgr_EntityOwner> & anObj) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_Filter,IsOk,anObj) };
// protected pure virtual
// private pure virtual
};
class Py_SelectMgr_SelectableObject : public SelectMgr_SelectableObject{
public:
using SelectMgr_SelectableObject::SelectMgr_SelectableObject;
// public pure virtual
void ComputeSelection(const opencascade::handle<SelectMgr_Selection> & theSelection,const Standard_Integer theMode) override { PYBIND11_OVERLOAD_PURE(void,SelectMgr_SelectableObject,ComputeSelection,theSelection,theMode) };
// protected pure virtual
void Compute(const opencascade::handle<PrsMgr_PresentationManager> & thePrsMgr,const opencascade::handle<Prs3d_Presentation> & thePrs,const Standard_Integer theMode) override { PYBIND11_OVERLOAD_PURE(void,PrsMgr_PresentableObject,Compute,thePrsMgr,thePrs,theMode) };
// private pure virtual
};
class Py_SelectMgr_SelectionImageFiller : public SelectMgr_SelectionImageFiller{
public:
using SelectMgr_SelectionImageFiller::SelectMgr_SelectionImageFiller;
// public pure virtual
void Fill(const Standard_Integer theCol,const Standard_Integer theRow,const Standard_Integer thePicked) override { PYBIND11_OVERLOAD_PURE(void,SelectMgr_SelectionImageFiller,Fill,theCol,theRow,thePicked) };
// protected pure virtual
// private pure virtual
};
class Py_SelectMgr_BaseFrustum : public SelectMgr_BaseFrustum{
public:
using SelectMgr_BaseFrustum::SelectMgr_BaseFrustum;
// public pure virtual
void Build() override { PYBIND11_OVERLOAD_PURE(void,SelectMgr_BaseIntersector,Build,) };
Standard_Boolean IsScalable() const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,IsScalable,) };
opencascade::handle<SelectMgr_BaseIntersector> ScaleAndTransform(const Standard_Integer theScaleFactor,const gp_GTrsf & theTrsf,const opencascade::handle<SelectMgr_FrustumBuilder> & theBuilder) const override { PYBIND11_OVERLOAD_PURE(opencascade::handle<SelectMgr_BaseIntersector>,SelectMgr_BaseIntersector,ScaleAndTransform,theScaleFactor,theTrsf,theBuilder) };
Standard_Boolean OverlapsBox( const NCollection_Vec3<Standard_Real> & theBoxMin, const NCollection_Vec3<Standard_Real> & theBoxMax,const SelectMgr_ViewClipRange & theClipRange,SelectBasics_PickResult & thePickResult) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsBox,theBoxMin,theBoxMax,theClipRange,thePickResult) };
Standard_Boolean OverlapsBox( const NCollection_Vec3<Standard_Real> & theBoxMin, const NCollection_Vec3<Standard_Real> & theBoxMax,Standard_Boolean * theInside) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsBox,theBoxMin,theBoxMax,theInside) };
Standard_Boolean OverlapsPoint(const gp_Pnt & thePnt,const SelectMgr_ViewClipRange & theClipRange,SelectBasics_PickResult & thePickResult) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsPoint,thePnt,theClipRange,thePickResult) };
Standard_Boolean OverlapsPoint(const gp_Pnt & thePnt) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsPoint,thePnt) };
Standard_Boolean OverlapsPolygon( const NCollection_Array1<gp_Pnt> & theArrayOfPnts,Select3D_TypeOfSensitivity theSensType,const SelectMgr_ViewClipRange & theClipRange,SelectBasics_PickResult & thePickResult) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsPolygon,theArrayOfPnts,theSensType,theClipRange,thePickResult) };
Standard_Boolean OverlapsSegment(const gp_Pnt & thePnt1,const gp_Pnt & thePnt2,const SelectMgr_ViewClipRange & theClipRange,SelectBasics_PickResult & thePickResult) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsSegment,thePnt1,thePnt2,theClipRange,thePickResult) };
Standard_Boolean OverlapsTriangle(const gp_Pnt & thePnt1,const gp_Pnt & thePnt2,const gp_Pnt & thePnt3,Select3D_TypeOfSensitivity theSensType,const SelectMgr_ViewClipRange & theClipRange,SelectBasics_PickResult & thePickResult) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsTriangle,thePnt1,thePnt2,thePnt3,theSensType,theClipRange,thePickResult) };
Standard_Boolean OverlapsSphere(const gp_Pnt & theCenter,const Standard_Real theRadius,Standard_Boolean * theInside) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsSphere,theCenter,theRadius,theInside) };
Standard_Boolean OverlapsSphere(const gp_Pnt & theCenter,const Standard_Real theRadius,const SelectMgr_ViewClipRange & theClipRange,SelectBasics_PickResult & thePickResult) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsSphere,theCenter,theRadius,theClipRange,thePickResult) };
Standard_Boolean OverlapsCylinder(const Standard_Real theBottomRad,const Standard_Real theTopRad,const Standard_Real theHeight,const gp_Trsf & theTrsf,const Standard_Boolean theIsHollow,const SelectMgr_ViewClipRange & theClipRange,SelectBasics_PickResult & thePickResult) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsCylinder,theBottomRad,theTopRad,theHeight,theTrsf,theIsHollow,theClipRange,thePickResult) };
Standard_Boolean OverlapsCylinder(const Standard_Real theBottomRad,const Standard_Real theTopRad,const Standard_Real theHeight,const gp_Trsf & theTrsf,const Standard_Boolean theIsHollow,Standard_Boolean * theInside) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsCylinder,theBottomRad,theTopRad,theHeight,theTrsf,theIsHollow,theInside) };
Standard_Boolean OverlapsCircle(const Standard_Real theBottomRad,const gp_Trsf & theTrsf,const Standard_Boolean theIsFilled,const SelectMgr_ViewClipRange & theClipRange,SelectBasics_PickResult & thePickResult) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsCircle,theBottomRad,theTrsf,theIsFilled,theClipRange,thePickResult) };
Standard_Boolean OverlapsCircle(const Standard_Real theBottomRad,const gp_Trsf & theTrsf,const Standard_Boolean theIsFilled,Standard_Boolean * theInside) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_BaseIntersector,OverlapsCircle,theBottomRad,theTrsf,theIsFilled,theInside) };
// protected pure virtual
// private pure virtual
};
class Py_SelectMgr_CompositionFilter : public SelectMgr_CompositionFilter{
public:
using SelectMgr_CompositionFilter::SelectMgr_CompositionFilter;
// public pure virtual
Standard_Boolean IsOk(const opencascade::handle<SelectMgr_EntityOwner> & anObj) const override { PYBIND11_OVERLOAD_PURE(Standard_Boolean,SelectMgr_Filter,IsOk,anObj) };
// protected pure virtual
// private pure virtual
};
// pre-register typdefs+classes (topologically sorted)
py::class_<SelectMgr , shared_ptr<SelectMgr> >(m,"SelectMgr",R"#(Auxiliary tools for SelectMgr package.)#");
py::class_<SelectMgr_SelectableObjectSet , shared_ptr<SelectMgr_SelectableObjectSet> >(m,"SelectMgr_SelectableObjectSet",R"#(The purpose of this class is to organize all selectable objects into data structure, allowing to build set of BVH trees for each transformation persistence subclass of selectable objects. This allow to minify number of updates for BVH trees - for example 2D persistent object subclass depends only on camera's projection and the corresponding BVH tree needs to be updated when camera's projection parameters change, while another tree for non-persistent objects can be left unchanged in this case.)#");
py::class_<SelectMgr_SortCriterion , shared_ptr<SelectMgr_SortCriterion> >(m,"SelectMgr_SortCriterion",R"#(This class provides data and criterion for sorting candidate entities in the process of interactive selection by mouse click)#");
py::class_<SelectMgr_ToleranceMap , shared_ptr<SelectMgr_ToleranceMap> >(m,"SelectMgr_ToleranceMap",R"#(An internal class for calculation of current largest tolerance value which will be applied for creation of selecting frustum by default. Each time the selection set is deactivated, maximum tolerance value will be recalculated. If a user enables custom precision using StdSelect_ViewerSelector3d::SetPixelTolerance, it will be applied to all sensitive entities without any checks.)#");
py::class_<SelectMgr_ViewClipRange , shared_ptr<SelectMgr_ViewClipRange> >(m,"SelectMgr_ViewClipRange",R"#(Class for handling depth clipping range. It is used to perform checks in case if global (for the whole view) clipping planes are defined inside of SelectMgr_RectangularFrustum class methods.)#");
py::class_<SelectMgr_BVHThreadPool ,opencascade::handle<SelectMgr_BVHThreadPool> , Standard_Transient >(m,"SelectMgr_BVHThreadPool",R"#(Class defining a thread pool for building BVH for the list of Select3D_SensitiveEntity within background thread(s).)#");
py::class_<SelectMgr_BaseIntersector ,opencascade::handle<SelectMgr_BaseIntersector> ,Py_SelectMgr_BaseIntersector , Standard_Transient >(m,"SelectMgr_BaseIntersector",R"#(This class is an interface for different types of selecting intersector, defining different selection types, like point, box or polyline selection. It contains signatures of functions for detection of overlap by sensitive entity and initializes some data for building the selecting intersector)#");
py::class_<SelectMgr_EntityOwner ,opencascade::handle<SelectMgr_EntityOwner> , Standard_Transient >(m,"SelectMgr_EntityOwner",R"#(A framework to define classes of owners of sensitive primitives. The owner is the link between application and selection data structures. For the application to make its own objects selectable, it must define owner classes inheriting this framework.A framework to define classes of owners of sensitive primitives. The owner is the link between application and selection data structures. For the application to make its own objects selectable, it must define owner classes inheriting this framework.)#");
py::class_<SelectMgr_Filter ,opencascade::handle<SelectMgr_Filter> ,Py_SelectMgr_Filter , Standard_Transient >(m,"SelectMgr_Filter",R"#(The root class to define filter objects for selection. Advance handling of objects requires the services of filters. These only allow dynamic detection and selection of objects which correspond to the criteria defined in each. Eight standard filters inheriting SelectMgr_Filter are defined in Open CASCADE. You can create your own filters by defining new filter classes inheriting this framework. You use these filters by loading them into an AIS interactive context.The root class to define filter objects for selection. Advance handling of objects requires the services of filters. These only allow dynamic detection and selection of objects which correspond to the criteria defined in each. Eight standard filters inheriting SelectMgr_Filter are defined in Open CASCADE. You can create your own filters by defining new filter classes inheriting this framework. You use these filters by loading them into an AIS interactive context.The root class to define filter objects for selection. Advance handling of objects requires the services of filters. These only allow dynamic detection and selection of objects which correspond to the criteria defined in each. Eight standard filters inheriting SelectMgr_Filter are defined in Open CASCADE. You can create your own filters by defining new filter classes inheriting this framework. You use these filters by loading them into an AIS interactive context.)#");
py::class_<SelectMgr_FrustumBuilder ,opencascade::handle<SelectMgr_FrustumBuilder> , Standard_Transient >(m,"SelectMgr_FrustumBuilder",R"#(The purpose of this class is to provide unified interface for building selecting frustum depending on current camera projection and orientation matrices, window size and viewport parameters.The purpose of this class is to provide unified interface for building selecting frustum depending on current camera projection and orientation matrices, window size and viewport parameters.)#");
preregister_template_NCollection_IndexedDataMap<opencascade::handle<SelectMgr_EntityOwner>, SelectMgr_SortCriterion>(m,"SelectMgr_IndexedDataMapOfOwnerCriterion");
preregister_template_NCollection_List<opencascade::handle<SelectMgr_Filter>>(m,"SelectMgr_ListOfFilter");
preregister_template_NCollection_DataMap<opencascade::handle<SelectMgr_EntityOwner>, Standard_Integer>(m,"SelectMgr_MapOfOwners");
py::class_<SelectMgr_RectangularFrustum , shared_ptr<SelectMgr_RectangularFrustum> >(m,"SelectMgr_RectangularFrustum",R"#(This class contains representation of rectangular selecting frustum, created in case of point and box selection, and algorithms for overlap detection between selecting frustum and sensitive entities. The principle of frustum calculation: - for point selection: on a near view frustum plane rectangular neighborhood of user-picked point is created according to the pixel tolerance given and then this rectangle is projected onto far view frustum plane. This rectangles define the parallel bases of selecting frustum; - for box selection: box points are projected onto near and far view frustum planes. These 2 projected rectangles define parallel bases of selecting frustum. Overlap detection tests are implemented according to the terms of separating axis theorem (SAT).)#");
py::class_<SelectMgr_SelectableObject ,opencascade::handle<SelectMgr_SelectableObject> ,Py_SelectMgr_SelectableObject , PrsMgr_PresentableObject >(m,"SelectMgr_SelectableObject",R"#(A framework to supply the structure of the object to be selected. At the first pick, this structure is created by calling the appropriate algorithm and retaining this framework for further picking. This abstract framework is inherited in Application Interactive Services (AIS), notably in AIS_InteractiveObject. Consequently, 3D selection should be handled by the relevant daughter classes and their member functions in AIS. This is particularly true in the creation of new interactive objects.A framework to supply the structure of the object to be selected. At the first pick, this structure is created by calling the appropriate algorithm and retaining this framework for further picking. This abstract framework is inherited in Application Interactive Services (AIS), notably in AIS_InteractiveObject. Consequently, 3D selection should be handled by the relevant daughter classes and their member functions in AIS. This is particularly true in the creation of new interactive objects.)#");
py::class_<SelectMgr_SelectingVolumeManager , shared_ptr<SelectMgr_SelectingVolumeManager> , SelectBasics_SelectingVolumeManager >(m,"SelectMgr_SelectingVolumeManager",R"#(This class is used to switch between active selecting volumes depending on selection type chosen by the user. The sample of correct selection volume initialization procedure:)#");
py::class_<SelectMgr_Selection ,opencascade::handle<SelectMgr_Selection> , Standard_Transient >(m,"SelectMgr_Selection",R"#(Represents the state of a given selection mode for a Selectable Object. Contains all the sensitive entities available for this mode. An interactive object can have an indefinite number of modes of selection, each representing a "decomposition" into sensitive primitives; each primitive has an Owner (SelectMgr_EntityOwner) which allows us to identify the exact entity which has been detected. Each Selection mode is identified by an index. The set of sensitive primitives which correspond to a given mode is stocked in a SelectMgr_Selection object. By Convention, the default selection mode which allows us to grasp the Interactive object in its entirety will be mode 0. AIS_Trihedron : 4 selection modes - mode 0 : selection of a trihedron - mode 1 : selection of the origin of the trihedron - mode 2 : selection of the axes - mode 3 : selection of the planes XOY, YOZ, XOZ when you activate one of modes 1 2 3 4 , you pick AIS objects of type: - AIS_Point - AIS_Axis (and information on the type of axis) - AIS_Plane (and information on the type of plane). AIS_PlaneTrihedron offers 3 selection modes: - mode 0 : selection of the whole trihedron - mode 1 : selection of the origin of the trihedron - mode 2 : selection of the axes - same remarks as for the Trihedron. AIS_Shape : 7 maximum selection modes, depending on the complexity of the shape : - mode 0 : selection of the AIS_Shape - mode 1 : selection of the vertices - mode 2 : selection of the edges - mode 3 : selection of the wires - mode 4 : selection of the faces - mode 5 : selection of the shells - mode 6 : selection of the constituent solids.Represents the state of a given selection mode for a Selectable Object. Contains all the sensitive entities available for this mode. An interactive object can have an indefinite number of modes of selection, each representing a "decomposition" into sensitive primitives; each primitive has an Owner (SelectMgr_EntityOwner) which allows us to identify the exact entity which has been detected. Each Selection mode is identified by an index. The set of sensitive primitives which correspond to a given mode is stocked in a SelectMgr_Selection object. By Convention, the default selection mode which allows us to grasp the Interactive object in its entirety will be mode 0. AIS_Trihedron : 4 selection modes - mode 0 : selection of a trihedron - mode 1 : selection of the origin of the trihedron - mode 2 : selection of the axes - mode 3 : selection of the planes XOY, YOZ, XOZ when you activate one of modes 1 2 3 4 , you pick AIS objects of type: - AIS_Point - AIS_Axis (and information on the type of axis) - AIS_Plane (and information on the type of plane). AIS_PlaneTrihedron offers 3 selection modes: - mode 0 : selection of the whole trihedron - mode 1 : selection of the origin of the trihedron - mode 2 : selection of the axes - same remarks as for the Trihedron. AIS_Shape : 7 maximum selection modes, depending on the complexity of the shape : - mode 0 : selection of the AIS_Shape - mode 1 : selection of the vertices - mode 2 : selection of the edges - mode 3 : selection of the wires - mode 4 : selection of the faces - mode 5 : selection of the shells - mode 6 : selection of the constituent solids.)#");
py::class_<SelectMgr_SelectionImageFiller ,opencascade::handle<SelectMgr_SelectionImageFiller> ,Py_SelectMgr_SelectionImageFiller , Standard_Transient >(m,"SelectMgr_SelectionImageFiller",R"#(Abstract class for filling pixel with color. This is internal tool for SelectMgr_ViewerSelector::ToPixMap().)#");
py::class_<SelectMgr_SelectionManager ,opencascade::handle<SelectMgr_SelectionManager> , Standard_Transient >(m,"SelectMgr_SelectionManager",R"#(A framework to manage selection from the point of view of viewer selectors. These can be added and removed, and selection modes can be activated and deactivated. In addition, objects may be known to all selectors or only to some.A framework to manage selection from the point of view of viewer selectors. These can be added and removed, and selection modes can be activated and deactivated. In addition, objects may be known to all selectors or only to some.)#");
py::class_<SelectMgr_SensitiveEntity ,opencascade::handle<SelectMgr_SensitiveEntity> , Standard_Transient >(m,"SelectMgr_SensitiveEntity",R"#(The purpose of this class is to mark sensitive entities selectable or not depending on current active selection of parent object for proper BVH traverseThe purpose of this class is to mark sensitive entities selectable or not depending on current active selection of parent object for proper BVH traverse)#");
py::class_<SelectMgr_SensitiveEntitySet , shared_ptr<SelectMgr_SensitiveEntitySet> >(m,"SelectMgr_SensitiveEntitySet",R"#(This class is used to store all calculated sensitive entities of one selectable object. It provides an interface for building BVH tree which is used to speed-up the performance of searching for overlap among sensitives of one selectable object)#");
preregister_template_NCollection_Sequence<opencascade::handle<SelectMgr_EntityOwner>>(m,"SelectMgr_SequenceOfOwner");
preregister_template_NCollection_Sequence<opencascade::handle<SelectMgr_Selection>>(m,"SelectMgr_SequenceOfSelection");
preregister_template_NCollection_List<opencascade::handle<SelectMgr_TriangularFrustum>>(m,"SelectMgr_TriangFrustums");
py::class_<SelectMgr_TriangularFrustum , shared_ptr<SelectMgr_TriangularFrustum> >(m,"SelectMgr_TriangularFrustum",R"#(This class contains representation of triangular selecting frustum, created in case of polyline selection, and algorithms for overlap detection between selecting frustum and sensitive entities. Overlap detection tests are implemented according to the terms of separating axis theorem (SAT). NOTE: the object of this class can be created only as part of SelectMgr_TriangularFrustumSet.)#");
preregister_template_NCollection_Vec3<Standard_Real>(m,"SelectMgr_Vec3");
py::class_<SelectMgr_ViewerSelector ,opencascade::handle<SelectMgr_ViewerSelector> , Standard_Transient >(m,"SelectMgr_ViewerSelector",R"#(A framework to define finding, sorting the sensitive primitives in a view. Services are also provided to define the return of the owners of those primitives selected. The primitives are sorted by criteria such as priority of the primitive or its depth in the view relative to that of other primitives. Note that in 3D, the inheriting framework StdSelect_ViewerSelector3d is only to be used if you do not want to use the services provided by AIS. Two tools are available to find and select objects found at a given position in the view. If you want to select the owners of all the objects detected at point x,y,z you use the Init - More - Next - Picked loop. If, on the other hand, you want to select only one object detected at that point, you use the Init - More - OnePicked loop. In this iteration, More is used to see if an object was picked and OnePicked, to get the object closest to the pick position. Viewer selectors are driven by SelectMgr_SelectionManager, and manipulate the SelectMgr_Selection objects given to them by the selection manager.A framework to define finding, sorting the sensitive primitives in a view. Services are also provided to define the return of the owners of those primitives selected. The primitives are sorted by criteria such as priority of the primitive or its depth in the view relative to that of other primitives. Note that in 3D, the inheriting framework StdSelect_ViewerSelector3d is only to be used if you do not want to use the services provided by AIS. Two tools are available to find and select objects found at a given position in the view. If you want to select the owners of all the objects detected at point x,y,z you use the Init - More - Next - Picked loop. If, on the other hand, you want to select only one object detected at that point, you use the Init - More - OnePicked loop. In this iteration, More is used to see if an object was picked and OnePicked, to get the object closest to the pick position. Viewer selectors are driven by SelectMgr_SelectionManager, and manipulate the SelectMgr_Selection objects given to them by the selection manager.)#");
py::class_<SelectMgr_AxisIntersector ,opencascade::handle<SelectMgr_AxisIntersector> , SelectMgr_BaseIntersector >(m,"SelectMgr_AxisIntersector",R"#(This class contains representation of selecting axis, created in case of point selection and algorithms for overlap detection between this axis and sensitive entities.)#");
py::class_<SelectMgr_BaseFrustum ,opencascade::handle<SelectMgr_BaseFrustum> ,Py_SelectMgr_BaseFrustum , SelectMgr_BaseIntersector >(m,"SelectMgr_BaseFrustum",R"#(This class is an interface for different types of selecting frustums, defining different selection types, like point, box or polyline selection. It contains signatures of functions for detection of overlap by sensitive entity and initializes some data for building the selecting frustum)#");
py::class_<SelectMgr_CompositionFilter ,opencascade::handle<SelectMgr_CompositionFilter> ,Py_SelectMgr_CompositionFilter , SelectMgr_Filter >(m,"SelectMgr_CompositionFilter",R"#(A framework to define a compound filter composed of two or more simple filters.A framework to define a compound filter composed of two or more simple filters.)#");
py::class_<SelectMgr_AndFilter ,opencascade::handle<SelectMgr_AndFilter> , SelectMgr_CompositionFilter >(m,"SelectMgr_AndFilter",R"#(A framework to define a selection filter for two or more types of entity.A framework to define a selection filter for two or more types of entity.A framework to define a selection filter for two or more types of entity.)#");
py::class_<SelectMgr_AndOrFilter ,opencascade::handle<SelectMgr_AndOrFilter> , SelectMgr_CompositionFilter >(m,"SelectMgr_AndOrFilter",R"#(A framework to define an OR or AND selection filter. To use an AND selection filter call SetUseOrFilter with False parameter. By default the OR selection filter is used.A framework to define an OR or AND selection filter. To use an AND selection filter call SetUseOrFilter with False parameter. By default the OR selection filter is used.)#");
py::class_<SelectMgr_OrFilter ,opencascade::handle<SelectMgr_OrFilter> , SelectMgr_CompositionFilter >(m,"SelectMgr_OrFilter",R"#(A framework to define an or selection filter. This selects one or another type of sensitive entity.A framework to define an or selection filter. This selects one or another type of sensitive entity.A framework to define an or selection filter. This selects one or another type of sensitive entity.)#");
py::class_<SelectMgr_TriangularFrustumSet ,opencascade::handle<SelectMgr_TriangularFrustumSet> , SelectMgr_BaseFrustum >(m,"SelectMgr_TriangularFrustumSet",R"#(This class is used to handle polyline selection. The main principle of polyline selection algorithm is to split the polygon defined by polyline onto triangles. Than each of them is considered as a base for triangular frustum building. In other words, each triangle vertex will be projected from 2d screen space to 3d world space onto near and far view frustum planes. Thus, the projected triangles make up the bases of selecting frustum. When the set of such frustums is created, the function determining selection iterates through triangular frustum set and searches for overlap with any frustum.)#");
};
// user-defined post-inclusion per module
// user-defined post
|
