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 #include <UT/UT_Assert.h>
17 #include <UT/UT_ComputeGPU.h>
18 #include <UT/UT_StringHolder.h>
19 #include <UT/UT_IntrusivePtr.h>
20 #include <UT/UT_StringArray.h>
21 
22 #include <PXL/PXL_Common.h>
23 #include <IMG/IMG_FileTypes.h>
24 
25 #define RE_MAX_PICK_DIST 100
26 
27 // The type of a window. Used to set hints for the windowing system
28 // to treat the window differently, and to set up borders and icon settings.
30 {
31  RE_WINDOW_MAIN, // An app window. App exits when all are closed.
32  RE_WINDOW_NORMAL, // A dialog window with min/max-imize buttons.
33  RE_WINDOW_DIALOG, // A transient dialog that should be on top
34  // of its parent window.
35  RE_WINDOW_UTILITY, // A non-transient (i.e., persistent) dialog
36  // like a toolbox or palette.
37  RE_WINDOW_SPLASH, // A splash screen window.
38  RE_WINDOW_TRANSIENT, // A *very* transient window displayed
39  // temporarily (like a tooltip or XCF slider).
40  // Grabs the pointer & is not managed.
41  RE_WINDOW_CHILD, // A child of a window (probably a child of a
42  // NORMAL window). Isn't managed.
43  RE_WINDOW_MENU, // A window for popup menus.
44  RE_WINDOW_HELPTIP, // Same as TRANSIENT, but without focus lock.
45 
46  RE_WINDOW_NORMAL_BORDERLESS,// A dialog window without a border, it is an extra type
47  RE_WINDOW_TRANSIENT_MODAL, // A transient *modal* window, it is an extra type
48  RE_WINDOW_INVALID_TYPE // Not a type. Used to mean "uninitialized."
49 };
50 // should always point to the last type.
51 #define RE_NUM_WINDOW_TYPES RE_WINDOW_INVALID_TYPE
53 {
54  RE_GPU_UINT1 = 0, // corresponds to GL_STENCIL_INDEX1
55  RE_GPU_UINT4, // corresponds to GL_STENCIL_INDEX4
59 
63 
65  RE_GPU_FLOAT24, // corresponds to GL_DEPTH_COMPONENT24
68 
69  // These can only be used in the context of a GLSL shader.
73 };
74 
76 {
77  switch (t)
78  {
79  case RE_GPU_UINT1: return UT_GPU_UINT1;
80  case RE_GPU_UINT4: return UT_GPU_UINT4;
81  case RE_GPU_UINT8: return UT_GPU_UINT8;
82  case RE_GPU_UINT16: return UT_GPU_UINT16;
83  case RE_GPU_UINT32: return UT_GPU_UINT32;
84 
85  case RE_GPU_INT8: return UT_GPU_INT8;
86  case RE_GPU_INT16: return UT_GPU_INT16;
87  case RE_GPU_INT32: return UT_GPU_INT32;
88 
89  case RE_GPU_FLOAT16: return UT_GPU_FLOAT16;
90  case RE_GPU_FLOAT24: return UT_GPU_FLOAT24;
91  case RE_GPU_FLOAT32: return UT_GPU_FLOAT32;
92  case RE_GPU_FLOAT64: return UT_GPU_FLOAT64;
93 
94  case RE_GPU_MATRIX2: return UT_GPU_MATRIX2;
95  case RE_GPU_MATRIX3: return UT_GPU_MATRIX3;
96  case RE_GPU_MATRIX4: return UT_GPU_MATRIX4;
97  }
98 
99  UT_ASSERT(!"Unknown RE_GPUType.");
100  return UT_GPU_UINT8;
101 }
102 
104 {
105  switch (t)
106  {
107  case UT_GPU_UINT1: return RE_GPU_UINT1;
108  case UT_GPU_UINT4: return RE_GPU_UINT4;
109  case UT_GPU_UINT8: return RE_GPU_UINT8;
110  case UT_GPU_UINT16: return RE_GPU_UINT16;
111  case UT_GPU_UINT32: return RE_GPU_UINT32;
112 
113  case UT_GPU_INT8: return RE_GPU_INT8;
114  case UT_GPU_INT16: return RE_GPU_INT16;
115  case UT_GPU_INT32: return RE_GPU_INT32;
116 
117  case UT_GPU_FLOAT16: return RE_GPU_FLOAT16;
118  case UT_GPU_FLOAT24: return RE_GPU_FLOAT24;
119  case UT_GPU_FLOAT32: return RE_GPU_FLOAT32;
120  case UT_GPU_FLOAT64: return RE_GPU_FLOAT64;
121 
122  case UT_GPU_MATRIX2: return RE_GPU_MATRIX2;
123  case UT_GPU_MATRIX3: return RE_GPU_MATRIX3;
124  case UT_GPU_MATRIX4: return RE_GPU_MATRIX4;
125  }
126 
127  UT_ASSERT(!"Unknown UT_GPUType.");
128  return RE_GPU_UINT8;
129 }
130 
131 // defined in RE_OGLRender.C
132 RE_API extern const char *REgetTypeName(RE_GPUType p);
133 
135 {
136  switch(t)
137  {
138  default:
139  case IMG_INT8: return RE_GPU_UINT8;
140  case IMG_INT16: return RE_GPU_UINT16;
141  case IMG_INT32: return RE_GPU_UINT32;
142  case IMG_FLOAT32: return RE_GPU_FLOAT32;
143  case IMG_FLOAT16: return RE_GPU_FLOAT16;
144  }
145 
146  UT_ASSERT(!"Unknown type");
147  return RE_GPU_UINT8;
148 }
149 
151 {
153 }
154 
155 // Function to get size in bits of a RE_GPUType
156 inline unsigned int REsizeOfGPUType(RE_GPUType gpu_type)
157 {
158  int bpp = 32;
159 
160  switch(gpu_type)
161  {
162  case RE_GPU_UINT1:
163  bpp = 1;
164  break;
165  case RE_GPU_UINT4:
166  bpp = 4;
167  break;
168  case RE_GPU_UINT8:
169  case RE_GPU_INT8:
170  bpp = 8;
171  break;
172  case RE_GPU_FLOAT16:
173  case RE_GPU_UINT16:
174  case RE_GPU_INT16:
175  bpp = 16;
176  break;
177  case RE_GPU_FLOAT64:
178  bpp = 64;
179  break;
180  case RE_GPU_MATRIX2:
181  bpp = 32 * 4;
182  break;
183  case RE_GPU_MATRIX3:
184  bpp = 32 * 9;
185  break;
186  case RE_GPU_MATRIX4:
187  bpp = 32 * 16;
188  break;
189  // FLOAT24 is padded to 32
190  default:
191  break;
192  }
193 
194  return bpp;
195 }
196 
197 
198 // RE definitions for GL primitives
200 {
203 
205 
209 
213 
214  RE_PRIM_LINES_ADJACENT, // for geometry shaders; includes
215  RE_PRIM_LINE_STRIP_ADJACENT, // extra vertices outside the primitive
216  RE_PRIM_TRIANGLES_ADJACENT, // for curvature
218 
219  RE_PRIM_POLYGONS, // General N-sided polygons
220 
221  RE_PRIM_PATCHES, // Patches sent to tessellation shaders
222 
224 };
225 
226 // defined in RE_OGLRender.C
227 RE_API extern int REgetGLPrim(RE_PrimType t);
228 RE_API extern RE_PrimType REgetREPrim(int gltype);
229 RE_API extern const char *REgetPrimName(RE_PrimType p);
230 
231 
232 // GLSL Shader stage types (bitfield in case a shader function can be applied
233 // to more than one stage type)
234 // Values of this enum must be in sync with VE_ShaderType!
236 {
242 
243  RE_SHADER_COMPUTE = 0x20, // cannot be used with other stages
244 
246 };
247 
249 {
250  switch(stage)
251  {
252  case RE_SHADER_VERTEX : return "vert";
253  case RE_SHADER_GEOMETRY : return "geom";
254  case RE_SHADER_FRAGMENT : return "frag";
255  case RE_SHADER_TESSCONTROL: return "tcs";
256  case RE_SHADER_TESSEVAL : return "tes";
257  case RE_SHADER_COMPUTE : return "comp";
258  default : return "";
259  }
260 }
261 
262 // Shader language type - now just GLSL.
264 {
267 
270 
272 };
273 
274 // Basic Primitive type that a shader program is designed for.
276 {
282 
284 };
285 
286 // returns the shader target that a given prim would require.
289 
290 // RE definitions for the various GL buffer objects
292 {
293  RE_BUFFER_ATTRIBUTE = 0x001, // generic vertex attribute
294  RE_BUFFER_ELEMENT = 0x002, // vertex connectivity index list
295 
296  RE_BUFFER_UNIFORM = 0x004, // uniform buffer object
297  RE_BUFFER_PIXEL_WRITE = 0x008, // pixels move from CPU->GPU
298  RE_BUFFER_PIXEL_READ = 0x010, // pixels move from GPU->CPU
299  RE_BUFFER_TEXTURE = 0x020, // For buffer textures
300  RE_BUFFER_SHADER_STORAGE = 0x040 // For generic buffers
301 };
302 
304 {
305  // passing data to GPU only.
306  RE_BUFFER_WRITE_ONCE, // written once only, redrawn many
307  RE_BUFFER_WRITE_FREQUENT, // written several times, redrawn many
308  RE_BUFFER_WRITE_STREAM, // one write per redraw
309 
310  // reading data from GPU only.
314 
315  // read and write (ex: rendering to a vertex list to use as geo)
319 };
320 
322 {
326 };
327 
329 {
341 
342 };
343 
345 {
346  RE_ARRAY_VERTEX, // sampled at vertex frequency
347  RE_ARRAY_POINT, // sampled at point frequency (default)
348  RE_ARRAY_PRIMITIVE, // sampled at primitive frequency
349  RE_ARRAY_INSTANCE, // sampled at instance frequency
350  RE_ARRAY_DETAIL, // sampled at detail frequency
351  RE_ARRAY_RANDOM, // randomly sampled
352  RE_ARRAY_NULL // placeholder only for vertex state match
353 };
354 
356 {
359 
367  RE_GENATTRIB_WIDTH, // shares vertex array slot with pscale
368  RE_GENATTRIB_CE, // shares slot with N
369 
374 
378 
384 
385  // sentinel
387 };
388 
389 /// Vertex shader input locations for known attribute types. All others
390 /// attributes are assigned starting at location 'RE_GENLOC_FIRST_CUSTOM'.
392 {
395 
396  RE_LOC_P = 0,
399  RE_LOC_N = 3,
407 
411 
413 };
414 
415 #if defined(WIN32) || defined(MBSD_COCOA)
416 typedef void * Display;
417 #endif
418 
419 // Default GL cache size. 32b machines get 384MB, while 64b machines get 2GB.
420 #ifdef AMD64
421 #define RE_TEXCACHE_DEFAULT_MAX_SIZE int64(512) * 1024 * 1024
422 #define RE_BUFCACHE_DEFAULT_MAX_SIZE int64(2) * 1024 * 1024 * 1024
423 #else
424 #define RE_TEXCACHE_DEFAULT_MAX_SIZE 96 * 1024 * 1024
425 #define RE_BUFCACHE_DEFAULT_MAX_SIZE 384 * 1024 * 1024
426 #endif
427 
428 #define RE_DEFAULT_DPI 85.0
429 #define RE_SCALE_BELOW_RESOLUTION 1000
430 #define RE_MIN_RESOLUTION_SCALE_FACTOR 0.85f
431 
432 #define MM_TO_INCHES(mm) ((mm) / 25.4)
433 
434 #define RE_HALF_TONE_ALPHA 0.6f
435 #define RE_QUARTER_TONE_ALPHA 0.3f
436 
438 {
439  RE_BUFFER_UNINIT = 0, // current buffer not known
440  RE_FRONT, // front buffer
441  RE_BACK, // back buffer (must be double buffered; single use front)
442  RE_BACK_LEFT, // back-left buffer for quad buffered stereo
443  RE_BACK_RIGHT, // back-right buffer for quad buffered stero
444 
445  RE_FBO_ZS, // for rendering to FBO depth or stencil attachments
446  RE_FBO_COLOR // for rendering to FBO attachments 0-15; add the # to
447  // this enum.
448 
449  // RE_BOTH has been removed because the back buffer is no longer valid
450  // after swapping, so you shouldn't need to write to both ever.
451 };
452 
454 {
457 };
458 
460 {
463 };
464 
466 {
469 };
470 
472 {
476 };
477 
479 {
488 };
489 
491 {
500 };
501 
503 {
512 };
513 
515 {
525 };
526 
528 {
537 };
538 
540 {
546 };
547 
549 {
553 };
554 
555 // keep in sync with the GL barrier types (GL_*_BARRIER_BIT)
557 {
573 
574  RE_BARRIER_ALL = 0xFFFFFFFF
575 };
576 
577 #define RE_MODE_MULTISAMPLE_MASK 0x60
578 #define RE_MODE_MULTISAMPLE_SHIFT 5
579 
581 {
582  // The mode components
583  RE_MODE_NONE = 0x000,
584  RE_MODE_RGB = 0x001, // RGB mode (req'd)
585  RE_MODE_DOUBLE = 0x002, // Double buffer
586  RE_MODE_ZBUFFER = 0x004, // Depth buffer
587  RE_MODE_ALPHA = 0x008, // Alpha buffer (RGBA)
588  RE_MODE_STENCIL = 0x010, // Stencil buffer
589  RE_MODE_MULTISAMPLE_LOW = 0x020, // 2x Full Scene AA
590  RE_MODE_MULTISAMPLE_MED = 0x040, // 4x Full Scene AA
591  RE_MODE_MULTISAMPLE_HIGH = 0x060, // 8x (NV) / 6x (ATI) FS AA
592  RE_MODE_ACCUM = 0x080, // Color Accumulation buffer
593  RE_MODE_ACCUM_ALPHA = 0x100, // Alpha accum (needs color acc)
594  RE_MODE_HDR = 0x200, // HDR FP16 (FBO only)
595  RE_MODE_HDR_FP32 = 0x400, // HDR FP32 (FBO only)
596  RE_MODE_STEREO = 0x800, // quad buffer stereo
597 
598  // The actual modes themselves; convenience enums.
601 
604 
607 
610 
614 
617 
621 
628 };
629 
631 {
635 };
636 
638 {
639  RE_SEVERITY_MESSAGE =0, // ARB_debug_group only
640 
644 };
645 
646 // This is a bitmask.
647 // *** You must update REgetDeviceName() if you change this ***
649 {
651 
654  RE_DEVICE_INTEL_GMA = 0x4, // Intel GMA (not supported)
655  RE_DEVICE_INTEL_HD = 0x8, // Intel HD graphics
656  RE_DEVICE_GDI = 0x10, // Software OGL on Windows
658 
659  RE_DEVICE_PRO = 0x100, // Professional series
660  RE_DEVICE_MAC = 0x200, // Mac versions of drivers
661  RE_DEVICE_MAC_SILICON = 0x600, // ARM-based Macs
662 
666 };
667 
669  const char *renderstring);
670 
672 {
673  return (dev & RE_DEVICE_PRO);
674 }
675 
677 {
678  return !(dev & RE_DEVICE_PRO);
679 }
680 
681 class UT_String;
683 
688 
690 
691 class IMG_Raster;
692 typedef IMG_Raster *(*RE_IconLoader)(int, int);
693 
694 class PXL_Lookup;
695 
697 {
698 public:
700 
701  RE_RasterOpts() : myZoomX(-1), myZoomY(-1), myRotation(0),
702  myColorScale(1.0f), myColorShift(0.0f),
703  myColorBlack(0.0f), myColorWhite(1.0f),
704  myAlphaScale(1.0f), myAlphaShift(0.0f),
705  myGamma(1.0f), myAspectRatio(1.0f), myVScale(1.0f),
706  myLUTSize(0), myComponent(-1), myModifyAlpha(false),
707  myDither(true), myComponentsAsGrey(true),
708  myLUTObject(0), myTransparent(0), myPremultiplyFlag(0),
709  myFragment16bit(0), myStereoMode(0), myPreBright(0),
710  myIgnoreGamma(false), myColorCorrectDisable(false),
711  myResetViewMatrix(true), myFlipX(false), myFlipY(false),
712  myVisualization(Visualization::NONE)
713  { myLUT[0] = myLUT[1] = myLUT[2] = myLUT[3] = 0; }
714 
715  float myZoomX;
716  float myZoomY;
724  float myGamma;
726  float myVScale;
727  float *myLUT[4];
731  unsigned myModifyAlpha :1,
732  myDither : 1,
733  myComponentsAsGrey :1,
734  myTransparent :1,
735  myPremultiplyFlag:1,
736  myFragment16bit : 2,
737  myStereoMode : 2,
738  myPreBright : 1,
739  myIgnoreGamma : 1,
740  myColorCorrectDisable : 1,
741  myResetViewMatrix :1,
742  myFlipX:1,
743  myFlipY:1;
745 };
746 
747 
748 
749 // stack item for blending & smoothing (which also modifies the blend state)
751 {
752 public:
754  {
755  mySmoothPushed = false;
756  mySmoothRequest = false;
757  mySmoothEnable = false;
758  myForceSmooth = 0;
759  myPrevLineWidth = -1.0f;
760 
761  myBlend = 0;
762  mySourceFactor = RE_SBLEND_ONE;
763  myDestFactor = RE_DBLEND_ZERO;
764  myAlphaSourceFactor = RE_SBLEND_ONE;
765  myAlphaDestFactor = RE_DBLEND_ZERO;
766  myEquation = RE_BLEND_ADD;
767  }
768 
770  {
771  mySmoothPushed = state.mySmoothPushed;
772  mySmoothRequest = state.mySmoothRequest;
773  mySmoothEnable = state.mySmoothEnable;
774  myForceSmooth = state.myForceSmooth;
775  myPrevLineWidth = state.myPrevLineWidth;
776 
777  myBlend = state.myBlend;
778  mySourceFactor = state.mySourceFactor;
779  myDestFactor = state.myDestFactor;
780  myAlphaSourceFactor = state.myAlphaSourceFactor;
781  myAlphaDestFactor = state.myAlphaDestFactor;
782  myEquation = state.myEquation;
783  }
784 
785  void get(bool &req_smooth, int &blend,
788  RE_BlendEquation &eq) const
789  {
790  req_smooth = mySmoothRequest;
791  blend = myBlend;
792  s = mySourceFactor;
793  d = myDestFactor;
794  sa = myAlphaSourceFactor;
795  da = myAlphaDestFactor;
796  eq = myEquation;
797  }
798 
799  void invalidate()
800  {
801  mySmoothRequest = false;
802  mySmoothEnable = -1;
803  myForceSmooth = -1;
804  myBlend = -1;
805  mySourceFactor = (RE_BlendSourceFactor)-1;
806  myDestFactor = (RE_BlendDestFactor)-1;
807  myAlphaSourceFactor = (RE_BlendSourceFactor)-1;
808  myAlphaDestFactor = (RE_BlendDestFactor)-1;
809  myEquation = RE_BlendEquation(-1);
810  }
811 
812  bool isValid()
813  {
814  return (mySmoothEnable != -1 &&
815  myForceSmooth != -1 &&
816  myBlend != -1 &&
817  mySourceFactor != (RE_BlendSourceFactor)-1 &&
818  myDestFactor != (RE_BlendDestFactor)-1 &&
819  myAlphaSourceFactor != (RE_BlendSourceFactor)-1 &&
820  myAlphaDestFactor != (RE_BlendDestFactor)-1 &&
821  myEquation != RE_BlendEquation(-1));
822  }
823 
829  int myBlend;
835 };
836 
837 // Stack item for stenciling
839 {
840 public:
842  {
843  myEnable = false;
844  myClearValue = 0;
845  myWriteMask = 1;
846  myFunc = RE_SALWAYS;
847  myRef = 0;
848  myValueMask = 1;
849  myFailOperation = RE_SKEEP;
850  myPassDepthFailOperation = RE_SKEEP;
851  myPassDepthPassOperation = RE_SKEEP;
852  }
853 
854  void set(bool enable,
855  int clearValue,
856  int writeMask,
858  int ref,
859  int valueMask,
860  RE_SOperation failOperation,
861  RE_SOperation passDepthFailOperation,
862  RE_SOperation passDepthPassOperation)
863  {
864  myEnable = enable;
865  myClearValue = clearValue;
866  myWriteMask = writeMask;
867  myFunc = func;
868  myRef = ref;
869  myValueMask = valueMask;
870  myFailOperation = failOperation;
871  myPassDepthFailOperation = passDepthFailOperation;
872  myPassDepthPassOperation = passDepthPassOperation;
873  }
874 
875  void get(bool &enable,
876  int &clearValue,
877  int &writeMask,
879  int &ref,
880  int &valueMask,
881  RE_SOperation &failOperation,
882  RE_SOperation &passDepthFailOperation,
883  RE_SOperation &passDepthPassOperation) const
884  {
885  enable = myEnable;
886  clearValue = myClearValue;
887  writeMask = myWriteMask;
888  func = myFunc;
889  ref = myRef;
890  valueMask = myValueMask;
891  failOperation = myFailOperation;
892  passDepthFailOperation = myPassDepthFailOperation;
893  passDepthPassOperation = myPassDepthPassOperation;
894  }
895 
896  bool myEnable;
900  int myRef;
905 };
906 
907 // Depth stack item for depth buffer state
909 {
910 public:
912  {
913  myDepthTest = -1;
914  myDepthBufferWrite = -1;
915  myZFunction = (RE_ZFunction) -1;
916  myDepthClamp = -1;
917  myZNear = 0.0;
918  myZFar = 1.0;
919  }
920 
925  double myZNear;
926  double myZFar;
927 };
928 
929 #define PATTERN_STACK_SIZE 7
930 #define RE_SMOOTH_STACK_SIZE 16
931 #define RE_STENCIL_STACK_SIZE 16
932 #define RE_ALIGN_STACK_SIZE 16
933 #define RE_FRAMEBUFFER_STACK_SIZE 8
934 #define RE_SHADER_STACK_SIZE 16
935 #define RE_BUFFER_STACK_SIZE 8
936 #define RE_DEPTH_STACK_SIZE 16
937 #define RE_UNIFORM_STACK_SIZE 16
938 
939 
940 #define RE_STACK_DEPTH 256
941 
942 // ============================================================================
943 // Platlform-specific implementation defines, typedefs and declarations.
944 // At the moment there is only the Qt implementation.
945 // ============================================================================
946 
947 // We use RE_OGLContext and only cast at the last possible minute,
948 // to avoid problems compiling against certain OpenGL drivers.
949 class QOpenGLContext;
950 typedef QOpenGLContext *RE_OGLContext;
951 
952 /// ==========================================================================
953 /// For OpenGL 2D UI drawing.
955 typedef RE_GLDrawable *OGLDrawable;
956 /// ==========================================================================
957 
958 #endif
typedef int(APIENTRYP RE_PFNGLXSWAPINTERVALSGIPROC)(int)
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:744
#define RE_API
Definition: RE_API.h:10
RE_API RE_GraphicsDevice REdetermineGraphicsDevice(const char *renderstring)
float myAspectRatio
Definition: RE_Types.h:725
RE_API void REgetDeviceName(RE_GraphicsDevice dev, UT_String &name)
RE_BlendSourceFactor mySourceFactor
Definition: RE_Types.h:830
double myZFar
Definition: RE_Types.h:926
RE_FaceMode
Definition: RE_Types.h:471
RE_GPUType REconvertIMGType(IMG_DataType t)
Definition: RE_Types.h:134
unsigned int REsizeOfGPUType(RE_GPUType gpu_type)
Definition: RE_Types.h:156
RE_GLDrawable * OGLDrawable
Definition: RE_Types.h:954
RE_GraphicsDevice
Definition: RE_Types.h:648
float myVScale
Definition: RE_Types.h:726
UT_StringArray RE_OverrideList
Definition: RE_Types.h:689
UT_IntrusivePtr< RE_OGLBuffer > RE_OGLBufferHandle
Definition: RE_Types.h:686
GLdouble s
Definition: glad.h:3009
RE_Severity
Definition: RE_Types.h:637
RE_LineStyle
Definition: RE_Types.h:459
int myDepthBufferWrite
Definition: RE_Types.h:923
PXL_Visualization Visualization
Definition: RE_Types.h:699
float myZoomX
Definition: RE_Types.h:715
int myDepthTest
Definition: RE_Types.h:921
RE_ZFunction myZFunction
Definition: RE_Types.h:924
RE_MatrixMode
Definition: RE_Types.h:453
RE_GPUType REconvertFromGPUType(UT_GPUType t)
Definition: RE_Types.h:103
RE_SFunction myFunc
Definition: RE_Types.h:899
float myColorWhite
Definition: RE_Types.h:721
RE_SOperation myPassDepthFailOperation
Definition: RE_Types.h:903
int myDepthClamp
Definition: RE_Types.h:922
RE_ShaderType
Definition: RE_Types.h:235
RE_GenericAttribID
Definition: RE_Types.h:355
float myColorShift
Definition: RE_Types.h:719
vint4 blend(const vint4 &a, const vint4 &b, const vbool4 &mask)
Definition: simd.h:4949
UT_GPUType
Definition: UT_ComputeGPU.h:42
RE_GPUType
Definition: RE_Types.h:52
RE_BufferType
Definition: RE_Types.h:291
GLfloat f
Definition: glcorearb.h:1926
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:108
UT_StringHolder REshaderStageExtension(RE_ShaderType stage)
Definition: RE_Types.h:248
UT_GPUType PXLconvertToUTGPUType(PXL_DataFormat t)
Definition: PXL_Common.h:107
double myZNear
Definition: RE_Types.h:925
Visualization myVisualization
Definition: RE_Types.h:730
RE_BufferBinding
Definition: RE_Types.h:328
RE_SOperation myPassDepthPassOperation
Definition: RE_Types.h:904
GLint ref
Definition: glcorearb.h:124
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:854
IMG_DataType
Definition: IMG_FileTypes.h:17
int myComponent
Definition: RE_Types.h:729
float myZoomY
Definition: RE_Types.h:716
RE_SmoothMode
Definition: RE_Types.h:465
RE_BlendSourceFactor myAlphaSourceFactor
Definition: RE_Types.h:832
RE_BlendEquation
Definition: RE_Types.h:539
void copy(const re_BlendSmoothState &state)
Definition: RE_Types.h:769
bool REisProfessionalDevice(RE_GraphicsDevice dev)
Definition: RE_Types.h:671
RE_MemoryBarrierBitfield
Definition: RE_Types.h:556
GLuint const GLchar * name
Definition: glcorearb.h:786
RE_DisplayMode
Definition: RE_Types.h:580
RE_ZFunction
Definition: RE_Types.h:478
PXL_DataFormat
Definition: PXL_Common.h:20
float myColorBlack
Definition: RE_Types.h:720
GLdouble t
Definition: glad.h:2397
RE_ShaderAttribLocation
Definition: RE_Types.h:391
float myGamma
Definition: RE_Types.h:724
RE_BlendDestFactor myAlphaDestFactor
Definition: RE_Types.h:833
float myColorScale
Definition: RE_Types.h:718
RE_BlendDestFactor myDestFactor
Definition: RE_Types.h:831
GLenum func
Definition: glcorearb.h:783
RE_BufferAccess
Definition: RE_Types.h:321
UT_GPUType REconvertToUTGPUType(RE_GPUType t)
Definition: RE_Types.h:75
RE_GPUType REconvertPXLType(PXL_DataFormat t)
Definition: RE_Types.h:150
float myAlphaScale
Definition: RE_Types.h:722
RE_SOperation
Definition: RE_Types.h:502
RE_BlendEquation myEquation
Definition: RE_Types.h:834
RE_VisualType
Definition: RE_Types.h:630
RE_BlendSourceFactor
Definition: RE_Types.h:514
RE_ArrayType
Definition: RE_Types.h:344
RE_BufferUsageHint
Definition: RE_Types.h:303
UT_IntrusivePtr< RE_Material > RE_MaterialPtr
Definition: RE_Types.h:684
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:156
RE_RenderBuf
Definition: RE_Types.h:437
RE_WindowType
Definition: RE_Types.h:29
RE_ShaderTarget
Definition: RE_Types.h:275
RE_API RE_PrimType REgetREPrim(int gltype)
QOpenGLContext * RE_OGLContext
Definition: RE_Types.h:949
RE_API const char * REgetTypeName(RE_GPUType p)
int myRotation
Definition: RE_Types.h:717
RE_ShaderLanguage
Definition: RE_Types.h:263
RE_PrimType
Definition: RE_Types.h:199
RE_SFunction
Definition: RE_Types.h:490
bool REisConsumerDevice(RE_GraphicsDevice dev)
Definition: RE_Types.h:676
state
Definition: core.h:2289
RE_PersistentBufferMode
Definition: RE_Types.h:548
float myAlphaShift
Definition: RE_Types.h:723
RE_SOperation myFailOperation
Definition: RE_Types.h:902
RE_API RE_ShaderTarget REgetShaderTargetForGLPrim(int gltype)
RE_BlendDestFactor
Definition: RE_Types.h:527
PXL_Visualization
Definition: PXL_Common.h:165