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