HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
RU_PixelFunctions.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: RU_PixelFunctions.h
7  *
8  * COMMENTS:
9  * Defines simple functions on a pixel value that may be chained together.
10  */
11 #ifndef RU_PixelFunctions_h
12 #define RU_PixelFunctions_h
13 
14 #include "RU_API.h"
15 #include <SYS/SYS_Math.h>
16 #include <UT/UT_Matrix4.h>
17 #include <PXL/PXL_Lookup.h>
18 #include <CL/CL_Clip.h>
19 #include "RU_PixelFunction.h"
20 
21 class UT_ComputeGPU;
22 
23 // ----------------------------------------------------------------------
24 // Simple scalar functions.
25 
27 {
28 public:
29  RU_AddFunc(float addend) : myAddend(addend) {}
30 protected:
31  static float add(RU_PixelFunction *pf, float val, int)
32  { return val +((RU_AddFunc*)pf)->myAddend; }
33 
34  virtual RUPixelFunc getPixelFunction() const { return add; }
35  virtual void getPixelShader(UT_String &frag_shader);
36 
37  float myAddend;
38 };
39 
40 
42 {
43 public:
44  RU_MultFunc(float fact) : myFactor(fact) {}
45 protected:
46  static float mult(RU_PixelFunction *pf, float val, int)
47  { return val * ((RU_MultFunc*)pf)->myFactor; }
48 
49  virtual RUPixelFunc getPixelFunction() const { return mult; }
50  virtual void getPixelShader(UT_String &frag_shader);
51 
52  float myFactor;
53 };
54 
56 {
57 public:
58  RU_MAddFunc(float fact, float add);
59  RU_MAddFunc(float fact[4], float add[4]);
60 
61 protected:
62  static float madd(RU_PixelFunction *pf, float val, int comp)
63  { return val * ((RU_MAddFunc*)pf)->myFactor[comp]
64  + ((RU_MAddFunc*)pf)->myAddend[comp]; }
65 
66  virtual RUPixelFunc getPixelFunction() const { return madd; }
67  virtual void getPixelShader(UT_String &frag_shader);
68 
69  virtual bool eachComponentDifferent() const { return myCompSep; }
70 
71  bool myCompSep;
72  float myFactor[4], myAddend[4];
73 };
74 
76 {
77 public:
78  RU_ScaleFunc(float scale, float pivot)
79  : myScale(scale), myPivot(pivot) {}
80 
81 protected:
82  static float scale(RU_PixelFunction *pf, float val, int )
83  { return (val - ((RU_ScaleFunc*)pf)->myPivot)
84  * ((RU_ScaleFunc*)pf)->myScale
85  + ((RU_ScaleFunc*)pf)->myPivot; }
86 
87  virtual RUPixelFunc getPixelFunction() const { return scale; }
88  virtual void getPixelShader(UT_String &frag_shader);
89 
90  float myScale, myPivot;
91 };
92 
93 
95 {
96 public:
97  RU_GammaFunc(float g) : myCompSep(false)
98  { float ig = 1.0f / g; myInvGamma[0] = myInvGamma[1] =
99  myInvGamma[2] = myInvGamma[3] = ig; }
100 
101  RU_GammaFunc(float r, float g, float b, float w)
102  : myCompSep(true)
103  { myInvGamma[0] = 1.0f / r; myInvGamma[1] = 1.0f / g;
104  myInvGamma[2] = 1.0f/ b; myInvGamma[3] = 1.0f / w; }
105 protected:
106  static float gamma(RU_PixelFunction *pf, float val, int);
107  static float gamma(float val, float g);
108 
109  virtual bool eachComponentDifferent() const { return myCompSep; }
110  virtual RUPixelFunc getPixelFunction() const { return gamma; }
111  virtual void getPixelShader(UT_String &frag_shader);
112 
113  float myInvGamma[4];
114  bool myCompSep;
115 };
116 
117 
119 {
120 public:
121 
122  RU_LimitFunc(bool lower, float lval, bool upper, float uval, bool clamp)
123  : myLClip(lower),
124  myUClip(upper),
125  myClamp(clamp),
126  myLLimit(lval),
127  myULimit(uval) {}
128 
129 protected:
130  static float limit(RU_PixelFunction *pf, float val, int);
131 
132  virtual RUPixelFunc getPixelFunction() const { return limit; }
133  virtual void getPixelShader(UT_String &frag_shader);
134 
135  unsigned char myLClip:1,
136  myUClip:1,
137  myClamp:1;
138  float myLLimit, myULimit;
139 };
140 
141 
143 {
144 public:
145  RU_QuantizeFunc(float step, float offset)
146  : myStep(step), myOffset(offset) {}
147 
148 protected:
149  static float quantize(RU_PixelFunction *pf, float val, int);
150  virtual RUPixelFunc getPixelFunction() const { return quantize; }
151  virtual void getPixelShader(UT_String &frag_shader);
152 
153  float myStep, myOffset;
154 };
155 
156 // ------------------------------------------------------------------------
157 // Vector based functions.
158 
160 {
161 public:
163 
164 protected:
165  static void luminance(RU_PixelFunction *f, float **vals,
166  const bool *scope);
167 
168  virtual bool needAllComponents() const { return true; }
169  virtual RUVectorFunc getVectorFunction() const { return luminance; }
170  virtual void getPixelShader(UT_String &frag_shader);
171 };
172 
174 {
175 public:
177 
178 protected:
179  static void luminance(RU_PixelFunction *f, float **vals,
180  const bool *scope);
181 
182  virtual bool needAllComponents() const { return true; }
183  virtual RUVectorFunc getVectorFunction() const { return luminance; }
184  virtual void getPixelShader(UT_String &frag_shader);
185 };
186 
187 
189 {
190 public:
192 
193 protected:
194  static void hue(RU_PixelFunction *f, float **vals,
195  const bool *scope);
196 
197  virtual bool needAllComponents() const { return true; }
198  virtual RUVectorFunc getVectorFunction() const { return hue; }
199  virtual void getPixelShader(UT_String &frag_shader);
200 
201 };
202 
203 
205 {
206 public:
208 
209 protected:
210  static void saturation(RU_PixelFunction *f, float **vals,
211  const bool *scope);
212 
213  virtual bool needAllComponents() const { return true; }
214  virtual RUVectorFunc getVectorFunction() const { return saturation; }
215  virtual void getPixelShader(UT_String &frag_shader);
216 };
217 
218 
220 {
221 public:
223 
224 protected:
225  static void maxfunc(RU_PixelFunction *f, float **vals,
226  const bool *scope);
227 
228  virtual bool needAllComponents() const { return true; }
229  virtual RUVectorFunc getVectorFunction() const { return maxfunc; }
230  virtual void getPixelShader(UT_String &frag_shader);
231 };
232 
233 
235 {
236 public:
238 
239 protected:
240  static void minfunc(RU_PixelFunction *f, float **vals,
241  const bool *scope);
242 
243  virtual bool needAllComponents() const { return true; }
244  virtual RUVectorFunc getVectorFunction() const { return minfunc; }
245  virtual void getPixelShader(UT_String &frag_shader);
246 };
247 
248 
250 {
251 public:
253 
254 protected:
255  static void average(RU_PixelFunction *f, float **vals,
256  const bool *scope);
257 
258  virtual bool needAllComponents() const { return true; }
259  virtual RUVectorFunc getVectorFunction() const { return average; }
260  virtual void getPixelShader(UT_String &frag_shader);
261 };
262 
263 
265 {
266 public:
268 
269 protected:
270  static void length(RU_PixelFunction *f, float **vals,
271  const bool *scope);
272 
273  virtual bool needAllComponents() const { return true; }
274  virtual RUVectorFunc getVectorFunction() const { return length; }
275  virtual void getPixelShader(UT_String &frag_shader);
276 };
277 
279 {
280 public:
281  RU_ComponentFunc(int comp) : myComponent(comp) {}
282 
283 protected:
284  static void component(RU_PixelFunction *f, float **vals,
285  const bool *scope);
286 
287  virtual bool needAllComponents() const { return true; }
288  virtual RUVectorFunc getVectorFunction() const { return component; }
289  virtual void getPixelShader(UT_String &frag_shader);
290 
292 };
293 
294 
296 {
297 public:
299 
300 protected:
301  static void normalize(RU_PixelFunction *f, float **vals,
302  const bool *scope);
303 
304  virtual bool needAllComponents() const { return true; }
305  virtual RUVectorFunc getVectorFunction() const { return normalize; }
306  virtual void getPixelShader(UT_String &frag_shader);
307 };
308 
310 {
311 public:
315  ADJUST_HSV
316  };
317 
318  RU_HSVConvertFunc(RU_HSVConvertOp op, float hues = 0.0f,
319  float *sat = 0, float *val = 0, bool maintain_lum = true)
320  : myHSVOp(op),
321  myHueShift(hues),
322  mySatScale(sat?sat[0]:1.0f),
323  mySatShift(sat?sat[1]:0.0f),
324  myValueScale(val?val[0]:1.0f),
325  myValueShift(val?val[1]:0.0f),
326  myMaintainLum(maintain_lum) {}
327 
328 protected:
329  static void toHSV(RU_PixelFunction *f, float **vals,
330  const bool *scope);
331  static void fromHSV(RU_PixelFunction *f, float **vals,
332  const bool *scope);
333  static void adjustHSV(RU_PixelFunction *f, float **vals,
334  const bool *scope);
335 
336  virtual bool needAllComponents() const { return true; }
338  { if(myHSVOp==CONVERT_TO_HSV) return toHSV;
339  if(myHSVOp==CONVERT_TO_RGB) return fromHSV;
340  return adjustHSV; }
341  virtual void getPixelShader(UT_String &frag_shader);
342 
344  float myHueShift;
345  float mySatScale, mySatShift;
346  float myValueScale, myValueShift;
348 };
349 
351 {
352 public:
353  RU_VectorFunc(const UT_Matrix4 &matrix) : myMatrix(matrix) {}
354 
355 protected:
356  static void matrixmult(RU_PixelFunction *f, float **vals,
357  const bool *scope);
358 
359  virtual bool needAllComponents() const { return true; }
360  virtual RUVectorFunc getVectorFunction() const { return matrixmult; }
361  virtual void getPixelShader(UT_String &frag_shader);
362 
364 };
365 
366 
368 {
369 public:
370  RU_LookupClipFunc(const CL_Clip *clip) : myClip(clip) {}
371 protected:
372  static float lookup(RU_PixelFunction *pf, float val, int);
373  static void vlookup(RU_PixelFunction *f, float **vals,
374  const bool *scope);
375 
376  virtual bool needAllComponents() const
377  { return myClip->getNumTracks() > 1; }
378  virtual RUVectorFunc getVectorFunction() const { return vlookup; }
379  virtual RUPixelFunc getPixelFunction() const { return lookup; }
380  virtual void getPixelShader(UT_String &frag_shader);
381 
382  const CL_Clip *myClip;
383 };
384 
386 {
387 public:
388  RU_LookupTableFunc(PXL_Lookup *table) : myTable(table) {}
389 
390  virtual ~RU_LookupTableFunc() { delete myTable; }
391 
392 protected:
393  static float lookup(RU_PixelFunction *pf, float val, int);
394  static void vlookup(RU_PixelFunction *f, float **vals,
395  const bool *scope);
396 
397  virtual bool eachComponentDifferent() const { return myTable->getNumChannels() > 1; }
398  virtual bool needAllComponents() const
399  { return myTable->is3DLUT(); }
400 
401  virtual RUPixelFunc getPixelFunction() const { return lookup; }
402  virtual RUVectorFunc getVectorFunction() const { return vlookup; }
403 
405 };
406 
407 
408 // Mathematical functions.
409 
411 {
412 public:
414 protected:
415  static float absolute(RU_PixelFunction *pf, float val, int);
416  virtual RUPixelFunc getPixelFunction() const { return absolute; }
417  virtual void getPixelShader(UT_String &frag_shader);
418 };
419 
421 {
422 public:
424 protected:
425  static float sign(RU_PixelFunction *pf, float val, int);
426  virtual RUPixelFunc getPixelFunction() const { return sign; }
427  virtual void getPixelShader(UT_String &frag_shader);
428 };
429 
431 {
432 public:
433  RU_PowerFunc(float exponent) : myExponent(exponent) {}
434 protected:
435  static float power(RU_PixelFunction *pf, float val, int);
436  virtual RUPixelFunc getPixelFunction() const { return power; }
437  virtual void getPixelShader(UT_String &frag_shader);
438  float myExponent;
439 };
440 
442 {
443 public:
444  RU_RaiseFunc(float base) : myBase(base) {}
445 protected:
446  static float raise(RU_PixelFunction *pf, float val, int);
447  virtual RUPixelFunc getPixelFunction() const { return raise; }
448  virtual void getPixelShader(UT_String &frag_shader);
449  float myBase;
450 };
451 
453 {
454 public:
455  RU_LogFunc(float base, bool replace, float value);
456 protected:
457  static float logarithm(RU_PixelFunction *pf, float val, int);
458  virtual RUPixelFunc getPixelFunction() const { return logarithm; }
459  virtual void getPixelShader(UT_String &frag_shader);
460  float myBase;
462  float myValue;
463 };
464 
466 {
467 public:
468  RU_SinFunc(float scale, float shift) : myScale(scale), myShift(shift) {}
469 protected:
470  static float sinfunc(RU_PixelFunction *pf, float val, int);
471  virtual RUPixelFunc getPixelFunction() const { return sinfunc; }
472  virtual void getPixelShader(UT_String &frag_shader);
473  float myScale;
474  float myShift;
475 };
476 
478 {
479 public:
480  RU_SinhFunc(float scale) : myScale(scale) {}
481 protected:
482  static float sinhfunc(RU_PixelFunction *pf, float val, int);
483  virtual RUPixelFunc getPixelFunction() const { return sinhfunc; }
484  virtual void getPixelShader(UT_String &frag_shader);
485  float myScale;
486 };
487 
489 {
490 public:
491  RU_CoshFunc(float scale) : myScale(scale) {}
492 protected:
493  static float coshfunc(RU_PixelFunction *pf, float val, int);
494  virtual RUPixelFunc getPixelFunction() const { return coshfunc; }
495  virtual void getPixelShader(UT_String &frag_shader);
496  float myScale;
497 };
498 
500 {
501 public:
502  RU_TanFunc(float scale, bool rep, float v)
503  : myScale(scale), myDoReplace(rep), myValue(v) {}
504 protected:
505  static float tanfunc(RU_PixelFunction *pf, float val, int);
506  virtual RUPixelFunc getPixelFunction() const { return tanfunc; }
507  virtual void getPixelShader(UT_String &frag_shader);
508  float myScale;
510  float myValue;
511 };
512 
514 {
515 public:
516  RU_TanhFunc(float scale) : myScale(scale) {}
517 protected:
518  static float tanhfunc(RU_PixelFunction *pf, float val, int);
519  virtual RUPixelFunc getPixelFunction() const { return tanhfunc; }
520  virtual void getPixelShader(UT_String &frag_shader);
521  float myScale;
522 };
523 
525 {
526 public:
527  RU_AtanFunc(float scale) : myScale(scale) {}
528 protected:
529  static float atanfunc(RU_PixelFunction *pf, float val, int);
530  virtual RUPixelFunc getPixelFunction() const { return atanfunc; }
531  virtual void getPixelShader(UT_String &frag_shader);
532  float myScale;
533 };
534 
536 {
537 public:
538  RU_AsinFunc(float scale, bool rep, float v)
539  : myScale(scale), myDoReplace(rep), myValue(v) {}
540 protected:
541  static float asinfunc(RU_PixelFunction *pf, float val, int);
542  virtual RUPixelFunc getPixelFunction() const { return asinfunc; }
543  virtual void getPixelShader(UT_String &frag_shader);
544  float myScale;
546  float myValue;
547 };
548 
550 {
551 public:
552  RU_AcosFunc(float scale, bool rep, float v)
553  : myScale(scale), myDoReplace(rep), myValue(v) {}
554 protected:
555  static float acosfunc(RU_PixelFunction *pf, float val, int);
556  virtual RUPixelFunc getPixelFunction() const { return acosfunc; }
557  virtual void getPixelShader(UT_String &frag_shader);
558  float myScale;
560  float myValue;
561 };
562 
564 {
565 public:
567 protected:
568  static float negate(RU_PixelFunction *pf, float val, int);
569  virtual RUPixelFunc getPixelFunction() const { return negate; }
570  virtual void getPixelShader(UT_String &frag_shader);
571 };
572 
574 {
575 public:
576  RU_InvertFunc(bool rep, float v) : myDoReplace(rep), myValue(v) {}
577 protected:
578  static float invert(RU_PixelFunction *pf, float val, int);
579  virtual RUPixelFunc getPixelFunction() const { return invert; }
580  virtual void getPixelShader(UT_String &frag_shader);
582  float myValue;
583 };
584 
586 {
587 public:
589 protected:
590  static float floorfunc(RU_PixelFunction *pf, float val, int);
591  virtual RUPixelFunc getPixelFunction() const { return floorfunc; }
592  virtual void getPixelShader(UT_String &frag_shader);
593 };
594 
596 {
597 public:
599 protected:
600  static float ceilfunc(RU_PixelFunction *pf, float val, int);
601  virtual RUPixelFunc getPixelFunction() const { return ceilfunc; }
602  virtual void getPixelShader(UT_String &frag_shader);
603 };
604 
606 {
607 public:
609 protected:
610  static float roundfunc(RU_PixelFunction *pf, float val, int);
611  virtual RUPixelFunc getPixelFunction() const { return roundfunc; }
612  virtual void getPixelShader(UT_String &frag_shader);
613 };
614 
616 {
617 public:
618  /// passing all data down, rather than precomputing MAdds, so that we can
619  /// correctly handle the degenerate cases of 0-width input ranges.
620  /// @param effect frame scope effect,
621  /// applied by the ctor to the ranges but not the gammas
622  /// (caller should apply it to the gammas)
623  RU_LevelsFunc(float effect,
624  float global_in_range_min, float global_in_range_max,
625  float global_out_range_min, float global_out_range_max,
626  float global_gamma,
627  float comp_in_range_min[4], float comp_in_range_max[4],
628  float comp_out_range_min[4], float comp_out_range_max[4],
629  float comp_gamma[4]);
630 
631  RU_LevelsFunc(float effect,
632  float global_in_range_min, float global_in_range_max,
633  float global_out_range_min, float global_out_range_max,
634  float global_gamma,
635  float comp_in_range_min, float comp_in_range_max,
636  float comp_out_range_min, float comp_out_range_max,
637  float comp_gamma);
638 
639 protected:
640  /// for the usual case, MAdd, gamma, MAdd, gamma
641  static float fastLevels(RU_PixelFunction *pf, float val, int);
642 
643  /// handles degenerate input level ranges
644  static float safeLevels(RU_PixelFunction *pf, float val, int);
645  float safeLevels(float val, int);
646 
647  static void colourMap(float const effect,
648  const float from_min, const float from_max,
649  const float to_min, const float to_max,
650  float& factor, float& addend);
651 
652 
653  virtual RUPixelFunc getPixelFunction() const { return myLevelsFunc; }
654  virtual void getPixelShader(UT_String &frag_shader);
655 
657 
658  // for fast levels
661  float myFactor[4];
662  float myAddend[4];
663 
664  // for safe levels
669  float myCompInRangeMin[4];
670  float myCompInRangeMax[4];
671  float myCompOutRangeMin[4];
672  float myCompOutRangeMax[4];
673 
675 };
676 
677 #endif
virtual RUPixelFunc getPixelFunction() const
RU_ScaleFunc(float scale, float pivot)
virtual RUPixelFunc getPixelFunction() const
virtual RUPixelFunc getPixelFunction() const
virtual RUPixelFunc getPixelFunction() const
RU_GammaFunc(float g)
static float mult(RU_PixelFunction *pf, float val, int)
virtual RUVectorFunc getVectorFunction() const
RU_LookupTableFunc(PXL_Lookup *table)
RU_SinhFunc(float scale)
virtual RUVectorFunc getVectorFunction() const
RU_PowerFunc(float exponent)
virtual RUPixelFunc getPixelFunction() const
RU_AcosFunc(float scale, bool rep, float v)
virtual RUPixelFunc getPixelFunction() const
virtual bool needAllComponents() const
GLboolean invert
Definition: glcorearb.h:548
virtual RUPixelFunc getPixelFunction() const
virtual bool needAllComponents() const
virtual RUPixelFunc getPixelFunction() const
const GLdouble * v
Definition: glcorearb.h:836
virtual RUVectorFunc getVectorFunction() const
GLboolean GLboolean g
Definition: glcorearb.h:1221
int myStep
Definition: GT_CurveEval.h:264
virtual bool eachComponentDifferent() const
#define RU_API
Definition: RU_API.h:10
virtual bool needAllComponents() const
virtual RUVectorFunc getVectorFunction() const
virtual bool needAllComponents() const
virtual RUPixelFunc getPixelFunction() const
virtual bool needAllComponents() const
RU_LookupClipFunc(const CL_Clip *clip)
virtual RUPixelFunc getPixelFunction() const
RU_GammaFunc(float r, float g, float b, float w)
virtual RUPixelFunc getPixelFunction() const
RU_CoshFunc(float scale)
virtual bool eachComponentDifferent() const
RUPixelFunc myLevelsFunc
virtual RUPixelFunc getPixelFunction() const
virtual bool eachComponentDifferent() const
virtual bool needAllComponents() const
virtual RUPixelFunc getPixelFunction() const
virtual RUPixelFunc getPixelFunction() const
static float scale(RU_PixelFunction *pf, float val, int)
virtual RUPixelFunc getPixelFunction() const
GA_API const UT_StringHolder scale
virtual RUPixelFunc getPixelFunction() const
GLfloat f
Definition: glcorearb.h:1925
virtual RUPixelFunc getPixelFunction() const
virtual RUPixelFunc getPixelFunction() const
virtual bool needAllComponents() const
virtual RUPixelFunc getPixelFunction() const
RU_ComponentFunc(int comp)
RU_AsinFunc(float scale, bool rep, float v)
virtual RUVectorFunc getVectorFunction() const
virtual RUVectorFunc getVectorFunction() const
virtual bool needAllComponents() const
UT_Matrix4 myMatrix
virtual RUVectorFunc getVectorFunction() const
GLintptr offset
Definition: glcorearb.h:664
virtual bool needAllComponents() const
virtual RUPixelFunc getPixelFunction() const
virtual bool needAllComponents() const
RU_VectorFunc(const UT_Matrix4 &matrix)
RU_TanhFunc(float scale)
virtual RUVectorFunc getVectorFunction() const
virtual RUPixelFunc getPixelFunction() const
int sign(T a)
Definition: ImathFun.h:63
virtual RUPixelFunc getPixelFunction() const
virtual RUVectorFunc getVectorFunction() const
GridType::Ptr normalize(const GridType &grid, bool threaded, InterruptT *interrupt)
Normalize the vectors of the given vector-valued grid.
GLboolean GLboolean GLboolean b
Definition: glcorearb.h:1221
virtual RUPixelFunc getPixelFunction() const
virtual RUVectorFunc getVectorFunction() const
virtual void getPixelShader(UT_String &frag_shader)
const CL_Clip * myClip
RU_SinFunc(float scale, float shift)
RU_QuantizeFunc(float step, float offset)
virtual RUVectorFunc getVectorFunction() const
virtual bool needAllComponents() const
RU_HSVConvertFunc(RU_HSVConvertOp op, float hues=0.0f, float *sat=0, float *val=0, bool maintain_lum=true)
GLsizei const GLfloat * value
Definition: glcorearb.h:823
static float madd(RU_PixelFunction *pf, float val, int comp)
IMATH_INTERNAL_NAMESPACE_HEADER_ENTER T clip(const T &p, const Box< T > &box)
Definition: ImathBoxAlgo.h:89
virtual RUVectorFunc getVectorFunction() const
typedef int
Definition: png.h:1175
RU_HSVConvertOp myHSVOp
RU_AtanFunc(float scale)
static float add(RU_PixelFunction *pf, float val, int)
RU_LimitFunc(bool lower, float lval, bool upper, float uval, bool clamp)
virtual RUPixelFunc getPixelFunction() const
GLuint GLfloat * val
Definition: glcorearb.h:1607
RU_InvertFunc(bool rep, float v)
GA_API const UT_StringHolder pivot
virtual bool needAllComponents() const
virtual RUPixelFunc getPixelFunction() const
virtual RUVectorFunc getVectorFunction() const
RU_MultFunc(float fact)
GLubyte GLubyte GLubyte GLubyte w
Definition: glcorearb.h:856
virtual bool needAllComponents() const
GLboolean r
Definition: glcorearb.h:1221
void(* RUVectorFunc)(RU_PixelFunction *, float **, const bool *)
RU_AddFunc(float addend)
virtual RUPixelFunc getPixelFunction() const
virtual RUVectorFunc getVectorFunction() const
virtual void getPixelShader(UT_String &frag_shader)
virtual RUPixelFunc getPixelFunction() const
float(* RUPixelFunc)(RU_PixelFunction *, float, int)
virtual bool needAllComponents() const
virtual RUPixelFunc getPixelFunction() const
RU_TanFunc(float scale, bool rep, float v)
GLenum clamp
Definition: glcorearb.h:1233
GLuint GLsizei GLsizei * length
Definition: glcorearb.h:794
RU_RaiseFunc(float base)