HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
POP_ContextData.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  */
7 
8 #ifndef __POP_ContextData_h__
9 #define __POP_ContextData_h__
10 
11 #include "POP_API.h"
12 #include <SYS/SYS_Math.h>
13 #include <UT/UT_IntArray.h>
14 #include <UT/UT_UniquePtr.h>
15 #include <UT/UT_ValArray.h>
16 #include <UT/UT_Array.h>
17 #include <UT/UT_Map.h>
18 #include <UT/UT_SymbolTable.h>
19 #include <GEO/GEO_Point.h>
20 #include <GU/GU_DetailHandle.h>
21 #include <OP/OP_Context.h>
22 #include "POP_Guide.h"
23 #include "POP_ParticleList.h"
24 
25 // ID where user variables start
26 #define POP_USER_VARIABLE 600
27 #define POP_TIMEDELTA 0.01
28 #define MAX_INPUT_GEOS 4
29 
30 class GEO_PrimParticle;
31 class GU_Detail;
32 class POP_Node;
33 class POP_UserVar;
34 class OP_Network;
35 class CH_LocalVariable;
36 class PHYS_Constraint;
37 class POP_BlindData;
39 class pop_ContextDataHandleRef;
40 
41 /// The POP_GuideHandleList provides indirect references to POP_Guide objects.
43 
46 /// A POP_ContextData encapsulates and caches data necessary to cook a POP
47 /// network. An instance is typically initialized by the entity that cooks
48 /// a POP network and passed from POP to POP as the cooking occurs.
49 ///
50 /// The POP_ContextData contains the geometry detail to update during the
51 /// cook along with many cached attribute offsets.
52 
54 {
55 public:
56  POP_ContextData (const char *owner);
57  virtual ~POP_ContextData (void);
58 
59  const char * getName() const { return myName; }
60 
61  // These methods are mainly used by classes that cook POPs (e.g.
62  // particle viewer, Pop Merge SOP, POP Network SOP).
63  //________________________________________________________________________
64 
65  // copyFrom() copies to this POP_ContextData, the state of another
66  // POP_ContextData. It will make a new copy of the geometry.
67  void copyFrom (const POP_ContextData &data,
68  GU_Detail* gdp = NULL);
69 
70  /// cook() is used to perform cooking on the POP specified by myCookPOP.
71  void cook (OP_Context& context);
72 
73  /// cookGuide() is like cook() except that it is used to recook the
74  /// guide geometry only.
75  void cookGuide (OP_Context& context);
76 
77  /// reset() is used to completely reset the POP_ContextData. It should
78  /// be called whenever a restart of the particle system is required.
79  void reset (POP_Node *pop,
80  GU_Detail *gdp,
81  const char *init,
82  bool keepgeo,
83  unsigned seed,
84  bool solveimmediately);
85 
86  /// frameReset() is used to reset some information on a per frame
87  /// basis. It should be called before an attempt to cook a POP.
88  /// However, once this is set, any number of calls to cook a POP can
89  /// be performed assuming the underlying network does not change.
90  void frameReset (void);
91 
92  /// offsetReset() resets the attribute offsets.
93  void offsetReset (void);
94 
95  /// @{
96  /// Access the context time
97  void setTime(fpreal time) { myTime = time; }
98  fpreal getTime() const { return myTime; }
99  void setTimeInc(fpreal tinc) { myTimeInc = tinc; }
100  fpreal getTimeInc() const { return myTimeInc; }
101  /// @}
102 
103  /// recacheOffset() will reacquire the attribute offsets from the gdp.
104  /// This method should be called if the offsets in the detail may have
105  /// changed, say as that result of a merge operation.
106  void recacheOffset (void);
107 
108  /// cacheMissingInternalOffsets() will acquire any attribute offsets from
109  /// the gdp that it currently has noted as missing.
110  /// @note This method does not affect user attribute offsets.
111  void cacheMissingInternalAttributes();
112 
113  // getDisplayDetail() returns the GU_Detail that corresponds to the
114  // passed in myDisplayPOP.
115  GU_Detail* getDisplayDetail (void) { return(myDisplayGdp); }
116 
117  // Marks the my own gdp as the display gdp, useful if you are
118  // setting up a POP_ContextData but haven't cooked it, so the cacheDisplay
119  // hasn't run.
120  void setDisplayToMyGdp() { myDisplayGdp = myGdp; }
121 
122  /// @name Blind Data Management
123  /// @{
124 
125  /// Return the blind data associated with the POP. If there is no data
126  /// stored for the pop, a null ptr will be returned.
127  POP_BlindData *getBlindData(const POP_Node *pop) const;
128 
129  /// Returns 1 if the data was added successfully to the context data.
130  /// At this point, the context assumes ownership of the data and may
131  /// delete it from time to time.
132  int addBlindData(POP_BlindData *data);
133 
134  /// Returns the blind data for the pop and gives up any responsiblity or
135  /// ownership of the data.
136  POP_BlindData *stealBlindData(const POP_Node *pop);
137  /// @}
138 
139  // These methods are mainly used by POPs themselves.
140  //________________________________________________________________________
141 
142  /// random() returns a random number between 0-1. This should be used
143  /// instead of SYSfastRandom() so that random numbers used within
144  /// POPs are completely deterministic.
145  float random (void);
146  /// This uses the same seed as random() but sends the result through
147  /// a hash... This is slower than random, but has the advantage
148  /// that succeeding calls produce values that are "more" independent
149  /// of each other. Specifically, if you sample a cube, you'll get a
150  /// nice distribution
151  float randomSample (void);
152 
153  unsigned getRandomSeed() const { return myFastRandomSeed; }
154 
155  /// @name GEO_PrimParticle Management
156  /// @{
157 
158  /// getPrimPart() returns the particle primitive generated by a
159  /// particular POP. If this particle doesn't exist already, it
160  /// creates a new one.
161  GEO_PrimParticle* getPrimPart (POP_Node* node);
162 
163  /// hasPrimPart() returns whether the node already has a particle
164  /// primitive assigned to it.
165  GEO_PrimParticle* hasPrimPart (POP_Node* node);
166 
167  /// getGenerator() returns the POP_Node that created a particular
168  /// particle primitive.
169  POP_Node* getGenerator (GEO_PrimParticle* part) const;
170  /// @}
171 
172  /// getDetail() returns the GU_Detail being processed by this
173  /// POP_ContextData.
174  GU_Detail* getDetail (void) const { return(myGdp); }
175 
176  /// @name Event Management
177  /// @{
178 
179  /// getEventAttr() returns the event attribute.
180  GA_RWAttributeRef getEventAttr (void);
181 
182  /// addEvent() signals that an event has occurred.
183  void addEvent (UT_String& events, float t);
184 
185  /// removeEvent() signals that an event is over.
186  void removeEvent (UT_String& events);
187 
188  /// clearAllEvents() clears any currently active events.
189  void clearAllEvents (void);
190  /// @}
191 
192  // cacheDetail() will cache the current gdp.
193  void cacheDetail (POP_Node* node);
194 
195  // addToParticleList() adds a new primitive to the stored particle
196  // list. This particle list is used to keep track of all particle
197  // primitives to be processed for timestepping.
198  void addToParticleList (GEO_PrimParticle* part,
199  POP_Node* pop, int idx);
200 
201  /// Erases the particle lists. You will need to reset() to rebuild
202  /// them, but this avoids having dangling pointers to primitives
203  /// You must clear lists if you will be losing control of the gdp
204  /// and someone else may delete primitives.
206  { myParticleList.clear(); myInitParticleList.clear(); }
207 
208  /// @name POP_Cache Reference Counting
209  /// Reference counting, used for caching in POP_Cache (through POPNET_Node)
210  /// Note that when the count reaches 0, myGdp is deleted along with this,
211  /// because in the POP_Cache a new gdp is created for each context data.
212  /// @{
213  void incRef()
214  {
215  myRefCount++;
216  }
217  void decRef()
218  {
219  myRefCount--;
220  if (!myRefCount)
221  {
222  delete myGdp;
223  delete this;
224  }
225  }
226  /// @}
227 
228  // This method is here for the use of POPNET_Node to ensure that its
229  // local contextdata has a pointer to the detail if no other method
230  // has yet been called to set it.
231  void setRefDetail(GU_Detail *gdp) { myGdp = gdp; }
232 
233  /// @name Cook Control Flags
234  /// These flags control how the pop network will cook. They globally
235  /// turn off various update rules so it is possible to, for example,
236  /// only perform the velocity update, or only perform the cooking.
237  /// @{
238  bool shouldDoReap() const { return myDoReap; }
239  void setDoReap(bool v) { myDoReap = v; }
240  bool shouldDoPrep() const { return myDoPrep; }
241  void setDoPrep(bool v) { myDoPrep = v; }
242  bool shouldDoApplyRules() const { return myDoApplyRules; }
243  void setDoApplyRules(bool v) { myDoApplyRules = v; }
244  bool shouldDoCook() const { return myDoCook; }
245  void setDoCook(bool v) { myDoCook = v; }
246  bool shouldDoCookFirst() const { return myDoCookFirst; }
247  void setDoCookFirst(bool v) { myDoCookFirst = v; }
248  /// @}
249 
250  /// Globally force the suppression of certain update rules when executing
251  /// POP_Node::applyRulesToList(). This should be a mask (bitfield) of the
252  /// relevant PART_STAT_SUPP* flags you want to suppress.
253  int getRuleSuppression() { return myRuleSuppression; }
254  /// @copydoc getRuleSuppression()
255  void setRuleSuppression(int suppress) { myRuleSuppression = suppress; }
256 
257  // getParticleList() returns the stored particle list.
258  POP_ParticleList* getParticleList (void) { return(&myParticleList); };
259 
260  /// @name Query Attribute Offsets
261  /// Methods to query cached offsets for common attributes to replace more
262  /// expensive lookups.
263  /// @{
264 #define BUILD_OFFSET_CACHE( ATTRIBNAME, TYPE ) \
265 public: \
266  const GA_RWAttributeRef &get##ATTRIBNAME##Offset () const { return my##ATTRIBNAME##Offset; } \
267  const GA_RWHandle##TYPE &get##ATTRIBNAME##Handle () const { return my##ATTRIBNAME##Handle; } \
268  void set##ATTRIBNAME##Offset (const GA_RWAttributeRef &offset) { my##ATTRIBNAME##Offset = offset; my##ATTRIBNAME##Handle.bind(offset.getAttribute()); } \
269  void clear##ATTRIBNAME##Offset () { my##ATTRIBNAME##Offset.clear(); my##ATTRIBNAME##Handle.clear(); } \
270 private: \
271  GA_RWAttributeRef my##ATTRIBNAME##Offset; \
272  GA_RWHandle##TYPE my##ATTRIBNAME##Handle; \
273 public: \
274 
276  BUILD_OFFSET_CACHE(Life, F)
277  BUILD_OFFSET_CACHE(Velocity, V3)
278  BUILD_OFFSET_CACHE(Accel, V3)
279  BUILD_OFFSET_CACHE(Backtrack, V4)
280  BUILD_OFFSET_CACHE(Born, F)
281  BUILD_OFFSET_CACHE(Source, I)
282  BUILD_OFFSET_CACHE(NextID, I)
284  BUILD_OFFSET_CACHE(AngVel, V3)
285  BUILD_OFFSET_CACHE(Attract, I)
286  BUILD_OFFSET_CACHE(Bounce, F)
287  BUILD_OFFSET_CACHE(Charge, F)
288  BUILD_OFFSET_CACHE(Cling, F)
289  BUILD_OFFSET_CACHE(Com, V3)
290  BUILD_OFFSET_CACHE(Diffuse, V3)
291  BUILD_OFFSET_CACHE(Distance, F)
292  BUILD_OFFSET_CACHE(Drag, F)
293  BUILD_OFFSET_CACHE(Follow, F)
294  BUILD_OFFSET_CACHE(FDynamic, F)
295  BUILD_OFFSET_CACHE(FStatic, F)
296  BUILD_OFFSET_CACHE(Gen, I)
297  BUILD_OFFSET_CACHE(Generator, S)
298  BUILD_OFFSET_CACHE(HitDiffuse, V3)
299  BUILD_OFFSET_CACHE(HitID, I)
300  BUILD_OFFSET_CACHE(HitForce, F)
301  BUILD_OFFSET_CACHE(HitNormal, V3)
302  BUILD_OFFSET_CACHE(HitPos, V3)
303  BUILD_OFFSET_CACHE(HitPosUV, V2)
304  BUILD_OFFSET_CACHE(HitTime, F)
305  BUILD_OFFSET_CACHE(HitUV, V2)
306  BUILD_OFFSET_CACHE(ID, I)
307  BUILD_OFFSET_CACHE(Instance, S)
308  BUILD_OFFSET_CACHE(Mass, F)
309  BUILD_OFFSET_CACHE(Nearest, I)
310  BUILD_OFFSET_CACHE(NearestDist, F)
311  BUILD_OFFSET_CACHE(Normal, V3)
312  BUILD_OFFSET_CACHE(NumHit, I)
313  BUILD_OFFSET_CACHE(NumProximity, I)
314  BUILD_OFFSET_CACHE(OrbitAxis, V3)
315  BUILD_OFFSET_CACHE(OrbitCenter, V3)
316  BUILD_OFFSET_CACHE(Orbit, F)
317  BUILD_OFFSET_CACHE(OrbitRadius, F)
318  BUILD_OFFSET_CACHE(OrbitSpeed, F)
320  BUILD_OFFSET_CACHE(Origin, I)
321  BUILD_OFFSET_CACHE(Parent, I)
323  BUILD_OFFSET_CACHE(PosPath, S)
324  BUILD_OFFSET_CACHE(PosPrim, I)
325  BUILD_OFFSET_CACHE(PosUV, V2)
326  BUILD_OFFSET_CACHE(PrevVel, V3)
327  BUILD_OFFSET_CACHE(Rest, V3)
328  BUILD_OFFSET_CACHE(Rot, Q)
329  BUILD_OFFSET_CACHE(Scale, F)
330  BUILD_OFFSET_CACHE(Scale3, V3)
331  BUILD_OFFSET_CACHE(Speed, F)
332  BUILD_OFFSET_CACHE(SpeedLimit, F)
333  BUILD_OFFSET_CACHE(SpringK, F)
334  BUILD_OFFSET_CACHE(SpriteRot, F)
335  BUILD_OFFSET_CACHE(SpriteScale, V3)
336  BUILD_OFFSET_CACHE(SpriteShop, S)
337  BUILD_OFFSET_CACHE(SpriteUV, V2)
338  BUILD_OFFSET_CACHE(Tension, F)
339  BUILD_OFFSET_CACHE(Texture, V3)
340  BUILD_OFFSET_CACHE(Trans, V3)
341  BUILD_OFFSET_CACHE(Torque, V3)
342  BUILD_OFFSET_CACHE(Up, V3)
343 
344  /// @}
345 
346  /// @name Cache Attribute Offsets
347  /// Methods to set the cached offsets for common attributes which can
348  /// later be queried to avoid more expensive lookups.
349  /// @{
350  // void setAlphaOffset (const GA_RWAttributeRef &offset) { myAlphaOffset = offset; }
351  /// @}
352 
353  /// @name User Local Variables
354  /// @{
355  CH_LocalVariable *getUserVariables (void) { return myUserVars; }
357  { return myUserVars; }
358 
359 
360  GA_RWAttributeRef addUserVariable(const char* name, int tuplesize,
362  GA_Defaults def, const char* local = 0);
363 
365  { return (index >= POP_USER_VARIABLE); }
366 
367  float getUserVariableValue (GEO_PointP ppt, int index, int thread);
368 
369  uint64 getUserVariableSerial() const { return myUserVarSerial; }
370  /// @}
371 
372  /// isGuideOnly() returns true when POP_Node::cookPop() implementations
373  /// should only update the guide geometry.
374  int isGuideOnly (void) const { return myGuideOnly; }
375 
376  /// nextId() returns the integer ID to assign to the next birthed particle.
377  /// @warning This method increments the internal state and so should only
378  /// be called when initializing the "id" attribute of a newly birthed
379  /// particle.
380  int nextID (void);
381 
382  /// bumpNumParticles() updates the running count of particles in the
383  /// network.
384  void bumpNumParticles (int delta) { myNumParticles += delta; }
385 
386  /// allowBirth() returns whether a new particle can be born.
387  int allowBirth (void);
388 
389  /// Query the path to the specified context geometry.
390  /// @param[out] path node path
391  /// @param[in] index [0 .. MAX_INPUT_GEOS-1]
392  void getInputGeo(UT_String &path, int index) const;
393  /// Set the path to the specified context geometry.
394  /// @param[in] path node path
395  /// @param[in] index [0 .. MAX_INPUT_GEOS-1]
396  void setInputGeo(const UT_String &path, int index);
397 
398  /// The following method is used to append guide geometry during a cook.
399  /// The specified GU_DetailHandle must be pointing to a POP_Guide.
400  void appendGuide(POP_Node *, const GU_DetailHandle &);
401 
402  /// The following method is used to specify the instance guide geometry
403  /// during a cook. The specified GU_DetailHandle must be pointing to a
404  /// POP_Guide.
405  void setInstanceGuide(POP_Node *, const GU_DetailHandle &);
406 
407  // Methods to set or query whether the last cook (or cookGuide) call
408  // changed the selection.
409  bool getSelectionChanged() const
410  { return mySelectionChanged; }
411  void setSelectionChanged() { mySelectionChanged = true; }
412 
413  // The following method is used mainly by expression functions.
414  //________________________________________________________________________
415 
416  /// Query the context with respect to which expression functions are to be
417  /// evaluated.
418  static POP_ContextData *getExpressionData(int thread);
419 
420  // Inputs
421  //________________________________________________________________________
422 
423  fpreal myTime; // time
424  fpreal myTimeInc; // per frame time increment
425  void* myUserData; // user data
426  int myRemoveUnused; // remove unused points flag
427  OP_Network* myXformObj; // transform object
428  POP_Node* myCookPOP; // POP to cook
429  POP_Node* myDisplayPOP; // POP to display
430  int myDoInfoButton; // compute info button text
431  int myDoUpdateViewport; // update viewport like guides.
432  int myMaxParticles; // Maximum number of particles allowed.
433 
434  // Outputs
435  //________________________________________________________________________
436 
437  // Rebuilt per cook.
438  POP_GuideHandleList myOPGuides; // guide geometries to display
439  UT_IntArray myGuidePOPs; // POPs that create guide geos
440 
442  GU_DetailHandle myInstanceOPGuide; // handle to a POP_Guide
444 
445 private:
446  void recacheUserOffset (void);
447 
448  void setupAttributes(GU_Detail *gdp);
449  void setupInitialState(GU_Detail *gdp);
450 
451  pop_ContextDataHandleRef *getIndirectHandle();
452 
453  UT_String myName;
454 
455  // Inputs
456  int myGuideOnly;
457 #ifdef INTEL_COMPILER
458  // This is a way of avoiding an internal compiler error
459  // when using Intel's compiler. In what looks like a
460  // compiler bug, it does not like an array of UT_Strings
461  // in this particular file.
462  std::vector<UT_String> myInputPaths;
463 #else
464  UT_String myInputPaths[MAX_INPUT_GEOS];
465 #endif
466 
467  // Rebuilt per cook.
468  UT_UniquePtr<GU_Detail> myCacheGdp;
469  GU_Detail* myDisplayGdp;
470 
471  // State
472  unsigned myFastRandomSeed;
473  POP_IdMap *myPrimParts;
474  POP_IdMap *myGenerators;
475  POP_IdMap *myInitPrimParts;
476  GU_Detail* myGdp;
477  POP_ParticleList myParticleList;
478  POP_ParticleList myInitParticleList;
479  float myPrevTimeInc;
480  bool mySolveImmediately;
481  bool mySelectionChanged;
482  int myNumParticles;
483 
484  // Flags controlling certain timestep behaviours. These allow
485  // us to globally turn off certain rules in the POP timestepping.
486  bool myDoPrep;
487  bool myDoReap;
488  bool myDoApplyRules;
489  bool myDoCook;
490  bool myDoCookFirst;
491 
492  // Global rule overrides. This uses the PART_STATE_SUP* flags for
493  // reference.
494  int myRuleSuppression;
495 
496  // user variables
497  //________________________________________________________________________
498 
499  CH_LocalVariable* getLocalVariable (const char* symbol);
500 
501  void resetUserVariables();
502  // The blind data flag is:
503  // 0 = bypass
504  // 1 = reset handling
505  // 2 = forced cleanup
506  void resetBlindData(int forced);
507 
508  int myUserVarSize;
509  int myUserVarEntries;
510  CH_LocalVariable* myUserVars;
511  POP_UserVarMap *myUserVarSymbols;
512  POP_UserVarMap *myUserVarIDs;
513  uint64 myUserVarSerial;
514  UT_Map<int, POP_BlindData *> *myBlindData;
515 
516  int myRefCount;
517 
518  pop_ContextDataHandleRef *myIndirectHandle;
519 
520  friend class POP_ContextDataHandle;
521 };
522 
523 inline float
525 {
526  return SYSfastRandom(myFastRandomSeed);
527 }
528 
529 inline float
531 {
532  return SYSrandom(myFastRandomSeed);
533 }
534 
535 /// A POP_ContextDataHandle is designed to allow arms length references to a
536 /// POP_ContextData. The handle is notified upon deletion of the underlying
537 /// data buffering any code using the handle from potentially dereferencing
538 /// a deleted object. This class does not provide any sort of access control
539 /// to the underlying POP_ContextData, nor does it bump the reference count
540 /// on the POP_ContextData. In other words, an active handle to a particular
541 /// POP_ContextData instance will not prevent said instance from destruction.
543 {
544 public:
548 
549  const POP_ContextDataHandle &operator=(const POP_ContextDataHandle &handle);
550 
551  /// Return a pointer to the bound data if it is still valid, 0 otherwise.
552  POP_ContextData *getContextData() const;
553 
554  /// Clear reference to any bound POP_ContextData. Equivalent to bind(0).
555  void clear();
556 
557  /// Bind to the specified data, releasing any current binding.
558  void bind(POP_ContextData *data);
559 private:
560  void setHandleRef(pop_ContextDataHandleRef *handle);
561  pop_ContextDataHandleRef *myHandle;
562 };
563 
564 /// A POP_UserVarResolveInfo caches information that can later be compared to
565 /// determine if local variable resolutions cached in compiled expressions may
566 /// no longer be valid.
568 {
569 public:
570  POP_UserVarResolveInfo() : mySerial(0) {}
571 
572  /// Update and return true if compiled expressions need to resolve local
573  /// variables again.
574  bool update(POP_ContextData *data);
575 
576 private:
577  POP_ContextDataHandle myContextData;
578  uint64 mySerial;
579 };
580 
581 #endif
bool shouldDoApplyRules() const
UT_ValArray< GEO_PointP > myInstancePoints
void setRefDetail(GU_Detail *gdp)
Class which stores the default values for a GA_Attribute.
Definition: GA_Defaults.h:35
#define POP_API
Definition: POP_API.h:10
GA_StorageClass
Definition: GA_Types.h:68
UT_SymbolMap< int > POP_IdMap
bool getSelectionChanged() const
GT_API const UT_StringHolder time
void setRuleSuppression(int suppress)
const GLdouble * v
Definition: glcorearb.h:836
uint64 getUserVariableSerial() const
GLsizei const GLchar *const * path
Definition: glcorearb.h:3340
GU_DetailHandle myInstanceOPGuide
float random(void)
void bumpNumParticles(int delta)
void setTimeInc(fpreal tinc)
void setDoPrep(bool v)
void setSelectionChanged()
unsigned getRandomSeed() const
bool shouldDoCook() const
This class provides a way to manage a reference to an attribute permitting Read-Write access...
#define BUILD_OFFSET_CACHE(ATTRIBNAME, TYPE)
unsigned long long uint64
Definition: SYS_Types.h:108
UT_IntArray myGuidePOPs
const CH_LocalVariable * getUserVariables(void) const
GU_Detail * getDetail(void) const
void setDoCookFirst(bool v)
OP_Network * myXformObj
UT_Array< GU_DetailHandle > POP_GuideHandleList
The POP_GuideHandleList provides indirect references to POP_Guide objects.
float randomSample(void)
fpreal getTime() const
GU_Detail * getDisplayDetail(void)
bool shouldDoPrep() const
GLboolean * data
Definition: glcorearb.h:130
GLuint const GLchar * name
Definition: glcorearb.h:785
#define MAX_INPUT_GEOS
void setDoCook(bool v)
void setDoReap(bool v)
double fpreal
Definition: SYS_Types.h:270
int isGuideOnly(void) const
bool shouldDoReap() const
GLuint index
Definition: glcorearb.h:785
const char * getName() const
fpreal getTimeInc() const
POP_GuideHandleList myOPGuides
POP_Node * myCookPOP
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
UT_SymbolMap< POP_UserVar * > POP_UserVarMap
POP_ParticleList * getParticleList(void)
POP_Node * myDisplayPOP
DO NOT USE THIS CLASS!!!
Definition: GEO_Point.h:389
#define POP_USER_VARIABLE
GA_API const UT_StringHolder Alpha
bool shouldDoCookFirst() const
void setTime(fpreal time)
int isUserVariable(int index)
void setDoApplyRules(bool v)