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 };
274 
276 {
277  // passing data to GPU only.
278  RE_BUFFER_WRITE_ONCE, // written once only, redrawn many
279  RE_BUFFER_WRITE_FREQUENT, // written several times, redrawn many
280  RE_BUFFER_WRITE_STREAM, // one write per redraw
281 
282  // reading data from GPU only.
286 
287  // read and write (ex: rendering to a vertex list to use as geo)
291 };
292 
294 {
298 };
299 
301 {
310 };
311 
313 {
314  RE_ARRAY_VERTEX, // sampled at vertex frequency
315  RE_ARRAY_POINT, // sampled at point frequency (default)
316  RE_ARRAY_PRIMITIVE, // sampled at primitive frequency
317  RE_ARRAY_INSTANCE, // sampled at instance frequency
318  RE_ARRAY_DETAIL, // sampled at detail frequency
319  RE_ARRAY_RANDOM, // randomly sampled
320  RE_ARRAY_NULL // placeholder only for vertex state match
321 };
322 
324 {
327 
335  RE_GENATTRIB_WIDTH, // shares vertex array slot with pscale
336 
341 
345 
351 
352  // sentinel
354 };
355 
356 /// Vertex shader input locations for known attribute types. All others
357 /// attributes are assigned starting at location 'RE_GENLOC_FIRST_CUSTOM'.
359 {
362 
363  RE_LOC_P = 0,
366  RE_LOC_N = 3,
372 
376 
378 };
379 
380 #if defined(WIN32) || defined(MBSD_COCOA)
381 typedef void * Display;
382 #endif
383 
384 // Default GL cache size. 32b machines get 384MB, while 64b machines get 2GB.
385 #ifdef AMD64
386 #define RE_TEXCACHE_DEFAULT_MAX_SIZE int64(512) * 1024 * 1024
387 #define RE_BUFCACHE_DEFAULT_MAX_SIZE int64(2) * 1024 * 1024 * 1024
388 #else
389 #define RE_TEXCACHE_DEFAULT_MAX_SIZE 96 * 1024 * 1024
390 #define RE_BUFCACHE_DEFAULT_MAX_SIZE 384 * 1024 * 1024
391 #endif
392 
393 #define RE_DEFAULT_DPI 85.0
394 #define RE_SCALE_BELOW_RESOLUTION 1000
395 #define RE_MIN_RESOLUTION_SCALE_FACTOR 0.85f
396 
397 #define MM_TO_INCHES(mm) ((mm) / 25.4)
398 
399 #define RE_HALF_TONE_ALPHA 0.6f
400 #define RE_QUARTER_TONE_ALPHA 0.3f
401 
403 {
404  RE_BUFFER_UNINIT = 0, // current buffer not known
405  RE_FRONT, // front buffer
406  RE_BACK, // back buffer (must be double buffered; single use front)
407  RE_BACK_LEFT, // back-left buffer for quad buffered stereo
408  RE_BACK_RIGHT, // back-right buffer for quad buffered stero
409 
410  RE_FBO_ZS, // for rendering to FBO depth or stencil attachments
411  RE_FBO_COLOR // for rendering to FBO attachments 0-15; add the # to
412  // this enum.
413 
414  // RE_BOTH has been removed because the back buffer is no longer valid
415  // after swapping, so you shouldn't need to write to both ever.
416 };
417 
419 {
422 };
423 
425 {
428 };
429 
431 {
434 };
435 
437 {
441 };
442 
444 {
453 };
454 
456 {
465 };
466 
468 {
477 };
478 
480 {
490 };
491 
493 {
502 };
503 
505 {
509 };
510 
511 // keep in sync with the GL barrier types (GL_*_BARRIER_BIT)
513 {
529 
530  RE_BARRIR_ALL = 0xFFFFFFFF
531 };
532 
533 #define RE_MODE_MULTISAMPLE_MASK 0x60
534 #define RE_MODE_MULTISAMPLE_SHIFT 5
535 
537 {
538  // The mode components
539  RE_MODE_NONE = 0x000,
540  RE_MODE_RGB = 0x001, // RGB mode (req'd)
541  RE_MODE_DOUBLE = 0x002, // Double buffer
542  RE_MODE_ZBUFFER = 0x004, // Depth buffer
543  RE_MODE_ALPHA = 0x008, // Alpha buffer (RGBA)
544  RE_MODE_STENCIL = 0x010, // Stencil buffer
545  RE_MODE_MULTISAMPLE_LOW = 0x020, // 2x Full Scene AA
546  RE_MODE_MULTISAMPLE_MED = 0x040, // 4x Full Scene AA
547  RE_MODE_MULTISAMPLE_HIGH = 0x060, // 8x (NV) / 6x (ATI) FS AA
548  RE_MODE_ACCUM = 0x080, // Color Accumulation buffer
549  RE_MODE_ACCUM_ALPHA = 0x100, // Alpha accum (needs color acc)
550  RE_MODE_HDR = 0x200, // HDR FP16 (FBO only)
551  RE_MODE_HDR_FP32 = 0x400, // HDR FP32 (FBO only)
552  RE_MODE_STEREO = 0x800, // quad buffer stereo
553 
554  // The actual modes themselves; convenience enums.
557 
560 
563 
566 
570 
573 
577 
584 };
585 
587 {
591 };
592 
594 {
595  RE_SEVERITY_MESSAGE =0, // ARB_debug_group only
596 
600 };
601 
602 // This is a bitmask.
603 // *** You must update REgetDeviceName() if you change this ***
605 {
607 
610  RE_DEVICE_INTEL_GMA = 0x4, // Intel GMA (not supported)
611  RE_DEVICE_INTEL_HD = 0x8, // Intel HD graphics
612  RE_DEVICE_GDI = 0x10, // Software OGL on Windows
614 
615  RE_DEVICE_PRO = 0x100, // Professional series
616  RE_DEVICE_MAC = 0x200, // Mac versions of drivers
617 
621 };
622 
624  const char *renderstring);
625 
627 {
628  return (dev & RE_DEVICE_PRO);
629 }
630 
632 {
633  return !(dev & RE_DEVICE_PRO);
634 }
635 
636 class UT_String;
638 
639 #include <UT/UT_IntrusivePtr.h>
644 
645 #include <UT/UT_StringArray.h>
646 
648 
649 class IMG_Raster;
650 typedef IMG_Raster *(*RE_IconLoader)(int, int);
651 
652 class PXL_Lookup;
653 
655 {
656 public:
657  RE_RasterOpts() : myZoomX(-1), myZoomY(-1),
658  myColorScale(1.0f), myColorShift(0.0f),
659  myColorBlack(0.0f), myColorWhite(1.0f),
660  myAlphaScale(1.0f), myAlphaShift(0.0f),
661  myGamma(1.0f), myAspectRatio(1.0f), myVScale(1.0f),
662  myLUTSize(0), myComponent(-1), myModifyAlpha(false),
663  myDither(true), myComponentsAsGrey(true),
664  myLUTObject(0), myTransparent(0), myPremultiplyFlag(0),
665  myFragment16bit(0), myStereoMode(0), myPreBright(0),
666  myIgnoreGamma(false), myColorCorrectDisable(false)
667  { myLUT[0] = myLUT[1] = myLUT[2] = myLUT[3] = 0; }
668 
669  float myZoomX;
670  float myZoomY;
677  float myGamma;
679  float myVScale;
680  float *myLUT[4];
683  unsigned myModifyAlpha :1,
684  myDither : 1,
685  myComponentsAsGrey :1,
686  myTransparent :1,
687  myPremultiplyFlag:1,
688  myFragment16bit : 2,
689  myStereoMode : 2,
690  myPreBright : 1,
691  myIgnoreGamma : 1,
692  myColorCorrectDisable : 1;
694 };
695 
696 
697 
698 // stack item for blending & smoothing (which also modifies the blend state)
700 {
701 public:
703  {
704  mySmoothPushed = false;
705  mySmoothRequest = false;
706  mySmoothEnable = false;
707  myForceSmooth = 0;
708  myPrevLineWidth = -1.0f;
709 
710  myBlend = 0;
711  mySourceFactor = RE_SBLEND_ONE;
712  myDestFactor = RE_DBLEND_ZERO;
713  myAlphaSourceFactor = RE_SBLEND_ONE;
714  myAlphaDestFactor = RE_DBLEND_ZERO;
715  }
716 
717  void copy(const re_BlendSmoothState &state)
718  {
719  mySmoothPushed = state.mySmoothPushed;
720  mySmoothRequest = state.mySmoothRequest;
721  mySmoothEnable = state.mySmoothEnable;
722  myForceSmooth = state.myForceSmooth;
723  myPrevLineWidth = state.myPrevLineWidth;
724 
725  myBlend = state.myBlend;
726  mySourceFactor = state.mySourceFactor;
727  myDestFactor = state.myDestFactor;
728  myAlphaSourceFactor = state.myAlphaSourceFactor;
729  myAlphaDestFactor = state.myAlphaDestFactor;
730  }
731 
732  void get(bool &req_smooth, int &blend,
735  {
736  req_smooth = mySmoothRequest;
737  blend = myBlend;
738  s = mySourceFactor;
739  d = myDestFactor;
740  sa = myAlphaSourceFactor;
741  da = myAlphaDestFactor;
742  }
743 
744  void invalidate()
745  {
746  mySmoothRequest = false;
747  mySmoothEnable = -1;
748  myForceSmooth = -1;
749  myBlend = -1;
750  mySourceFactor = (RE_BlendSourceFactor)-1;
751  myDestFactor = (RE_BlendDestFactor)-1;
752  myAlphaSourceFactor = (RE_BlendSourceFactor)-1;
753  myAlphaDestFactor = (RE_BlendDestFactor)-1;
754  }
755 
756  bool isValid()
757  {
758  return (mySmoothEnable != -1 &&
759  myForceSmooth != -1 &&
760  myBlend != -1 &&
761  mySourceFactor != (RE_BlendSourceFactor)-1 &&
762  myDestFactor != (RE_BlendDestFactor)-1 &&
763  myAlphaSourceFactor != (RE_BlendSourceFactor)-1 &&
764  myAlphaDestFactor != (RE_BlendDestFactor)-1);
765  }
766 
772  int myBlend;
777 };
778 
779 // Stack item for stenciling
781 {
782 public:
784  {
785  myEnable = false;
786  myClearValue = 0;
787  myWriteMask = 1;
788  myFunc = RE_SALWAYS;
789  myRef = 0;
790  myValueMask = 1;
791  myFailOperation = RE_SKEEP;
792  myPassDepthFailOperation = RE_SKEEP;
793  myPassDepthPassOperation = RE_SKEEP;
794  }
795 
796  void set(bool enable,
797  int clearValue,
798  int writeMask,
800  int ref,
801  int valueMask,
802  RE_SOperation failOperation,
803  RE_SOperation passDepthFailOperation,
804  RE_SOperation passDepthPassOperation)
805  {
806  myEnable = enable;
807  myClearValue = clearValue;
808  myWriteMask = writeMask;
809  myFunc = func;
810  myRef = ref;
811  myValueMask = valueMask;
812  myFailOperation = failOperation;
813  myPassDepthFailOperation = passDepthFailOperation;
814  myPassDepthPassOperation = passDepthPassOperation;
815  }
816 
817  void get(bool &enable,
818  int &clearValue,
819  int &writeMask,
821  int &ref,
822  int &valueMask,
823  RE_SOperation &failOperation,
824  RE_SOperation &passDepthFailOperation,
825  RE_SOperation &passDepthPassOperation) const
826  {
827  enable = myEnable;
828  clearValue = myClearValue;
829  writeMask = myWriteMask;
830  func = myFunc;
831  ref = myRef;
832  valueMask = myValueMask;
833  failOperation = myFailOperation;
834  passDepthFailOperation = myPassDepthFailOperation;
835  passDepthPassOperation = myPassDepthPassOperation;
836  }
837 
838  bool myEnable;
842  int myRef;
847 };
848 
849 // Depth stack item for depth buffer state
851 {
852 public:
854  {
855  myDepthTest = -1;
856  myDepthBufferWrite = -1;
857  myZFunction = (RE_ZFunction) -1;
858  myDepthClamp = -1;
859  myZNear = 0.0;
860  myZFar = 1.0;
861  }
862 
867  double myZNear;
868  double myZFar;
869 };
870 
871 #define PATTERN_STACK_SIZE 7
872 #define RE_SMOOTH_STACK_SIZE 16
873 #define RE_STENCIL_STACK_SIZE 16
874 #define RE_ALIGN_STACK_SIZE 16
875 #define RE_FRAMEBUFFER_STACK_SIZE 8
876 #define RE_SHADER_STACK_SIZE 16
877 #define RE_BUFFER_STACK_SIZE 8
878 #define RE_DEPTH_STACK_SIZE 16
879 #define RE_UNIFORM_STACK_SIZE 16
880 
881 
882 #define RE_STACK_DEPTH 256
883 
884 // ============================================================================
885 // Platlform-specific implementation defines, typedefs and declarations.
886 // At the moment there is only the Qt implementation.
887 // ============================================================================
888 
889 // We use RE_OGLContext and only cast at the last possible minute,
890 // to avoid problems compiling against certain OpenGL drivers.
891 class QOpenGLContext;
892 typedef QOpenGLContext *RE_OGLContext;
893 
895 typedef RE_GLDrawable *OGLDrawable;
896 
897 #endif
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:693
#define RE_API
Definition: RE_API.h:10
RE_API RE_GraphicsDevice REdetermineGraphicsDevice(const char *renderstring)
float myAspectRatio
Definition: RE_Types.h:678
RE_API void REgetDeviceName(RE_GraphicsDevice dev, UT_String &name)
RE_BlendSourceFactor mySourceFactor
Definition: RE_Types.h:773
double myZFar
Definition: RE_Types.h:868
RE_FaceMode
Definition: RE_Types.h:436
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:894
RE_GraphicsDevice
Definition: RE_Types.h:604
float myVScale
Definition: RE_Types.h:679
UT_StringArray RE_OverrideList
Definition: RE_Types.h:647
UT_IntrusivePtr< RE_OGLBuffer > RE_OGLBufferHandle
Definition: RE_Types.h:642
RE_Severity
Definition: RE_Types.h:593
RE_LineStyle
Definition: RE_Types.h:424
int myDepthBufferWrite
Definition: RE_Types.h:865
float myZoomX
Definition: RE_Types.h:669
int myDepthTest
Definition: RE_Types.h:863
RE_ZFunction myZFunction
Definition: RE_Types.h:866
RE_MatrixMode
Definition: RE_Types.h:418
RE_GPUType REconvertFromGPUType(UT_GPUType t)
Definition: RE_Types.h:95
RE_SFunction myFunc
Definition: RE_Types.h:841
float myColorWhite
Definition: RE_Types.h:674
RE_SOperation myPassDepthFailOperation
Definition: RE_Types.h:845
int myDepthClamp
Definition: RE_Types.h:864
RE_ShaderType
Definition: RE_Types.h:228
RE_GenericAttribID
Definition: RE_Types.h:323
float myColorShift
Definition: RE_Types.h:672
UT_GPUType
Definition: UT_ComputeGPU.h:41
RE_GPUType
Definition: RE_Types.h:44
RE_BufferType
Definition: RE_Types.h:264
GLfloat f
Definition: glcorearb.h:1925
UT_GPUType PXLconvertToUTGPUType(PXL_DataFormat t)
Definition: PXL_Common.h:73
double myZNear
Definition: RE_Types.h:867
RE_BufferBinding
Definition: RE_Types.h:300
RE_SOperation myPassDepthPassOperation
Definition: RE_Types.h:846
GLint ref
Definition: glcorearb.h:123
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:796
IMG_DataType
Definition: IMG_FileTypes.h:17
int myComponent
Definition: RE_Types.h:682
float myZoomY
Definition: RE_Types.h:670
RE_SmoothMode
Definition: RE_Types.h:430
RE_BlendSourceFactor myAlphaSourceFactor
Definition: RE_Types.h:775
void copy(const re_BlendSmoothState &state)
Definition: RE_Types.h:717
bool REisProfessionalDevice(RE_GraphicsDevice dev)
Definition: RE_Types.h:626
RE_MemoryBarrierBitfield
Definition: RE_Types.h:512
RE_DisplayMode
Definition: RE_Types.h:536
GLuint const GLchar * name
Definition: glcorearb.h:785
RE_ZFunction
Definition: RE_Types.h:443
PXL_DataFormat
Definition: PXL_Common.h:19
float myColorBlack
Definition: RE_Types.h:673
RE_ShaderAttribLocation
Definition: RE_Types.h:358
float myGamma
Definition: RE_Types.h:677
RE_BlendDestFactor myAlphaDestFactor
Definition: RE_Types.h:776
float myColorScale
Definition: RE_Types.h:671
RE_BlendDestFactor myDestFactor
Definition: RE_Types.h:774
GLenum func
Definition: glcorearb.h:782
RE_BufferAccess
Definition: RE_Types.h:293
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:675
typedef int
Definition: png.h:1175
RE_SOperation
Definition: RE_Types.h:467
RE_VisualType
Definition: RE_Types.h:586
RE_BlendSourceFactor
Definition: RE_Types.h:479
RE_ArrayType
Definition: RE_Types.h:312
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
RE_BufferUsageHint
Definition: RE_Types.h:275
UT_IntrusivePtr< RE_Material > RE_MaterialPtr
Definition: RE_Types.h:640
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:126
RE_RenderBuf
Definition: RE_Types.h:402
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:891
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:455
bool REisConsumerDevice(RE_GraphicsDevice dev)
Definition: RE_Types.h:631
RE_PersistentBufferMode
Definition: RE_Types.h:504
float myAlphaShift
Definition: RE_Types.h:676
RE_SOperation myFailOperation
Definition: RE_Types.h:844
RE_API RE_ShaderTarget REgetShaderTargetForGLPrim(int gltype)
RE_BlendDestFactor
Definition: RE_Types.h:492