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  RE_GENATTRIB_CE, // shares slot with N
342 
347 
351 
357 
358  // sentinel
360 };
361 
362 /// Vertex shader input locations for known attribute types. All others
363 /// attributes are assigned starting at location 'RE_GENLOC_FIRST_CUSTOM'.
365 {
368 
369  RE_LOC_P = 0,
372  RE_LOC_N = 3,
380 
384 
386 };
387 
388 #if defined(WIN32) || defined(MBSD_COCOA)
389 typedef void * Display;
390 #endif
391 
392 // Default GL cache size. 32b machines get 384MB, while 64b machines get 2GB.
393 #ifdef AMD64
394 #define RE_TEXCACHE_DEFAULT_MAX_SIZE int64(512) * 1024 * 1024
395 #define RE_BUFCACHE_DEFAULT_MAX_SIZE int64(2) * 1024 * 1024 * 1024
396 #else
397 #define RE_TEXCACHE_DEFAULT_MAX_SIZE 96 * 1024 * 1024
398 #define RE_BUFCACHE_DEFAULT_MAX_SIZE 384 * 1024 * 1024
399 #endif
400 
401 #define RE_DEFAULT_DPI 85.0
402 #define RE_SCALE_BELOW_RESOLUTION 1000
403 #define RE_MIN_RESOLUTION_SCALE_FACTOR 0.85f
404 
405 #define MM_TO_INCHES(mm) ((mm) / 25.4)
406 
407 #define RE_HALF_TONE_ALPHA 0.6f
408 #define RE_QUARTER_TONE_ALPHA 0.3f
409 
411 {
412  RE_BUFFER_UNINIT = 0, // current buffer not known
413  RE_FRONT, // front buffer
414  RE_BACK, // back buffer (must be double buffered; single use front)
415  RE_BACK_LEFT, // back-left buffer for quad buffered stereo
416  RE_BACK_RIGHT, // back-right buffer for quad buffered stero
417 
418  RE_FBO_ZS, // for rendering to FBO depth or stencil attachments
419  RE_FBO_COLOR // for rendering to FBO attachments 0-15; add the # to
420  // this enum.
421 
422  // RE_BOTH has been removed because the back buffer is no longer valid
423  // after swapping, so you shouldn't need to write to both ever.
424 };
425 
427 {
430 };
431 
433 {
436 };
437 
439 {
442 };
443 
445 {
449 };
450 
452 {
461 };
462 
464 {
473 };
474 
476 {
485 };
486 
488 {
498 };
499 
501 {
510 };
511 
513 {
519 };
520 
522 {
526 };
527 
528 // keep in sync with the GL barrier types (GL_*_BARRIER_BIT)
530 {
546 
547  RE_BARRIER_ALL = 0xFFFFFFFF
548 };
549 
550 #define RE_MODE_MULTISAMPLE_MASK 0x60
551 #define RE_MODE_MULTISAMPLE_SHIFT 5
552 
554 {
555  // The mode components
556  RE_MODE_NONE = 0x000,
557  RE_MODE_RGB = 0x001, // RGB mode (req'd)
558  RE_MODE_DOUBLE = 0x002, // Double buffer
559  RE_MODE_ZBUFFER = 0x004, // Depth buffer
560  RE_MODE_ALPHA = 0x008, // Alpha buffer (RGBA)
561  RE_MODE_STENCIL = 0x010, // Stencil buffer
562  RE_MODE_MULTISAMPLE_LOW = 0x020, // 2x Full Scene AA
563  RE_MODE_MULTISAMPLE_MED = 0x040, // 4x Full Scene AA
564  RE_MODE_MULTISAMPLE_HIGH = 0x060, // 8x (NV) / 6x (ATI) FS AA
565  RE_MODE_ACCUM = 0x080, // Color Accumulation buffer
566  RE_MODE_ACCUM_ALPHA = 0x100, // Alpha accum (needs color acc)
567  RE_MODE_HDR = 0x200, // HDR FP16 (FBO only)
568  RE_MODE_HDR_FP32 = 0x400, // HDR FP32 (FBO only)
569  RE_MODE_STEREO = 0x800, // quad buffer stereo
570 
571  // The actual modes themselves; convenience enums.
574 
577 
580 
583 
587 
590 
594 
601 };
602 
604 {
608 };
609 
611 {
612  RE_SEVERITY_MESSAGE =0, // ARB_debug_group only
613 
617 };
618 
619 // This is a bitmask.
620 // *** You must update REgetDeviceName() if you change this ***
622 {
624 
627  RE_DEVICE_INTEL_GMA = 0x4, // Intel GMA (not supported)
628  RE_DEVICE_INTEL_HD = 0x8, // Intel HD graphics
629  RE_DEVICE_GDI = 0x10, // Software OGL on Windows
631 
632  RE_DEVICE_PRO = 0x100, // Professional series
633  RE_DEVICE_MAC = 0x200, // Mac versions of drivers
634  RE_DEVICE_MAC_SILICON = 0x600, // ARM-based Macs
635 
639 };
640 
642  const char *renderstring);
643 
645 {
646  return (dev & RE_DEVICE_PRO);
647 }
648 
650 {
651  return !(dev & RE_DEVICE_PRO);
652 }
653 
654 class UT_String;
656 
657 #include <UT/UT_IntrusivePtr.h>
662 
663 #include <UT/UT_StringArray.h>
664 
666 
667 class IMG_Raster;
668 typedef IMG_Raster *(*RE_IconLoader)(int, int);
669 
670 class PXL_Lookup;
671 
673 {
674 public:
675  RE_RasterOpts() : myZoomX(-1), myZoomY(-1),
676  myColorScale(1.0f), myColorShift(0.0f),
677  myColorBlack(0.0f), myColorWhite(1.0f),
678  myAlphaScale(1.0f), myAlphaShift(0.0f),
679  myGamma(1.0f), myAspectRatio(1.0f), myVScale(1.0f),
680  myLUTSize(0), myComponent(-1), myModifyAlpha(false),
681  myDither(true), myComponentsAsGrey(true),
682  myLUTObject(0), myTransparent(0), myPremultiplyFlag(0),
683  myFragment16bit(0), myStereoMode(0), myPreBright(0),
684  myIgnoreGamma(false), myColorCorrectDisable(false),
685  myResetViewMatrix(true)
686  { myLUT[0] = myLUT[1] = myLUT[2] = myLUT[3] = 0; }
687 
688  float myZoomX;
689  float myZoomY;
696  float myGamma;
698  float myVScale;
699  float *myLUT[4];
702  unsigned myModifyAlpha :1,
703  myDither : 1,
704  myComponentsAsGrey :1,
705  myTransparent :1,
706  myPremultiplyFlag:1,
707  myFragment16bit : 2,
708  myStereoMode : 2,
709  myPreBright : 1,
710  myIgnoreGamma : 1,
711  myColorCorrectDisable : 1,
712  myResetViewMatrix :1;
714 };
715 
716 
717 
718 // stack item for blending & smoothing (which also modifies the blend state)
720 {
721 public:
723  {
724  mySmoothPushed = false;
725  mySmoothRequest = false;
726  mySmoothEnable = false;
727  myForceSmooth = 0;
728  myPrevLineWidth = -1.0f;
729 
730  myBlend = 0;
731  mySourceFactor = RE_SBLEND_ONE;
732  myDestFactor = RE_DBLEND_ZERO;
733  myAlphaSourceFactor = RE_SBLEND_ONE;
734  myAlphaDestFactor = RE_DBLEND_ZERO;
735  myEquation = RE_BLEND_ADD;
736  }
737 
738  void copy(const re_BlendSmoothState &state)
739  {
740  mySmoothPushed = state.mySmoothPushed;
741  mySmoothRequest = state.mySmoothRequest;
742  mySmoothEnable = state.mySmoothEnable;
743  myForceSmooth = state.myForceSmooth;
744  myPrevLineWidth = state.myPrevLineWidth;
745 
746  myBlend = state.myBlend;
747  mySourceFactor = state.mySourceFactor;
748  myDestFactor = state.myDestFactor;
749  myAlphaSourceFactor = state.myAlphaSourceFactor;
750  myAlphaDestFactor = state.myAlphaDestFactor;
751  myEquation = state.myEquation;
752  }
753 
754  void get(bool &req_smooth, int &blend,
757  RE_BlendEquation &eq) const
758  {
759  req_smooth = mySmoothRequest;
760  blend = myBlend;
761  s = mySourceFactor;
762  d = myDestFactor;
763  sa = myAlphaSourceFactor;
764  da = myAlphaDestFactor;
765  eq = myEquation;
766  }
767 
768  void invalidate()
769  {
770  mySmoothRequest = false;
771  mySmoothEnable = -1;
772  myForceSmooth = -1;
773  myBlend = -1;
774  mySourceFactor = (RE_BlendSourceFactor)-1;
775  myDestFactor = (RE_BlendDestFactor)-1;
776  myAlphaSourceFactor = (RE_BlendSourceFactor)-1;
777  myAlphaDestFactor = (RE_BlendDestFactor)-1;
778  myEquation = RE_BlendEquation(-1);
779  }
780 
781  bool isValid()
782  {
783  return (mySmoothEnable != -1 &&
784  myForceSmooth != -1 &&
785  myBlend != -1 &&
786  mySourceFactor != (RE_BlendSourceFactor)-1 &&
787  myDestFactor != (RE_BlendDestFactor)-1 &&
788  myAlphaSourceFactor != (RE_BlendSourceFactor)-1 &&
789  myAlphaDestFactor != (RE_BlendDestFactor)-1 &&
790  myEquation != RE_BlendEquation(-1));
791  }
792 
798  int myBlend;
804 };
805 
806 // Stack item for stenciling
808 {
809 public:
811  {
812  myEnable = false;
813  myClearValue = 0;
814  myWriteMask = 1;
815  myFunc = RE_SALWAYS;
816  myRef = 0;
817  myValueMask = 1;
818  myFailOperation = RE_SKEEP;
819  myPassDepthFailOperation = RE_SKEEP;
820  myPassDepthPassOperation = RE_SKEEP;
821  }
822 
823  void set(bool enable,
824  int clearValue,
825  int writeMask,
827  int ref,
828  int valueMask,
829  RE_SOperation failOperation,
830  RE_SOperation passDepthFailOperation,
831  RE_SOperation passDepthPassOperation)
832  {
833  myEnable = enable;
834  myClearValue = clearValue;
835  myWriteMask = writeMask;
836  myFunc = func;
837  myRef = ref;
838  myValueMask = valueMask;
839  myFailOperation = failOperation;
840  myPassDepthFailOperation = passDepthFailOperation;
841  myPassDepthPassOperation = passDepthPassOperation;
842  }
843 
844  void get(bool &enable,
845  int &clearValue,
846  int &writeMask,
848  int &ref,
849  int &valueMask,
850  RE_SOperation &failOperation,
851  RE_SOperation &passDepthFailOperation,
852  RE_SOperation &passDepthPassOperation) const
853  {
854  enable = myEnable;
855  clearValue = myClearValue;
856  writeMask = myWriteMask;
857  func = myFunc;
858  ref = myRef;
859  valueMask = myValueMask;
860  failOperation = myFailOperation;
861  passDepthFailOperation = myPassDepthFailOperation;
862  passDepthPassOperation = myPassDepthPassOperation;
863  }
864 
865  bool myEnable;
869  int myRef;
874 };
875 
876 // Depth stack item for depth buffer state
878 {
879 public:
881  {
882  myDepthTest = -1;
883  myDepthBufferWrite = -1;
884  myZFunction = (RE_ZFunction) -1;
885  myDepthClamp = -1;
886  myZNear = 0.0;
887  myZFar = 1.0;
888  }
889 
894  double myZNear;
895  double myZFar;
896 };
897 
898 #define PATTERN_STACK_SIZE 7
899 #define RE_SMOOTH_STACK_SIZE 16
900 #define RE_STENCIL_STACK_SIZE 16
901 #define RE_ALIGN_STACK_SIZE 16
902 #define RE_FRAMEBUFFER_STACK_SIZE 8
903 #define RE_SHADER_STACK_SIZE 16
904 #define RE_BUFFER_STACK_SIZE 8
905 #define RE_DEPTH_STACK_SIZE 16
906 #define RE_UNIFORM_STACK_SIZE 16
907 
908 
909 #define RE_STACK_DEPTH 256
910 
911 // ============================================================================
912 // Platlform-specific implementation defines, typedefs and declarations.
913 // At the moment there is only the Qt implementation.
914 // ============================================================================
915 
916 // We use RE_OGLContext and only cast at the last possible minute,
917 // to avoid problems compiling against certain OpenGL drivers.
918 class QOpenGLContext;
919 typedef QOpenGLContext *RE_OGLContext;
920 
922 typedef RE_GLDrawable *OGLDrawable;
923 
924 #endif
GLint ref
Definition: glcorearb.h:123
GLboolean enable
Definition: glew.h:2750
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:713
#define RE_API
Definition: RE_API.h:10
RE_API RE_GraphicsDevice REdetermineGraphicsDevice(const char *renderstring)
float myAspectRatio
Definition: RE_Types.h:697
RE_API void REgetDeviceName(RE_GraphicsDevice dev, UT_String &name)
RE_BlendSourceFactor mySourceFactor
Definition: RE_Types.h:799
double myZFar
Definition: RE_Types.h:895
RE_FaceMode
Definition: RE_Types.h:444
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:921
RE_GraphicsDevice
Definition: RE_Types.h:621
float myVScale
Definition: RE_Types.h:698
UT_StringArray RE_OverrideList
Definition: RE_Types.h:665
UT_IntrusivePtr< RE_OGLBuffer > RE_OGLBufferHandle
Definition: RE_Types.h:660
RE_Severity
Definition: RE_Types.h:610
RE_LineStyle
Definition: RE_Types.h:432
GLuint const GLchar * name
Definition: glcorearb.h:785
int myDepthBufferWrite
Definition: RE_Types.h:892
GLdouble GLdouble t
Definition: glew.h:1403
float myZoomX
Definition: RE_Types.h:688
int myDepthTest
Definition: RE_Types.h:890
RE_ZFunction myZFunction
Definition: RE_Types.h:893
RE_MatrixMode
Definition: RE_Types.h:426
RE_GPUType REconvertFromGPUType(UT_GPUType t)
Definition: RE_Types.h:95
RE_SFunction myFunc
Definition: RE_Types.h:868
float myColorWhite
Definition: RE_Types.h:693
RE_SOperation myPassDepthFailOperation
Definition: RE_Types.h:872
int myDepthClamp
Definition: RE_Types.h:891
RE_ShaderType
Definition: RE_Types.h:228
RE_GenericAttribID
Definition: RE_Types.h:328
float myColorShift
Definition: RE_Types.h:691
vint4 blend(const vint4 &a, const vint4 &b, const vbool4 &mask)
Definition: simd.h:4761
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:894
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
RE_BufferBinding
Definition: RE_Types.h:301
RE_SOperation myPassDepthPassOperation
Definition: RE_Types.h:873
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:823
IMG_DataType
Definition: IMG_FileTypes.h:17
int myComponent
Definition: RE_Types.h:701
float myZoomY
Definition: RE_Types.h:689
RE_SmoothMode
Definition: RE_Types.h:438
RE_BlendSourceFactor myAlphaSourceFactor
Definition: RE_Types.h:801
RE_BlendEquation
Definition: RE_Types.h:512
void copy(const re_BlendSmoothState &state)
Definition: RE_Types.h:738
GLfloat GLfloat p
Definition: glew.h:16656
bool REisProfessionalDevice(RE_GraphicsDevice dev)
Definition: RE_Types.h:644
typedef int(WINAPI *PFNWGLRELEASEPBUFFERDCARBPROC)(HPBUFFERARB hPbuffer
RE_MemoryBarrierBitfield
Definition: RE_Types.h:529
RE_DisplayMode
Definition: RE_Types.h:553
RE_ZFunction
Definition: RE_Types.h:451
PXL_DataFormat
Definition: PXL_Common.h:20
float myColorBlack
Definition: RE_Types.h:692
RE_ShaderAttribLocation
Definition: RE_Types.h:364
float myGamma
Definition: RE_Types.h:696
RE_BlendDestFactor myAlphaDestFactor
Definition: RE_Types.h:802
float myColorScale
Definition: RE_Types.h:690
RE_BlendDestFactor myDestFactor
Definition: RE_Types.h:800
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:694
RE_SOperation
Definition: RE_Types.h:475
RE_BlendEquation myEquation
Definition: RE_Types.h:803
RE_VisualType
Definition: RE_Types.h:603
RE_BlendSourceFactor
Definition: RE_Types.h:487
RE_ArrayType
Definition: RE_Types.h:317
GLfloat f
Definition: glcorearb.h:1925
RE_BufferUsageHint
Definition: RE_Types.h:276
UT_IntrusivePtr< RE_Material > RE_MaterialPtr
Definition: RE_Types.h:658
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:171
RE_RenderBuf
Definition: RE_Types.h:410
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:918
RE_API const char * REgetTypeName(RE_GPUType p)
RE_ShaderLanguage
Definition: RE_Types.h:242
RE_PrimType
Definition: RE_Types.h:193
GLdouble s
Definition: glew.h:1395
RE_SFunction
Definition: RE_Types.h:463
bool REisConsumerDevice(RE_GraphicsDevice dev)
Definition: RE_Types.h:649
RE_PersistentBufferMode
Definition: RE_Types.h:521
float myAlphaShift
Definition: RE_Types.h:695
RE_SOperation myFailOperation
Definition: RE_Types.h:871
RE_API RE_ShaderTarget REgetShaderTargetForGLPrim(int gltype)
RE_BlendDestFactor
Definition: RE_Types.h:500