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(%kwargs addArrayAttrib;)
382  SWIGOUT(%newobject addArrayAttrib;)
383  virtual HOM_Attrib *addArrayAttrib(
384  HOM_EnumValue &type, const char *name,
385  HOM_EnumValue &data_type,
386  int64 tuple_size = 1) = 0;
387 
388 
389  virtual void setGlobalAttribValue(
390  HOM_Attrib &attrib, int64 attrib_value) = 0;
391  virtual void setGlobalAttribValue(
392  HOM_Attrib &attrib, double attrib_value) = 0;
393  virtual void setGlobalAttribValue(
394  HOM_Attrib &attrib, const char *attrib_value) = 0;
395  virtual void setGlobalAttribValue(
396  HOM_Attrib &attrib, const std::vector<int64> &attrib_value) = 0;
397  virtual void setGlobalAttribValue(
398  HOM_Attrib &attrib, const std::vector<double> &attrib_value) = 0;
399  virtual void setGlobalAttribValue(
400  HOM_Attrib &attrib, const std::vector<std::string> &attrib_value) = 0;
401 
402  virtual void setGlobalAttribValue(
403  const char *attrib_name, int64 attrib_value) = 0;
404  virtual void setGlobalAttribValue(
405  const char *attrib_name, double attrib_value) = 0;
406  virtual void setGlobalAttribValue(
407  const char *attrib_name, const char *attrib_value) = 0;
408  // Note that, because of strangess the with way swig works when deciding
409  // which overloaded method to call, it's very important that we list the
410  // vector of ints before the vector of doubles. Otherwise, swig will call
411  // the double version when you pass in a vector of ints.
412  virtual void setGlobalAttribValue(
413  const char *attrib_name, const std::vector<int64> &attrib_value) = 0;
414  virtual void setGlobalAttribValue(
415  const char *attrib_name, const std::vector<double> &attrib_value) = 0;
416  virtual void setGlobalAttribValue(
417  const char *attrib_name,
418  const std::vector<std::string> &attrib_value) = 0;
419 
420 #ifdef SWIG
421 %extend
422 {
423  InterpreterObject attribValue(const char *name)
424  { return HOMattribValue(*self, name); }
425 
426  InterpreterObject attribValue(HOM_Attrib &attrib)
427  { return HOMattribValue(*self, attrib); }
428 }
429 #endif
430 
431 
432  virtual std::vector<std::string> intrinsicNames() = 0;
433 
434  virtual hboost::any intrinsicValue(
435  const char *intrinsic_name) = 0;
436  virtual size_t intrinsicSize(const char *intrinsic_name) = 0;
437  virtual bool intrinsicReadOnly(const char *intrinsic_name) = 0;
438 
439  virtual void setIntrinsicValue(const char *intrinsic_name, double value) = 0;
440  virtual void setIntrinsicValue(const char *intrinsic_name, int value) = 0;
441  virtual void setIntrinsicValue(const char *intrinsic_name, int64 value) = 0;
442  virtual void setIntrinsicValue(
443  const char *intrinsic_name, const char *value) = 0;
444  virtual void setIntrinsicValue(
445  const char *intrinsic_name, const std::vector<double> &value) = 0;
446  virtual void setIntrinsicValue(
447  const char *intrinsic_name, const std::vector<int> &value) = 0;
448  virtual void setIntrinsicValue(
449  const char *intrinsic_name, const std::vector<int64> &value) = 0;
450  virtual void setIntrinsicValue(
451  const char *intrinsic_name, const std::vector<std::string> &value) = 0;
452 
453  virtual HOM_BinaryString data() = 0;
454 
455  virtual void saveToFile(const char *file_name) = 0;
456 
457  virtual void loadFromFile(const char *file_name) = 0;
458 
459  virtual void merge(HOM_Geometry &geometry) = 0;
460 
461  virtual void clear() = 0;
462 
463  virtual int intersect(
464  const HOM_Vector3 &rayorig, const HOM_Vector3 &dir,
466  const char *pattern = nullptr) = 0;
467 
468  virtual std::vector<HOM_ElemPtr<HOM_PointGroup> > pointGroups() = 0;
469 
470  SWIGOUT(%newobject findPointGroup;)
471  virtual HOM_PointGroup *findPointGroup(const char *name) = 0;
472 
473  SWIGOUT(%newobject createPointGroup;)
474  virtual HOM_PointGroup *createPointGroup(
475  const char *name, bool is_ordered=false) = 0;
476 
477 
478  virtual std::vector<HOM_ElemPtr<HOM_PrimGroup> > primGroups() = 0;
479 
480  SWIGOUT(%newobject findPrimGroup;)
481  virtual HOM_PrimGroup *findPrimGroup(const char *name) = 0;
482 
483  SWIGOUT(%newobject createPrimGroup;)
484  virtual HOM_PrimGroup *createPrimGroup(
485  const char *name, bool is_ordered=false) = 0;
486 
487  virtual std::vector<HOM_ElemPtr<HOM_EdgeGroup> > edgeGroups() = 0;
488 
489  SWIGOUT(%newobject findEdgeGroup;)
490  virtual HOM_EdgeGroup *findEdgeGroup(const char *name) = 0;
491 
492  SWIGOUT(%newobject createEdgeGroup;)
493  virtual HOM_EdgeGroup *createEdgeGroup(
494  const char *name) = 0;
495 
496  SWIGOUT(%newobject findEdge;)
497  virtual HOM_Edge *findEdge(HOM_Point * p0, HOM_Point * p1) = 0;
498 
499  virtual HOM_BoundingBox boundingBox() = 0;
500  virtual HOM_BoundingBox pointBoundingBox(const char *ptgroup) = 0;
501  virtual HOM_BoundingBox primBoundingBox(const char *primgroup) = 0;
502 
503  virtual hboost::tuple<HOM_ElemPtr<HOM_Prim>, double, double, double>
504  nearestPrim(const std::vector<double> &position) = 0;
505 
506  SWIGOUT(%kwargs primLoop;)
507  virtual std::vector<HOM_ElemPtr<HOM_Prim> >
508  primLoop(std::vector<HOM_Prim *> prims,
509  HOM_EnumValue &loop_type = HOM_componentLoopType::Partial) = 0;
510  SWIGOUT(%kwargs pointLoop;)
511  virtual std::vector<HOM_ElemPtr<HOM_Point> >
512  pointLoop(std::vector<HOM_Point *> points,
513  HOM_EnumValue &loop_type = HOM_componentLoopType::Partial) = 0;
514  SWIGOUT(%kwargs edgeLoop;)
515  virtual std::vector<HOM_ElemPtr<HOM_Edge> >
516  edgeLoop(std::vector<HOM_Edge *> edges,
517  HOM_EnumValue &loop_type = HOM_componentLoopType::Partial,
518  bool full_loop_per_edge = true,
519  bool force_ring = false,
520  bool allow_ring = true) = 0;
521 
522  SWIGOUT(%newobject selection;)
523  virtual HOM_Selection *selection() = 0;
524 
525  // This method is not documented in the user documentation. See
526  // the comments in HOMF_Geometry.C for what it does.
527  virtual HOM_GUDetailHandle *_guDetailHandle() = 0;
528 };
529 
530 #endif
#define HOM_DESTRUCT_OBJECT(pointer)
Definition: HOM_Module.h:983
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:106
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:982
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