HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
VEX_GeoCommand.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  * NAME: VEX_GeoCommand.h ( VEX Library, C++)
7  *
8  * COMMENTS: Generic commands and queues to store geometry
9  * edit operations
10  */
11 
12 #ifndef __VEX_GeoCommand__
13 #define __VEX_GeoCommand__
14 
15 #include "VEX_API.h"
16 
17 #include "VEX_Types.h"
18 
19 #include <UT/UT_Array.h>
20 #include <UT/UT_SharedString.h>
21 #include <UT/UT_StringHolder.h>
22 #include <UT/UT_StringSet.h>
23 #include <UT/UT_Vector3.h>
24 #include <UT/UT_VectorTypes.h>
25 #include <UT/UT_IntArray.h>
26 #include <UT/UT_PageArray.h>
27 
28 #include <hboost/variant.hpp>
29 
30 // Do NOT use VEX_API here for template classes with all code in the header!
31 
32 enum class VEX_GeoMode
33 {
34  SET,
35  ADD,
36  MAX,
37  MIN,
38  MULTIPLY,
39  TOGGLE,
40  APPEND,
41 
42  INVALID
43 };
44 enum class VEX_GeoPrimType
45 {
46  POLY_OPEN,
48  TET,
49  SPHERE,
50  CIRCLE,
51  TUBE,
52  METABALL,
53  METASQUAD,
55  PACKEDDISK,
56 
57  INVALID
58 };
59 enum class VEX_GeoDictType
60 {
61  DETAIL,
62  PRIM,
64  PRIMGROUP,
65  POINT,
66  POINTGROUP,
67  VERTEX,
69 
70  INVALID
71 };
72 enum class VEX_GeoTypeInfo
73 {
74  NOCHANGE = -1,
75  NONE = 0,
76  POINT,
77  HPOINT,
78  VECTOR,
79  NORMAL,
80  COLOR,
81  TRANSFORM,
82  QUATERNION,
83  INDEXPAIR,
87 };
88 
89 
90 namespace VEX_Geo
91 {
92  VEX_API VEX_GeoMode modeFromString(const char*);
96 
97 } // namespace VEX_Geo
98 
100 {
101 public:
102  VEX_GeoCommand(exint srcelem) { mySourceElem = srcelem; }
103  VEX_GeoCommand(): mySourceElem(-1) {}
104 
105  exint elem() const { return mySourceElem; }
106 
107 protected:
109 };
110 
111 template <VEX_Precision PREC>
113 {
114 public:
116  : VEX_GeoCommand(srcelem)
117  , myType(primtype)
118  {
119  }
121 
122  VEX_GeoPrimType type() const { return myType; }
123 
124 protected:
126 };
127 
128 template <VEX_Precision PREC>
130 {
131 public:
133  : VEX_GeoCommand(srcelem)
134  , myPos(pos)
135  , mySrcPt(-1)
136  {
137  }
139  : VEX_GeoCommand(srcelem)
140  , myPos(0.0, 0.0, 0.0)
141  , mySrcPt(srcpt)
142  {
143  }
145 
146  VEXvec3<PREC> pos() const { return myPos; }
147  VEXint<PREC> srcpt() const { return mySrcPt; }
148 
149 protected:
150  // Ideally we'd union, but C++ makes this frustrating.
153 };
154 
155 template <VEX_Precision PREC>
157 {
158 public:
161  : VEX_GeoCommand(srcelem)
162  , myPrimNum(primnum)
163  , myPtNum(ptnum)
164  {
165  }
167 
168  VEXint<PREC> primnum() const { return myPrimNum; }
169  VEXint<PREC> ptnum() const { return myPtNum; }
170 
171 protected:
174 };
175 
176 template <VEX_Precision PREC>
178 {
179 public:
181  : VEX_GeoCommand(srcelem)
182  , myObjNum(objnum)
183  {
184  }
186 
187  VEXint<PREC> objnum() const { return myObjNum; }
188 
189 protected:
191 };
192 
193 template <VEX_Precision PREC, typename T>
195 {
196 public:
200  : VEX_GeoCommand(srcelem)
201  , myObjNum(objnum)
202  , mySecNum(secnum)
203  , myMode(mode)
204  , myData(data)
205  {
206  }
208  : myObjNum(-1)
209  , mySecNum(-1)
211  , myData(T()) {}
212 
213  VEXint<PREC> objnum() const { return myObjNum; }
214  VEXint<PREC> secnum() const { return mySecNum; }
215  VEX_GeoMode mode() const { return myMode; }
216  T data() const { return myData; }
217 
218 protected:
223 };
224 
225 template <VEX_Precision PREC>
227 {
228 public:
230  exint srcelem, VEXint<PREC> primnum,
231  VEXint<PREC> vtxidx, VEXint<PREC> newptnum)
232  : VEX_GeoCommand(srcelem)
233  , myPrimNum(primnum)
234  , myVtxIdx(vtxidx)
235  , myPtNum(newptnum)
236  {
237  }
239 
240  // -1 for primnum implies a linear vertex
241  VEXint<PREC> primnum() const { return myPrimNum; }
242  VEXint<PREC> vtxidx() const { return myVtxIdx; }
243  VEXint<PREC> ptnum() const { return myPtNum; }
244 
245 protected:
247 };
248 
249 template <VEX_Precision PREC>
251 {
252 public:
255  : VEX_GeoCommand(srcelem),
256  myPrimNum(primnum),
257  myData(SingleEdit(xform, xformidx)),
258  myWorldSpace(worldspace)
259  {
260  }
262  const UT_Array<VEXmat4<PREC>> &xforms, bool worldspace)
263  : VEX_GeoCommand(srcelem),
264  myPrimNum(primnum),
266  myWorldSpace(worldspace)
267  {
268  }
270 
271  VEXint<PREC> primnum() const { return myPrimNum; }
272  const VEXmat4<PREC> &xform() const
273  {
274  UT_ASSERT(myData.which() == 0);
275  return hboost::get<SingleEdit>(myData).first;
276  }
278  {
279  UT_ASSERT(myData.which() == 0);
280  return hboost::get<SingleEdit>(myData).second;
281  }
283  {
284  UT_ASSERT(myData.which() == 1);
285  return hboost::get<FullEdit>(myData);
286  }
287  bool worldspace() const { return myWorldSpace; }
288 
289  bool isSingleEdit() const { return myData.which() == 0; }
290 
291 protected:
292  typedef std::pair<VEXmat4<PREC>,VEXint<PREC>> SingleEdit;
294 
296  // Allow setting a single transform or setting all of them
297  hboost::variant<SingleEdit, FullEdit> myData;
299 };
300 
301 template <VEX_Precision PREC>
303 {
304 public:
306  const UT_StringArray &clipnames,
314  : VEX_GeoCommand(srcelem),
315  myPrimNum(primnum),
316  myClipNames(clipnames),
319  myClipXformGroups(clipxformgroups),
324  {
325  }
326 
327  VEX_GeoCommandAgentClipEdit() = default;
332 
333  const VEXint<PREC> primnum() const { return myPrimNum; }
334  const UT_StringArray &clipnames() const { return myClipNames; }
335  const UT_Array<VEXfloat<PREC>> &cliptimes() const { return myClipTimes; }
342 
343 protected:
353 };
354 
355 class CL_Clip;
356 
357 template <VEX_Precision PREC>
359 {
360 public:
362  exint srcelem,
364  const UT_StringHolder &clip_name,
365  const UT_StringHolder &clip_path,
366  bool keep_ref)
367  : VEX_GeoCommand(srcelem)
368  , myPrimNum(primnum)
369  , myClipName(clip_name)
370  , myClipPath(clip_path)
371  , myKeepRef(keep_ref)
372  {
373  }
375  : VEX_GeoCommand()
376  , myPrimNum(-1)
377  , myClipName()
378  , myClipPath()
379  , myKeepRef(true)
380  {
381  }
382 
383  VEXint<PREC> primnum() const { return myPrimNum; }
384 
388  bool myKeepRef;
389 };
390 
391 template <VEX_Precision PREC>
393 {
394 public:
395  //
396  // A variant of all VEXint,VEXfloat,VEXvecN,VEXmatN types
398  {
399  public:
400  DefaultValue() { memset(f, 0, sizeof(VEXfloat<PREC>)*16); i = 0; }
401 
402  void set(VEXint<PREC> v) { i = v; }
403  void set(VEXfloat<PREC> v) { f[0] = v; }
404  void set(VEXvec2<PREC> v) { memcpy(f, &v, sizeof(v)); }
405  void set(VEXvec3<PREC> v) { memcpy(f, &v, sizeof(v)); }
406  void set(VEXvec4<PREC> v) { memcpy(f, &v, sizeof(v)); }
407  void set(VEXmat2<PREC> v) { memcpy(f, &v, sizeof(v)); }
408  void set(VEXmat3<PREC> v) { memcpy(f, &v, sizeof(v)); }
409  void set(VEXmat4<PREC> v) { memcpy(f, &v, sizeof(v)); }
410 
413  };
414 
415  VEX_GeoAttribEdit(VEX_GeoDictType dict, const char *name);
417  void setTypeInfo(exint srcelem,
418  const char *typeinfo);
419 
420  void addAttribute(exint srcelem,
421  VEX_Type type,
422  bool isarray,
423  const DefaultValue &value);
424 
425  void appendEdit(exint srcelem,
426  VEXint<PREC> objnum,
427  VEXint<PREC> secnum,
430  void appendEdit(exint srcelem,
431  VEXint<PREC> objnum,
432  VEXint<PREC> secnum,
435  void appendEdit(exint srcelem,
436  VEXint<PREC> objnum,
437  VEXint<PREC> secnum,
440  void appendEdit(exint srcelem,
441  VEXint<PREC> objnum,
442  VEXint<PREC> secnum,
445  void appendEdit(exint srcelem,
446  VEXint<PREC> objnum,
447  VEXint<PREC> secnum,
450  void appendEdit(exint srcelem,
451  VEXint<PREC> objnum,
452  VEXint<PREC> secnum,
455  void appendEdit(exint srcelem,
456  VEXint<PREC> objnum,
457  VEXint<PREC> secnum,
460  void appendEdit(exint srcelem,
461  VEXint<PREC> objnum,
462  VEXint<PREC> secnum,
465  void appendEdit(exint srcelem,
466  VEXint<PREC> objnum,
467  VEXint<PREC> secnum,
469  const char *data);
470  void appendEdit(exint srcelem,
471  VEXint<PREC> objnum,
472  VEXint<PREC> secnum,
474  const UT_Array<VEXfloat<PREC>> *data);
475  void appendEdit(exint srcelem,
476  VEXint<PREC> objnum,
477  VEXint<PREC> secnum,
479  const UT_Array<VEXvec2<PREC>> *data);
480  void appendEdit(exint srcelem,
481  VEXint<PREC> objnum,
482  VEXint<PREC> secnum,
484  const UT_Array<VEXvec3<PREC>> *data);
485  void appendEdit(exint srcelem,
486  VEXint<PREC> objnum,
487  VEXint<PREC> secnum,
489  const UT_Array<VEXvec4<PREC>> *data);
490  void appendEdit(exint srcelem,
491  VEXint<PREC> objnum,
492  VEXint<PREC> secnum,
494  const UT_Array<VEXmat2<PREC>> *data);
495  void appendEdit(exint srcelem,
496  VEXint<PREC> objnum,
497  VEXint<PREC> secnum,
499  const UT_Array<VEXmat3<PREC>> *data);
500  void appendEdit(exint srcelem,
501  VEXint<PREC> objnum,
502  VEXint<PREC> secnum,
504  const UT_Array<VEXmat4<PREC>> *data);
505  void appendEdit(exint srcelem,
506  VEXint<PREC> objnum,
507  VEXint<PREC> secnum,
509  const UT_Array<VEXint<PREC>> *data);
510  void appendEdit(exint srcelem,
511  VEXint<PREC> objnum,
512  VEXint<PREC> secnum,
515 
516 
517  // This may steal the command list from the source!
518  void merge(VEX_GeoAttribEdit &src);
519 
520  void sort();
521 
522  void clear();
523 
524  // These convert our command list to the specified type.
525  //
526  // If the stored VEX_Type matches the return type, the result will be
527  // valid. Otherwise nullptr is returned.
528 
529  // Functions:
530  // fCmd, iCmd, v2Cmd, v3Cmd, v4Cmd, m2Cmd, m3Cmd, m4Cmd, sCmd
531  // afCmd, aiCmd, av2Cmd, av3Cmd, av4Cmd, am2Cmd, am3Cmd, am4Cmd, asCmd
532 #define VEX_GEOATTRIBEDIT_CASE(vtype, type, name, isarray) \
533  UT_Array<VEX_GeoCommandAttribEdit<PREC, type>> * name##Cmd()\
534  {\
535  if (myType == vtype && myIsArray == isarray)\
536  return (UT_Array<VEX_GeoCommandAttribEdit<PREC, type>>*) myCmdList;\
537  return nullptr;\
538  }
539 #define VEX_GEOATTRIBEDIT_CASE_DIRECT(ty, name) \
540  VEX_GEOATTRIBEDIT_CASE(VEX_VexTypeResolver<VEX##ty<PREC>>::type,VEX##ty<PREC>,name,false)
541 #define VEX_GEOATTRIBEDIT_CASE_ARRAY(ty, name) \
542  VEX_GEOATTRIBEDIT_CASE(VEX_VexTypeResolver<VEX##ty<PREC>>::type,const UT_Array<VEX##ty<PREC>>*,name,true)
543 
552 
554 
563 
564  VEX_GEOATTRIBEDIT_CASE(VEX_TYPE_STRING, const UT_Array<const char*>*, as, true)
565 
566 #undef VEX_GEOATTRIBEDIT_CASE_ARRAY
567 #undef VEX_GEOATTRIBEDIT_CASE_DIRECT
568 #undef VEX_GEOATTRIBEDIT_CASE
569 
570  VEX_GeoDictType dict() const { return myDict; }
571  const char *name() const { return myName; }
572  VEX_Type type() const { return myType; }
573  bool isArray() const { return myIsArray; }
574  bool shouldcreate() const { return myDoCreate; }
575  VEX_GeoTypeInfo typeinfo() const { return myTypeInfo; }
576  const DefaultValue &defaultValue() const { return myDefValue; }
577 
578 protected:
579  // The earliest proc that refered to us.
584  bool myIsArray;
585  // The proc that set the typeinfo.
586  // Because we are logically overwriting, it makes sense for this
587  // to be the last person to set it!
590 
591  void *myCmdList;
592  // The proc that marked us for creation
596 };
597 
598 template <VEX_Precision PREC>
600 {
601 public:
603  exint srcelem,
604  VEXint<PREC> ptnum0, VEXint<PREC> ptnum1,
606  : VEX_GeoCommand(srcelem)
607  , myPtNum0(ptnum0)
608  , myPtNum1(ptnum1)
609  , myData(data)
610  {
611  }
613  : VEX_GeoCommand(), myPtNum0(-1) , myPtNum1(-1), myData(-1)
614  {}
615 
616  VEXint<PREC> ptNum0() const { return myPtNum0; }
617  VEXint<PREC> ptNum1() const { return myPtNum1; }
618  VEXint<PREC> data() const { return myData; }
619 
620 protected:
624 };
625 
626 template <VEX_Precision PREC>
628 {
629 public:
630  VEX_GeoEdgeGroupEdit(const UT_StringHolder &groupname): myGroupName(groupname) {}
631 
632  const UT_StringHolder &groupName() const { return myGroupName; }
633 
634  const UT_Array<VEX_GeoCommandEdgeGroupEdit<PREC>> &cmd() const { return myCmdList; }
635 
636  void appendEdit(exint srcelem,
637  VEXint<PREC> ptnum0,
638  VEXint<PREC> ptnum1,
640 
641  void merge(VEX_GeoEdgeGroupEdit &src);
642 
643  void sort();
644 
645 protected:
648 };
649 
650 template <VEX_Precision PREC>
652 {
653 public:
656 
657  // Converts the given string to one in our string table, ensuring
658  // the pointer remains valid and avoids duplication.
659  const char *hardenString(const char *str);
660 
661  // Creates a new array which is owned by this queue. Does
662  // not de-duplicate, but will return 0 for empty lists.
663  const UT_Array<VEXfloat<PREC>> *hardenArray(const UT_Array<VEXfloat<PREC>> &arr);
664  const UT_Array<VEXvec2<PREC>> *hardenArray(const UT_Array<VEXvec2<PREC>> &arr);
665  const UT_Array<VEXvec3<PREC>> *hardenArray(const UT_Array<VEXvec3<PREC>> &arr);
666  const UT_Array<VEXvec4<PREC>> *hardenArray(const UT_Array<VEXvec4<PREC>> &arr);
667  const UT_Array<VEXmat2<PREC>> *hardenArray(const UT_Array<VEXmat2<PREC>> &arr);
668  const UT_Array<VEXmat3<PREC>> *hardenArray(const UT_Array<VEXmat3<PREC>> &arr);
669  const UT_Array<VEXmat4<PREC>> *hardenArray(const UT_Array<VEXmat4<PREC>> &arr);
670  const UT_Array<VEXint<PREC>> *hardenArray(const UT_Array<VEXint<PREC>> &arr);
671  // ALSO hardens the contents:
672  const UT_Array<const char *> *hardenArray(const UT_Array<const char *> &arr);
673 
674  // Merges the src into us. Note that the result may still
675  // reference strings in the stringtable of src, so src must *not*
676  // be deleted until the queue is processed!
677  // This also may destroy src in the merging if stealing is more
678  // efficient.
679  void merge(VEX_GeoCommandQueue &src);
680  // Ensure our commands are in srcelem order.
681  void sort();
682 
683  bool isEmpty() const
684  {
685  return myPointAdd.isEmpty() &&
686  myPrimAdd.isEmpty() &&
687  myVertexAdd.isEmpty() &&
688  myVertexRewire.isEmpty() &&
689  myAttribEdit.isEmpty() &&
690  myEdgeGroupEdit.isEmpty() &&
691  myAgentXformEdit.isEmpty() &&
692  myAgentClipEdit.isEmpty() &&
693  myAgentAddClip.isEmpty() &&
694  myPointRemove.isEmpty() &&
695  myPointWithPrimRemove.isEmpty() &&
696  myPrimRemove.isEmpty() &&
697  myPrimWithPointRemove.isEmpty() &&
698  myLocalVariables.empty() &&
699  !myNewVisualizers;
700  }
701 
702  // These return the new element number *relative* to the srcelem!
703  VEXint<PREC> addPrim(exint srcelem, VEX_GeoPrimType primtype);
704  VEXint<PREC> addPoint(exint srcelem, VEXvec3<PREC> pos);
705  VEXint<PREC> addPoint(exint srcelem, VEXint<PREC> srcpt);
706  VEXint<PREC> addVertex(exint srcelem, VEXint<PREC> primnum,
707  VEXint<PREC> ptnum);
708 
709  void setEdgeGroup(
710  exint srcelem,
711  const UT_StringHolder &groupname,
712  VEXint<PREC> ptnum0, VEXint<PREC> ptnum1,
714 
715  void addLocalVariable(exint srcelem, const char *attrib, const char *local);
716  void addVisualizer(const UT_StringHolder &visualizer);
717 
718  // If the given primnum is -1, it will treat vtxidx as a linear vertex
719  void rewireVertex( exint srcelem, VEXint<PREC> primum,
720  VEXint<PREC> vtxidx, VEXint<PREC> ptnum);
721 
722  void removePoint(exint srcelem, VEXint<PREC> ptnum, bool includeprims);
723  void removePrim(exint srcelem, VEXint<PREC> primnum, bool includepoints);
724 
725  void setAgentTransform(exint srcelem, VEXint<PREC> primnum,
726  const VEXmat4<PREC> &xform, VEXint<PREC> xformidx,
727  bool worldspace);
728 
729  void setAgentTransforms(exint srcelem, VEXint<PREC> primnum,
730  const UT_Array<VEXmat4<PREC>> &xforms,
731  bool worldspace);
732 
733  void setAgentClips(exint srcelem, VEXint<PREC> primnum,
734  const UT_StringArray &clipnames,
735  const UT_Array<VEXfloat<PREC>> &cliptimes,
736  const UT_Array<VEXfloat<PREC>> &clipweights,
737  const UT_StringArray &clipxformgroups,
738  const UT_Array<VEXint<PREC>> &cliplayerids,
739  const UT_Array<VEXint<PREC>> &cliplayermodes,
740  const UT_Array<VEXfloat<PREC>> &cliplayerweights,
741  const UT_Array<VEXint<PREC>> &cliplayerparents);
742 
743  void agentAddClip(
744  exint srcelem,
745  VEXint<PREC> primnum,
746  const UT_StringHolder &clip_name,
747  const UT_StringHolder &clip,
748  const bool keep_ref);
749 
750  VEX_GeoAttribEdit<PREC> *findEdit( VEX_GeoDictType dict, const char *name);
751  VEX_GeoAttribEdit<PREC> *findOrCreateEdit( VEX_GeoDictType dict,
752  const char *name);
753 
754  VEX_GeoEdgeGroupEdit<PREC> *findOrCreateEdgeGroupEdit(
755  const UT_StringHolder &groupname);
756 
757  // Creators
761  // Requested local variables.
763  {
765  const char *local; // hardened!
766  };
768 
770 
771  // Edits
778 
779  // Destructors
780  // Note we don't have to sort these. We do need to track
781  // the source element to be able to lookup the relevant point
782  // or primitive number, however.
787 
788  typedef UT_PageArray<
789  /* DATA_T */ VEXint<PREC>,
790  /* TSIZE */ 1,
791  /* TABLEHARDENED (owns its data) */ true,
792  /* PAGESHARDENED */ false,
793  /* THEPAGEBITS (2^10 tuples/page) */ 10,
794  /* INDEX_T */ exint
799 
800  exint myNumPrim, myNumPoint, myNumVertex;
801 
802 private:
803  UT_SharedString *myStrings;
804  UT_Array< UT_Array<VEXint<PREC>> *> myIntArrays;
805  UT_Array< UT_Array<VEXfloat<PREC>> *> myFloatArrays;
806  UT_Array< UT_Array<VEXvec2<PREC>> *> myV2Arrays;
807  UT_Array< UT_Array<VEXvec3<PREC>> *> myV3Arrays;
808  UT_Array< UT_Array<VEXvec4<PREC>> *> myV4Arrays;
809  UT_Array< UT_Array<VEXmat2<PREC>> *> myM2Arrays;
810  UT_Array< UT_Array<VEXmat3<PREC>> *> myM3Arrays;
811  UT_Array< UT_Array<VEXmat4<PREC>> *> myM4Arrays;
812  UT_Array< UT_Array<const char *> *> myCstArrays;
813 };
814 
821 
822 #endif
exint elem() const
VEX_GeoCommandAgentAddClip(exint srcelem, VEXint< PREC > primnum, const UT_StringHolder &clip_name, const UT_StringHolder &clip_path, bool keep_ref)
VEX_Type
VEX variable types.
Definition: VEX_VexTypes.h:18
UT_Array< VEX_GeoCommandPrimAdd< PREC > > myPrimAdd
GLint first
Definition: glcorearb.h:404
const UT_Array< VEXfloat< PREC > > & clipweights() const
#define VEX_GEOATTRIBEDIT_CASE_ARRAY(ty, name)
UT_Array< VEX_GeoCommandAgentXformEdit< PREC > > myAgentXformEdit
const char * local
VEXint< PREC > primnum() const
VEX_GeoCommandAgentXformEdit(exint srcelem, VEXint< PREC > primnum, const UT_Array< VEXmat4< PREC >> &xforms, bool worldspace)
void set(VEXvec4< PREC > v)
UT_StringMap< VariableEntry > myLocalVariables
UT_Array< VEX_GeoEdgeGroupEdit< PREC > * > myEdgeGroupEdit
const UT_Array< VEXint< PREC > > & cliplayerids() const
const char * name() const
bool isArray() const
VEX_GeoDictType myDict
BlockArray myNetVertices
UT_PageArray< VEXint< PREC >, 1, true, false, 10, exint > BlockArray
std::pair< VEXmat4< PREC >, VEXint< PREC > > SingleEdit
const GLdouble * v
Definition: glcorearb.h:836
VEXint< PREC > objnum() const
DefaultValue myDefValue
VEXint< PREC > primnum() const
VEX_GeoCommandAttribEdit(exint srcelem, VEXint< PREC > objnum, VEXint< PREC > secnum, VEX_GeoMode mode, T data)
VEX_GeoDictType dict() const
VEX_GeoEdgeGroupEdit(const UT_StringHolder &groupname)
UT_Array< VEX_GeoCommandEdgeGroupEdit< PREC > > myCmdList
UT_StringSet * myNewVisualizers
UT_Array< VEXfloat< PREC > > myClipTimes
VEX_API VEX_GeoPrimType typeFromString(const char *)
UT_Array< VEXint< PREC > > myClipLayerIds
VEX_GeoCommandPrimAdd(exint srcelem, VEX_GeoPrimType primtype)
VEXint< PREC > ptnum() const
VEX_GeoCommandPointAdd(exint srcelem, VEXint< PREC > srcpt)
void set(VEXvec3< PREC > v)
#define VEX_GEOATTRIBEDIT_CASE_DIRECT(ty, name)
GLfloat GLfloat GLfloat v2
Definition: glcorearb.h:817
#define VEX_API
Definition: VEX_API.h:12
const UT_StringHolder & groupName() const
GLfloat GLfloat GLfloat GLfloat v3
Definition: glcorearb.h:818
typename VEX_PrecisionResolver< P >::vec3_type VEXvec3
Definition: VEX_PodTypes.h:70
exint elem
png_uint_32 i
Definition: png.h:2877
UT_Array< VEX_GeoCommandObjectRemove< PREC > > myPrimRemove
VEXint< PREC > primnum() const
#define VEX_GEOATTRIBEDIT_CASE(vtype, type, name, isarray)
VEXint< PREC > data() const
UT_Array< VEXmat4< PREC > > FullEdit
UT_Array< VEXint< PREC > > myClipLayerParents
bool isEmpty() const
VEX_GeoDictType
UT_Array< VEX_GeoCommandAgentClipEdit< PREC > > myAgentClipEdit
VEX_GeoCommandEdgeGroupEdit(exint srcelem, VEXint< PREC > ptnum0, VEXint< PREC > ptnum1, VEXint< PREC > data)
VEX_GeoTypeInfo
GLfloat f
Definition: glcorearb.h:1925
VEXint< PREC > xformidx() const
VEX_GeoMode mode() const
UT_StringHolder myGroupName
bool shouldcreate() const
const UT_Array< VEX_GeoCommandEdgeGroupEdit< PREC > > & cmd() const
VEX_GeoCommand(exint srcelem)
VEX_GeoCommandAgentXformEdit(exint srcelem, VEXint< PREC > primnum, const VEXmat4< PREC > &xform, VEXint< PREC > xformidx, bool worldspace)
int64 exint
Definition: SYS_Types.h:116
typename VEX_PrecisionResolver< P >::float_type VEXfloat
Definition: VEX_PodTypes.h:67
VEX_GeoMode
VEXint< PREC > myPrimNum
const DefaultValue & defaultValue() const
UT_Array< VEX_GeoCommandPointAdd< PREC > > myPointAdd
VEXint< PREC > srcpt() const
VEX_GeoPrimType myType
VEX_GeoTypeInfo typeinfo() const
typename VEX_PrecisionResolver< P >::mat4_type VEXmat4
Definition: VEX_PodTypes.h:74
const VEXmat4< PREC > & xform() const
GLboolean * data
Definition: glcorearb.h:130
GLuint const GLchar * name
Definition: glcorearb.h:785
hboost::variant< SingleEdit, FullEdit > myData
void set(VEXmat2< PREC > v)
VEXint< PREC > ptNum0() const
VEX_GeoCommandObjectRemove(exint srcelem, VEXint< PREC > objnum)
VEXint< PREC > ptNum1() const
const UT_Array< VEXint< PREC > > & cliplayermodes() const
GLenum mode
Definition: glcorearb.h:98
VEX_API VEX_GeoMode modeFromString(const char *)
const UT_StringArray & clipnames() const
typename VEX_PrecisionResolver< P >::mat2_type VEXmat2
Definition: VEX_PodTypes.h:72
VEXint< PREC > primnum() const
void set(VEXmat4< PREC > v)
GLsizei const GLfloat * value
Definition: glcorearb.h:823
VEX_GeoCommandAgentClipEdit(exint srcelem, VEXint< PREC > primnum, const UT_StringArray &clipnames, const UT_Array< VEXfloat< PREC >> &cliptimes, const UT_Array< VEXfloat< PREC >> &clipweights, const UT_StringArray &clipxformgroups, const UT_Array< VEXint< PREC >> &cliplayerids, const UT_Array< VEXint< PREC >> &cliplayermodes, const UT_Array< VEXfloat< PREC >> &cliplayerweights, const UT_Array< VEXint< PREC >> &cliplayerparents)
IMATH_INTERNAL_NAMESPACE_HEADER_ENTER T clip(const T &p, const Box< T > &box)
Definition: ImathBoxAlgo.h:89
typename VEX_PrecisionResolver< P >::vec2_type VEXvec2
Definition: VEX_PodTypes.h:69
VEX_GeoCommandPointAdd(exint srcelem, VEXvec3< PREC > pos)
const UT_Array< VEXfloat< PREC > > & cliplayerweights() const
VEX_EXTERN_TEMPLATE(VEX_GeoAttribEdit< VEX_32 >)
VEXint< PREC > ptnum() const
UT_Array< VEX_GeoCommandVertexAdd< PREC > > myVertexAdd
UT_Array< VEXint< PREC > > myClipLayerModes
UT_Array< VEXfloat< PREC > > myClipLayerWeights
void set(VEXint< PREC > v)
const UT_Array< VEXmat4< PREC > > & xforms() const
UT_Array< VEX_GeoCommandObjectRemove< PREC > > myPointWithPrimRemove
VEXvec3< PREC > myPos
VEX_GeoPrimType type() const
void set(VEXfloat< PREC > v)
UT_Array< VEX_GeoCommandVertexRewire< PREC > > myVertexRewire
VEXint< PREC > mySrcPt
UT_Array< VEX_GeoCommandObjectRemove< PREC > > myPrimWithPointRemove
typename VEX_PrecisionResolver< P >::vec4_type VEXvec4
Definition: VEX_PodTypes.h:71
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
UT_Array< VEXfloat< PREC > > myClipWeights
typename VEX_PrecisionResolver< P >::int_type VEXint
Definition: VEX_PodTypes.h:68
VEXint< PREC > vtxidx() const
VEX_API VEX_GeoDictType dictFromString(const char *)
VEX_GeoCommandVertexAdd(exint srcelem, VEXint< PREC > primnum, VEXint< PREC > ptnum)
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:126
const VEXint< PREC > primnum() const
VEX_GeoPrimType
const UT_Array< VEXfloat< PREC > > & cliptimes() const
UT_Array< VEX_GeoCommandAgentAddClip< PREC > > myAgentAddClip
#define const
Definition: zconf.h:214
VEX_GeoTypeInfo myTypeInfo
VEXint< PREC > objnum() const
const UT_Array< VEXint< PREC > > & cliplayerparents() const
typename VEX_PrecisionResolver< P >::mat3_type VEXmat3
Definition: VEX_PodTypes.h:73
VEXvec3< PREC > pos() const
UT_Array< VEX_GeoAttribEdit< PREC > * > myAttribEdit
UT_Array< VEX_GeoCommandObjectRemove< PREC > > myPointRemove
VEX_Type type() const
VEX_GeoCommandAgentClipEdit & operator=(const VEX_GeoCommandAgentClipEdit &)=default
VEX_GeoCommandVertexRewire(exint srcelem, VEXint< PREC > primnum, VEXint< PREC > vtxidx, VEXint< PREC > newptnum)
void set(VEXmat3< PREC > v)
const UT_StringArray & clipxformgroups() const
void set(VEXvec2< PREC > v)
UT_StringArray myClipXformGroups
GLenum src
Definition: glcorearb.h:1792
VEX_API VEX_GeoTypeInfo typeinfoFromString(const char *)
VEXint< PREC > secnum() const