HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SOP_BrushBase.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: SOP Library (C++)
7  *
8  * COMMENTS: This is the base class for all brushes.
9  *
10  */
11 
12 #ifndef __SOP_BrushBase_h__
13 #define __SOP_BrushBase_h__
14 
15 #include "SOP_GDT.h"
16 
17 #include "SOP_API.h"
19 #include <GU/GU_Brush.h>
20 #include <GA/GA_Names.h>
21 
22 
23 class GEO_PointTree;
24 class GU_RayIntersect;
25 class GU_RayInfo;
26 class TIL_TextureMap;
27 class GEO_Primitive;
28 
29 class PRM_MenuEntry;
30 
37 };
38 
63 };
64 
69 };
70 
74 };
75 
79 };
80 
81 #define SOP_BRUSH_NUM_PENS 2
82 
84 {
85 public:
86  SOP_BrushBase(OP_Network *net, const char *name, OP_Operator *entry);
87  ~SOP_BrushBase() override;
88 
89  OP_ERROR cookInputGroups(OP_Context &context, int alone = 0) override;
90 
91  // These set functions adjust the brushes current state.
92  // The MSS State will use them to inform the SOP how to recook.
93  virtual void setAccumulateStencil(bool yesno) = 0;
94  virtual void setRayOrigin(const UT_Vector3 &orig, fpreal t) = 0;
95  virtual void setRayOrientation(const UT_Vector3 &orient, fpreal t) = 0;
96  virtual void setHitPrimitive(int primidx, fpreal t) = 0;
97  virtual void setHitPoint(int /* ptidx */, fpreal /* t */) {}
98  virtual void setHitUVW(fpreal u, fpreal v, fpreal w, fpreal t) = 0;
99  virtual void setHitPressure(fpreal pressure, fpreal t) = 0;
100  virtual void setHitInUV(bool inuv, const UT_StringHolder &uvattribname)
101  {
102  myHitInUV = inuv;
103  if (myHitInUV)
104  {
105  UT_ASSERT(uvattribname.isstring());
106  if (uvattribname.isstring())
107  myUVAttribName = uvattribname;
108  else
109  myUVAttribName = GA_Names::uv;
110  }
111  else
112  {
113  myUVAttribName = UT_StringHolder::theEmptyString;
114  }
115  }
116  virtual void setBrushEvent(SOP_BrushEvent event) = 0;
117  virtual void setBrushOp(SOP_BrushOp op) = 0;
118  virtual void setBrushShape(SOP_BrushShape shape) = 0;
119  virtual void setProjectionType(int projtype) = 0;
120  virtual void useForegroundColor() = 0;
121  virtual void useBackgroundColor() = 0;
122  // These are used to update the current radius.
123  virtual void setRadius(fpreal radius, fpreal t) = 0;
124  virtual void setUVRadius(fpreal radius, fpreal t) = 0;
125 
126  void setCachedOp(int pen, SOP_BrushOp op);
127  SOP_BrushOp getCachedOp(int pen) const { UT_ASSERT(pen < SOP_BRUSH_NUM_PENS); return myCachedBrushOp[pen]; }
128 
130  {
131  return (const GA_PrimitiveGroup*) myGroup;
132  }
133 
134  // Gets the rayintersector for this current group setup and specified time.
135  // If the checkgeo is true, it will test to see if the intersect geo
136  // has changed. We normally do NOT want to do this as rebuilding the
137  // cache is expensive if it was our own change. However, when locating
138  // or mouse down we should enable this to catch other triggers.
139  // The probeonly, if set to true, will prevent the rebuilding of
140  // the GU_RayIntersect, so may return null. This provides a fast way
141  // to update the flags needed to check if geometry changes and
142  // a rebuild is necessary later.
143  virtual GU_RayIntersect *getRayIntersect(
144  fpreal t,
145  bool checkgeochange = false,
146  bool probeonly = false);
147 
148  // Gets the GEO_PointTree for the current group setup.
149  GEO_PointTree *getPointTree();
150  /// NOTE: This is only valid if gdp hasn't been evicted/replaced,
151  /// though this was exactly as unsafe as before, when
152  /// GEO_PointTree held onto a pointer to the detail, and
153  /// MSS_EditState and MSS_BrushBaseState were accessing the
154  /// detail through there, since the GEO_PointTree didn't have
155  /// a read handle on the detail.
157  { return myGdpHandle.readLock(); }
158  void unlockPointTreeDetail(const GU_Detail *detail)
159  { myGdpHandle.unlock(detail); }
160 
161  // Gets or creates the cursor geometry:
162  GU_Detail *getCursorGdp();
163 
164  // This both orients the cursor and tracks what the current brush
165  // direction is.
166  // isuv is true if the intersection is from the UV viewport.
167  // hitu & hitv will be the parametric coordinates of the hit location
168  // on prim. prim will be null for 2d viewports (or in the 3d viewport
169  // if there was no hit)
170  void orientCursor(fpreal t, const UT_Vector3 &orig,
171  const UT_Vector3 &dir,
172  float scalehistory,
173  bool isuv, GA_Index prim,
174  float hitu, float hitv, float hitw);
175 
176  // Gets the interesction gdp.
177  virtual const GU_Detail *getIsectGdp(fpreal t);
178 
179  // The *Static methods can be hooked into buttons as callbacks to
180  // perform the listed function.
181 
182  // applyStencil will copy the current delta into the permament delta
183  // and clear the current.
184  static int applyStencilStatic(void *op, int idx, fpreal t,
185  const PRM_Template *);
186  void applyStencil(fpreal t, int recook = 1);
187 
188  // resetNormal recalculates the surface normals off the current deformed
189  // geometry.
190  static int resetNormalStatic(void *op, int idx, fpreal t,
191  const PRM_Template *);
192  void resetNormal(fpreal t);
193 
194  // flood applies the current operation (as found using OP()) to the
195  // entire selection.
196  static int floodStatic(void *op, int idx, fpreal t,
197  const PRM_Template *);
198  virtual void flood(fpreal t);
199 
200  // NOTE: There is a SOP_GDT::clearallStatic which can be used
201  // for reset all changes.
202  void clearAllDeltas(fpreal t) override;
203 
204  static void customMergeModeStatic(GA_Offset ptoff,
205  GA_Offset vtxoff,
207  const UT_Vector3 &cd,
208  const UT_Vector3 &origcol,
209  void *data);
210  void customMergeMode(GA_Offset ptoff,
211  GA_Offset vtxoff,
213  const UT_Vector3 &cd,
214  const UT_Vector3 &origcol);
215 
216  static void brushOpCallbackStatic(
217  fpreal t,
218  GA_Offset pt,
219  const UT_Array<GA_Offset> *ptneighbour,
220  GA_Offset vtx,
221  const UT_Array<GA_Offset> *vtxneighbor,
222  float alpha,
223  GEO_Delta *delta,
224  const GU_Detail *isectgdp,
225  void *data);
226  virtual void brushOpCallback(
227  fpreal t,
228  GA_Offset pt,
229  const UT_Array<GA_Offset> *ptneighbour,
230  GA_Offset vtx,
231  const UT_Array<GA_Offset> *vtxneighbour,
232  float alpha,
233  GEO_Delta *delta,
234  const GU_Detail *isectgdp);
235 
236  // Returns 1 if there is anything in the brush's accumulation buffer
237  bool hasStencil() const;
238 
239  virtual void setCurrentColor(const UT_Vector3 &cd);
240 
241  // Use our brush & visualization mode to do the visualization:
242  void applyVisualizeStencil();
243  void applyVisualize();
244  void applyCaptureVisualize();
245 
246  virtual int getIsectNodeId() const
247  {
248  return myIsectNodeId;
249  }
250  void setIsectNodeId(int node_id)
251  {
252  myIsectNodeId = node_id;
253  }
254 
255  void unloadDataHack() override;
256  bool unloadData() override;
257 
258 protected:
259  // cookMySop will apply the GDT and react to the Brush events,
260  // but you won't be able to patch in your own code.
261  OP_ERROR cookMySop(OP_Context &context) override;
262 
263  // A wrapper function for duplicateChangedSource. At this level,
264  // it simply calls duplicateChnagedSource, but can be overridden
265  // in subclasses to define attributes on the duplicated gdp
266  // (for instance)
267  virtual void duplicateChangedSourceWrapper(
268  unsigned idx,
269  OP_Context &context,
270  int *changed,
271  bool force=false);
272 
273  // Call this method do all the GDT application and brush parsing.
274  // After calling this, any current brush strokes triggerd by the
275  // brush state will be processed, and your gdp will have the result
276  // of applying the GDT.
277  // This should be called after you have duplicateSource (and/or merely
278  // did a rollback), and have created any attributes you wish.
279  // Note that as a result of this, new attributes may be created,
280  // so attribute offsets should be refetched.
281  virtual OP_ERROR processBrushOp(OP_Context &context,
282  bool changed_input, bool changed_group);
283 
284  void checkInputGroup(const GU_Detail *isectgdp);
285  void applyDab(fpreal t, GU_BrushNib *nib,
286  bool dodab, const GEO_Primitive *seed,
287  GA_Offset seedptoff,
288  const UT_Vector3 &cd,
289  float stencilval,
290  const GU_Detail *isectgdp);
291  int sendRay(GU_RayIntersect *inter,
292  const UT_Vector3 &orig,
293  const UT_Vector3 &dir,
294  GU_RayInfo &hitinfo);
295 
296  // This determines whether the given undoblock name matches one of our
297  // undoblocks. If it matches, then our undo is collapsed with this block.
298  // Remember to call the base class!
299  bool matchesUndo(
300  const char *undoname) const override;
301 
302 protected:
303  // These apply the named operation through the brush's stencil,
304  // taking into account the various unusual parameters.
305  void doDeformation(fpreal t, const UT_Vector3 &cd);
306  void doPaint(fpreal t, const UT_Vector3 &cd,
307  int enablestamping = 1);
308  virtual void doErase() = 0;
309  virtual void addEraseAttributes(GU_Brush &brush) {}
310 
311  virtual OP_Node *getRestGeoInput() { return 0; }
312 
313 public:
314  // If the action of the brush will change point positions, altersGeometry
315  // should return 1.
316  virtual int altersGeometry() const = 0;
317  // If the action of the brush will change point colours, altersColor
318  // should return 1.
319  virtual int altersColor() const = 0;
320 
321  // The RADIUS and OPACITY are defined locally as they take into
322  // account the current RAY_HITPRESSURE.
323  // The RADIUS function will also switch its output between RAWRADIUS
324  // and RAWUVRADIUS depending on the state of the brush cursor.
325  virtual fpreal RADIUS(fpreal t);
326  virtual fpreal RAWRADIUS(fpreal t) = 0;
327  virtual fpreal RAWUVRADIUS(fpreal t) = 0;
328  virtual fpreal RADIUSPRESSURE(fpreal t) = 0;
329  virtual fpreal OPACITY(fpreal t);
330  virtual fpreal RAWOPACITY(fpreal t) = 0;
331  virtual fpreal OPACITYPRESSURE(fpreal t) = 0;
332 
333  // DEPTH is how far into the surface the brush should stick,
334  // and HEIGHT is how far above.
335  virtual fpreal DEPTH(fpreal /* t */) { return 1.0; }
336  virtual fpreal HEIGHT(fpreal /* t */) { return 1.0; }
337 
338  virtual int USEDEPTH() { return 0; }
339  virtual int USECONNECTIVITY() { return 1; }
340  virtual int USENORMALS() { return 1; }
341 
342  virtual SOP_BrushOp OP() = 0;
343  virtual int ACCUMSTENCIL() = 0;
344  virtual int PROJECTIONTYPE() = 0;
345  virtual int REALTIME() = 0;
346  virtual int SHAPE(fpreal t) = 0;
347 protected:
348  virtual int MERGEMODE() = 0;
349  // Script does not yet do anything, and is reserved.
350  virtual void SCRIPT(UT_String &s, fpreal t) = 0;
351  virtual int AXIS() = 0;
352  virtual fpreal USERX(fpreal t) = 0;
353  virtual fpreal USERY(fpreal t) = 0;
354  virtual fpreal USERZ(fpreal t) = 0;
355 
356  virtual fpreal RAYORIENTX(fpreal t) = 0;
357  virtual fpreal RAYORIENTY(fpreal t) = 0;
358  virtual fpreal RAYORIENTZ(fpreal t) = 0;
359  virtual fpreal RAYHITX(fpreal t) = 0;
360  virtual fpreal RAYHITY(fpreal t) = 0;
361  virtual fpreal RAYHITZ(fpreal t) = 0;
362  virtual fpreal RAYHITU(fpreal t) = 0;
363  virtual fpreal RAYHITV(fpreal t) = 0;
364  virtual fpreal RAYHITW(fpreal t) = 0;
365  virtual fpreal RAYHITPRESSURE(fpreal t) = 0;
366  virtual int PRIMHIT(fpreal t) = 0;
367  virtual int PTHIT(fpreal /* t */) { return -1; }
368  virtual int EVENT() = 0;
369  virtual int HITINUV() { return myHitInUV; }
370  virtual UT_Vector3 BRUSHDIR(fpreal t) { return myBrushDir; }
371 
372  virtual bool USE_FOREGROUND() = 0;
373  virtual fpreal FGR(fpreal t) = 0;
374  virtual fpreal FGG(fpreal t) = 0;
375  virtual fpreal FGB(fpreal t) = 0;
376  virtual fpreal BGR(fpreal t) = 0;
377  virtual fpreal BGG(fpreal t) = 0;
378  virtual fpreal BGB(fpreal t) = 0;
379 
380  virtual fpreal SOFTEDGE(fpreal t) = 0;
381  virtual void KERNEL(UT_String &str, fpreal t) = 0;
382  virtual int UPTYPE(fpreal t) = 0;
383  virtual fpreal UPX(fpreal t) = 0;
384  virtual fpreal UPY(fpreal t) = 0;
385  virtual fpreal UPZ(fpreal t) = 0;
386 
387  virtual fpreal PAPERNOISE(fpreal t) = 0;
388  virtual fpreal SPLATTER(fpreal t) = 0;
389  virtual void BITMAP(UT_String &str, fpreal t) = 0;
390  virtual int BITMAPCHAN(fpreal t) = 0;
391  virtual fpreal ANGLE(fpreal t) = 0;
392  virtual fpreal SQUASH(fpreal t) = 0;
393  virtual int DOSTAMPING() = 0;
394  virtual int WRITEALPHA() = 0;
395  virtual int OVERRIDECD() = 0;
396  virtual void CDNAME(UT_String &str, fpreal t) = 0;
397  virtual int OVERRIDEALPHA() = 0;
398  virtual void ALPHANAME(UT_String &str, fpreal t) = 0;
399  virtual int PRESERVENML() { return 0; }
400  virtual int OVERRIDENML() = 0;
401  virtual void NMLNAME(UT_String &str, fpreal t) = 0;
402 
403  virtual fpreal SYMMETRYDIRX(fpreal t) = 0;
404  virtual fpreal SYMMETRYDIRY(fpreal t) = 0;
405  virtual fpreal SYMMETRYDIRZ(fpreal t) = 0;
406  virtual fpreal SYMMETRYORIGX(fpreal t) = 0;
407  virtual fpreal SYMMETRYORIGY(fpreal t) = 0;
408  virtual fpreal SYMMETRYORIGZ(fpreal t) = 0;
409  virtual int DOREFLECTION() = 0;
410  virtual int DOPOINTREFLECTION() { return 0; };
411  virtual int DOROTATION() = 0;
412  virtual int SYMMETRYROT(fpreal t) = 0;
413  virtual fpreal SYMMETRYDIST(fpreal t) = 0;
414 
415  virtual int DOUVREFLECTION() { return 0; }
416  virtual fpreal SYMMETRYUVORIGU(fpreal /*t*/) { return 0.5; }
417  virtual fpreal SYMMETRYUVORIGV(fpreal /*t*/) { return 0.5; }
418  virtual fpreal SYMMETRYUVANGLE(fpreal /*t*/) { return 0.0; }
419 
420  virtual int ADDATTRIB() = 0;
421  virtual void UVATTRIB(UT_String &uvattribname, fpreal t)
422  { uvattribname.clear(); }
423  virtual void UVATTRIBNAME(UT_String &uvattribname, fpreal t)
424  { uvattribname = myUVAttribName; }
425  virtual int VISUALIZE() { return 0; }
426  virtual int VISTYPE() { return 0; }
427  virtual fpreal VISLOW(fpreal /*t*/) { return 0.0; }
428  virtual fpreal VISHIGH(fpreal /*t*/) { return 1.0; }
429  virtual int VISMODE() { return 0; }
430  virtual fpreal ZEROWEIGHTCOLOR_R() { return 1.0; }
431  virtual fpreal ZEROWEIGHTCOLOR_G() { return 1.0; }
432  virtual fpreal ZEROWEIGHTCOLOR_B() { return 1.0; }
433 
434  virtual int NORMALIZEWEIGHT() { return 0; }
435 
436  virtual int USECAPTURE() { return 0; }
437  virtual int CAPTUREIDX(fpreal /*t*/) { return 0; }
440 
441  // Find out if the brush has moved or done anything to cause us to add its
442  // effect to the current gdp.
443  virtual bool hasStrokeChanged(fpreal t) = 0;
444  virtual bool hasStyleChanged (fpreal t) = 0;
445 
446  // Find if the nib file has changed:
447  virtual bool hasNibFileChanged(fpreal t) = 0;
448 
449  // Find if any of the nib description values have changed:
450  virtual bool hasNibLookChanged(fpreal t) = 0;
451  virtual bool hasAccumStencilChanged(fpreal t) = 0;
452 
453  virtual bool hasCaptureIdxChanged(fpreal /*t*/) { return 0; }
454 
455  virtual bool hasVisrangeChanged(fpreal /*t*/) { return 0; }
456 
457  // Do we want our cook selection to be updated and displayed?
458  virtual bool wantsCookSelection() const { return false; }
459 
460  void rollbackCurrentDelta() override;
462  override;
464  void applyAndClearCurrentDelta() override;
465  void applyPermanentDelta() override;
466 
467  virtual const GA_PointGroup *getPointGroup() { return 0; }
468  virtual bool isGroupParmDirty(OP_Context &context)
469  {
470  return isParmDirty(SOP_GDT_GRP_IDX, context.getTime());
471  }
472 
473  void rebuildCaches(
474  const GU_Detail *isectgdp,
475  const GA_PrimitiveGroup *primgroup,
476  const GA_PointGroup *ptgroup,
477  bool invalidate_vtx,
478  bool invalidate_pt);
479 
482 
483  // This stores the last uv location chosen in the 3d viewport.
486 
487  // This is the last uv location chosen in the 3d viewport that
488  // was cooked with.
491 
492  // This is the last uv position that was cooked with.
495 
503 
504  // These two are intentionally ephemeral variable which is NOT saved.
505  // The state tweaks this to turn on/off visualization.
508 
509  /// These track our last geo and last isectgeo to see if it has changed.
510  /// @{
520  /// @}
521 
522  // This is so our callbacks know our cook time...
524 
525  bool myHitInUV;
527 
529 
531 
532  SOP_BrushOp myCachedBrushOp[SOP_BRUSH_NUM_PENS];
533 };
534 
535 #endif
virtual void applyAndClearCurrentDelta()
SOP_BrushOp getCachedOp(int pen) const
virtual int VISMODE()
virtual int VISUALIZE()
SOP_BrushUpType
Definition: SOP_BrushBase.h:71
virtual void rollbackCurrentDelta()
Applies the inverse of myCurrentDelta to the gdp.
virtual int VISTYPE()
virtual void applyPermanentDelta()
Applies myPermanentDelta to the gdp.
virtual int USEDEPTH()
virtual fpreal ZEROWEIGHTCOLOR_R()
GU_Brush myBrush
GA_API const UT_StringHolder uv
fpreal getTime() const
Definition: OP_Context.h:59
UT_Vector3 myUVBrushPos
void unlockPointTreeDetail(const GU_Detail *detail)
virtual bool matchesUndo(const char *undoname) const
GDT_Detail myMirroredDelta
GA_Index myLastUVPrimitive
virtual void unloadDataHack()
Do not use this function! Using it will likely cause crashes.
virtual int CAPTUREIDX(fpreal)
virtual void clearAllDeltas(fpreal t)
UT_ErrorSeverity
Definition: UT_Error.h:25
virtual int USECONNECTIVITY()
TIL_TextureMap * myNibFile
GU_RayIntersect * myRayIntersect
virtual void UVATTRIB(UT_String &uvattribname, fpreal t)
int64 myLastIsectGDPPrGrpId
virtual int PRESERVENML()
virtual GEO_Detail::CaptureType CAPTURETYPE()
GLuint const GLchar * name
Definition: glcorearb.h:786
UT_Vector3 myPendingLastUVPrimitiveUV
int64 myLastIsectGDPTopoId
virtual bool wantsCookSelection() const
GLdouble GLdouble t
Definition: glew.h:1403
void clear()
Reset the string to the default constructor.
Definition: UT_String.h:302
exint GA_Size
Defines the bit width for index and offset types in GA.
Definition: GA_Types.h:234
virtual int USENORMALS()
virtual int PTHIT(fpreal)
struct _cl_event * event
Definition: glcorearb.h:2961
GLubyte GLubyte GLubyte GLubyte w
Definition: glcorearb.h:857
GA_Size GA_Offset
Definition: GA_Types.h:640
virtual bool hasCaptureIdxChanged(fpreal)
int64 myLastIsectGDPVisId
GU_Detail * myBrushCursor
GDT_MirrorTransform myMirrorTransform
virtual void rollbackCurrentDeltaElementsToInputValues()
GLuint64EXT * result
Definition: glew.h:14311
CaptureType
Methods for manipulating capture weights (GEO_CaptureWeight.C)
Definition: GEO_Detail.h:983
virtual void addEraseAttributes(GU_Brush &brush)
GA_Index myPendingLastUVPrimitive
#define SOP_BRUSH_NUM_PENS
Definition: SOP_BrushBase.h:81
virtual fpreal VISHIGH(fpreal)
static const UT_StringHolder theEmptyString
virtual fpreal ZEROWEIGHTCOLOR_B()
const GLdouble * v
Definition: glcorearb.h:837
UT_Vector3 myLastUVPrimitiveUV
int64 myLastIsectGDPPrimId
const GA_Group * myGroup
Definition: SOP_GDT.h:138
long long int64
Definition: SYS_Types.h:116
virtual fpreal SYMMETRYUVORIGV(fpreal)
SOP_BrushOp
Definition: SOP_BrushBase.h:39
virtual fpreal SYMMETRYUVANGLE(fpreal)
int64 myLastIsectGDPPtGrpId
virtual int NORMALIZEWEIGHT()
virtual void setHitPoint(int, fpreal)
Definition: SOP_BrushBase.h:97
virtual int getIsectNodeId() const
GA_Size GA_Index
Define the strictness of GA_Offset/GA_Index.
Definition: GA_Types.h:634
virtual OP_ERROR cookInputGroups(OP_Context &context, int alone=0)
virtual void setHitInUV(bool inuv, const UT_StringHolder &uvattribname)
GA_API const UT_StringHolder orient
void setIsectNodeId(int node_id)
UT_Vector3 myLastUVPos
#define SOP_GDT_GRP_IDX
Definition: SOP_GDT.h:22
virtual fpreal DEPTH(fpreal)
virtual bool hasVisrangeChanged(fpreal)
virtual fpreal ZEROWEIGHTCOLOR_G()
virtual OP_Node * getRestGeoInput()
UT_Matrix3 myCursorOrient
virtual int DOPOINTREFLECTION()
virtual void UVATTRIBNAME(UT_String &uvattribname, fpreal t)
UT_Vector3 myLastPos
virtual fpreal SYMMETRYUVORIGU(fpreal)
UT_StringHolder myUVAttribName
virtual bool isGroupParmDirty(OP_Context &context)
fpreal64 fpreal
Definition: SYS_Types.h:277
virtual const GA_PointGroup * getPointGroup()
UT_Vector3 myUVBrushDir
virtual const GA_PrimitiveGroup * getPrimitiveSelection() const
virtual fpreal VISLOW(fpreal)
GA_Size myLastIsectGDPPtCount
#define SOP_API
Definition: SOP_API.h:10
int64 myLastIsectGDPPId
virtual fpreal HEIGHT(fpreal)
const GU_Detail * lockPointTreeDetail()
virtual int HITINUV()
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:153
virtual int USECAPTURE()
virtual UT_Vector3 BRUSHDIR(fpreal t)
SOP_BrushEvent
Definition: SOP_BrushBase.h:31
virtual int DOUVREFLECTION()
SOP_BrushVisType
Definition: SOP_BrushBase.h:76
virtual OP_ERROR cookMySop(OP_Context &context)=0
SOP_BrushShape
Definition: SOP_BrushBase.h:65
GLfloat GLfloat GLfloat alpha
Definition: glcorearb.h:112
GLdouble s
Definition: glew.h:1395
UT_Vector3 myBrushDir
SYS_FORCE_INLINE bool isstring() const
Definition: format.h:895
virtual void rollbackCurrentDeltaElementsToPermanentDeltaValues()
bool isParmDirty(int idx, fpreal t)
bool unloadData() override