HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
HOM_Geometry.h
Go to the documentation of this file.
1 /*
2  * PROPRIETARY INFORMATION. This software is proprietary to
3  * Side Effects Software Inc., and is not to be reproduced,
4  * transmitted, or disclosed in any way without written permission.
5  *
6  * COMMENTS:
7  */
8 
9 #ifndef __HOM_Geometry_h__
10 #define __HOM_Geometry_h__
11 
12 #include "HOM_API.h"
13 #include "HOM_BinaryString.h"
14 #include "HOM_Defines.h"
15 #include "HOM_Errors.h"
16 #include "HOM_IterableList.h"
17 #include "HOM_BoundingBox.h"
18 #include "HOM_Attrib.h"
19 #include <UT/UT_Tuple.h>
20 #include <vector>
21 #include <string>
22 
23 class HOM_Point;
24 class HOM_Vertex;
25 class HOM_Prim;
26 class HOM_Edge;
27 class HOM_Face;
28 class HOM_Polygon;
29 class HOM_Surface;
30 class HOM_PackedPrim;
31 class HOM_Volume;
32 class HOM_VDB;
33 class HOM_PointGroup;
34 class HOM_PrimGroup;
35 class HOM_EdgeGroup;
36 class HOM_SopNode;
37 class HOM_Vector2;
38 class HOM_Vector3;
39 class HOM_Matrix4;
40 class HOM_GUDetailHandle;
41 class HOM_Selection;
42 
43 SWIGOUT(%rename(Geometry) HOM_Geometry;)
44 // Force SWIG to output an __init__ method even though it determines this
45 // class is abstract.
46 SWIGOUT(%feature("notabstract") HOM_Geometry;)
47 
49 {
50 public:
51 #ifdef SWIG
52 %extend
53 {
54  HOM_Geometry()
55  { return HOM().newGeometry(); }
57  { return HOM().newGeometry(geo); }
58 }
59 #else
61  { HOM_CONSTRUCT_OBJECT(this) }
63  { HOM_CONSTRUCT_OBJECT(this) }
64 #endif
65  virtual ~HOM_Geometry()
66  { HOM_DESTRUCT_OBJECT(this) }
67 
68  virtual std::string __repr__() = 0;
69 
70  SWIGOUT(%newobject sopNode;)
71  virtual HOM_SopNode *sopNode() = 0;
72  virtual int sopNodeOutputIndex() = 0;
73 
74  SWIGOUT(%newobject freeze;)
75  virtual HOM_Geometry *freeze(bool read_only=false) = 0;
76 
77  SWIGOUT(%newobject iterPoints;)
78  virtual HOM_IterableList<HOM_Point> *iterPoints() = 0;
79 
80  virtual std::vector<HOM_ElemPtr<HOM_Point> > points() = 0;
81 
82  SWIGOUT(%newobject point;)
83  virtual HOM_Point *point(int index) = 0;
84 
85  SWIGOUT(%newobject iterPrims;)
86  virtual HOM_IterableList<HOM_Prim> *iterPrims() = 0;
87 
88  virtual std::vector<HOM_ElemPtr<HOM_Prim> > prims() = 0;
89 
90  SWIGOUT(%newobject prim;)
91  virtual HOM_Prim *prim(int index) = 0;
92 
93  virtual bool containsPrimType(const char *type_name) = 0;
94  virtual bool containsPrimType(HOM_EnumValue &prim_type) = 0;
95  virtual int64 countPrimType(const char *type_name) = 0;
96  virtual int64 countPrimType(HOM_EnumValue &prim_type) = 0;
97 
98  virtual double averageMinDistance(
99  const HOM_Matrix4& local_transform,
100  HOM_Geometry& geometry,
101  const HOM_Matrix4& geometry_transform) = 0;
102 
103  virtual double averageEdgeLength() = 0;
104 
105  virtual std::vector<HOM_ElemPtr<HOM_Point> > globPoints(const char *pattern) = 0;
106 
107  virtual std::vector<HOM_ElemPtr<HOM_Prim> > globPrims(const char *pattern) = 0;
108 
109  virtual std::vector<HOM_ElemPtr<HOM_Vertex> > globVertices(
110  const char *pattern) = 0;
111 
112  virtual std::vector<HOM_ElemPtr<HOM_Edge> > globEdges(const char *pattern) = 0;
113 
114  virtual std::vector<HOM_ElemPtr<HOM_Attrib> > pointAttribs() = 0;
115 
116  virtual std::vector<HOM_ElemPtr<HOM_Attrib> > primAttribs() = 0;
117 
118  virtual std::vector<HOM_ElemPtr<HOM_Attrib> > vertexAttribs() = 0;
119 
120  virtual std::vector<HOM_ElemPtr<HOM_Attrib> > globalAttribs() = 0;
121 
122 
123  SWIGOUT(%newobject findPointAttrib;)
124  virtual HOM_Attrib *findPointAttrib(const char *name) = 0;
125 
126  SWIGOUT(%newobject findPrimAttrib;)
127  virtual HOM_Attrib *findPrimAttrib(const char *name) = 0;
128 
129  SWIGOUT(%newobject findVertexAttrib;)
130  virtual HOM_Attrib *findVertexAttrib(const char *name) = 0;
131 
132  SWIGOUT(%newobject findGlobalAttrib;)
133  virtual HOM_Attrib *findGlobalAttrib(const char *name) = 0;
134 
135  virtual HOM_EnumValue& attribType() = 0;
136 
137 
138  // These methods return global (detail) attribute values.
139  virtual double floatAttribValue(const char *name) = 0;
140 
141  virtual double floatAttribValue(HOM_Attrib &attrib) = 0;
142 
143  virtual std::vector<double> floatListAttribValue(const char *name) = 0;
144 
145  virtual std::vector<double> floatListAttribValue(HOM_Attrib &attrib) = 0;
146 
147  virtual int64 intAttribValue(const char *name) = 0;
148 
149  virtual int64 intAttribValue(HOM_Attrib &attrib) = 0;
150 
151  virtual std::vector<int64> intListAttribValue(const char *name) = 0;
152 
153  virtual std::vector<int64> intListAttribValue(HOM_Attrib &attrib) = 0;
154 
155  virtual std::string stringAttribValue(const char *name) = 0;
156 
157  virtual std::string stringAttribValue(HOM_Attrib &attrib) = 0;
158 
159  virtual std::vector<std::string> stringListAttribValue(const char *name) = 0;
160 
161  virtual std::vector<std::string> stringListAttribValue(HOM_Attrib &attrib) = 0;
162 
163 
164  // These methods return/set arrays of point/primitive attribute values.
165  virtual std::vector<double> pointFloatAttribValues(const char *name) = 0;
166  SWIGOUT(%kwargs pointFloatAttribValuesAsString;)
167  virtual HOM_BinaryString pointFloatAttribValuesAsString(const char *name,
168  HOM_EnumValue &float_type = HOM_numericData::Float32) = 0;
169  virtual std::vector<double> primFloatAttribValues(const char *name) = 0;
170  SWIGOUT(%kwargs primFloatAttribValuesAsString;)
171  virtual HOM_BinaryString primFloatAttribValuesAsString(const char *name,
172  HOM_EnumValue &float_type = HOM_numericData::Float32) = 0;
173 
174  virtual std::vector<int64> pointIntAttribValues(const char *name) = 0;
175  SWIGOUT(%kwargs pointIntAttribValuesAsString;)
176  virtual HOM_BinaryString pointIntAttribValuesAsString(const char *name,
177  HOM_EnumValue &int_type = HOM_numericData::Int32) = 0;
178  virtual std::vector<int64> primIntAttribValues(const char *name) = 0;
179  SWIGOUT(%kwargs primIntAttribValuesAsString;)
180  virtual HOM_BinaryString primIntAttribValuesAsString(const char *name,
181  HOM_EnumValue &int_type = HOM_numericData::Int32) = 0;
182 
183  virtual std::vector<std::string> pointStringAttribValues(const char *name) = 0;
184  virtual std::vector<std::string> primStringAttribValues(const char *name) = 0;
185 
186  virtual void setPointFloatAttribValues(
187  const char *name, const std::vector<double> &values) = 0;
188  virtual void setPrimFloatAttribValues(
189  const char *name, const std::vector<double> &values) = 0;
190 
191  SWIGOUT(%ignore opaqueSetPointFloatAttribValuesFromString);
192  virtual void opaqueSetPointFloatAttribValuesFromString(
193  const char *name, const char *values, int64 length,
194  HOM_EnumValue &float_type) = 0;
195  SWIGOUT(%ignore opaqueSetPrimFloatAttribValuesFromString);
196  virtual void opaqueSetPrimFloatAttribValuesFromString(
197  const char *name, const char *values, int64 length,
198  HOM_EnumValue &float_type) = 0;
199 
200 #ifdef SWIG
201 %extend
202 {
203  %kwargs setPointFloatAttribValuesFromString;
204  void setPointFloatAttribValuesFromString(
205  const char *name, InterpreterObject values,
206  HOM_EnumValue &float_type = HOM_numericData::Float32)
207  {
208  HOM_PyBuffer buffer(values);
209  self->opaqueSetPointFloatAttribValuesFromString(
210  name, (const char *)buffer.myData, buffer.myLength, float_type);
211  }
212 
213  %kwargs setPrimFloatAttribValuesFromString;
214  void setPrimFloatAttribValuesFromString(
215  const char *name, InterpreterObject values,
216  HOM_EnumValue &float_type = HOM_numericData::Float32)
217  {
218  HOM_PyBuffer buffer(values);
219  self->opaqueSetPrimFloatAttribValuesFromString(
220  name, (const char *)buffer.myData, buffer.myLength, float_type);
221  }
222 }
223 #endif
224 
225  virtual void setPointIntAttribValues(
226  const char *name, const std::vector<int64> &values) = 0;
227  virtual void setPrimIntAttribValues(
228  const char *name, const std::vector<int64> &values) = 0;
229 
230  SWIGOUT(%ignore opaqueSetPointIntAttribValuesFromString);
231  virtual void opaqueSetPointIntAttribValuesFromString(
232  const char *name, const char *values, int64 length,
233  HOM_EnumValue &int_type) = 0;
234  SWIGOUT(%ignore opaqueSetPrimIntAttribValuesFromString);
235  virtual void opaqueSetPrimIntAttribValuesFromString(
236  const char *name, const char *values, int64 length,
237  HOM_EnumValue &int_type) = 0;
238 
239 #ifdef SWIG
240 %extend
241 {
242  %kwargs setPointIntAttribValuesFromString;
243  void setPointIntAttribValuesFromString(
244  const char *name, InterpreterObject values,
246  {
247  HOM_PyBuffer buffer(values);
248  self->opaqueSetPointIntAttribValuesFromString(
249  name, (const char *)buffer.myData, buffer.myLength, int_type);
250  }
251 
252  %kwargs setPrimIntAttribValuesFromString;
253  void setPrimIntAttribValuesFromString(
254  const char *name, InterpreterObject values,
256  {
257  HOM_PyBuffer buffer(values);
258  self->opaqueSetPrimIntAttribValuesFromString(
259  name, (const char *)buffer.myData, buffer.myLength, int_type);
260  }
261 }
262 #endif
263 
264  virtual void setPointStringAttribValues(
265  const char *name, const std::vector<std::string> &values) = 0;
266  virtual void setPrimStringAttribValues(
267  const char *name, const std::vector<std::string> &values) = 0;
268 
269  virtual void renamePointAttrib(const char *old_name, const char *new_name) = 0;
270  virtual void renamePrimAttrib(const char *old_name, const char *new_name) = 0;
271  virtual void renameVertexAttrib(const char *old_name, const char *new_name) = 0;
272  virtual void renameGlobalAttrib(const char *old_name, const char *new_name) = 0;
273 
274  SWIGOUT(%newobject createPoint;)
275  virtual HOM_Point *createPoint() = 0;
276  virtual std::vector<HOM_ElemPtr<HOM_Point> >createPoints(
277  const std::vector<std::vector<double> > &point_positions) = 0;
278  virtual std::vector<HOM_ElemPtr<HOM_Point> >createPoints(
279  const std::vector<HOM_Vector3 *> &point_positions) = 0;
280 
281  SWIGOUT(%newobject createPolygon;)
282  virtual HOM_Polygon *createPolygon() = 0;
283  virtual std::vector<HOM_ElemPtr<HOM_Polygon> >createPolygons(
284  const std::vector<std::vector<HOM_Point *> > &points) = 0;
285  virtual std::vector<HOM_ElemPtr<HOM_Polygon> >createPolygons(
286  const std::vector<std::vector<int> > &point_numbers) = 0;
287 
288  SWIGOUT(%newobject createPacked;)
289  virtual HOM_PackedPrim *createPacked(const char *packed_type) = 0;
290 
291  SWIGOUT(%newobject createTetrahedron;)
292  virtual HOM_Prim *createTetrahedron() = 0;
293 
294  SWIGOUT(%newobject createTetrahedronInPlace;)
295  virtual HOM_Prim *createTetrahedronInPlace(HOM_Point *p0, HOM_Point *p1,
296  HOM_Point *p2, HOM_Point *p3) = 0;
297 
298  SWIGOUT(%newobject createNURBSCurve;)
299  SWIGOUT(%kwargs createNURBSCurve;)
300  virtual HOM_Face *createNURBSCurve(int num_points=4, bool is_closed=false,
301  int order=4) = 0;
302 
303  SWIGOUT(%newobject createBezierCurve;)
304  SWIGOUT(%kwargs createBezierCurve;)
305  virtual HOM_Face *createBezierCurve(int num_points=4, bool is_closed=false,
306  int order=4) = 0;
307 
308  SWIGOUT(%newobject createNURBSSurface;)
309  SWIGOUT(%kwargs createNURBSSurface;)
310  virtual HOM_Surface *createNURBSSurface(
311  int rows, int cols,
312  bool is_closed_in_u=false, bool is_closed_in_v=false,
313  int order_u=4, int order_v=4) = 0;
314 
315  SWIGOUT(%newobject createBezierSurface;)
316  SWIGOUT(%kwargs createBezierSurface;)
317  virtual HOM_Surface *createBezierSurface(
318  int rows, int cols,
319  bool is_closed_in_u=false, bool is_closed_in_v=false,
320  int order_u=4, int order_v=4) = 0;
321 
322  SWIGOUT(%newobject createMeshSurface;)
323  SWIGOUT(%kwargs createMeshSurface;)
324  virtual HOM_Surface *createMeshSurface(
325  int rows, int cols,
326  bool is_closed_in_u=false, bool is_closed_in_v=false) = 0;
327 
328  SWIGOUT(%newobject createVolume;)
329  SWIGOUT(%kwargs createVolume;)
330  virtual HOM_Volume *createVolume(
331  int xres, int yres, int zres, HOM_BoundingBox *bounding_box=NULL) = 0;
332 
333 
334  virtual void transform(HOM_Matrix4 &matrix) = 0;
335 
336  virtual void transformPrims(
337  const std::vector<HOM_Prim *> &prims, HOM_Matrix4 &matrix) = 0;
338 
339  SWIGOUT(%kwargs deletePrims;)
340  virtual void deletePrims(
341  const std::vector<HOM_Prim *> &prims, bool keep_points=false) = 0;
342 
343  virtual void deletePoints(const std::vector<HOM_Point *> &points) = 0;
344 
345 
346  // Swig does not allow keyword arguments for overloaded functions, so
347  // addAttrib is wrapped in houpythonportion.py to enable keyword
348  // arguments. If you want to change the signature of addAttrib, you must
349  // also edit houpythonportion.py.
350  SWIGOUT(%newobject addAttrib;)
351  virtual HOM_Attrib *addAttrib(
352  HOM_EnumValue &type, const char *name,
353  int64 default_value,
354  bool transform_as_normal,
355  bool create_local_variable) = 0;
356 
357  virtual HOM_Attrib *addAttrib(
358  HOM_EnumValue &type, const char *name,
359  double default_value,
360  bool transform_as_normal,
361  bool create_local_variable) = 0;
362 
363  virtual HOM_Attrib *addAttrib(
364  HOM_EnumValue &type, const char *name,
365  const char *default_value,
366  bool transform_as_normal,
367  bool create_local_variable) = 0;
368 
369  virtual HOM_Attrib *addAttrib(
371  const char *name,
372  const std::vector<int64> &default_value,
373  bool transform_as_normal,
374  bool create_local_variable) = 0;
375 
376  virtual HOM_Attrib *addAttrib(
378  const char *name,
379  const std::vector<double> &default_value,
380  bool transform_as_normal,
381  bool create_local_variable) = 0;
382 
383  virtual HOM_Attrib *addAttrib(
385  const char *name,
386  const std::vector<std::string> &default_value,
387  bool transform_as_normal,
388  bool create_local_variable) = 0;
389 
390  SWIGOUT(%kwargs addArrayAttrib;)
391  SWIGOUT(%newobject addArrayAttrib;)
392  virtual HOM_Attrib *addArrayAttrib(
393  HOM_EnumValue &type, const char *name,
394  HOM_EnumValue &data_type,
395  int64 tuple_size = 1) = 0;
396 
397 
398  virtual void setGlobalAttribValue(
399  HOM_Attrib &attrib, int64 attrib_value) = 0;
400  virtual void setGlobalAttribValue(
401  HOM_Attrib &attrib, double attrib_value) = 0;
402  virtual void setGlobalAttribValue(
403  HOM_Attrib &attrib, const char *attrib_value) = 0;
404  virtual void setGlobalAttribValue(
405  HOM_Attrib &attrib, const std::vector<int64> &attrib_value) = 0;
406  virtual void setGlobalAttribValue(
407  HOM_Attrib &attrib, const std::vector<double> &attrib_value) = 0;
408  virtual void setGlobalAttribValue(
409  HOM_Attrib &attrib, const std::vector<std::string> &attrib_value) = 0;
410 
411  virtual void setGlobalAttribValue(
412  const char *attrib_name, int64 attrib_value) = 0;
413  virtual void setGlobalAttribValue(
414  const char *attrib_name, double attrib_value) = 0;
415  virtual void setGlobalAttribValue(
416  const char *attrib_name, const char *attrib_value) = 0;
417  // Note that, because of strangess the with way swig works when deciding
418  // which overloaded method to call, it's very important that we list the
419  // vector of ints before the vector of doubles. Otherwise, swig will call
420  // the double version when you pass in a vector of ints.
421  virtual void setGlobalAttribValue(
422  const char *attrib_name, const std::vector<int64> &attrib_value) = 0;
423  virtual void setGlobalAttribValue(
424  const char *attrib_name, const std::vector<double> &attrib_value) = 0;
425  virtual void setGlobalAttribValue(
426  const char *attrib_name,
427  const std::vector<std::string> &attrib_value) = 0;
428 
429 #ifdef SWIG
430 %extend
431 {
432  InterpreterObject attribValue(const char *name)
433  { return HOMattribValue(*self, name); }
434 
435  InterpreterObject attribValue(HOM_Attrib &attrib)
436  { return HOMattribValue(*self, attrib); }
437 }
438 #endif
439 
440  virtual std::vector<std::string> attributeCaptureRegions() = 0;
441  virtual std::vector<std::string> attributeCaptureObjectPaths() = 0;
442 
443 
444  virtual std::vector<std::string> intrinsicNames() = 0;
445 
446  virtual hboost::any intrinsicValue(
447  const char *intrinsic_name) = 0;
448  virtual size_t intrinsicSize(const char *intrinsic_name) = 0;
449  virtual bool intrinsicReadOnly(const char *intrinsic_name) = 0;
450 
451  virtual void setIntrinsicValue(const char *intrinsic_name, double value) = 0;
452  virtual void setIntrinsicValue(const char *intrinsic_name, int value) = 0;
453  virtual void setIntrinsicValue(const char *intrinsic_name, int64 value) = 0;
454  virtual void setIntrinsicValue(
455  const char *intrinsic_name, const char *value) = 0;
456  virtual void setIntrinsicValue(
457  const char *intrinsic_name, const std::vector<double> &value) = 0;
458  virtual void setIntrinsicValue(
459  const char *intrinsic_name, const std::vector<int> &value) = 0;
460  virtual void setIntrinsicValue(
461  const char *intrinsic_name, const std::vector<int64> &value) = 0;
462  virtual void setIntrinsicValue(
463  const char *intrinsic_name, const std::vector<std::string> &value) = 0;
464 
465  virtual HOM_BinaryString data() = 0;
466 
467  virtual void saveToFile(const char *file_name) = 0;
468 
469  virtual void loadFromFile(const char *file_name) = 0;
470 
471  virtual void merge(HOM_Geometry &geometry) = 0;
472 
473  virtual void clear() = 0;
474 
475  SWIGOUT(%kwargs intersect;)
476  virtual int intersect(
477  const HOM_Vector3 &rayorig, const HOM_Vector3 &dir,
479  const char *pattern = nullptr, float min_hit=1e-2f, float max_hit=1e18f) = 0;
480 
481  virtual std::vector<int> _orderedPoints(
482  const char *groupname,
483  const char *corner_groupname,
484  HOM_Vector2 &dimensions) = 0;
485 
486  virtual std::vector<HOM_ElemPtr<HOM_PointGroup> > pointGroups() = 0;
487 
488  SWIGOUT(%newobject findPointGroup;)
489  virtual HOM_PointGroup *findPointGroup(const char *name) = 0;
490 
491  SWIGOUT(%newobject createPointGroup;)
492  virtual HOM_PointGroup *createPointGroup(
493  const char *name, bool is_ordered=false) = 0;
494 
495 
496  virtual std::vector<HOM_ElemPtr<HOM_PrimGroup> > primGroups() = 0;
497 
498  SWIGOUT(%newobject findPrimGroup;)
499  virtual HOM_PrimGroup *findPrimGroup(const char *name) = 0;
500 
501  SWIGOUT(%newobject createPrimGroup;)
502  virtual HOM_PrimGroup *createPrimGroup(
503  const char *name, bool is_ordered=false) = 0;
504 
505  virtual std::vector<HOM_ElemPtr<HOM_EdgeGroup> > edgeGroups() = 0;
506 
507  SWIGOUT(%newobject findEdgeGroup;)
508  virtual HOM_EdgeGroup *findEdgeGroup(const char *name) = 0;
509 
510  SWIGOUT(%newobject createEdgeGroup;)
511  virtual HOM_EdgeGroup *createEdgeGroup(
512  const char *name) = 0;
513 
514  SWIGOUT(%newobject findEdge;)
515  virtual HOM_Edge *findEdge(HOM_Point * p0, HOM_Point * p1) = 0;
516 
517  virtual HOM_BoundingBox boundingBox() = 0;
518  virtual HOM_BoundingBox pointBoundingBox(const char *ptgroup) = 0;
519  virtual HOM_BoundingBox primBoundingBox(const char *primgroup) = 0;
520 
521  virtual UT_Tuple<HOM_ElemPtr<HOM_Prim>, double, double, double>
522  nearestPrim(const std::vector<double> &position) = 0;
523 
524  SWIGOUT(%kwargs primLoop;)
525  virtual std::vector<HOM_ElemPtr<HOM_Prim> >
526  primLoop(std::vector<HOM_Prim *> prims,
527  HOM_EnumValue &loop_type = HOM_componentLoopType::Partial) = 0;
528  SWIGOUT(%kwargs pointLoop;)
529  virtual std::vector<HOM_ElemPtr<HOM_Point> >
530  pointLoop(std::vector<HOM_Point *> points,
531  HOM_EnumValue &loop_type = HOM_componentLoopType::Partial) = 0;
532  SWIGOUT(%kwargs edgeLoop;)
533  virtual std::vector<HOM_ElemPtr<HOM_Edge> >
534  edgeLoop(std::vector<HOM_Edge *> edges,
535  HOM_EnumValue &loop_type = HOM_componentLoopType::Partial,
536  bool full_loop_per_edge = true,
537  bool force_ring = false,
538  bool allow_ring = true) = 0;
539 
540  virtual std::vector<HOM_Vector3>
541  pointNormals(const std::vector<HOM_Point *> &points) = 0;
542 
543  SWIGOUT(%newobject selection;)
544  virtual HOM_Selection *selection() = 0;
545 
546  // This method is not documented in the user documentation. See
547  // the comments in HOMF_Geometry.C for what it does.
548  virtual HOM_GUDetailHandle *_guDetailHandle() = 0;
549 };
550 
551 #endif
GT_API const UT_StringHolder selection
#define HOM_DESTRUCT_OBJECT(pointer)
Definition: HOM_Module.h:1053
GLsizei const GLchar *const * string
Definition: glcorearb.h:813
virtual std::vector< HOM_ElemPtr< HOM_Prim > > prims(HOM_Geometry &geo)=0
#define SWIGOUT(x)
Definition: HOM_Defines.h:24
string __repr__(VtArray< T > const &self)
Definition: wrapArray.h:344
std::tuple< Types...> UT_Tuple
Definition: UT_Tuple.h:53
virtual void clear()=0
GLuint buffer
Definition: glcorearb.h:659
long long int64
Definition: SYS_Types.h:107
GLdouble n
Definition: glcorearb.h:2007
GLfloat f
Definition: glcorearb.h:1925
bool intersect(const Line3< T > &line, const Vec3< T > &v0, const Vec3< T > &v1, const Vec3< T > &v2, Vec3< T > &pt, Vec3< T > &barycentric, bool &front)
#define HOM_API
Definition: HOM_API.h:13
HOM_Geometry(const HOM_Geometry &)
Definition: HOM_Geometry.h:62
#define HOM_CONSTRUCT_OBJECT(pointer)
Definition: HOM_Module.h:1052
virtual std::vector< HOM_ElemPtr< HOM_Edge > > edges(HOM_Geometry &geo)=0
GLenum GLsizei GLsizei GLint * values
Definition: glcorearb.h:1601
virtual std::vector< HOM_ElemPtr< HOM_Point > > points(HOM_Geometry &geo)=0
GLboolean * data
Definition: glcorearb.h:130
GLuint const GLchar * name
Definition: glcorearb.h:785
GA_API const UT_StringHolder transform
GLsizei const GLfloat * value
Definition: glcorearb.h:823
virtual HOM_Selection * freeze()=0
GLuint index
Definition: glcorearb.h:785
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
virtual ~HOM_Geometry()
Definition: HOM_Geometry.h:65
virtual HOM_Geometry * newGeometry()=0
HOM_API HOM_Module & HOM()
GLuint GLsizei GLsizei * length
Definition: glcorearb.h:794