HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
SOP_BrushHairLen.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2018
3  * Side Effects Software Inc. All rights reserved.
4  *
5  * Redistribution and use of Houdini Development Kit samples in source and
6  * binary forms, with or without modification, are permitted provided that the
7  * following conditions are met:
8  * 1. Redistributions of source code must retain the above copyright notice,
9  * this list of conditions and the following disclaimer.
10  * 2. The name of Side Effects Software may not be used to endorse or
11  * promote products derived from this software without specific prior
12  * written permission.
13  *
14  * THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE `AS IS' AND ANY EXPRESS
15  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
17  * NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
19  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
20  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
21  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
22  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
23  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  *
25  *----------------------------------------------------------------------------
26  */
27 
28 #ifndef __SOP_BrushHairLen__
29 #define __SOP_BrushHairLen__
30 
31 #include <SOP/SOP_Node.h>
32 #include <SOP/SOP_BrushBase.h>
33 
34 namespace HDK_Sample {
36 {
37 public:
38  SOP_BrushHairLen(OP_Network *net, const char *, OP_Operator *entry);
39  virtual ~SOP_BrushHairLen();
40 
41  static OP_Node *myConstructor(OP_Network *net, const char *name,
42  OP_Operator *entry);
44 
45  /// This is the callback triggered when a BRUSHOP_CALLBACK is used:
46  void brushOpCallback(
47  GA_Offset pt,
48  const UT_Array<GA_Offset> *ptneighbour,
49  GA_Offset vtx,
50  const UT_Array<GA_Offset> *vtxneighbour,
51  float alpha,
52  GEO_Delta *delta);
53 
54 protected:
55  virtual OP_ERROR cookMySop (OP_Context &context);
56 
57  /// These are the many & various methods used by BrushBase to
58  /// determine the current brush status. We can either hook them
59  /// up to parameters (via evalFloat) or hard code them. In this
60  /// case we have hard coded most.
61 
62  /// Public methods needed by MSS:
63 public:
64  /// Finds the geometry to do the intersection with.
65  const GU_Detail *getIsectGdp(fpreal t);
66 
67  /// If the action of the brush will change point positions,
68  /// we should set this to 1. We create geometry, but leave point
69  /// positions untouched.
70  virtual int altersGeometry() const
71  { return 0; }
72  /// We do attribute changes.
73  virtual int altersColor() const
74  { return 1; }
75  /// This gets the current radius of the brush, unmodulated by the
76  /// current pressure amount.
77  virtual fpreal RAWRADIUS(fpreal t)
78  { return evalFloat("radius", 0, t); }
79  /// This gets the raw radius for the UV space.
81  { return evalFloat("uvradius", 0, t); }
82  /// This is how much the HITPRESSURE should affect the RADIUS.
83  virtual fpreal RADIUSPRESSURE(fpreal /*t*/)
84  { return 1.0f; }
85  /// The opacity, hardcoded to 1.0f, for a full replace
86  virtual fpreal RAWOPACITY(fpreal /*t*/)
87  { return 1.0f; }
88  virtual fpreal OPACITYPRESSURE(fpreal /*t*/)
89  { return 1.0f; }
90 
91  /// This is how far along the brush axis it will be able to paint.
92  /// We tie it directly to the raidus here.
93  virtual fpreal DEPTH(fpreal t)
94  { return evalFloat("radius", 0, t); }
95  virtual fpreal HEIGHT(fpreal t)
96  { return evalFloat("radius", 0, t); }
97  /// Whether to use depth clipping at all.
98  virtual int USEDEPTH()
99  { return 1; }
100  /// Whether to not paint across unconnected seams. We are using depth
101  /// clipping in this tool, so have it off.
102  virtual int USECONNECTIVITY()
103  { return 0; }
104 
105  /// This needs to map our OP_Menu into SOP_BrushOp. We leave this
106  /// to the C code.
107  virtual SOP_BrushOp OP();
108 
109  /// Whether accumulate stencil is currently on. We keep it off.
110  virtual int ACCUMSTENCIL()
111  { return 0; }
112  /// Projection Type 1 is orient to surface, 0 is to use it flat on.
113  /// We hard code it to flat on.
114  virtual int PROJECTIONTYPE()
115  { return 0; }
116  /// In realtime mode, all changes are applied immediately to the
117  /// gdp, rather than being stored in the CurrentDelta during a brush
118  /// stroke. Some types of brushing require this behaviour implicitly.
119  virtual int REALTIME()
120  { return 1; }
121  /// This returns a SOP_BrushShape. We hardcode to circle.
122  virtual int SHAPE(fpreal /*t*/)
123  { return SOP_BRUSHSHAPE_CIRCLE; }
124 
125  /// Protected methods needed by SOP_BrushBase:
126 protected:
127  /// This returns a GU_BrushMergeMode, defined in GU_Brush.h
128  /// We just use the standard replace.
129  virtual int MERGEMODE()
130  { return GU_BRUSHMERGEMODE_REPLACE; }
131 
132  /// Not used:
133  virtual void SCRIPT(UT_String & /*s*/, fpreal /*t*/)
134  { }
135 
136  /// These are used by deformation brush ops:
137  virtual int AXIS()
138  { return 0; }
139  virtual fpreal USERX(fpreal /*t*/)
140  { return 0.0f; }
141  virtual fpreal USERY(fpreal /*t*/)
142  { return 0.0f; }
143  virtual fpreal USERZ(fpreal /*t*/)
144  { return 0.0f; }
145 
146  /// These query the current raystate. We read off the cached values...
147  virtual fpreal RAYORIENTX(fpreal /*t*/)
148  { return myRayOrient.x(); }
149  virtual fpreal RAYORIENTY(fpreal /*t*/)
150  { return myRayOrient.y(); }
151  virtual fpreal RAYORIENTZ(fpreal /*t*/)
152  { return myRayOrient.z(); }
153  virtual fpreal RAYHITX(fpreal /*t*/)
154  { return myRayHit.x(); }
155  virtual fpreal RAYHITY(fpreal /*t*/)
156  { return myRayHit.y(); }
157  virtual fpreal RAYHITZ(fpreal /*t*/)
158  { return myRayHit.z(); }
159  virtual fpreal RAYHITU(fpreal /*t*/)
160  { return myRayHitU; }
161  virtual fpreal RAYHITV(fpreal /*t*/)
162  { return myRayHitV; }
163  virtual fpreal RAYHITW(fpreal /*t*/)
164  { return myRayHitW; }
165  virtual fpreal RAYHITPRESSURE(fpreal /*t*/)
166  { return myRayHitPressure; }
167  virtual int PRIMHIT(fpreal /*t*/)
168  { return myPrimHit; }
169  virtual int PTHIT(fpreal /*t*/)
170  { return myPtHit; }
171  virtual int EVENT()
172  { return myEvent; }
173 
174  /// These query the current "colours" of the brush...
175  /// F is for foreground, B, for background. Up to a 3 vector is
176  /// possible in the order R, G, B.
177  /// If USE_FOREGROUND is true, the F will be used, otherwise B.
178  virtual bool USE_FOREGROUND()
179  { return myUseFore; }
180  virtual fpreal FGR(fpreal t)
181  { return evalFloat("flen", 0, t); }
182  virtual fpreal FGG(fpreal /*t*/)
183  { return 0.0f; }
184  virtual fpreal FGB(fpreal /*t*/)
185  { return 0.0f; }
186  virtual fpreal BGR(fpreal t)
187  { return evalFloat("blen", 0, t); }
188  virtual fpreal BGG(fpreal /*t*/)
189  { return 0.0f; }
190  virtual fpreal BGB(fpreal /*t*/)
191  { return 0.0f; }
192 
193  /// These control the shape of the nib. We have hard coded
194  /// most of them...
195  /// What percentage of the radius to devote to the fall off curve.
196  virtual fpreal SOFTEDGE(fpreal /*t*/)
197  { return 1.0f; }
198  /// Which metaball kernel to use as the fall off curve.
199  virtual void KERNEL(UT_String &str, fpreal /*t*/)
200  { str = "Elendt"; }
201  /// How to determine the upvector, unnecessary with circular brushes.
202  virtual int UPTYPE(fpreal /*t*/)
203  { return 0; }
204  virtual fpreal UPX(fpreal /*t*/)
205  { return 0.0f; }
206  virtual fpreal UPY(fpreal /*t*/)
207  { return 0.0f; }
208  virtual fpreal UPZ(fpreal /*t*/)
209  { return 0.0f; }
210 
211  /// Alpha noise in the paper space
212  virtual fpreal PAPERNOISE(fpreal /*t*/)
213  { return 0.0f; }
214  /// Alpha noise in the brush space
215  virtual fpreal SPLATTER(fpreal /*t*/)
216  { return 0.0f; }
217  /// Name of the bitmap to use if bitmap brush is on, which it isn't.
218  virtual void BITMAP(UT_String & /*str*/, fpreal /*t*/)
219  { }
220  /// Which channel of the bitmap brush should be used.
221  virtual int BITMAPCHAN(fpreal /*t*/)
222  { return 0; }
223  /// More hard coded stuff directly from the Nib tab...
224  virtual fpreal ANGLE(fpreal /*t*/)
225  { return 0.0f; }
226  virtual fpreal SQUASH(fpreal /*t*/)
227  { return 1.0f; }
228  virtual int DOSTAMPING()
229  { return 0; }
230  virtual int WRITEALPHA()
231  { return 0; }
232  /// We explicitly override these parameters as we want the brush
233  /// to automatically edit our "hairlen" point attribute.
234  virtual int OVERRIDECD()
235  { return 1; }
236  virtual void CDNAME(UT_String &str, fpreal /*t*/)
237  { str = "hairlen"; }
238  /// As WRITEALPHA is off, this is irrelevant:
239  virtual int OVERRIDEALPHA()
240  { return 0; }
241  virtual void ALPHANAME(UT_String & /*str*/, fpreal /*t*/)
242  { }
243  /// For Comb style brushes, this preserves the normal length.
244  virtual int PRESERVENML()
245  { return 0; }
246  /// For Comb style brushes this allows overriding the normal attribute.
247  virtual int OVERRIDENML()
248  { return 0; }
249  virtual void NMLNAME(UT_String & /*str*/, fpreal /*t*/)
250  { }
251 
252  /// These methods are used to get the current symmetry operations
253  /// that are enabled with the brush. We don't use any of them here.
254  virtual int DOREFLECTION()
255  { return 0; }
256  virtual int DOROTATION()
257  { return 0; }
258  virtual fpreal SYMMETRYDIRX(fpreal /*t*/)
259  { return 0.0f; }
260  virtual fpreal SYMMETRYDIRY(fpreal /*t*/)
261  { return 0.0f; }
262  virtual fpreal SYMMETRYDIRZ(fpreal /*t*/)
263  { return 0.0f; }
264  virtual fpreal SYMMETRYORIGX(fpreal /*t*/)
265  { return 0.0f; }
266  virtual fpreal SYMMETRYORIGY(fpreal /*t*/)
267  { return 0.0f; }
268  virtual fpreal SYMMETRYORIGZ(fpreal /*t*/)
269  { return 0.0f; }
270  virtual int SYMMETRYROT(fpreal /*t*/)
271  { return 0; }
272  virtual fpreal SYMMETRYDIST(fpreal /*t*/)
273  { return 0.0f; }
274 
275  /// This determines if the Cd or Normal should be auto-added.
276  /// We have it off as we add it by hand in our cook.
277  virtual int ADDATTRIB()
278  { return 0; }
279  /// This determines if visualization will occur.
280  virtual int VISUALIZE()
281  { return 0; }
282  virtual int VISTYPE()
283  { return 0; }
284  virtual fpreal VISLOW(fpreal /*t*/)
285  { return 0.0f; }
286  virtual fpreal VISHIGH(fpreal /*t*/)
287  { return 1.0f; }
288  virtual int VISMODE()
289  { return 0; }
291  { return 1.0f; }
293  { return 1.0f; }
295  { return 1.0f; }
296 
297  /// This is used by capture brushes to determine if they should
298  /// normalize the weights.
299  virtual int NORMALIZEWEIGHT()
300  { return 0; }
301 
302  /// Should return true if this brush will affect capture regions.
303  virtual int USECAPTURE()
304  { return 0; }
305  /// Returns the capture region to brush for such brushes.
306  virtual int CAPTUREIDX(fpreal /*t*/)
307  { return 0; }
308 
309  /// These determine if the relevant parameters have changed. They are
310  /// often used to determine when to invalidate internal caches.
311 
312  /// hasStrokeChanged should return true if any of the setHit* were called,
313  /// as it will cause a new dab to be applied.
314  virtual bool hasStrokeChanged(fpreal /*t*/)
315  { return myStrokeChanged; }
316  /// This should return true if the style of the brush changed, specifically
317  /// the foreground or background colours. We test this trhough isParmDirty
318  /// in the C code.
319  virtual bool hasStyleChanged(fpreal t);
320  /// This determines if the nib file changed. We don't have a nib file.
321  virtual bool hasNibFileChanged(fpreal /*t*/)
322  { return false; }
323  /// This returns true if any nib parameters (such as shape, etc) have
324  /// changed since the last cook.
325  virtual bool hasNibLookChanged(fpreal /*t*/)
326  { return false; }
327  /// This returns true if the type of accumulation mode changed.
328  virtual bool hasAccumStencilChanged(fpreal /*t*/)
329  { return false; }
330  /// This returns true if the capture index has changed.
331  virtual bool hasCaptureIdxChanged(fpreal /*t*/)
332  { return false; }
333  /// This return strue if the visualization range has changed.
334  virtual bool hasVisrangeChanged(fpreal /*t*/)
335  { return false; }
336 
337  /// If this returns true, the selection will be cooked as the
338  /// group. We don't want that, so return false.
339  virtual bool wantsCookSelection() const
340  { return false; }
341 
342  /// public methods used by MSS level to write to this level:
343  /// The usual brush ops (such as Paint, etc) will set parameters
344  /// with these values. We just cache them locally here.
345 public:
346  /// We are locking off accumulate stencil (ACCUMSTENCIL) so can
347  /// ignore attempts to turn it on.
348  virtual void setAccumulateStencil(bool /*yesno*/) {}
349  virtual void setRayOrigin(const UT_Vector3 &orig, fpreal /*t*/)
350  { myRayHit = orig; myStrokeChanged = true; forceRecook(); }
351  virtual void setRayOrientation(const UT_Vector3 &orient, fpreal /*t*/)
352  { myRayOrient = orient; myStrokeChanged = true; forceRecook(); }
353  virtual void setHitPrimitive(int primidx, fpreal /*t*/)
354  { myPrimHit = primidx; myStrokeChanged = true; forceRecook(); }
355  virtual void setHitPoint(int ptidx, fpreal /*t*/)
356  { myPtHit = ptidx; myStrokeChanged = true; forceRecook(); }
357  virtual void setHitUVW(fpreal u, fpreal v, fpreal w, fpreal /*t*/)
358  {
359  myRayHitU = u;
360  myRayHitV = v;
361  myRayHitW = w;
362  myStrokeChanged = true;
363  forceRecook();
364  }
365  virtual void setHitPressure(fpreal pressure, fpreal /*t*/)
366  { myRayHitPressure = pressure; myStrokeChanged = true; forceRecook(); }
368  { myEvent = event; myStrokeChanged = true; forceRecook(); }
369  /// This one must map from SOP_BrushOp into our own op menu.
370  /// Thus it is left to the C file.
371  virtual void setBrushOp(SOP_BrushOp op);
372  /// As we are always returning CIRCLE for SHAPE(), we ignore
373  /// requests to change the brush shape.
374  virtual void setBrushShape(SOP_BrushShape /*shape*/) {}
375  /// As we are locking projection type to not orient to surface,
376  /// we can ignore these change requests (see PROJECTIONTYPE)
377  virtual void setProjectionType(int /*projtype*/) {}
378  virtual void useForegroundColor()
379  { myUseFore = true; }
380  virtual void useBackgroundColor()
381  { myUseFore = false; }
382  /// This is used by the eyedropper to write into the current colour
383  /// field.
384  virtual void setCurrentColor(const UT_Vector3 &cd)
385  {
386  setFloat(myUseFore ? "flen" : "blen", 0, 0, cd.x());
387  }
388 
389  /// This is used to update the radii from the state:
390  virtual void setRadius(fpreal r, fpreal t)
391  {
392  setFloat("radius", 0, t, r);
393  }
394  virtual void setUVRadius(fpreal r, fpreal t)
395  {
396  setFloat("uvradius", 0, t, r);
397  }
398 
399 protected:
400  /// This method handles the erase callback relevant to this type
401  /// of brush.
402  virtual void doErase();
403 
404 private:
405  /// Here we cache the current ray hit values...
406  UT_Vector3 myRayOrient, myRayHit;
407  float myRayHitU, myRayHitV, myRayHitW;
408  float myRayHitPressure;
409  int myPrimHit;
410  int myPtHit;
411  int myEvent;
412  bool myUseFore;
413  bool myStrokeChanged;
414 
415 
416  /// These are cached for the brushop callback to know the attribute
417  /// indices.
418  bool myHairlenFound;
419  GA_RWHandleF myHairlenHandle;
420  fpreal myTime;
421 };
422 } // End HDK_Sample namespace
423 
424 #endif
virtual fpreal ZEROWEIGHTCOLOR_B()
virtual void setProjectionType(int)
virtual fpreal FGR(fpreal t)
virtual void SCRIPT(UT_String &, fpreal)
Not used:
virtual fpreal USERY(fpreal)
virtual fpreal SYMMETRYDIST(fpreal)
virtual fpreal SYMMETRYDIRZ(fpreal)
virtual fpreal BGG(fpreal)
void brushOpCallback(GA_Offset pt, const UT_Array< GA_Offset > *ptneighbour, GA_Offset vtx, const UT_Array< GA_Offset > *vtxneighbour, float alpha, GEO_Delta *delta)
This is the callback triggered when a BRUSHOP_CALLBACK is used:
virtual bool hasCaptureIdxChanged(fpreal)
This returns true if the capture index has changed.
virtual fpreal RAYHITX(fpreal)
const GLdouble * v
Definition: glcorearb.h:836
virtual void setHitUVW(fpreal u, fpreal v, fpreal w, fpreal)
virtual fpreal RAWRADIUS(fpreal t)
virtual fpreal ANGLE(fpreal)
More hard coded stuff directly from the Nib tab...
virtual fpreal PAPERNOISE(fpreal)
Alpha noise in the paper space.
virtual void setRadius(fpreal r, fpreal t)
This is used to update the radii from the state:
virtual int altersGeometry() const
virtual int altersColor() const
We do attribute changes.
virtual void forceRecook(bool evensmartcache=true)
virtual void setBrushEvent(SOP_BrushEvent event)
fpreal evalFloat(int pi, int vi, fpreal t) const
virtual int PRESERVENML()
For Comb style brushes, this preserves the normal length.
UT_ErrorSeverity
Definition: UT_Error.h:25
virtual fpreal SPLATTER(fpreal)
Alpha noise in the brush space.
virtual bool hasStyleChanged(fpreal t)
virtual fpreal SYMMETRYDIRX(fpreal)
virtual fpreal SYMMETRYORIGY(fpreal)
virtual fpreal RAYHITW(fpreal)
virtual void setRayOrigin(const UT_Vector3 &orig, fpreal)
virtual fpreal UPY(fpreal)
virtual fpreal VISHIGH(fpreal)
SYS_FORCE_INLINE T & x(void)
Definition: UT_Vector3.h:581
virtual void setBrushOp(SOP_BrushOp op)
virtual fpreal SOFTEDGE(fpreal)
virtual bool hasVisrangeChanged(fpreal)
This return strue if the visualization range has changed.
virtual void KERNEL(UT_String &str, fpreal)
Which metaball kernel to use as the fall off curve.
virtual int VISUALIZE()
This determines if visualization will occur.
virtual fpreal FGG(fpreal)
struct _cl_event * event
Definition: glcorearb.h:2960
virtual int ACCUMSTENCIL()
Whether accumulate stencil is currently on. We keep it off.
virtual int BITMAPCHAN(fpreal)
Which channel of the bitmap brush should be used.
virtual void setRayOrientation(const UT_Vector3 &orient, fpreal)
GA_Size GA_Offset
Definition: GA_Types.h:617
SYS_FORCE_INLINE T & z(void)
Definition: UT_Vector3.h:585
virtual fpreal BGR(fpreal t)
virtual void setUVRadius(fpreal r, fpreal t)
virtual fpreal SYMMETRYORIGZ(fpreal)
virtual fpreal SYMMETRYORIGX(fpreal)
virtual bool wantsCookSelection() const
virtual bool hasNibFileChanged(fpreal)
This determines if the nib file changed. We don't have a nib file.
static OP_Node * myConstructor(OP_Network *net, const char *name, OP_Operator *entry)
virtual fpreal BGB(fpreal)
virtual fpreal RAYHITPRESSURE(fpreal)
void setFloat(int parmi, int vectori, fpreal t, fpreal value, int h=0)
virtual fpreal RAYHITU(fpreal)
virtual void setHitPoint(int ptidx, fpreal)
virtual fpreal SQUASH(fpreal)
virtual int MERGEMODE()
Protected methods needed by SOP_BrushBase:
virtual void setCurrentColor(const UT_Vector3 &cd)
virtual void ALPHANAME(UT_String &, fpreal)
virtual void setHitPrimitive(int primidx, fpreal)
virtual void NMLNAME(UT_String &, fpreal)
GLfloat GLfloat GLfloat alpha
Definition: glcorearb.h:111
SOP_BrushOp
Definition: SOP_BrushBase.h:38
virtual int CAPTUREIDX(fpreal)
Returns the capture region to brush for such brushes.
virtual void setBrushShape(SOP_BrushShape)
virtual fpreal OPACITYPRESSURE(fpreal)
virtual fpreal RAYHITY(fpreal)
GLuint const GLchar * name
Definition: glcorearb.h:785
virtual fpreal FGB(fpreal)
virtual int USEDEPTH()
Whether to use depth clipping at all.
virtual fpreal ZEROWEIGHTCOLOR_R()
GA_API const UT_StringHolder orient
virtual fpreal RAYHITZ(fpreal)
virtual fpreal RAYORIENTZ(fpreal)
virtual int USECAPTURE()
Should return true if this brush will affect capture regions.
static PRM_Template myTemplateList[]
SYS_FORCE_INLINE T & y(void)
Definition: UT_Vector3.h:583
double fpreal
Definition: SYS_Types.h:263
virtual void setHitPressure(fpreal pressure, fpreal)
virtual fpreal ZEROWEIGHTCOLOR_G()
virtual fpreal USERZ(fpreal)
virtual fpreal UPX(fpreal)
virtual void CDNAME(UT_String &str, fpreal)
virtual fpreal RAYHITV(fpreal)
virtual fpreal VISLOW(fpreal)
virtual int SYMMETRYROT(fpreal)
virtual fpreal SYMMETRYDIRY(fpreal)
virtual void BITMAP(UT_String &, fpreal)
Name of the bitmap to use if bitmap brush is on, which it isn't.
virtual fpreal DEPTH(fpreal t)
virtual int UPTYPE(fpreal)
How to determine the upvector, unnecessary with circular brushes.
virtual fpreal HEIGHT(fpreal t)
virtual bool hasNibLookChanged(fpreal)
virtual fpreal RAYORIENTX(fpreal)
These query the current raystate. We read off the cached values...
GLubyte GLubyte GLubyte GLubyte w
Definition: glcorearb.h:856
virtual bool hasStrokeChanged(fpreal)
SOP_BrushEvent
Definition: SOP_BrushBase.h:30
GLboolean r
Definition: glcorearb.h:1221
virtual fpreal USERX(fpreal)
virtual int OVERRIDENML()
For Comb style brushes this allows overriding the normal attribute.
SOP_BrushShape
Definition: SOP_BrushBase.h:62
virtual void setAccumulateStencil(bool)
virtual fpreal UPZ(fpreal)
virtual SOP_BrushOp OP()
const GU_Detail * getIsectGdp(fpreal t)
Public methods needed by MSS:
virtual int AXIS()
These are used by deformation brush ops:
virtual fpreal RAYORIENTY(fpreal)
virtual fpreal RAWUVRADIUS(fpreal t)
This gets the raw radius for the UV space.
virtual fpreal RADIUSPRESSURE(fpreal)
This is how much the HITPRESSURE should affect the RADIUS.
SOP_BrushHairLen(OP_Network *net, const char *, OP_Operator *entry)
virtual int SHAPE(fpreal)
This returns a SOP_BrushShape. We hardcode to circle.
virtual fpreal RAWOPACITY(fpreal)
The opacity, hardcoded to 1.0f, for a full replace.
virtual OP_ERROR cookMySop(OP_Context &context)
virtual int OVERRIDEALPHA()
As WRITEALPHA is off, this is irrelevant:
virtual bool hasAccumStencilChanged(fpreal)
This returns true if the type of accumulation mode changed.