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_OrientedBoundingBox.h"
19 #include "HOM_Attrib.h"
20 #include "HOM_LopNode.h"
21 #include "HOM_LopSelectionRule.h"
22 #include <UT/UT_Tuple.h>
23 #include <vector>
24 #include <string>
25 
26 class HOM_AttribDataId;
27 class HOM_CameraPrim;
28 class HOM_ChannelPrim;
29 class HOM_Edge;
30 class HOM_EdgeGroup;
31 class HOM_Face;
32 class HOM_GUDetailHandle;
33 class HOM_LopLockedStage;
34 class HOM_Matrix4;
35 class HOM_PackedGeometry;
36 class HOM_PackedPrim;
37 class HOM_Parm;
38 class HOM_Point;
39 class HOM_PointGroup;
40 class HOM_Polygon;
41 class HOM_Prim;
42 class HOM_PrimGroup;
43 class HOM_Selection;
44 class HOM_SopNode;
45 class HOM_Surface;
46 class HOM_VDB;
47 class HOM_Vector2;
48 class HOM_Vector3;
49 class HOM_Vertex;
50 class HOM_VertexGroup;
51 class HOM_Volume;
52 class HOMF_GeometryHandle;
53 
54 SWIGOUT(%rename(Geometry) HOM_Geometry;)
55 // Force SWIG to output an __init__ method even though it determines this
56 // class is abstract.
57 SWIGOUT(%feature("notabstract") HOM_Geometry;)
58 
59 class HOM_API HOM_Geometry
60 {
61 public:
62 #ifdef SWIG
63 %extend
64 {
65  HOM_Geometry(HOM_Geometry *geo=nullptr, bool clone_data_ids=false)
66  { return HOM().newGeometry(geo, clone_data_ids); }
67 }
68 #else
69  HOM_Geometry()
70  { HOM_CONSTRUCT_OBJECT(this) }
71  HOM_Geometry(const HOM_Geometry &)
72  { HOM_CONSTRUCT_OBJECT(this) }
73 #endif
74  virtual ~HOM_Geometry()
75  { HOM_DESTRUCT_OBJECT(this) }
76 
77  virtual std::string __repr__() = 0;
78 
79  SWIGOUT(%newobject sopNode;)
80  virtual HOM_SopNode *sopNode() = 0;
81  virtual int sopNodeOutputIndex() = 0;
82 
83  virtual bool isValid() = 0;
84 
85  SWIGOUT(%newobject freeze;)
86  virtual HOM_Geometry *freeze(bool read_only=false,
87  bool clone_data_ids=false) = 0;
88 
89  virtual int64 pointCount() = 0;
90  virtual int64 vertexCount() = 0;
91  virtual int64 primCount() = 0;
92 
93  SWIGOUT(%newobject iterPoints;)
94  virtual HOM_IterableList<HOM_Point> *iterPoints() = 0;
95 
96  virtual std::vector<HOM_ElemPtr<HOM_Point> > points() = 0;
97 
98  SWIGOUT(%newobject point;)
99  virtual HOM_Point *point(int index) = 0;
100 
101  SWIGOUT(%newobject iterPrims;)
102  virtual HOM_IterableList<HOM_Prim> *iterPrims() = 0;
103 
104  virtual std::vector<HOM_ElemPtr<HOM_Prim> > prims() = 0;
105 
106  SWIGOUT(%newobject prim;)
107  virtual HOM_Prim *prim(int index) = 0;
108 
109  SWIGOUT(%newobject vertex;)
110  virtual HOM_Vertex *vertex(int index) = 0;
111 
112  virtual std::vector<std::string> primTypeNames() = 0;
113  virtual std::vector<std::string> primTypeLabels() = 0;
114  virtual std::vector<std::string> primTypeIcons() = 0;
115  virtual bool containsPrimType(const char *type_name) = 0;
116  virtual bool containsPrimType(HOM_EnumValue &prim_type) = 0;
117  virtual int64 countPrimType(const char *type_name) = 0;
118  virtual int64 countPrimType(HOM_EnumValue &prim_type) = 0;
119  virtual int64 countUnusedPoints() = 0;
120 
121  virtual std::vector<HOM_ElemPtr<HOM_Prim> > primsOfType(HOM_EnumValue &prim_type) = 0;
122 
123  SWIGOUT(%newobject prim;)
124  virtual HOM_Prim *primByName(const char *name) = 0;
125 
126  SWIGOUT(%newobject iterPrimsOfType;)
127  virtual HOM_IterableList<HOM_Prim> *iterPrimsOfType(HOM_EnumValue &prim_type) = 0;
128 
129  virtual int64 preferredPrecision() = 0;
130  virtual void setPreferredPrecision(int64 prec) = 0;
131 
132  virtual double averageMinDistance(
133  const HOM_Matrix4& local_transform,
134  HOM_Geometry& geometry,
135  const HOM_Matrix4& geometry_transform) = 0;
136 
137  virtual double averageEdgeLength() = 0;
138 
139  virtual std::vector<HOM_ElemPtr<HOM_Point> > globPoints(const char *pattern, bool ordered = false) = 0;
140 
141  virtual std::vector<HOM_ElemPtr<HOM_Prim> > globPrims(const char *pattern) = 0;
142 
143  virtual std::vector<HOM_ElemPtr<HOM_Vertex> > globVertices(
144  const char *pattern) = 0;
145 
146  virtual std::vector<HOM_ElemPtr<HOM_Edge> > globEdges(const char *pattern) = 0;
147 
148  // Wrapped in houpythonportion.py for the deprecated include_private flag
149  virtual std::vector<HOM_ElemPtr<HOM_Attrib> > _pointAttribs(
150  HOM_EnumValue &scope = HOM_attribScope::Public) = 0;
151 
152  // Wrapped in houpythonportion.py for the deprecated include_private flag
153  virtual std::vector<HOM_ElemPtr<HOM_Attrib> > _primAttribs(
154  HOM_EnumValue &scope = HOM_attribScope::Public) = 0;
155 
156  // Wrapped in houpythonportion.py for the deprecated include_private flag
157  virtual std::vector<HOM_ElemPtr<HOM_Attrib> > _vertexAttribs(
158  HOM_EnumValue &scope = HOM_attribScope::Public) = 0;
159 
160  // Wrapped in houpythonportion.py for the deprecated include_private flag
161  virtual std::vector<HOM_ElemPtr<HOM_Attrib> > _globalAttribs(
162  HOM_EnumValue &scope = HOM_attribScope::Public) = 0;
163 
164 
165  SWIGOUT(%newobject findPointAttrib;)
166  virtual HOM_Attrib *findPointAttrib(
167  const char *name, HOM_EnumValue &scope = HOM_attribScope::Public) = 0;
168 
169  SWIGOUT(%newobject findPrimAttrib;)
170  virtual HOM_Attrib *findPrimAttrib(
171  const char *name, HOM_EnumValue &scope = HOM_attribScope::Public) = 0;
172 
173  SWIGOUT(%newobject findVertexAttrib;)
174  virtual HOM_Attrib *findVertexAttrib(
175  const char *name, HOM_EnumValue &scope = HOM_attribScope::Public) = 0;
176 
177  SWIGOUT(%newobject findGlobalAttrib;)
178  virtual HOM_Attrib *findGlobalAttrib(
179  const char *name, HOM_EnumValue &scope = HOM_attribScope::Public) = 0;
180 
181  virtual HOM_EnumValue& attribType() = 0;
182 
183 
184  // These methods return global (detail) attribute values.
185  virtual double floatAttribValue(const char *name) = 0;
186 
187  virtual double floatAttribValue(HOM_Attrib &attrib) = 0;
188 
189  virtual std::vector<double> floatListAttribValue(const char *name) = 0;
190 
191  virtual std::vector<double> floatListAttribValue(HOM_Attrib &attrib) = 0;
192 
193  virtual int64 intAttribValue(const char *name) = 0;
194 
195  virtual int64 intAttribValue(HOM_Attrib &attrib) = 0;
196 
197  virtual std::vector<int64> intListAttribValue(const char *name) = 0;
198 
199  virtual std::vector<int64> intListAttribValue(HOM_Attrib &attrib) = 0;
200 
201  virtual std::string stringAttribValue(const char *name) = 0;
202 
203  virtual std::string stringAttribValue(HOM_Attrib &attrib) = 0;
204 
205  virtual std::vector<std::string> stringListAttribValue(const char *name) = 0;
206 
207  virtual std::vector<std::string> stringListAttribValue(HOM_Attrib &attrib) = 0;
208  virtual std::map<std::string,hboost::any> dictAttribValue(const char *name) = 0;
209  virtual std::map<std::string,hboost::any> dictAttribValue(HOM_Attrib &name) = 0;
210  virtual std::vector<std::map<std::string,hboost::any> > dictListAttribValue(const char *name) = 0;
211  virtual std::vector<std::map<std::string,hboost::any> > dictListAttribValue(HOM_Attrib &name) = 0;
212 
213 
214  // These methods return/set arrays of point/primitive attribute values.
215  virtual std::vector<double> pointFloatAttribValues(const char *name) = 0;
216  SWIGOUT(%kwargs pointFloatAttribValuesAsString;)
217  virtual HOM_BinaryString pointFloatAttribValuesAsString(const char *name,
218  HOM_EnumValue &float_type = HOM_numericData::Float32) = 0;
219  virtual std::vector<double> primFloatAttribValues(const char *name) = 0;
220  SWIGOUT(%kwargs primFloatAttribValuesAsString;)
221  virtual HOM_BinaryString primFloatAttribValuesAsString(const char *name,
222  HOM_EnumValue &float_type = HOM_numericData::Float32) = 0;
223  virtual std::vector<double> vertexFloatAttribValues(const char *name) = 0;
224  SWIGOUT(%kwargs vertexFloatAttribValuesAsString;)
225  virtual HOM_BinaryString vertexFloatAttribValuesAsString(const char *name,
226  HOM_EnumValue &float_type = HOM_numericData::Float32) = 0;
227 
228  virtual std::vector<int64> pointIntAttribValues(const char *name) = 0;
229  SWIGOUT(%kwargs pointIntAttribValuesAsString;)
230  virtual HOM_BinaryString pointIntAttribValuesAsString(const char *name,
231  HOM_EnumValue &int_type = HOM_numericData::Int32) = 0;
232  virtual std::vector<int64> primIntAttribValues(const char *name) = 0;
233  SWIGOUT(%kwargs primIntAttribValuesAsString;)
234  virtual HOM_BinaryString primIntAttribValuesAsString(const char *name,
235  HOM_EnumValue &int_type = HOM_numericData::Int32) = 0;
236  virtual std::vector<int64> vertexIntAttribValues(const char *name) = 0;
237  SWIGOUT(%kwargs vertexIntAttribValuesAsString;)
238  virtual HOM_BinaryString vertexIntAttribValuesAsString(const char *name,
239  HOM_EnumValue &int_type = HOM_numericData::Int32) = 0;
240 
241  virtual std::vector<std::string> pointStringAttribValues(const char *name) = 0;
242  virtual std::vector<std::string> primStringAttribValues(const char *name) = 0;
243  virtual std::vector<std::string> vertexStringAttribValues(const char *name) = 0;
244 
245  virtual void setPointFloatAttribValues(
246  const char *name, const std::vector<double> &values) = 0;
247  virtual void setPrimFloatAttribValues(
248  const char *name, const std::vector<double> &values) = 0;
249  virtual void setVertexFloatAttribValues(
250  const char *name, const std::vector<double> &values) = 0;
251 
252  SWIGOUT(%ignore opaqueSetPointFloatAttribValuesFromString);
253  virtual void opaqueSetPointFloatAttribValuesFromString(
254  const char *name, const char *values, int64 length,
255  HOM_EnumValue &float_type) = 0;
256  SWIGOUT(%ignore opaqueSetPrimFloatAttribValuesFromString);
257  virtual void opaqueSetPrimFloatAttribValuesFromString(
258  const char *name, const char *values, int64 length,
259  HOM_EnumValue &float_type) = 0;
260  SWIGOUT(%ignore opaqueSetVertexFloatAttribValuesFromString);
261  virtual void opaqueSetVertexFloatAttribValuesFromString(
262  const char *name, const char *values, int64 length,
263  HOM_EnumValue &float_type) = 0;
264 
265  virtual std::vector<std::vector<std::string>> pointStringListAttribValues(const char *name) = 0;
266  virtual std::vector<std::vector<std::string>> primStringListAttribValues(const char *name) = 0;
267  virtual std::vector<std::vector<std::string>> vertexStringListAttribValues(const char *name) = 0;
268 
269  virtual std::vector<std::vector<int64>> pointIntListAttribValues(const char *name) = 0;
270  virtual std::vector<std::vector<int64>> primIntListAttribValues(const char *name) = 0;
271  virtual std::vector<std::vector<int64>> vertexIntListAttribValues(const char *name) = 0;
272 
273  virtual std::vector<std::vector<double>> pointFloatListAttribValues(const char *name) = 0;
274  virtual std::vector<std::vector<double>> primFloatListAttribValues(const char *name) = 0;
275  virtual std::vector<std::vector<double>> vertexFloatListAttribValues(const char *name) = 0;
276 
277 
278 #ifdef SWIG
279 %extend
280 {
281  %kwargs setPointFloatAttribValuesFromString;
282  void setPointFloatAttribValuesFromString(
283  const char *name, InterpreterObject values,
284  HOM_EnumValue &float_type = HOM_numericData::Float32)
285  {
286  HOM_PyBuffer buffer(values);
287  self->opaqueSetPointFloatAttribValuesFromString(
288  name, (const char *)buffer.myData, buffer.myLength, float_type);
289  }
290 
291  %kwargs setPrimFloatAttribValuesFromString;
292  void setPrimFloatAttribValuesFromString(
293  const char *name, InterpreterObject values,
294  HOM_EnumValue &float_type = HOM_numericData::Float32)
295  {
296  HOM_PyBuffer buffer(values);
297  self->opaqueSetPrimFloatAttribValuesFromString(
298  name, (const char *)buffer.myData, buffer.myLength, float_type);
299  }
300 
301  %kwargs setVertexFloatAttribValuesFromString;
302  void setVertexFloatAttribValuesFromString(
303  const char *name, InterpreterObject values,
304  HOM_EnumValue &float_type = HOM_numericData::Float32)
305  {
306  HOM_PyBuffer buffer(values);
307  self->opaqueSetVertexFloatAttribValuesFromString(
308  name, (const char *)buffer.myData, buffer.myLength, float_type);
309  }
310 }
311 #endif
312 
313  virtual void setPointIntAttribValues(
314  const char *name, const std::vector<int64> &values) = 0;
315  virtual void setPrimIntAttribValues(
316  const char *name, const std::vector<int64> &values) = 0;
317  virtual void setVertexIntAttribValues(
318  const char *name, const std::vector<int64> &values) = 0;
319 
320  SWIGOUT(%ignore opaqueSetPointIntAttribValuesFromString);
321  virtual void opaqueSetPointIntAttribValuesFromString(
322  const char *name, const char *values, int64 length,
323  HOM_EnumValue &int_type) = 0;
324  SWIGOUT(%ignore opaqueSetPrimIntAttribValuesFromString);
325  virtual void opaqueSetPrimIntAttribValuesFromString(
326  const char *name, const char *values, int64 length,
327  HOM_EnumValue &int_type) = 0;
328  SWIGOUT(%ignore opaqueSetVertexIntAttribValuesFromString);
329  virtual void opaqueSetVertexIntAttribValuesFromString(
330  const char *name, const char *values, int64 length,
331  HOM_EnumValue &int_type) = 0;
332 
333 #ifdef SWIG
334 %extend
335 {
336  %kwargs setPointIntAttribValuesFromString;
337  void setPointIntAttribValuesFromString(
338  const char *name, InterpreterObject values,
339  HOM_EnumValue &int_type = HOM_numericData::Int32)
340  {
341  HOM_PyBuffer buffer(values);
342  self->opaqueSetPointIntAttribValuesFromString(
343  name, (const char *)buffer.myData, buffer.myLength, int_type);
344  }
345 
346  %kwargs setPrimIntAttribValuesFromString;
347  void setPrimIntAttribValuesFromString(
348  const char *name, InterpreterObject values,
349  HOM_EnumValue &int_type = HOM_numericData::Int32)
350  {
351  HOM_PyBuffer buffer(values);
352  self->opaqueSetPrimIntAttribValuesFromString(
353  name, (const char *)buffer.myData, buffer.myLength, int_type);
354  }
355 
356  %kwargs setVertexIntAttribValuesFromString;
357  void setVertexIntAttribValuesFromString(
358  const char *name, InterpreterObject values,
359  HOM_EnumValue &int_type = HOM_numericData::Int32)
360  {
361  HOM_PyBuffer buffer(values);
362  self->opaqueSetVertexIntAttribValuesFromString(
363  name, (const char *)buffer.myData, buffer.myLength, int_type);
364  }
365 }
366 #endif
367 
368  virtual void setPointStringAttribValues(
369  const char *name, const std::vector<std::string> &values) = 0;
370  virtual void setPrimStringAttribValues(
371  const char *name, const std::vector<std::string> &values) = 0;
372  virtual void setVertexStringAttribValues(
373  const char *name, const std::vector<std::string> &values) = 0;
374 
375  virtual void renamePointAttrib(const char *old_name, const char *new_name) = 0;
376  virtual void renamePrimAttrib(const char *old_name, const char *new_name) = 0;
377  virtual void renameVertexAttrib(const char *old_name, const char *new_name) = 0;
378  virtual void renameGlobalAttrib(const char *old_name, const char *new_name) = 0;
379 
380  SWIGOUT(%newobject createPoint;)
381  virtual HOM_Point *createPoint() = 0;
382  virtual std::vector<HOM_ElemPtr<HOM_Point> >createPoints(
383  const std::vector<std::vector<double> > &point_positions) = 0;
384  virtual std::vector<HOM_ElemPtr<HOM_Point> >createPoints(
385  const std::vector<HOM_Vector3 *> &point_positions) = 0;
386 
387  SWIGOUT(%newobject createPolygon;)
388  virtual HOM_Polygon *createPolygon(bool is_closed=true) = 0;
389  virtual std::vector<HOM_ElemPtr<HOM_Polygon> >createPolygons(
390  const std::vector<std::vector<HOM_Point *> > &points,
391  bool is_closed=true) = 0;
392  virtual std::vector<HOM_ElemPtr<HOM_Polygon> >createPolygons(
393  const std::vector<std::vector<int> > &point_numbers,
394  bool is_closed=true) = 0;
395 
396  SWIGOUT(%newobject createPacked;)
397  virtual HOM_PackedPrim *createPacked(
398  const char *packed_type,
399  HOM_Point *point = nullptr) = 0;
400 
401  SWIGOUT(%newobject createTetrahedron;)
402  virtual HOM_Prim *createTetrahedron() = 0;
403 
404  SWIGOUT(%newobject createTetrahedronInPlace;)
405  virtual HOM_Prim *createTetrahedronInPlace(HOM_Point *p0, HOM_Point *p1,
406  HOM_Point *p2, HOM_Point *p3) = 0;
407 
408  SWIGOUT(%newobject createHexahedron;)
409  virtual HOM_Prim *createHexahedron() = 0;
410 
411  SWIGOUT(%newobject createHexahedronInPlace;)
412  virtual HOM_Prim *createHexahedronInPlace(HOM_Point *p0, HOM_Point *p1,
413  HOM_Point *p2, HOM_Point *p3,
414  HOM_Point *p4, HOM_Point *p5,
415  HOM_Point *p6, HOM_Point *p7
416  ) = 0;
417 
418  SWIGOUT(%newobject createNURBSCurve;)
419  SWIGOUT(%kwargs createNURBSCurve;)
420  virtual HOM_Face *createNURBSCurve(int num_points=4, bool is_closed=false,
421  int order=4) = 0;
422 
423  SWIGOUT(%newobject createBezierCurve;)
424  SWIGOUT(%kwargs createBezierCurve;)
425  virtual HOM_Face *createBezierCurve(int num_points=4, bool is_closed=false,
426  int order=4) = 0;
427 
428  SWIGOUT(%newobject createNURBSSurface;)
429  SWIGOUT(%kwargs createNURBSSurface;)
430  virtual HOM_Surface *createNURBSSurface(
431  int rows, int cols,
432  bool is_closed_in_u=false, bool is_closed_in_v=false,
433  int order_u=4, int order_v=4) = 0;
434 
435  SWIGOUT(%newobject createBezierSurface;)
436  SWIGOUT(%kwargs createBezierSurface;)
437  virtual HOM_Surface *createBezierSurface(
438  int rows, int cols,
439  bool is_closed_in_u=false, bool is_closed_in_v=false,
440  int order_u=4, int order_v=4) = 0;
441 
442  SWIGOUT(%newobject createMeshSurface;)
443  SWIGOUT(%kwargs createMeshSurface;)
444  virtual HOM_Surface *createMeshSurface(
445  int rows, int cols,
446  bool is_closed_in_u=false, bool is_closed_in_v=false) = 0;
447 
448  SWIGOUT(%newobject createVolume;)
449  SWIGOUT(%kwargs createVolume;)
450  virtual HOM_Volume *createVolume(
451  int xres, int yres, int zres, HOM_BoundingBox *bounding_box=NULL) = 0;
452 
453  SWIGOUT(%newobject createChannelPrim;)
454  SWIGOUT(%kwargs createChannelPrim;)
455  virtual HOM_ChannelPrim *createChannelPrim() = 0;
456 
457  SWIGOUT(%newobject createCameraPrim;)
458  SWIGOUT(%kwargs createCameraPrim;)
459  virtual HOM_CameraPrim *createCameraPrim() = 0;
460 
461 
462  virtual void transform(HOM_Matrix4 &matrix) = 0;
463 
464  virtual void transformPrims(
465  const std::vector<HOM_Prim *> &prims, const HOM_Matrix4 &matrix) = 0;
466  virtual void transformPrims(
467  const HOM_PrimGroup &prims, const HOM_Matrix4 &matrix) = 0;
468 
469  // Swig does not allow keyword arguments for overloaded functions, so
470  // deletePrims is wrapped in houpythonportion.py to enable keyword
471  // arguments. If you want to change the signature of deletePrims, you must
472  // also edit houpythonportion.py.
473  virtual void deletePrims(
474  const std::vector<HOM_Prim *> &prims, bool keep_points = false) = 0;
475  virtual void deletePrims(
476  const HOM_PrimGroup &prims, bool keep_points = false) = 0;
477 
478  SWIGOUT(%kwargs deletePrimsOutsideBoundingBox;)
479  virtual void deletePrimsOutsideBoundingBox(
480  const HOM_BoundingBox &bbox) = 0;
481 
482  virtual void deletePoints(const std::vector<HOM_Point *> &points) = 0;
483  virtual void deletePoints(const HOM_PointGroup &points) = 0;
484 
485 
486  // Swig does not allow keyword arguments for overloaded functions, so
487  // addAttrib is wrapped in houpythonportion.py to enable keyword
488  // arguments. If you want to change the signature of addAttrib, you must
489  // also edit houpythonportion.py.
490  SWIGOUT(%newobject addAttrib;)
491  virtual HOM_Attrib *addAttrib(
492  HOM_EnumValue &type, const char *name,
493  int64 default_value,
494  bool transform_as_normal,
495  bool create_local_variable) = 0;
496 
497  virtual HOM_Attrib *addAttrib(
498  HOM_EnumValue &type, const char *name,
499  double default_value,
500  bool transform_as_normal,
501  bool create_local_variable) = 0;
502 
503  virtual HOM_Attrib *addAttrib(
504  HOM_EnumValue &type, const char *name,
505  const char *default_value,
506  bool transform_as_normal,
507  bool create_local_variable) = 0;
508 
509  virtual HOM_Attrib *addAttrib(
510  HOM_EnumValue &type,
511  const char *name,
512  const std::vector<int64> &default_value,
513  bool transform_as_normal,
514  bool create_local_variable) = 0;
515 
516  virtual HOM_Attrib *addAttrib(
517  HOM_EnumValue &type,
518  const char *name,
519  const std::vector<double> &default_value,
520  bool transform_as_normal,
521  bool create_local_variable) = 0;
522 
523  virtual HOM_Attrib *addAttrib(
524  HOM_EnumValue &type,
525  const char *name,
526  const std::vector<std::string> &default_value,
527  bool transform_as_normal,
528  bool create_local_variable) = 0;
529 
530  virtual HOM_Attrib *addAttrib(
531  HOM_EnumValue &type,
532  const char *name,
533  const std::map<std::string, hboost::any> &default_value,
534  bool transform_as_normal,
535  bool create_local_variable) = 0;
536 
537  SWIGOUT(%kwargs addArrayAttrib;)
538  SWIGOUT(%newobject addArrayAttrib;)
539  virtual HOM_Attrib *addArrayAttrib(
540  HOM_EnumValue &type, const char *name,
541  HOM_EnumValue &data_type,
542  int64 tuple_size = 1) = 0;
543 
544 
545  virtual void setGlobalAttribValue(
546  HOM_Attrib &attrib, int64 attrib_value) = 0;
547  virtual void setGlobalAttribValue(
548  HOM_Attrib &attrib, double attrib_value) = 0;
549  virtual void setGlobalAttribValue(
550  HOM_Attrib &attrib, const char *attrib_value) = 0;
551  virtual void setGlobalAttribValue(
552  HOM_Attrib &attrib, const std::vector<int64> &attrib_value) = 0;
553  virtual void setGlobalAttribValue(
554  HOM_Attrib &attrib, const std::vector<double> &attrib_value) = 0;
555  virtual void setGlobalAttribValue(
556  HOM_Attrib &attrib, const std::vector<std::string> &attrib_value) = 0;
557  virtual void setGlobalAttribValue(
558  HOM_Attrib &attrib, const std::map<std::string, hboost::any> &attrib_value) = 0;
559  virtual void setGlobalAttribValue(
560  HOM_Attrib &attrib, const std::vector<std::map<std::string,hboost::any> > &attrib_value) = 0;
561 
562  virtual void setGlobalAttribValue(
563  const char *attrib_name, int64 attrib_value) = 0;
564  virtual void setGlobalAttribValue(
565  const char *attrib_name, double attrib_value) = 0;
566  virtual void setGlobalAttribValue(
567  const char *attrib_name, const char *attrib_value) = 0;
568  // Note that, because of strangess the with way swig works when deciding
569  // which overloaded method to call, it's very important that we list the
570  // vector of ints before the vector of doubles. Otherwise, swig will call
571  // the double version when you pass in a vector of ints.
572  // It isn't that simple, the order is important but also depends on
573  // everything else in the override, so you may have to switch these
574  // until SWIG generates the right code...
575  virtual void setGlobalAttribValue(
576  const char *attrib_name, const std::vector<int64> &attrib_value) = 0;
577  virtual void setGlobalAttribValue(
578  const char *attrib_name, const std::vector<double> &attrib_value) = 0;
579  virtual void setGlobalAttribValue(
580  const char *attrib_name,
581  const std::vector<std::string> &attrib_value) = 0;
582  virtual void setGlobalAttribValue(
583  const char *attrib_name,
584  const std::map<std::string, hboost::any> &attrib_value) = 0;
585  virtual void setGlobalAttribValue(
586  const char *attrib_name,
587  const std::vector<std::map<std::string,hboost::any> > &attrib_value) = 0;
588 
589  virtual void copyAttrib(HOM_Attrib *attrib) = 0;
590  virtual void copyAttribs(const std::vector<HOM_Attrib *> &attribs) = 0;
591 
592  SWIGOUT(%kwargs copy;)
593  virtual void copy(HOM_Geometry &geometry, bool clone_data_ids = false,
594  const HOM_Selection *prims = nullptr) = 0;
595 
596  virtual void copyPoints(HOM_Geometry &geometry, const HOM_PointGroup *points = nullptr) = 0;
597  virtual void copyPrims(HOM_Geometry &geometry, const HOM_PrimGroup *prims = nullptr) = 0;
598  virtual void copyEdges(HOM_Geometry &geometry, const HOM_EdgeGroup *edges = nullptr) = 0;
599 
600  virtual int _copySelectionForDrawable(HOM_Geometry &src_geo, const HOM_Selection *sel) = 0;
601  virtual int _copyPrimsForDrawable(HOM_Geometry &src_geo, const std::vector<HOM_Prim*> &prims) = 0;
602  virtual int _copyClearForDrawable(bool keep) = 0;
603  virtual int _replaceWith(HOM_Geometry &src_geo) = 0;
604  virtual int _copyCacheTopology(HOM_Geometry &src_geo) = 0;
605 
606  virtual std::vector<HOM_ElemPtr<HOM_Point> > _getPointChildren(HOM_Point *pt) = 0;
607 #ifdef SWIG
608 %extend
609 {
610  InterpreterObject attribValue(const char *name)
611  { return HOMattribValue(*self, name); }
612 
613  InterpreterObject attribValue(HOM_Attrib &attrib)
614  { return HOMattribValue(*self, attrib); }
615 }
616 #endif
617 
618  virtual std::vector<std::string> attributeCaptureRegions() = 0;
619  virtual std::vector<std::string> attributeCaptureObjectPaths() = 0;
620 
621 
622  virtual std::vector<std::string> intrinsicNames() = 0;
623 
624  virtual hboost::any intrinsicValue(
625  const char *intrinsic_name) = 0;
626  virtual size_t intrinsicSize(const char *intrinsic_name) = 0;
627  virtual bool intrinsicReadOnly(const char *intrinsic_name) = 0;
628 
629  virtual void setIntrinsicValue(const char *intrinsic_name, double value) = 0;
630  virtual void setIntrinsicValue(const char *intrinsic_name, int value) = 0;
631  virtual void setIntrinsicValue(const char *intrinsic_name, int64 value) = 0;
632  virtual void setIntrinsicValue(
633  const char *intrinsic_name, const char *value) = 0;
634  virtual void setIntrinsicValue(
635  const char *intrinsic_name, const std::vector<double> &value) = 0;
636  virtual void setIntrinsicValue(
637  const char *intrinsic_name, const std::vector<int> &value) = 0;
638  virtual void setIntrinsicValue(
639  const char *intrinsic_name, const std::vector<int64> &value) = 0;
640  virtual void setIntrinsicValue(
641  const char *intrinsic_name, const std::vector<std::string> &value) = 0;
642 
643  virtual HOM_BinaryString data() = 0;
644  virtual void load(HOM_BinaryString data) = 0;
645 
646  virtual void saveToFile(const char *file_name) = 0;
647 
648  virtual void loadFromFile(const char *file_name) = 0;
649 
650  SWIGOUT(%kwargs merge;)
651  virtual void merge(HOM_Geometry &geometry, bool clone_data_ids = false,
652  const HOM_Selection *prims = nullptr) = 0;
653 
654  virtual void mergePoints(HOM_Geometry &geometry, const HOM_PointGroup *points = nullptr) = 0;
655  virtual void mergePrims(HOM_Geometry &geometry, const HOM_PrimGroup *prims = nullptr) = 0;
656  virtual void mergeEdges(HOM_Geometry &geometry, const HOM_EdgeGroup *edges = nullptr) = 0;
657 
658  virtual void clear() = 0;
659 
660  SWIGOUT(%kwargs intersect;)
661  virtual int intersect(
662  const HOM_Vector3 &rayorig, const HOM_Vector3 &dir,
663  HOM_Vector3 &p, HOM_Vector3 &n, HOM_Vector3 &uvw,
664  const char *pattern = nullptr, float min_hit=1e-2f, float max_hit=1e18f,
665  float tolerance=1e-2F) = 0;
666 
667  virtual std::vector<int> _orderedPoints(
668  const char *groupname,
669  const char *corner_groupname,
670  HOM_Vector2 &dimensions) = 0;
671 
672  virtual std::vector<HOM_ElemPtr<HOM_PointGroup> > pointGroups(
673  HOM_EnumValue &scope = HOM_groupScope::Public) = 0;
674 
675  SWIGOUT(%newobject findPointGroup;)
676  virtual HOM_PointGroup *findPointGroup(
677  const char *name, HOM_EnumValue &scope = HOM_groupScope::Public) = 0;
678 
679  SWIGOUT(%newobject createPointGroup;)
680  SWIGOUT(%kwargs createPointGroup;)
681  virtual HOM_PointGroup *createPointGroup(
682  const char *name,
683  bool is_ordered = false,
684  bool unique_name = false) = 0;
685 
686  virtual std::vector<HOM_ElemPtr<HOM_PrimGroup> > primGroups(
687  HOM_EnumValue &scope = HOM_groupScope::Public) = 0;
688 
689  SWIGOUT(%newobject findPrimGroup;)
690  virtual HOM_PrimGroup *findPrimGroup(
691  const char *name, HOM_EnumValue &scope = HOM_groupScope::Public) = 0;
692 
693  SWIGOUT(%newobject createPrimGroup;)
694  SWIGOUT(%kwargs createPrimGroup;)
695  virtual HOM_PrimGroup *createPrimGroup(
696  const char *name,
697  bool is_ordered = false,
698  bool unique_name = false) = 0;
699 
700  virtual std::vector<HOM_ElemPtr<HOM_EdgeGroup> > edgeGroups(
701  HOM_EnumValue &scope = HOM_groupScope::Public) = 0;
702 
703  SWIGOUT(%newobject findEdgeGroup;)
704  virtual HOM_EdgeGroup *findEdgeGroup(
705  const char *name, HOM_EnumValue &scope = HOM_groupScope::Public) = 0;
706 
707  SWIGOUT(%newobject createEdgeGroup;)
708  virtual HOM_EdgeGroup *createEdgeGroup(
709  const char *name) = 0;
710 
711  virtual std::vector<HOM_ElemPtr<HOM_VertexGroup> > vertexGroups(
712  HOM_EnumValue &scope = HOM_groupScope::Public) = 0;
713 
714  SWIGOUT(%newobject findVertexGroup;)
715  virtual HOM_VertexGroup *findVertexGroup(
716  const char *name, HOM_EnumValue &scope = HOM_groupScope::Public) = 0;
717 
718  SWIGOUT(%newobject createVertexGroup;)
719  virtual HOM_VertexGroup *createVertexGroup(
720  const char *name, bool is_ordered=false) = 0;
721 
722  SWIGOUT(%newobject findEdge;)
723  virtual HOM_Edge *findEdge(HOM_Point * p0, HOM_Point * p1) = 0;
724 
725  virtual HOM_BoundingBox boundingBox(HOM_Matrix4* transform = nullptr) = 0;
726  virtual HOM_BoundingBox pointBoundingBox(const char *ptgroup) = 0;
727  virtual HOM_BoundingBox primBoundingBox(const char *primgroup) = 0;
728 
729  virtual HOM_OrientedBoundingBox orientedBoundingBox() = 0;
730  virtual HOM_OrientedBoundingBox orientedPointBoundingBox(const char *ptgroup) = 0;
731  virtual HOM_OrientedBoundingBox orientedPrimBoundingBox(const char *primgroup) = 0;
732 
733  virtual UT_Tuple<HOM_ElemPtr<HOM_Prim>, double, double, double>
734  nearestPrim(const std::vector<double> &position) = 0;
735 
736  SWIGOUT(%newobject nearestPoint;)
737  SWIGOUT(%kwargs nearestPoint;)
738  virtual HOM_Point *
739  nearestPoint(const std::vector<double> &position,
740  const char *ptgroup = nullptr,
741  double max_radius = 1e+18f) = 0;
742 
743  SWIGOUT(%kwargs nearestPoints;)
744  virtual std::vector<HOM_ElemPtr<HOM_Point> >
745  nearestPoints(const std::vector<double> &position,
746  int64 max_points,
747  const char *ptgroup = nullptr,
748  double max_radius = 1e+18f) = 0;
749 
750  SWIGOUT(%kwargs primLoop;)
751  virtual std::vector<HOM_ElemPtr<HOM_Prim> >
752  primLoop(const std::vector<HOM_Prim *> &prims,
753  HOM_EnumValue &loop_type = HOM_componentLoopType::Partial) = 0;
754  SWIGOUT(%kwargs pointLoop;)
755  virtual std::vector<HOM_ElemPtr<HOM_Point> >
756  pointLoop(const std::vector<HOM_Point *> &points,
757  HOM_EnumValue &loop_type = HOM_componentLoopType::Partial) = 0;
758  SWIGOUT(%kwargs edgeLoop;)
759  virtual std::vector<HOM_ElemPtr<HOM_Edge> >
760  edgeLoop(const std::vector<HOM_Edge *> &edges,
761  HOM_EnumValue &loop_type = HOM_componentLoopType::Partial,
762  bool full_loop_per_edge = true,
763  bool force_ring = false,
764  bool allow_ring = true) = 0;
765 
766  virtual std::vector<HOM_Vector3>
767  pointNormals(const std::vector<HOM_Point *> &points) = 0;
768  virtual std::vector<HOM_Vector3>
769  pointNormals(const HOM_PointGroup &points) = 0;
770 
771  SWIGOUT(%newobject importLop;)
772  SWIGOUT(%kwargs importLop;)
773  virtual HOM_LopLockedStage *
774  importLop(
775  HOM_LopNode &lopnode,
776  HOM_LopSelectionRule &selection_rule,
777  const char *purpose = NULL,
778  const char *traversal = NULL,
779  const char *path_attrib_name = NULL,
780  const char *name_attrib_name = NULL,
781  bool strip_layers = false,
782  HOM_OptionalDouble frame = HOM_OptionalDouble(),
783  int lop_output_index = -1) = 0;
784 
785  SWIGOUT(%ignore importUsdStageOpaque;)
786  virtual void importUsdStageOpaque(
787  void *stage,
788  HOM_LopSelectionRule &selection_rule,
789  const char *purpose = NULL,
790  const char *traversal = NULL,
791  const char *path_attrib_name = NULL,
792  const char *name_attrib_name = NULL,
793  HOM_OptionalDouble frame = HOM_OptionalDouble()) = 0;
794 
795 #ifdef SWIG
796 %extend
797 {
798  %kwargs importUsdStage;
799  void importUsdStage(
800  InterpreterObject stage,
801  HOM_LopSelectionRule &selection_rule,
802  const char *purpose = NULL,
803  const char *traversal = NULL,
804  const char *path_attrib_name = NULL,
805  const char *name_attrib_name = NULL,
806  HOM_OptionalDouble frame = HOM_OptionalDouble())
807  {
808  return self->importUsdStageOpaque(
809  stage, selection_rule, purpose, traversal,
810  path_attrib_name, name_attrib_name, frame);
811  }
812 }
813 #endif
814 
815  SWIGOUT(%newobject selection;)
816  virtual HOM_Selection *selection() = 0;
817 
818  // This method is not documented in the user documentation. See
819  // the comments in HOMF_Geometry.C for what it does.
820  SWIGOUT(%newobject _guDetailHandle;)
821  virtual HOM_GUDetailHandle *_guDetailHandle() = 0;
822 
823  // This method is not documented in the user documentation. See the
824  // comments in HOMF_Geometry.C for what it does.
825  virtual HOMF_GeometryHandle& _geometryHandle() = 0;
826 
827  virtual std::vector<int> vexAttribDataId() = 0;
828 
829  virtual int64 modificationCounter() = 0;
830  virtual void incrementModificationCounter() = 0;
831 
832  virtual void incrementAllDataIds() = 0;
833 
834  SWIGOUT(%kwargs incrementDataIdsForAddOrRemove;)
835  virtual void incrementDataIdsForAddOrRemove(
836  bool for_points=true, bool for_prims=true) = 0;
837 
838  SWIGOUT(%newobject primitiveIntrinsicsDataId;)
839  virtual HOM_AttribDataId *primitiveIntrinsicsDataId() = 0;
840  virtual void incrementPrimitiveIntrinsicsDataId() = 0;
841 
842  SWIGOUT(%newobject topologyDataId;)
843  virtual HOM_AttribDataId *topologyDataId() = 0;
844  virtual void incrementTopologyDataId() = 0;
845 
846  SWIGOUT(%kwargs generateAttribMenu;)
847  virtual std::vector<std::string> generateAttribMenu(
848  HOM_EnumValue *attrib_type = nullptr,
849  HOM_EnumValue *data_type = nullptr,
850  int min_size = 1,
851  int max_size = -1,
852  bool array_type = true,
853  bool scalar_type = true,
854  bool case_sensitive = true,
855  const char *pattern = "*",
856  bool decode_tokens = false) = 0;
857 
858  // Wrapped in houpythonportion to handle kwargs for an overloaded method.
859  virtual std::vector<std::string> _generateGroupMenu(
860  const std::vector<HOM_EnumValue *> &group_types,
861  bool include_selection,
862  bool include_name_attrib,
863  bool case_sensitive,
864  const char *pattern,
865  bool decode_tokens,
866  HOM_Parm *parm) = 0;
867 
868  virtual bool isReadOnly() = 0;
869 
870  virtual void _attribInfo( const char *name, int &attr_data_type, int &attr_size, bool &is_array_type) = 0;
871 
872  virtual std::vector<std::string> extractPackedPaths(const char *pattern) = 0;
873  SWIGOUT(%newobject unpackFromFolder;)
874  virtual HOM_Geometry *unpackFromFolder(const char *path) = 0;
875  SWIGOUT(%newobject unpackPropertiesFromFolder;)
876  virtual std::map<std::string, hboost::any> packedFolderProperties(const char *path) = 0;
877  SWIGOUT(%kwargs packToFolder;)
878  virtual bool packToFolder(
879  const char *path,
880  HOM_Geometry &geometry,
881  bool is_folder = false,
882  bool is_visible = true,
883  bool pack = true) = 0;
884 
885  virtual bool removeFromFolder(const char *path) = 0;
886 };
887 
888 #endif
SIM_ConstraintNetwork::Names::vertex
SIM_API const UT_StringHolder vertex
HOM_BoundingBox.h
HOM_Geometry
Definition: HOM_Geometry.h:59
GT_Names::selection
GT_API const UT_StringHolder selection
nanovdb::pointCount
__hostdev__ uint64_t pointCount() const
Definition: NanoVDB.h:5974
HOM_DESTRUCT_OBJECT
#define HOM_DESTRUCT_OBJECT(pointer)
Definition: HOM_Module.h:1398
HOM_LopSelectionRule.h
points
GLdouble GLdouble GLint GLint const GLdouble * points
Definition: glad.h:2676
HOM_LopLockedStage
Definition: HOM_LopLockedStage.h:20
data
GLboolean * data
Definition: glcorearb.h:131
Filesystem::copy
OIIO_UTIL_API bool copy(string_view from, string_view to, std::string &err)
value
GLsizei const GLfloat * value
Definition: glcorearb.h:824
HOM_Vertex
Definition: HOM_Vertex.h:24
path
GLsizei const GLchar *const * path
Definition: glcorearb.h:3341
HOM_GUDetailHandle
Definition: HOM_GUDetailHandle.h:24
SWIGOUT
#define SWIGOUT(x)
Definition: HOM_Defines.h:24
HOM_Polygon
Definition: HOM_Polygon.h:17
length
GLuint GLsizei GLsizei * length
Definition: glcorearb.h:795
HOM_BinaryString
Definition: HOM_BinaryString.h:16
Vt_WrapArray::__repr__
string __repr__(VtArray< T > const &self)
Definition: wrapArray.h:312
UT_Tuple
std::tuple< Types...> UT_Tuple
Definition: UT_Tuple.h:53
HOM_VertexGroup
Definition: HOM_VertexGroup.h:26
HOM_Geometry::HOM_Geometry
HOM_Geometry()
Definition: HOM_Geometry.h:69
HOM_Module::newGeometry
virtual HOM_Geometry * newGeometry(HOM_Geometry *geo=nullptr, bool clone_data_ids=false)=0
HOM_Parm
Definition: HOM_Parm.h:34
HOM_API.h
HOM_Vector3
Definition: HOM_Vector3.h:26
buffer
GLuint buffer
Definition: glcorearb.h:660
HOM_PackedGeometry
Definition: HOM_PackedGeometry.h:18
HOM_Attrib
Definition: HOM_Attrib.h:27
HOM_Vector2
Definition: HOM_Vector2.h:24
HOM_OrientedBoundingBox
Definition: HOM_OrientedBoundingBox.h:25
HOM_LopNode.h
n
GLdouble n
Definition: glcorearb.h:2008
f
GLfloat f
Definition: glcorearb.h:1926
type
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:108
HOM_Matrix4
Definition: HOM_Matrix4.h:25
HOM_PointGroup
Definition: HOM_PointGroup.h:26
simd::any
bool any(const vbool4 &v)
Definition: simd.h:3600
HOM_API
#define HOM_API
Definition: HOM_API.h:13
HOM_Selection
Definition: HOM_Selection.h:25
HOM_Geometry::HOM_Geometry
HOM_Geometry(const HOM_Geometry &)
Definition: HOM_Geometry.h:71
HOM_Surface
Definition: HOM_Surface.h:24
VULKAN_HPP_NAMESPACE::ignore
void ignore(T const &) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:6508
HOM_BoundingBox
Definition: HOM_BoundingBox.h:25
pxr_CLI::CLI::detail::type_name
constexpr std::enable_if< I< type_count_base< T >::value, int >::type tuple_type_size(){return subtype_count< typename std::tuple_element< I, T >::type >::value+tuple_type_size< T, I+1 >);}template< typename T > struct type_count< T, typename std::enable_if< is_tuple_like< T >::value >::type >{static constexpr int value{tuple_type_size< T, 0 >)};};template< typename T > struct subtype_count{static constexpr int value{is_mutable_container< T >::value?expected_max_vector_size:type_count< T >::value};};template< typename T, typename Enable=void > struct type_count_min{static const int value{0};};template< typename T >struct type_count_min< T, typename std::enable_if<!is_mutable_container< T >::value &&!is_tuple_like< T >::value &&!is_wrapper< T >::value &&!is_complex< T >::value &&!std::is_void< T >::value >::type >{static constexpr int value{type_count< T >::value};};template< typename T > struct type_count_min< T, typename std::enable_if< is_complex< T >::value >::type >{static constexpr int value{1};};template< typename T >struct type_count_min< T, typename std::enable_if< is_wrapper< T >::value &&!is_complex< T >::value &&!is_tuple_like< T >::value >::type >{static constexpr int value{subtype_count_min< typename T::value_type >::value};};template< typename T, std::size_t I >constexpr typename std::enable_if< I==type_count_base< T >::value, int >::type tuple_type_size_min(){return 0;}template< typename T, std::size_t I > constexpr typename std::enable_if< I< type_count_base< T >::value, int >::type tuple_type_size_min(){return subtype_count_min< typename std::tuple_element< I, T >::type >::value+tuple_type_size_min< T, I+1 >);}template< typename T > struct type_count_min< T, typename std::enable_if< is_tuple_like< T >::value >::type >{static constexpr int value{tuple_type_size_min< T, 0 >)};};template< typename T > struct subtype_count_min{static constexpr int value{is_mutable_container< T >::value?((type_count< T >::value< expected_max_vector_size)?type_count< T >::value:0):type_count_min< T >::value};};template< typename T, typename Enable=void > struct expected_count{static const int value{0};};template< typename T >struct expected_count< T, typename std::enable_if<!is_mutable_container< T >::value &&!is_wrapper< T >::value &&!std::is_void< T >::value >::type >{static constexpr int value{1};};template< typename T > struct expected_count< T, typename std::enable_if< is_mutable_container< T >::value >::type >{static constexpr int value{expected_max_vector_size};};template< typename T >struct expected_count< T, typename std::enable_if<!is_mutable_container< T >::value &&is_wrapper< T >::value >::type >{static constexpr int value{expected_count< typename T::value_type >::value};};enum class object_category:int{char_value=1, integral_value=2, unsigned_integral=4, enumeration=6, boolean_value=8, floating_point=10, number_constructible=12, double_constructible=14, integer_constructible=16, string_assignable=23, string_constructible=24, other=45, wrapper_value=50, complex_number=60, tuple_value=70, container_value=80,};template< typename T, typename Enable=void > struct classify_object{static constexpr object_category value{object_category::other};};template< typename T >struct classify_object< T, typename std::enable_if< std::is_integral< T >::value &&!std::is_same< T, char >::value &&std::is_signed< T >::value &&!is_bool< T >::value &&!std::is_enum< T >::value >::type >{static constexpr object_category value{object_category::integral_value};};template< typename T >struct classify_object< T, typename std::enable_if< std::is_integral< T >::value &&std::is_unsigned< T >::value &&!std::is_same< T, char >::value &&!is_bool< T >::value >::type >{static constexpr object_category value{object_category::unsigned_integral};};template< typename T >struct classify_object< T, typename std::enable_if< std::is_same< T, char >::value &&!std::is_enum< T >::value >::type >{static constexpr object_category value{object_category::char_value};};template< typename T > struct classify_object< T, typename std::enable_if< is_bool< T >::value >::type >{static constexpr object_category value{object_category::boolean_value};};template< typename T > struct classify_object< T, typename std::enable_if< std::is_floating_point< T >::value >::type >{static constexpr object_category value{object_category::floating_point};};template< typename T >struct classify_object< T, typename std::enable_if<!std::is_floating_point< T >::value &&!std::is_integral< T >::value &&std::is_assignable< T &, std::string >::value >::type >{static constexpr object_category value{object_category::string_assignable};};template< typename T >struct classify_object< T, typename std::enable_if<!std::is_floating_point< T >::value &&!std::is_integral< T >::value &&!std::is_assignable< T &, std::string >::value &&(type_count< T >::value==1)&&std::is_constructible< T, std::string >::value >::type >{static constexpr object_category value{object_category::string_constructible};};template< typename T > struct classify_object< T, typename std::enable_if< std::is_enum< T >::value >::type >{static constexpr object_category value{object_category::enumeration};};template< typename T > struct classify_object< T, typename std::enable_if< is_complex< T >::value >::type >{static constexpr object_category value{object_category::complex_number};};template< typename T > struct uncommon_type{using type=typename std::conditional<!std::is_floating_point< T >::value &&!std::is_integral< T >::value &&!std::is_assignable< T &, std::string >::value &&!std::is_constructible< T, std::string >::value &&!is_complex< T >::value &&!is_mutable_container< T >::value &&!std::is_enum< T >::value, std::true_type, std::false_type >::type;static constexpr bool value=type::value;};template< typename T >struct classify_object< T, typename std::enable_if<(!is_mutable_container< T >::value &&is_wrapper< T >::value &&!is_tuple_like< T >::value &&uncommon_type< T >::value)>::type >{static constexpr object_category value{object_category::wrapper_value};};template< typename T >struct classify_object< T, typename std::enable_if< uncommon_type< T >::value &&type_count< T >::value==1 &&!is_wrapper< T >::value &&is_direct_constructible< T, double >::value &&is_direct_constructible< T, int >::value >::type >{static constexpr object_category value{object_category::number_constructible};};template< typename T >struct classify_object< T, typename std::enable_if< uncommon_type< T >::value &&type_count< T >::value==1 &&!is_wrapper< T >::value &&!is_direct_constructible< T, double >::value &&is_direct_constructible< T, int >::value >::type >{static constexpr object_category value{object_category::integer_constructible};};template< typename T >struct classify_object< T, typename std::enable_if< uncommon_type< T >::value &&type_count< T >::value==1 &&!is_wrapper< T >::value &&is_direct_constructible< T, double >::value &&!is_direct_constructible< T, int >::value >::type >{static constexpr object_category value{object_category::double_constructible};};template< typename T >struct classify_object< T, typename std::enable_if< is_tuple_like< T >::value &&((type_count< T >::value >=2 &&!is_wrapper< T >::value)||(uncommon_type< T >::value &&!is_direct_constructible< T, double >::value &&!is_direct_constructible< T, int >::value)||(uncommon_type< T >::value &&type_count< T >::value >=2))>::type >{static constexpr object_category value{object_category::tuple_value};};template< typename T > struct classify_object< T, typename std::enable_if< is_mutable_container< T >::value >::type >{static constexpr object_category value{object_category::container_value};};template< typename T, enable_if_t< classify_object< T >::value==object_category::char_value, detail::enabler >=detail::dummy >constexpr const char *type_name(){return"CHAR";}template< typename T, enable_if_t< classify_object< T >::value==object_category::integral_value||classify_object< T >::value==object_category::integer_constructible, detail::enabler >=detail::dummy >constexpr const char *type_name(){return"INT";}template< typename T, enable_if_t< classify_object< T >::value==object_category::unsigned_integral, detail::enabler >=detail::dummy >constexpr const char *type_name(){return"UINT";}template< typename T, enable_if_t< classify_object< T >::value==object_category::floating_point||classify_object< T >::value==object_category::number_constructible||classify_object< T >::value==object_category::double_constructible, detail::enabler >=detail::dummy >constexpr const char *type_name(){return"FLOAT";}template< typename T, enable_if_t< classify_object< T >::value==object_category::enumeration, detail::enabler >=detail::dummy >constexpr const char *type_name(){return"ENUM";}template< typename T, enable_if_t< classify_object< T >::value==object_category::boolean_value, detail::enabler >=detail::dummy >constexpr const char *type_name(){return"BOOLEAN";}template< typename T, enable_if_t< classify_object< T >::value==object_category::complex_number, detail::enabler >=detail::dummy >constexpr const char *type_name(){return"COMPLEX";}template< typename T, enable_if_t< classify_object< T >::value >=object_category::string_assignable &&classify_object< T >::value<=object_category::other, detail::enabler >=detail::dummy >constexpr const char *type_name(){return"TEXT";}template< typename T, enable_if_t< classify_object< T >::value==object_category::tuple_value &&type_count_base< T >::value >=2, detail::enabler >=detail::dummy >std::string type_name();template< typename T, enable_if_t< classify_object< T >::value==object_category::container_value||classify_object< T >::value==object_category::wrapper_value, detail::enabler >=detail::dummy >std::string type_name();template< typename T, enable_if_t< classify_object< T >::value==object_category::tuple_value &&type_count_base< T >::value==1, detail::enabler >=detail::dummy >inline std::string type_name(){return type_name< typename std::decay< typename std::tuple_element< 0, T >::type >::type >);}template< typename T, std::size_t I >inline typename std::enable_if< I==type_count_base< T >::value, std::string >::type tuple_name(){return std::string{};}template< typename T, std::size_t I >inline typename std::enable_if<(I< type_count_base< T >::value), std::string >::type tuple_name(){auto str=std::string{type_name< typename std::decay< typename std::tuple_element< I, T >::type >::type >)}+ ','+tuple_name< T, I+1 >);if(str.back()== ',') str.pop_back();return str;}template< typename T, enable_if_t< classify_object< T >::value==object_category::tuple_value &&type_count_base< T >::value >=2, detail::enabler > > std::string type_name()
Recursively generate the tuple type name.
Definition: CLI11.h:1729
apex::Geometry
ApexGeometry Geometry
Definition: APEX_Include.h:69
HOM_CONSTRUCT_OBJECT
#define HOM_CONSTRUCT_OBJECT(pointer)
Definition: HOM_Module.h:1397
HOM_LopSelectionRule
Definition: HOM_LopSelectionRule.h:24
HOM_OrientedBoundingBox.h
HOM_Edge
Definition: HOM_Edge.h:26
order
GLdouble GLdouble GLint GLint order
Definition: glad.h:2676
int64
long long int64
Definition: SYS_Types.h:116
HOM_Face
Definition: HOM_Face.h:24
HOM_Defines.h
HOM_ChannelPrim
Definition: HOM_ChannelPrim.h:22
name
GLuint const GLchar * name
Definition: glcorearb.h:786
pattern
GLushort pattern
Definition: glad.h:2583
GA_Names::transform
GA_API const UT_StringHolder transform
HOM_AttribDataId
Definition: HOM_AttribDataId.h:26
HOM_PackedPrim
Definition: HOM_PackedPrim.h:20
UT_Tuple.h
HOM_ElemPtr
Definition: HOM_ElemPtr.h:44
HOM_PrimGroup
Definition: HOM_PrimGroup.h:26
HOM_CameraPrim
Definition: HOM_CameraPrim.h:21
HOM_LopNode
Definition: HOM_LopNode.h:22
values
GLenum GLsizei GLsizei GLint * values
Definition: glcorearb.h:1602
Filesystem::rename
OIIO_UTIL_API bool rename(string_view from, string_view to, std::string &err)
HOM_Volume
Definition: HOM_Volume.h:20
HOM_Prim
Definition: HOM_Prim.h:34
HOM_Errors.h
index
GLuint index
Definition: glcorearb.h:786
SIM_ConstraintNetwork::Names::position
SIM_API const UT_StringHolder position
intersect
IMATH_CONSTEXPR14 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) IMATH_NOEXCEPT
Definition: ImathLineAlgo.h:85
HOM_EdgeGroup
Definition: HOM_EdgeGroup.h:25
HOM_OptionalDouble
UT_Optional< double > HOM_OptionalDouble
Definition: HOM_Defines.h:46
HOM_Geometry::~HOM_Geometry
virtual ~HOM_Geometry()
Definition: HOM_Geometry.h:74
openvdb::OPENVDB_VERSION_NAME::tools::merge
OutGridT XformOp bool bool MergePolicy merge
Definition: ValueTransformer.h:141
HOM_EnumValue
Definition: HOM_EnumValue.h:23
HOM_VDB
Definition: HOM_VDB.h:24
HOM
HOM_API HOM_Module & HOM()
HOM_BinaryString.h
HOM_IterableList.h
HOM_Attrib.h
data
Definition: format.h:1821
HOM_Point
Definition: HOM_Point.h:24
HOM_SopNode
Definition: HOM_SopNode.h:26