HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
RE_Types.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: RE_Types.h ( UI Library, C++)
7  *
8  * COMMENTS:
9  * Common enums and defines for Open GL.
10  */
11 #ifndef __RE_Types__
12 #define __RE_Types__
13 
14 #include "RE_API.h"
15 
16 #define RE_MAX_PICK_DIST 100
17 
18 // The type of a window. Used to set hints for the windowing system
19 // to treat the window differently, and to set up borders and icon settings.
21 {
22  RE_WINDOW_MAIN, // An app window. App exits when all are closed.
23  RE_WINDOW_NORMAL, // A dialog window with min/max-imize buttons.
24  RE_WINDOW_DIALOG, // A transient dialog that should be on top
25  // of its parent window.
26  RE_WINDOW_UTILITY, // A non-transient (i.e., persistent) dialog
27  // like a toolbox or palette.
28  RE_WINDOW_SPLASH, // A splash screen window.
29  RE_WINDOW_TRANSIENT, // A *very* transient window displayed
30  // temporarily (like a tooltip or XCF slider).
31  // Grabs the pointer & is not managed.
32  RE_WINDOW_CHILD, // A child of a window (probably a child of a
33  // NORMAL window). Isn't managed.
34  RE_WINDOW_MENU, // A window for popup menus.
35  RE_WINDOW_HELPTIP, // Same as TRANSIENT, but without focus lock.
36 
37  RE_WINDOW_NORMAL_BORDERLESS,// A dialog window without a border, it is an extra type
38  RE_WINDOW_INVALID_TYPE // Not a type. Used to mean "uninitialized."
39 };
40 // should always point to the last type.
41 #define RE_NUM_WINDOW_TYPES RE_WINDOW_INVALID_TYPE
42 #include <UT/UT_Assert.h>
43 #include <UT/UT_ComputeGPU.h>
45 {
46  RE_GPU_UINT1 = 0, // corresponds to GL_STENCIL_INDEX1
47  RE_GPU_UINT4, // corresponds to GL_STENCIL_INDEX4
51 
55 
57  RE_GPU_FLOAT24, // corresponds to GL_DEPTH_COMPONENT24
60 
61  // These can only be used in the context of a GLSL shader.
65 };
66 
68 {
69  switch (t)
70  {
71  case RE_GPU_UINT1: return UT_GPU_UINT1;
72  case RE_GPU_UINT4: return UT_GPU_UINT4;
73  case RE_GPU_UINT8: return UT_GPU_UINT8;
74  case RE_GPU_UINT16: return UT_GPU_UINT16;
75  case RE_GPU_UINT32: return UT_GPU_UINT32;
76 
77  case RE_GPU_INT8: return UT_GPU_INT8;
78  case RE_GPU_INT16: return UT_GPU_INT16;
79  case RE_GPU_INT32: return UT_GPU_INT32;
80 
81  case RE_GPU_FLOAT16: return UT_GPU_FLOAT16;
82  case RE_GPU_FLOAT24: return UT_GPU_FLOAT24;
83  case RE_GPU_FLOAT32: return UT_GPU_FLOAT32;
84  case RE_GPU_FLOAT64: return UT_GPU_FLOAT64;
85 
86  case RE_GPU_MATRIX2: return UT_GPU_MATRIX2;
87  case RE_GPU_MATRIX3: return UT_GPU_MATRIX3;
88  case RE_GPU_MATRIX4: return UT_GPU_MATRIX4;
89  }
90 
91  UT_ASSERT(!"Unknown RE_GPUType.");
92  return UT_GPU_UINT8;
93 }
94 
96 {
97  switch (t)
98  {
99  case UT_GPU_UINT1: return RE_GPU_UINT1;
100  case UT_GPU_UINT4: return RE_GPU_UINT4;
101  case UT_GPU_UINT8: return RE_GPU_UINT8;
102  case UT_GPU_UINT16: return RE_GPU_UINT16;
103  case UT_GPU_UINT32: return RE_GPU_UINT32;
104 
105  case UT_GPU_INT8: return RE_GPU_INT8;
106  case UT_GPU_INT16: return RE_GPU_INT16;
107  case UT_GPU_INT32: return RE_GPU_INT32;
108 
109  case UT_GPU_FLOAT16: return RE_GPU_FLOAT16;
110  case UT_GPU_FLOAT24: return RE_GPU_FLOAT24;
111  case UT_GPU_FLOAT32: return RE_GPU_FLOAT32;
112  case UT_GPU_FLOAT64: return RE_GPU_FLOAT64;
113 
114  case UT_GPU_MATRIX2: return RE_GPU_MATRIX2;
115  case UT_GPU_MATRIX3: return RE_GPU_MATRIX3;
116  case UT_GPU_MATRIX4: return RE_GPU_MATRIX4;
117  }
118 
119  UT_ASSERT(!"Unknown UT_GPUType.");
120  return RE_GPU_UINT8;
121 }
122 
123 // defined in RE_OGLRender.C
124 RE_API extern const char *REgetTypeName(RE_GPUType p);
125 
126 #include <PXL/PXL_Common.h>
127 #include <IMG/IMG_FileTypes.h>
129 {
130  switch(t)
131  {
132  default:
133  case IMG_INT8: return RE_GPU_UINT8;
134  case IMG_INT16: return RE_GPU_UINT16;
135  case IMG_INT32: return RE_GPU_UINT32;
136  case IMG_FLOAT32: return RE_GPU_FLOAT32;
137  case IMG_FLOAT16: return RE_GPU_FLOAT16;
138  }
139 
140  UT_ASSERT(!"Unknown type");
141  return RE_GPU_UINT8;
142 }
143 
145 {
147 }
148 
149 // Function to get size in bits of a RE_GPUType
150 inline unsigned int REsizeOfGPUType(RE_GPUType gpu_type)
151 {
152  int bpp = 32;
153 
154  switch(gpu_type)
155  {
156  case RE_GPU_UINT1:
157  bpp = 1;
158  break;
159  case RE_GPU_UINT4:
160  bpp = 4;
161  break;
162  case RE_GPU_UINT8:
163  case RE_GPU_INT8:
164  bpp = 8;
165  break;
166  case RE_GPU_FLOAT16:
167  case RE_GPU_UINT16:
168  case RE_GPU_INT16:
169  bpp = 16;
170  break;
171  case RE_GPU_FLOAT64:
172  bpp = 64;
173  break;
174  case RE_GPU_MATRIX2:
175  bpp = 32 * 4;
176  break;
177  case RE_GPU_MATRIX3:
178  bpp = 32 * 9;
179  break;
180  case RE_GPU_MATRIX4:
181  bpp = 32 * 16;
182  break;
183  // FLOAT24 is padded to 32
184  default:
185  break;
186  }
187 
188  return bpp;
189 }
190 
191 
192 // RE definitions for GL primitives
194 {
197 
199 
203 
207 
208  RE_PRIM_LINES_ADJACENT, // for geometry shaders; includes
209  RE_PRIM_LINE_STRIP_ADJACENT, // extra vertices outside the primitive
210  RE_PRIM_TRIANGLES_ADJACENT, // for curvature
212 
213  RE_PRIM_POLYGONS, // General N-sided polygons
214 
215  RE_PRIM_PATCHES, // Patches sent to tessellation shaders
216 
218 };
219 
220 // defined in RE_OGLRender.C
221 RE_API extern int REgetGLPrim(RE_PrimType t);
222 RE_API extern RE_PrimType REgetREPrim(int gltype);
223 RE_API extern const char *REgetPrimName(RE_PrimType p);
224 
225 
226 // GLSL Shader stage types (bitfield in case a shader function can be applied
227 // to more than one stage type)
229 {
235 
236  RE_SHADER_COMPUTE = 0x20, // cannot be used with other stages
237 
239 };
240 
241 // Shader language type - now just GLSL.
243 {
247 };
248 
249 // Basic Primitive type that a shader program is designed for.
251 {
255 
257 };
258 
259 // returns the shader target that a given prim would require.
262 
263 // RE definitions for the various GL buffer objects
265 {
266  RE_BUFFER_ATTRIBUTE = 0x001, // generic vertex attribute
267  RE_BUFFER_ELEMENT = 0x002, // vertex connectivity index list
268 
269  RE_BUFFER_UNIFORM = 0x004, // uniform buffer object
270  RE_BUFFER_PIXEL_WRITE = 0x008, // pixels move from CPU->GPU
271  RE_BUFFER_PIXEL_READ = 0x010, // pixels move from GPU->CPU
272  RE_BUFFER_TEXTURE = 0x020, // For buffer textures
273  RE_BUFFER_SHADER_STORAGE = 0x040 // For generic buffers
274 };
275 
277 {
278  // passing data to GPU only.
279  RE_BUFFER_WRITE_ONCE, // written once only, redrawn many
280  RE_BUFFER_WRITE_FREQUENT, // written several times, redrawn many
281  RE_BUFFER_WRITE_STREAM, // one write per redraw
282 
283  // reading data from GPU only.
287 
288  // read and write (ex: rendering to a vertex list to use as geo)
292 };
293 
295 {
299 };
300 
302 {
314 
315 };
316 
318 {
319  RE_ARRAY_VERTEX, // sampled at vertex frequency
320  RE_ARRAY_POINT, // sampled at point frequency (default)
321  RE_ARRAY_PRIMITIVE, // sampled at primitive frequency
322  RE_ARRAY_INSTANCE, // sampled at instance frequency
323  RE_ARRAY_DETAIL, // sampled at detail frequency
324  RE_ARRAY_RANDOM, // randomly sampled
325  RE_ARRAY_NULL // placeholder only for vertex state match
326 };
327 
329 {
332 
340  RE_GENATTRIB_WIDTH, // shares vertex array slot with pscale
341 
346 
350 
356 
357  // sentinel
359 };
360 
361 /// Vertex shader input locations for known attribute types. All others
362 /// attributes are assigned starting at location 'RE_GENLOC_FIRST_CUSTOM'.
364 {
367 
368  RE_LOC_P = 0,
371  RE_LOC_N = 3,
377 
381 
383 };
384 
385 #if defined(WIN32) || defined(MBSD_COCOA)
386 typedef void * Display;
387 #endif
388 
389 // Default GL cache size. 32b machines get 384MB, while 64b machines get 2GB.
390 #ifdef AMD64
391 #define RE_TEXCACHE_DEFAULT_MAX_SIZE int64(512) * 1024 * 1024
392 #define RE_BUFCACHE_DEFAULT_MAX_SIZE int64(2) * 1024 * 1024 * 1024
393 #else
394 #define RE_TEXCACHE_DEFAULT_MAX_SIZE 96 * 1024 * 1024
395 #define RE_BUFCACHE_DEFAULT_MAX_SIZE 384 * 1024 * 1024
396 #endif
397 
398 #define RE_DEFAULT_DPI 85.0
399 #define RE_SCALE_BELOW_RESOLUTION 1000
400 #define RE_MIN_RESOLUTION_SCALE_FACTOR 0.85f
401 
402 #define MM_TO_INCHES(mm) ((mm) / 25.4)
403 
404 #define RE_HALF_TONE_ALPHA 0.6f
405 #define RE_QUARTER_TONE_ALPHA 0.3f
406 
408 {
409  RE_BUFFER_UNINIT = 0, // current buffer not known
410  RE_FRONT, // front buffer
411  RE_BACK, // back buffer (must be double buffered; single use front)
412  RE_BACK_LEFT, // back-left buffer for quad buffered stereo
413  RE_BACK_RIGHT, // back-right buffer for quad buffered stero
414 
415  RE_FBO_ZS, // for rendering to FBO depth or stencil attachments
416  RE_FBO_COLOR // for rendering to FBO attachments 0-15; add the # to
417  // this enum.
418 
419  // RE_BOTH has been removed because the back buffer is no longer valid
420  // after swapping, so you shouldn't need to write to both ever.
421 };
422 
424 {
427 };
428 
430 {
433 };
434 
436 {
439 };
440 
442 {
446 };
447 
449 {
458 };
459 
461 {
470 };
471 
473 {
482 };
483 
485 {
495 };
496 
498 {
507 };
508 
510 {
516 };
517 
519 {
523 };
524 
525 // keep in sync with the GL barrier types (GL_*_BARRIER_BIT)
527 {
543 
544  RE_BARRIR_ALL = 0xFFFFFFFF
545 };
546 
547 #define RE_MODE_MULTISAMPLE_MASK 0x60
548 #define RE_MODE_MULTISAMPLE_SHIFT 5
549 
551 {
552  // The mode components
553  RE_MODE_NONE = 0x000,
554  RE_MODE_RGB = 0x001, // RGB mode (req'd)
555  RE_MODE_DOUBLE = 0x002, // Double buffer
556  RE_MODE_ZBUFFER = 0x004, // Depth buffer
557  RE_MODE_ALPHA = 0x008, // Alpha buffer (RGBA)
558  RE_MODE_STENCIL = 0x010, // Stencil buffer
559  RE_MODE_MULTISAMPLE_LOW = 0x020, // 2x Full Scene AA
560  RE_MODE_MULTISAMPLE_MED = 0x040, // 4x Full Scene AA
561  RE_MODE_MULTISAMPLE_HIGH = 0x060, // 8x (NV) / 6x (ATI) FS AA
562  RE_MODE_ACCUM = 0x080, // Color Accumulation buffer
563  RE_MODE_ACCUM_ALPHA = 0x100, // Alpha accum (needs color acc)
564  RE_MODE_HDR = 0x200, // HDR FP16 (FBO only)
565  RE_MODE_HDR_FP32 = 0x400, // HDR FP32 (FBO only)
566  RE_MODE_STEREO = 0x800, // quad buffer stereo
567 
568  // The actual modes themselves; convenience enums.
571 
574 
577 
580 
584 
587 
591 
598 };
599 
601 {
605 };
606 
608 {
609  RE_SEVERITY_MESSAGE =0, // ARB_debug_group only
610 
614 };
615 
616 // This is a bitmask.
617 // *** You must update REgetDeviceName() if you change this ***
619 {
621 
624  RE_DEVICE_INTEL_GMA = 0x4, // Intel GMA (not supported)
625  RE_DEVICE_INTEL_HD = 0x8, // Intel HD graphics
626  RE_DEVICE_GDI = 0x10, // Software OGL on Windows
628 
629  RE_DEVICE_PRO = 0x100, // Professional series
630  RE_DEVICE_MAC = 0x200, // Mac versions of drivers
631 
635 };
636 
638  const char *renderstring);
639 
641 {
642  return (dev & RE_DEVICE_PRO);
643 }
644 
646 {
647  return !(dev & RE_DEVICE_PRO);
648 }
649 
650 class UT_String;
652 
653 #include <UT/UT_IntrusivePtr.h>
658 
659 #include <UT/UT_StringArray.h>
660 
662 
663 class IMG_Raster;
664 typedef IMG_Raster *(*RE_IconLoader)(int, int);
665 
666 class PXL_Lookup;
667 
669 {
670 public:
671  RE_RasterOpts() : myZoomX(-1), myZoomY(-1),
672  myColorScale(1.0f), myColorShift(0.0f),
673  myColorBlack(0.0f), myColorWhite(1.0f),
674  myAlphaScale(1.0f), myAlphaShift(0.0f),
675  myGamma(1.0f), myAspectRatio(1.0f), myVScale(1.0f),
676  myLUTSize(0), myComponent(-1), myModifyAlpha(false),
677  myDither(true), myComponentsAsGrey(true),
678  myLUTObject(0), myTransparent(0), myPremultiplyFlag(0),
679  myFragment16bit(0), myStereoMode(0), myPreBright(0),
680  myIgnoreGamma(false), myColorCorrectDisable(false),
681  myResetViewMatrix(true)
682  { myLUT[0] = myLUT[1] = myLUT[2] = myLUT[3] = 0; }
683 
684  float myZoomX;
685  float myZoomY;
692  float myGamma;
694  float myVScale;
695  float *myLUT[4];
698  unsigned myModifyAlpha :1,
699  myDither : 1,
700  myComponentsAsGrey :1,
701  myTransparent :1,
702  myPremultiplyFlag:1,
703  myFragment16bit : 2,
704  myStereoMode : 2,
705  myPreBright : 1,
706  myIgnoreGamma : 1,
707  myColorCorrectDisable : 1,
708  myResetViewMatrix :1;
710 };
711 
712 
713 
714 // stack item for blending & smoothing (which also modifies the blend state)
716 {
717 public:
719  {
720  mySmoothPushed = false;
721  mySmoothRequest = false;
722  mySmoothEnable = false;
723  myForceSmooth = 0;
724  myPrevLineWidth = -1.0f;
725 
726  myBlend = 0;
727  mySourceFactor = RE_SBLEND_ONE;
728  myDestFactor = RE_DBLEND_ZERO;
729  myAlphaSourceFactor = RE_SBLEND_ONE;
730  myAlphaDestFactor = RE_DBLEND_ZERO;
731  myEquation = RE_BLEND_ADD;
732  }
733 
734  void copy(const re_BlendSmoothState &state)
735  {
736  mySmoothPushed = state.mySmoothPushed;
737  mySmoothRequest = state.mySmoothRequest;
738  mySmoothEnable = state.mySmoothEnable;
739  myForceSmooth = state.myForceSmooth;
740  myPrevLineWidth = state.myPrevLineWidth;
741 
742  myBlend = state.myBlend;
743  mySourceFactor = state.mySourceFactor;
744  myDestFactor = state.myDestFactor;
745  myAlphaSourceFactor = state.myAlphaSourceFactor;
746  myAlphaDestFactor = state.myAlphaDestFactor;
747  myEquation = state.myEquation;
748  }
749 
750  void get(bool &req_smooth, int &blend,
753  RE_BlendEquation &eq) const
754  {
755  req_smooth = mySmoothRequest;
756  blend = myBlend;
757  s = mySourceFactor;
758  d = myDestFactor;
759  sa = myAlphaSourceFactor;
760  da = myAlphaDestFactor;
761  eq = myEquation;
762  }
763 
764  void invalidate()
765  {
766  mySmoothRequest = false;
767  mySmoothEnable = -1;
768  myForceSmooth = -1;
769  myBlend = -1;
770  mySourceFactor = (RE_BlendSourceFactor)-1;
771  myDestFactor = (RE_BlendDestFactor)-1;
772  myAlphaSourceFactor = (RE_BlendSourceFactor)-1;
773  myAlphaDestFactor = (RE_BlendDestFactor)-1;
774  myEquation = RE_BlendEquation(-1);
775  }
776 
777  bool isValid()
778  {
779  return (mySmoothEnable != -1 &&
780  myForceSmooth != -1 &&
781  myBlend != -1 &&
782  mySourceFactor != (RE_BlendSourceFactor)-1 &&
783  myDestFactor != (RE_BlendDestFactor)-1 &&
784  myAlphaSourceFactor != (RE_BlendSourceFactor)-1 &&
785  myAlphaDestFactor != (RE_BlendDestFactor)-1 &&
786  myEquation != RE_BlendEquation(-1));
787  }
788 
794  int myBlend;
800 };
801 
802 // Stack item for stenciling
804 {
805 public:
807  {
808  myEnable = false;
809  myClearValue = 0;
810  myWriteMask = 1;
811  myFunc = RE_SALWAYS;
812  myRef = 0;
813  myValueMask = 1;
814  myFailOperation = RE_SKEEP;
815  myPassDepthFailOperation = RE_SKEEP;
816  myPassDepthPassOperation = RE_SKEEP;
817  }
818 
819  void set(bool enable,
820  int clearValue,
821  int writeMask,
823  int ref,
824  int valueMask,
825  RE_SOperation failOperation,
826  RE_SOperation passDepthFailOperation,
827  RE_SOperation passDepthPassOperation)
828  {
829  myEnable = enable;
830  myClearValue = clearValue;
831  myWriteMask = writeMask;
832  myFunc = func;
833  myRef = ref;
834  myValueMask = valueMask;
835  myFailOperation = failOperation;
836  myPassDepthFailOperation = passDepthFailOperation;
837  myPassDepthPassOperation = passDepthPassOperation;
838  }
839 
840  void get(bool &enable,
841  int &clearValue,
842  int &writeMask,
844  int &ref,
845  int &valueMask,
846  RE_SOperation &failOperation,
847  RE_SOperation &passDepthFailOperation,
848  RE_SOperation &passDepthPassOperation) const
849  {
850  enable = myEnable;
851  clearValue = myClearValue;
852  writeMask = myWriteMask;
853  func = myFunc;
854  ref = myRef;
855  valueMask = myValueMask;
856  failOperation = myFailOperation;
857  passDepthFailOperation = myPassDepthFailOperation;
858  passDepthPassOperation = myPassDepthPassOperation;
859  }
860 
861  bool myEnable;
865  int myRef;
870 };
871 
872 // Depth stack item for depth buffer state
874 {
875 public:
877  {
878  myDepthTest = -1;
879  myDepthBufferWrite = -1;
880  myZFunction = (RE_ZFunction) -1;
881  myDepthClamp = -1;
882  myZNear = 0.0;
883  myZFar = 1.0;
884  }
885 
890  double myZNear;
891  double myZFar;
892 };
893 
894 #define PATTERN_STACK_SIZE 7
895 #define RE_SMOOTH_STACK_SIZE 16
896 #define RE_STENCIL_STACK_SIZE 16
897 #define RE_ALIGN_STACK_SIZE 16
898 #define RE_FRAMEBUFFER_STACK_SIZE 8
899 #define RE_SHADER_STACK_SIZE 16
900 #define RE_BUFFER_STACK_SIZE 8
901 #define RE_DEPTH_STACK_SIZE 16
902 #define RE_UNIFORM_STACK_SIZE 16
903 
904 
905 #define RE_STACK_DEPTH 256
906 
907 // ============================================================================
908 // Platlform-specific implementation defines, typedefs and declarations.
909 // At the moment there is only the Qt implementation.
910 // ============================================================================
911 
912 // We use RE_OGLContext and only cast at the last possible minute,
913 // to avoid problems compiling against certain OpenGL drivers.
914 class QOpenGLContext;
915 typedef QOpenGLContext *RE_OGLContext;
916 
918 typedef RE_GLDrawable *OGLDrawable;
919 
920 #endif
GLdouble s
Definition: glew.h:1390
RE_API int REgetGLPrim(RE_PrimType t)
RE_API const char * REgetPrimName(RE_PrimType p)
RE_API RE_ShaderTarget REgetShaderTargetForPrim(RE_PrimType type)
PXL_Lookup * myLUTObject
Definition: RE_Types.h:709
GLenum GLint ref
Definition: glew.h:1845
GLuint const GLchar * name
Definition: glew.h:1814
#define RE_API
Definition: RE_API.h:10
RE_API RE_GraphicsDevice REdetermineGraphicsDevice(const char *renderstring)
float myAspectRatio
Definition: RE_Types.h:693
RE_API void REgetDeviceName(RE_GraphicsDevice dev, UT_String &name)
RE_BlendSourceFactor mySourceFactor
Definition: RE_Types.h:795
double myZFar
Definition: RE_Types.h:891
RE_FaceMode
Definition: RE_Types.h:441
RE_GPUType REconvertIMGType(IMG_DataType t)
Definition: RE_Types.h:128
unsigned int REsizeOfGPUType(RE_GPUType gpu_type)
Definition: RE_Types.h:150
RE_GLDrawable * OGLDrawable
Definition: RE_Types.h:917
RE_GraphicsDevice
Definition: RE_Types.h:618
float myVScale
Definition: RE_Types.h:694
UT_StringArray RE_OverrideList
Definition: RE_Types.h:661
UT_IntrusivePtr< RE_OGLBuffer > RE_OGLBufferHandle
Definition: RE_Types.h:656
RE_Severity
Definition: RE_Types.h:607
RE_LineStyle
Definition: RE_Types.h:429
int myDepthBufferWrite
Definition: RE_Types.h:888
float myZoomX
Definition: RE_Types.h:684
int myDepthTest
Definition: RE_Types.h:886
RE_ZFunction myZFunction
Definition: RE_Types.h:889
RE_MatrixMode
Definition: RE_Types.h:423
RE_GPUType REconvertFromGPUType(UT_GPUType t)
Definition: RE_Types.h:95
RE_SFunction myFunc
Definition: RE_Types.h:864
float myColorWhite
Definition: RE_Types.h:689
RE_SOperation myPassDepthFailOperation
Definition: RE_Types.h:868
int myDepthClamp
Definition: RE_Types.h:887
RE_ShaderType
Definition: RE_Types.h:228
RE_GenericAttribID
Definition: RE_Types.h:328
float myColorShift
Definition: RE_Types.h:687
vint4 blend(const vint4 &a, const vint4 &b, const vbool4 &mask)
Definition: simd.h:4648
UT_GPUType
Definition: UT_ComputeGPU.h:41
RE_GPUType
Definition: RE_Types.h:44
RE_BufferType
Definition: RE_Types.h:264
UT_GPUType PXLconvertToUTGPUType(PXL_DataFormat t)
Definition: PXL_Common.h:99
double myZNear
Definition: RE_Types.h:890
GLclampf f
Definition: glew.h:3499
RE_BufferBinding
Definition: RE_Types.h:301
RE_SOperation myPassDepthPassOperation
Definition: RE_Types.h:869
void set(bool enable, int clearValue, int writeMask, RE_SFunction func, int ref, int valueMask, RE_SOperation failOperation, RE_SOperation passDepthFailOperation, RE_SOperation passDepthPassOperation)
Definition: RE_Types.h:819
IMG_DataType
Definition: IMG_FileTypes.h:17
int myComponent
Definition: RE_Types.h:697
float myZoomY
Definition: RE_Types.h:685
RE_SmoothMode
Definition: RE_Types.h:435
RE_BlendSourceFactor myAlphaSourceFactor
Definition: RE_Types.h:797
RE_BlendEquation
Definition: RE_Types.h:509
void copy(const re_BlendSmoothState &state)
Definition: RE_Types.h:734
bool REisProfessionalDevice(RE_GraphicsDevice dev)
Definition: RE_Types.h:640
typedef int(WINAPI *PFNWGLRELEASEPBUFFERDCARBPROC)(HPBUFFERARB hPbuffer
RE_MemoryBarrierBitfield
Definition: RE_Types.h:526
RE_DisplayMode
Definition: RE_Types.h:550
RE_ZFunction
Definition: RE_Types.h:448
PXL_DataFormat
Definition: PXL_Common.h:20
float myColorBlack
Definition: RE_Types.h:688
GLuint GLuint GLsizei GLenum type
Definition: glew.h:1253
RE_ShaderAttribLocation
Definition: RE_Types.h:363
float myGamma
Definition: RE_Types.h:692
RE_BlendDestFactor myAlphaDestFactor
Definition: RE_Types.h:798
float myColorScale
Definition: RE_Types.h:686
RE_BlendDestFactor myDestFactor
Definition: RE_Types.h:796
GLfloat GLfloat p
Definition: glew.h:16321
GLenum func
Definition: glcorearb.h:782
RE_BufferAccess
Definition: RE_Types.h:294
UT_GPUType REconvertToUTGPUType(RE_GPUType t)
Definition: RE_Types.h:67
RE_GPUType REconvertPXLType(PXL_DataFormat t)
Definition: RE_Types.h:144
float myAlphaScale
Definition: RE_Types.h:690
RE_SOperation
Definition: RE_Types.h:472
RE_BlendEquation myEquation
Definition: RE_Types.h:799
RE_VisualType
Definition: RE_Types.h:600
RE_BlendSourceFactor
Definition: RE_Types.h:484
RE_ArrayType
Definition: RE_Types.h:317
RE_BufferUsageHint
Definition: RE_Types.h:276
UT_IntrusivePtr< RE_Material > RE_MaterialPtr
Definition: RE_Types.h:654
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:135
RE_RenderBuf
Definition: RE_Types.h:407
RE_WindowType
Definition: RE_Types.h:20
RE_ShaderTarget
Definition: RE_Types.h:250
RE_API RE_PrimType REgetREPrim(int gltype)
QOpenGLContext * RE_OGLContext
Definition: RE_Types.h:914
RE_API const char * REgetTypeName(RE_GPUType p)
RE_ShaderLanguage
Definition: RE_Types.h:242
RE_PrimType
Definition: RE_Types.h:193
RE_SFunction
Definition: RE_Types.h:460
bool REisConsumerDevice(RE_GraphicsDevice dev)
Definition: RE_Types.h:645
GLboolean enable
Definition: glew.h:2745
GLdouble GLdouble t
Definition: glew.h:1398
RE_PersistentBufferMode
Definition: RE_Types.h:518
float myAlphaShift
Definition: RE_Types.h:691
RE_SOperation myFailOperation
Definition: RE_Types.h:867
RE_API RE_ShaderTarget REgetShaderTargetForGLPrim(int gltype)
RE_BlendDestFactor
Definition: RE_Types.h:497