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  RE_DEVICE_MAC_SILICON = 0x600, // ARM-based Macs
632 
636 };
637 
639  const char *renderstring);
640 
642 {
643  return (dev & RE_DEVICE_PRO);
644 }
645 
647 {
648  return !(dev & RE_DEVICE_PRO);
649 }
650 
651 class UT_String;
653 
654 #include <UT/UT_IntrusivePtr.h>
659 
660 #include <UT/UT_StringArray.h>
661 
663 
664 class IMG_Raster;
665 typedef IMG_Raster *(*RE_IconLoader)(int, int);
666 
667 class PXL_Lookup;
668 
670 {
671 public:
672  RE_RasterOpts() : myZoomX(-1), myZoomY(-1),
673  myColorScale(1.0f), myColorShift(0.0f),
674  myColorBlack(0.0f), myColorWhite(1.0f),
675  myAlphaScale(1.0f), myAlphaShift(0.0f),
676  myGamma(1.0f), myAspectRatio(1.0f), myVScale(1.0f),
677  myLUTSize(0), myComponent(-1), myModifyAlpha(false),
678  myDither(true), myComponentsAsGrey(true),
679  myLUTObject(0), myTransparent(0), myPremultiplyFlag(0),
680  myFragment16bit(0), myStereoMode(0), myPreBright(0),
681  myIgnoreGamma(false), myColorCorrectDisable(false),
682  myResetViewMatrix(true)
683  { myLUT[0] = myLUT[1] = myLUT[2] = myLUT[3] = 0; }
684 
685  float myZoomX;
686  float myZoomY;
693  float myGamma;
695  float myVScale;
696  float *myLUT[4];
699  unsigned myModifyAlpha :1,
700  myDither : 1,
701  myComponentsAsGrey :1,
702  myTransparent :1,
703  myPremultiplyFlag:1,
704  myFragment16bit : 2,
705  myStereoMode : 2,
706  myPreBright : 1,
707  myIgnoreGamma : 1,
708  myColorCorrectDisable : 1,
709  myResetViewMatrix :1;
711 };
712 
713 
714 
715 // stack item for blending & smoothing (which also modifies the blend state)
717 {
718 public:
720  {
721  mySmoothPushed = false;
722  mySmoothRequest = false;
723  mySmoothEnable = false;
724  myForceSmooth = 0;
725  myPrevLineWidth = -1.0f;
726 
727  myBlend = 0;
728  mySourceFactor = RE_SBLEND_ONE;
729  myDestFactor = RE_DBLEND_ZERO;
730  myAlphaSourceFactor = RE_SBLEND_ONE;
731  myAlphaDestFactor = RE_DBLEND_ZERO;
732  myEquation = RE_BLEND_ADD;
733  }
734 
735  void copy(const re_BlendSmoothState &state)
736  {
737  mySmoothPushed = state.mySmoothPushed;
738  mySmoothRequest = state.mySmoothRequest;
739  mySmoothEnable = state.mySmoothEnable;
740  myForceSmooth = state.myForceSmooth;
741  myPrevLineWidth = state.myPrevLineWidth;
742 
743  myBlend = state.myBlend;
744  mySourceFactor = state.mySourceFactor;
745  myDestFactor = state.myDestFactor;
746  myAlphaSourceFactor = state.myAlphaSourceFactor;
747  myAlphaDestFactor = state.myAlphaDestFactor;
748  myEquation = state.myEquation;
749  }
750 
751  void get(bool &req_smooth, int &blend,
754  RE_BlendEquation &eq) const
755  {
756  req_smooth = mySmoothRequest;
757  blend = myBlend;
758  s = mySourceFactor;
759  d = myDestFactor;
760  sa = myAlphaSourceFactor;
761  da = myAlphaDestFactor;
762  eq = myEquation;
763  }
764 
765  void invalidate()
766  {
767  mySmoothRequest = false;
768  mySmoothEnable = -1;
769  myForceSmooth = -1;
770  myBlend = -1;
771  mySourceFactor = (RE_BlendSourceFactor)-1;
772  myDestFactor = (RE_BlendDestFactor)-1;
773  myAlphaSourceFactor = (RE_BlendSourceFactor)-1;
774  myAlphaDestFactor = (RE_BlendDestFactor)-1;
775  myEquation = RE_BlendEquation(-1);
776  }
777 
778  bool isValid()
779  {
780  return (mySmoothEnable != -1 &&
781  myForceSmooth != -1 &&
782  myBlend != -1 &&
783  mySourceFactor != (RE_BlendSourceFactor)-1 &&
784  myDestFactor != (RE_BlendDestFactor)-1 &&
785  myAlphaSourceFactor != (RE_BlendSourceFactor)-1 &&
786  myAlphaDestFactor != (RE_BlendDestFactor)-1 &&
787  myEquation != RE_BlendEquation(-1));
788  }
789 
795  int myBlend;
801 };
802 
803 // Stack item for stenciling
805 {
806 public:
808  {
809  myEnable = false;
810  myClearValue = 0;
811  myWriteMask = 1;
812  myFunc = RE_SALWAYS;
813  myRef = 0;
814  myValueMask = 1;
815  myFailOperation = RE_SKEEP;
816  myPassDepthFailOperation = RE_SKEEP;
817  myPassDepthPassOperation = RE_SKEEP;
818  }
819 
820  void set(bool enable,
821  int clearValue,
822  int writeMask,
824  int ref,
825  int valueMask,
826  RE_SOperation failOperation,
827  RE_SOperation passDepthFailOperation,
828  RE_SOperation passDepthPassOperation)
829  {
830  myEnable = enable;
831  myClearValue = clearValue;
832  myWriteMask = writeMask;
833  myFunc = func;
834  myRef = ref;
835  myValueMask = valueMask;
836  myFailOperation = failOperation;
837  myPassDepthFailOperation = passDepthFailOperation;
838  myPassDepthPassOperation = passDepthPassOperation;
839  }
840 
841  void get(bool &enable,
842  int &clearValue,
843  int &writeMask,
845  int &ref,
846  int &valueMask,
847  RE_SOperation &failOperation,
848  RE_SOperation &passDepthFailOperation,
849  RE_SOperation &passDepthPassOperation) const
850  {
851  enable = myEnable;
852  clearValue = myClearValue;
853  writeMask = myWriteMask;
854  func = myFunc;
855  ref = myRef;
856  valueMask = myValueMask;
857  failOperation = myFailOperation;
858  passDepthFailOperation = myPassDepthFailOperation;
859  passDepthPassOperation = myPassDepthPassOperation;
860  }
861 
862  bool myEnable;
866  int myRef;
871 };
872 
873 // Depth stack item for depth buffer state
875 {
876 public:
878  {
879  myDepthTest = -1;
880  myDepthBufferWrite = -1;
881  myZFunction = (RE_ZFunction) -1;
882  myDepthClamp = -1;
883  myZNear = 0.0;
884  myZFar = 1.0;
885  }
886 
891  double myZNear;
892  double myZFar;
893 };
894 
895 #define PATTERN_STACK_SIZE 7
896 #define RE_SMOOTH_STACK_SIZE 16
897 #define RE_STENCIL_STACK_SIZE 16
898 #define RE_ALIGN_STACK_SIZE 16
899 #define RE_FRAMEBUFFER_STACK_SIZE 8
900 #define RE_SHADER_STACK_SIZE 16
901 #define RE_BUFFER_STACK_SIZE 8
902 #define RE_DEPTH_STACK_SIZE 16
903 #define RE_UNIFORM_STACK_SIZE 16
904 
905 
906 #define RE_STACK_DEPTH 256
907 
908 // ============================================================================
909 // Platlform-specific implementation defines, typedefs and declarations.
910 // At the moment there is only the Qt implementation.
911 // ============================================================================
912 
913 // We use RE_OGLContext and only cast at the last possible minute,
914 // to avoid problems compiling against certain OpenGL drivers.
915 class QOpenGLContext;
916 typedef QOpenGLContext *RE_OGLContext;
917 
919 typedef RE_GLDrawable *OGLDrawable;
920 
921 #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:710
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:694
RE_API void REgetDeviceName(RE_GraphicsDevice dev, UT_String &name)
RE_BlendSourceFactor mySourceFactor
Definition: RE_Types.h:796
double myZFar
Definition: RE_Types.h:892
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:918
RE_GraphicsDevice
Definition: RE_Types.h:618
float myVScale
Definition: RE_Types.h:695
UT_StringArray RE_OverrideList
Definition: RE_Types.h:662
UT_IntrusivePtr< RE_OGLBuffer > RE_OGLBufferHandle
Definition: RE_Types.h:657
RE_Severity
Definition: RE_Types.h:607
RE_LineStyle
Definition: RE_Types.h:429
int myDepthBufferWrite
Definition: RE_Types.h:889
float myZoomX
Definition: RE_Types.h:685
int myDepthTest
Definition: RE_Types.h:887
RE_ZFunction myZFunction
Definition: RE_Types.h:890
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:865
float myColorWhite
Definition: RE_Types.h:690
RE_SOperation myPassDepthFailOperation
Definition: RE_Types.h:869
int myDepthClamp
Definition: RE_Types.h:888
RE_ShaderType
Definition: RE_Types.h:228
RE_GenericAttribID
Definition: RE_Types.h:328
float myColorShift
Definition: RE_Types.h:688
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:891
GLclampf f
Definition: glew.h:3499
RE_BufferBinding
Definition: RE_Types.h:301
RE_SOperation myPassDepthPassOperation
Definition: RE_Types.h:870
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:820
IMG_DataType
Definition: IMG_FileTypes.h:17
int myComponent
Definition: RE_Types.h:698
float myZoomY
Definition: RE_Types.h:686
RE_SmoothMode
Definition: RE_Types.h:435
RE_BlendSourceFactor myAlphaSourceFactor
Definition: RE_Types.h:798
RE_BlendEquation
Definition: RE_Types.h:509
void copy(const re_BlendSmoothState &state)
Definition: RE_Types.h:735
bool REisProfessionalDevice(RE_GraphicsDevice dev)
Definition: RE_Types.h:641
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:689
GLuint GLuint GLsizei GLenum type
Definition: glew.h:1253
RE_ShaderAttribLocation
Definition: RE_Types.h:363
float myGamma
Definition: RE_Types.h:693
RE_BlendDestFactor myAlphaDestFactor
Definition: RE_Types.h:799
float myColorScale
Definition: RE_Types.h:687
RE_BlendDestFactor myDestFactor
Definition: RE_Types.h:797
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:691
RE_SOperation
Definition: RE_Types.h:472
RE_BlendEquation myEquation
Definition: RE_Types.h:800
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:655
#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:915
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:646
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:692
RE_SOperation myFailOperation
Definition: RE_Types.h:868
RE_API RE_ShaderTarget REgetShaderTargetForGLPrim(int gltype)
RE_BlendDestFactor
Definition: RE_Types.h:497