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