HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros 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  RE_WINDOW_INVALID_TYPE // Not a type. Used to mean "uninitialized."
37 };
38 // should always point to the last type.
39 #define RE_NUM_WINDOW_TYPES RE_WINDOW_INVALID_TYPE
40 #include <UT/UT_Assert.h>
41 #include <UT/UT_ComputeGPU.h>
43 {
44  RE_GPU_UINT1 = 0, // corresponds to GL_STENCIL_INDEX1
45  RE_GPU_UINT4, // corresponds to GL_STENCIL_INDEX4
49 
53 
55  RE_GPU_FLOAT24, // corresponds to GL_DEPTH_COMPONENT24
58 
59  // These can only be used in the context of a GLSL shader.
63 };
64 
66 {
67  switch (t)
68  {
69  case RE_GPU_UINT1: return UT_GPU_UINT1;
70  case RE_GPU_UINT4: return UT_GPU_UINT4;
71  case RE_GPU_UINT8: return UT_GPU_UINT8;
72  case RE_GPU_UINT16: return UT_GPU_UINT16;
73  case RE_GPU_UINT32: return UT_GPU_UINT32;
74 
75  case RE_GPU_INT8: return UT_GPU_INT8;
76  case RE_GPU_INT16: return UT_GPU_INT16;
77  case RE_GPU_INT32: return UT_GPU_INT32;
78 
79  case RE_GPU_FLOAT16: return UT_GPU_FLOAT16;
80  case RE_GPU_FLOAT24: return UT_GPU_FLOAT24;
81  case RE_GPU_FLOAT32: return UT_GPU_FLOAT32;
82  case RE_GPU_FLOAT64: return UT_GPU_FLOAT64;
83 
84  case RE_GPU_MATRIX2: return UT_GPU_MATRIX2;
85  case RE_GPU_MATRIX3: return UT_GPU_MATRIX3;
86  case RE_GPU_MATRIX4: return UT_GPU_MATRIX4;
87  }
88 
89  UT_ASSERT(!"Unknown RE_GPUType.");
90  return UT_GPU_UINT8;
91 }
92 
94 {
95  switch (t)
96  {
97  case UT_GPU_UINT1: return RE_GPU_UINT1;
98  case UT_GPU_UINT4: return RE_GPU_UINT4;
99  case UT_GPU_UINT8: return RE_GPU_UINT8;
100  case UT_GPU_UINT16: return RE_GPU_UINT16;
101  case UT_GPU_UINT32: return RE_GPU_UINT32;
102 
103  case UT_GPU_INT8: return RE_GPU_INT8;
104  case UT_GPU_INT16: return RE_GPU_INT16;
105  case UT_GPU_INT32: return RE_GPU_INT32;
106 
107  case UT_GPU_FLOAT16: return RE_GPU_FLOAT16;
108  case UT_GPU_FLOAT24: return RE_GPU_FLOAT24;
109  case UT_GPU_FLOAT32: return RE_GPU_FLOAT32;
110  case UT_GPU_FLOAT64: return RE_GPU_FLOAT64;
111 
112  case UT_GPU_MATRIX2: return RE_GPU_MATRIX2;
113  case UT_GPU_MATRIX3: return RE_GPU_MATRIX3;
114  case UT_GPU_MATRIX4: return RE_GPU_MATRIX4;
115  }
116 
117  UT_ASSERT(!"Unknown UT_GPUType.");
118  return RE_GPU_UINT8;
119 }
120 
121 // defined in RE_OGLRender.C
122 RE_API extern const char *REgetTypeName(RE_GPUType p);
123 
124 #include <PXL/PXL_Common.h>
125 #include <IMG/IMG_FileTypes.h>
127 {
128  switch(t)
129  {
130  default:
131  case IMG_INT8: return RE_GPU_UINT8;
132  case IMG_INT16: return RE_GPU_UINT16;
133  case IMG_INT32: return RE_GPU_UINT32;
134  case IMG_FLOAT32: return RE_GPU_FLOAT32;
135  case IMG_FLOAT16: return RE_GPU_FLOAT16;
136  }
137 
138  UT_ASSERT(!"Unknown type");
139  return RE_GPU_UINT8;
140 }
141 
143 {
145 }
146 
147 // Function to get size in bits of a RE_GPUType
148 inline unsigned int REsizeOfGPUType(RE_GPUType gpu_type)
149 {
150  int bpp = 32;
151 
152  switch(gpu_type)
153  {
154  case RE_GPU_UINT1:
155  bpp = 1;
156  break;
157  case RE_GPU_UINT4:
158  bpp = 4;
159  break;
160  case RE_GPU_UINT8:
161  case RE_GPU_INT8:
162  bpp = 8;
163  break;
164  case RE_GPU_FLOAT16:
165  case RE_GPU_UINT16:
166  case RE_GPU_INT16:
167  bpp = 16;
168  break;
169  case RE_GPU_FLOAT64:
170  bpp = 64;
171  break;
172  case RE_GPU_MATRIX2:
173  bpp = 32 * 4;
174  break;
175  case RE_GPU_MATRIX3:
176  bpp = 32 * 9;
177  break;
178  case RE_GPU_MATRIX4:
179  bpp = 32 * 16;
180  break;
181  // FLOAT24 is padded to 32
182  default:
183  break;
184  }
185 
186  return bpp;
187 }
188 
189 
190 // RE definitions for GL primitives
192 {
195 
197 
201 
205 
206  RE_PRIM_LINES_ADJACENT, // for geometry shaders; includes
207  RE_PRIM_LINE_STRIP_ADJACENT, // extra vertices outside the primitive
208  RE_PRIM_TRIANGLES_ADJACENT, // for curvature
210 
211  RE_PRIM_POLYGONS, // General N-sided polygons
212 
213  RE_PRIM_PATCHES, // Patches sent to tessellation shaders
214 
216 };
217 
218 // defined in RE_OGLRender.C
219 RE_API extern int REgetGLPrim(RE_PrimType t);
220 RE_API extern RE_PrimType REgetREPrim(int gltype);
221 RE_API extern const char *REgetPrimName(RE_PrimType p);
222 
223 
224 // GLSL Shader stage types (bitfield in case a shader function can be applied
225 // to more than one stage type)
227 {
233 
234  RE_SHADER_COMPUTE = 0x20, // cannot be used with other stages
235 
237 };
238 
239 // Shader language type - now just GLSL.
241 {
245 };
246 
247 // Basic Primitive type that a shader program is designed for.
249 {
253 
255 };
256 
257 // returns the shader target that a given prim would require.
260 
261 // RE definitions for the various GL buffer objects
263 {
264  RE_BUFFER_ATTRIBUTE = 0x001, // generic vertex attribute
265  RE_BUFFER_ELEMENT = 0x002, // vertex connectivity index list
266 
267  RE_BUFFER_UNIFORM = 0x004, // uniform buffer object
268  RE_BUFFER_PIXEL_WRITE = 0x008, // pixels move from CPU->GPU
269  RE_BUFFER_PIXEL_READ = 0x010, // pixels move from GPU->CPU
270  RE_BUFFER_TEXTURE = 0x020 // For buffer textures
271 };
272 
274 {
275  // passing data to GPU only.
276  RE_BUFFER_WRITE_ONCE, // written once only, redrawn many
277  RE_BUFFER_WRITE_FREQUENT, // written several times, redrawn many
278  RE_BUFFER_WRITE_STREAM, // one write per redraw
279 
280  // reading data from GPU only.
284 
285  // read and write (ex: rendering to a vertex list to use as geo)
289 };
290 
292 {
296 };
297 
299 {
308 };
309 
311 {
312  RE_ARRAY_VERTEX, // sampled at vertex frequency
313  RE_ARRAY_POINT, // sampled at point frequency (default)
314  RE_ARRAY_PRIMITIVE, // sampled at primitive frequency
315  RE_ARRAY_INSTANCE, // sampled at instance frequency
316  RE_ARRAY_DETAIL, // sampled at detail frequency
317  RE_ARRAY_RANDOM, // randomly sampled
318  RE_ARRAY_NULL // placeholder only for vertex state match
319 };
320 
322 {
325 
333 
338 
342 
348 
349  // sentinel
351 };
352 
353 /// Vertex shader input locations for known attribute types. All others
354 /// attributes are assigned starting at location 'RE_GENLOC_FIRST_CUSTOM'.
356 {
359 
360  RE_LOC_P = 0,
363  RE_LOC_N = 3,
369 
373 
375 };
376 
377 #if defined(WIN32) || defined(MBSD_COCOA)
378 typedef void * Display;
379 #endif
380 
381 // Default GL cache size. 32b machines get 384MB, while 64b machines get 2GB.
382 #ifdef AMD64
383 #define RE_TEXCACHE_DEFAULT_MAX_SIZE int64(512) * 1024 * 1024
384 #define RE_BUFCACHE_DEFAULT_MAX_SIZE int64(2) * 1024 * 1024 * 1024
385 #else
386 #define RE_TEXCACHE_DEFAULT_MAX_SIZE 96 * 1024 * 1024
387 #define RE_BUFCACHE_DEFAULT_MAX_SIZE 384 * 1024 * 1024
388 #endif
389 
390 #define RE_DEFAULT_DPI 85.0
391 #define RE_SCALE_BELOW_RESOLUTION 1000
392 #define RE_MIN_RESOLUTION_SCALE_FACTOR 0.85f
393 
394 #define MM_TO_INCHES(mm) ((mm) / 25.4)
395 
396 #define RE_HALF_TONE_ALPHA 0.6f
397 #define RE_QUARTER_TONE_ALPHA 0.3f
398 
400 {
401  RE_BUFFER_UNINIT = 0, // current buffer not known
402  RE_FRONT, // front buffer
403  RE_BACK, // back buffer (must be double buffered; single use front)
404  RE_BACK_LEFT, // back-left buffer for quad buffered stereo
405  RE_BACK_RIGHT, // back-right buffer for quad buffered stero
406 
407  RE_FBO_ZS, // for rendering to FBO depth or stencil attachments
408  RE_FBO_COLOR // for rendering to FBO attachments 0-15; add the # to
409  // this enum.
410 
411  // RE_BOTH has been removed because the back buffer is no longer valid
412  // after swapping, so you shouldn't need to write to both ever.
413 };
414 
416 {
419 };
420 
422 {
425 };
426 
428 {
431 };
432 
434 {
438 };
439 
441 {
450 };
451 
453 {
462 };
463 
465 {
474 };
475 
477 {
487 };
488 
490 {
499 };
500 
502 {
506 };
507 
508 // keep in sync with the GL barrier types (GL_*_BARRIER_BIT)
510 {
526 
527  RE_BARRIR_ALL = 0xFFFFFFFF
528 };
529 
530 #define RE_MODE_MULTISAMPLE_MASK 0x60
531 #define RE_MODE_MULTISAMPLE_SHIFT 5
532 
534 {
535  // The mode components
536  RE_MODE_NONE = 0x000,
537  RE_MODE_RGB = 0x001, // RGB mode (req'd)
538  RE_MODE_DOUBLE = 0x002, // Double buffer
539  RE_MODE_ZBUFFER = 0x004, // Depth buffer
540  RE_MODE_ALPHA = 0x008, // Alpha buffer (RGBA)
541  RE_MODE_STENCIL = 0x010, // Stencil buffer
542  RE_MODE_MULTISAMPLE_LOW = 0x020, // 2x Full Scene AA
543  RE_MODE_MULTISAMPLE_MED = 0x040, // 4x Full Scene AA
544  RE_MODE_MULTISAMPLE_HIGH = 0x060, // 8x (NV) / 6x (ATI) FS AA
545  RE_MODE_ACCUM = 0x080, // Color Accumulation buffer
546  RE_MODE_ACCUM_ALPHA = 0x100, // Alpha accum (needs color acc)
547  RE_MODE_HDR = 0x200, // HDR FP16 (FBO only)
548  RE_MODE_HDR_FP32 = 0x400, // HDR FP32 (FBO only)
549  RE_MODE_STEREO = 0x800, // quad buffer stereo
550 
551  // The actual modes themselves; convenience enums.
554 
557 
560 
563 
567 
570 
574 
581 };
582 
584 {
588 };
589 
591 {
592  RE_SEVERITY_MESSAGE =0, // ARB_debug_group only
593 
597 };
598 
599 // This is a bitmask.
600 // *** You must update REgetDeviceName() if you change this ***
602 {
604 
607  RE_DEVICE_INTEL_GMA = 0x4, // Intel GMA (not supported)
608  RE_DEVICE_INTEL_HD = 0x8, // Intel HD graphics
609  RE_DEVICE_GDI = 0x10, // Software OGL on Windows
611 
612  RE_DEVICE_PRO = 0x100, // Professional series
613  RE_DEVICE_MAC = 0x200, // Mac versions of drivers
614 
618 };
619 
621  const char *renderstring);
622 
624 {
625  return (dev & RE_DEVICE_PRO);
626 }
627 
629 {
630  return !(dev & RE_DEVICE_PRO);
631 }
632 
633 class UT_String;
635 
636 #include <UT/UT_IntrusivePtr.h>
641 
642 #include <UT/UT_StringArray.h>
643 
645 
646 class IMG_Raster;
647 typedef IMG_Raster *(*RE_IconLoader)(int, int);
648 
649 class PXL_Lookup;
650 
652 {
653 public:
654  RE_RasterOpts() : myZoomX(-1), myZoomY(-1),
655  myColorScale(1.0f), myColorShift(0.0f),
656  myColorBlack(0.0f), myColorWhite(1.0f),
657  myAlphaScale(1.0f), myAlphaShift(0.0f),
658  myGamma(1.0f), myAspectRatio(1.0f), myVScale(1.0f),
659  myLUTSize(0), myComponent(-1), myModifyAlpha(false),
660  myDither(true), myComponentsAsGrey(true),
661  myLUTObject(0), myTransparent(0), myPremultiplyFlag(0),
662  myFragment16bit(0), myStereoMode(0), myPreBright(0),
663  myIgnoreGamma(false), myColorCorrectDisable(false)
664  { myLUT[0] = myLUT[1] = myLUT[2] = myLUT[3] = 0; }
665 
666  float myZoomX;
667  float myZoomY;
674  float myGamma;
676  float myVScale;
677  float *myLUT[4];
680  unsigned myModifyAlpha :1,
681  myDither : 1,
682  myComponentsAsGrey :1,
683  myTransparent :1,
684  myPremultiplyFlag:1,
685  myFragment16bit : 2,
686  myStereoMode : 2,
687  myPreBright : 1,
688  myIgnoreGamma : 1,
689  myColorCorrectDisable : 1;
691 };
692 
693 
694 
695 // stack item for blending & smoothing (which also modifies the blend state)
697 {
698 public:
700  {
701  mySmoothPushed = false;
702  mySmoothRequest = false;
703  mySmoothEnable = false;
704  myForceSmooth = 0;
705  myPrevLineWidth = -1.0f;
706 
707  myBlend = 0;
708  mySourceFactor = RE_SBLEND_ONE;
709  myDestFactor = RE_DBLEND_ZERO;
710  myAlphaSourceFactor = RE_SBLEND_ONE;
711  myAlphaDestFactor = RE_DBLEND_ZERO;
712  }
713 
714  void copy(const re_BlendSmoothState &state)
715  {
716  mySmoothPushed = state.mySmoothPushed;
717  mySmoothRequest = state.mySmoothRequest;
718  mySmoothEnable = state.mySmoothEnable;
719  myForceSmooth = state.myForceSmooth;
720  myPrevLineWidth = state.myPrevLineWidth;
721 
722  myBlend = state.myBlend;
723  mySourceFactor = state.mySourceFactor;
724  myDestFactor = state.myDestFactor;
725  myAlphaSourceFactor = state.myAlphaSourceFactor;
726  myAlphaDestFactor = state.myAlphaDestFactor;
727  }
728 
729  void get(bool &req_smooth, int &blend,
732  {
733  req_smooth = mySmoothRequest;
734  blend = myBlend;
735  s = mySourceFactor;
736  d = myDestFactor;
737  sa = myAlphaSourceFactor;
738  da = myAlphaDestFactor;
739  }
740 
746  int myBlend;
751 };
752 
753 // Stack item for stenciling
755 {
756 public:
758  {
759  myEnable = false;
760  myClearValue = 0;
761  myWriteMask = 1;
762  myFunc = RE_SALWAYS;
763  myRef = 0;
764  myValueMask = 1;
765  myFailOperation = RE_SKEEP;
766  myPassDepthFailOperation = RE_SKEEP;
767  myPassDepthPassOperation = RE_SKEEP;
768  }
769 
770  void set(bool enable,
771  int clearValue,
772  int writeMask,
774  int ref,
775  int valueMask,
776  RE_SOperation failOperation,
777  RE_SOperation passDepthFailOperation,
778  RE_SOperation passDepthPassOperation)
779  {
780  myEnable = enable;
781  myClearValue = clearValue;
782  myWriteMask = writeMask;
783  myFunc = func;
784  myRef = ref;
785  myValueMask = valueMask;
786  myFailOperation = failOperation;
787  myPassDepthFailOperation = passDepthFailOperation;
788  myPassDepthPassOperation = passDepthPassOperation;
789  }
790 
791  void get(bool &enable,
792  int &clearValue,
793  int &writeMask,
795  int &ref,
796  int &valueMask,
797  RE_SOperation &failOperation,
798  RE_SOperation &passDepthFailOperation,
799  RE_SOperation &passDepthPassOperation) const
800  {
801  enable = myEnable;
802  clearValue = myClearValue;
803  writeMask = myWriteMask;
804  func = myFunc;
805  ref = myRef;
806  valueMask = myValueMask;
807  failOperation = myFailOperation;
808  passDepthFailOperation = myPassDepthFailOperation;
809  passDepthPassOperation = myPassDepthPassOperation;
810  }
811 
812  bool myEnable;
816  int myRef;
821 };
822 
823 // Depth stack item for depth buffer state
825 {
826 public:
828  {
829  myDepthTest = -1;
830  myDepthBufferWrite = -1;
831  myZFunction = (RE_ZFunction) -1;
832  myDepthClamp = -1;
833  }
834 
839 };
840 
841 #define PATTERN_STACK_SIZE 7
842 #define RE_SMOOTH_STACK_SIZE 16
843 #define RE_STENCIL_STACK_SIZE 16
844 #define RE_ALIGN_STACK_SIZE 16
845 #define RE_FRAMEBUFFER_STACK_SIZE 8
846 #define RE_SHADER_STACK_SIZE 16
847 #define RE_BUFFER_STACK_SIZE 8
848 #define RE_DEPTH_STACK_SIZE 16
849 #define RE_UNIFORM_STACK_SIZE 16
850 
851 
852 #define RE_STACK_DEPTH 256
853 
854 // ============================================================================
855 // Platlform-specific implementation defines, typedefs and declarations.
856 // At the moment there is only the Qt implementation.
857 // ============================================================================
858 
859 // We use RE_OGLContext and only cast at the last possible minute,
860 // to avoid problems compiling against certain OpenGL drivers.
861 #if defined(USE_QT5)
862 class QOpenGLContext;
863 typedef QOpenGLContext *RE_OGLContext;
864 #else
865 typedef void *RE_OGLContext;
866 #endif
867 
868 #if defined(USE_QT5)
869 class RE_GLDrawable;
870 typedef RE_GLDrawable * OGLDrawable;
871 #else
872 class QGLWidget;
873 typedef QGLWidget * OGLDrawable;
874 #endif
875 
876 #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:690
#define RE_API
Definition: RE_API.h:10
RE_API RE_GraphicsDevice REdetermineGraphicsDevice(const char *renderstring)
float myAspectRatio
Definition: RE_Types.h:675
RE_API void REgetDeviceName(RE_GraphicsDevice dev, UT_String &name)
RE_BlendSourceFactor mySourceFactor
Definition: RE_Types.h:747
RE_FaceMode
Definition: RE_Types.h:433
RE_GPUType REconvertIMGType(IMG_DataType t)
Definition: RE_Types.h:126
unsigned int REsizeOfGPUType(RE_GPUType gpu_type)
Definition: RE_Types.h:148
RE_GraphicsDevice
Definition: RE_Types.h:601
float myVScale
Definition: RE_Types.h:676
UT_StringArray RE_OverrideList
Definition: RE_Types.h:644
UT_IntrusivePtr< RE_OGLBuffer > RE_OGLBufferHandle
Definition: RE_Types.h:639
RE_Severity
Definition: RE_Types.h:590
RE_LineStyle
Definition: RE_Types.h:421
int myDepthBufferWrite
Definition: RE_Types.h:837
float myZoomX
Definition: RE_Types.h:666
int myDepthTest
Definition: RE_Types.h:835
RE_ZFunction myZFunction
Definition: RE_Types.h:838
RE_MatrixMode
Definition: RE_Types.h:415
RE_GPUType REconvertFromGPUType(UT_GPUType t)
Definition: RE_Types.h:93
void * RE_OGLContext
Definition: RE_Types.h:865
RE_SFunction myFunc
Definition: RE_Types.h:815
float myColorWhite
Definition: RE_Types.h:671
RE_SOperation myPassDepthFailOperation
Definition: RE_Types.h:819
int myDepthClamp
Definition: RE_Types.h:836
RE_ShaderType
Definition: RE_Types.h:226
RE_GenericAttribID
Definition: RE_Types.h:321
float myColorShift
Definition: RE_Types.h:669
UT_GPUType
Definition: UT_ComputeGPU.h:41
RE_GPUType
Definition: RE_Types.h:42
RE_BufferType
Definition: RE_Types.h:262
GLfloat f
Definition: glcorearb.h:1925
UT_GPUType PXLconvertToUTGPUType(PXL_DataFormat t)
Definition: PXL_Common.h:73
RE_BufferBinding
Definition: RE_Types.h:298
RE_SOperation myPassDepthPassOperation
Definition: RE_Types.h:820
GLint ref
Definition: glcorearb.h:123
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:102
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:770
IMG_DataType
Definition: IMG_FileTypes.h:17
int myComponent
Definition: RE_Types.h:679
float myZoomY
Definition: RE_Types.h:667
RE_SmoothMode
Definition: RE_Types.h:427
RE_BlendSourceFactor myAlphaSourceFactor
Definition: RE_Types.h:749
void copy(const re_BlendSmoothState &state)
Definition: RE_Types.h:714
bool REisProfessionalDevice(RE_GraphicsDevice dev)
Definition: RE_Types.h:623
RE_MemoryBarrierBitfield
Definition: RE_Types.h:509
RE_DisplayMode
Definition: RE_Types.h:533
GLuint const GLchar * name
Definition: glcorearb.h:785
RE_ZFunction
Definition: RE_Types.h:440
PXL_DataFormat
Definition: PXL_Common.h:19
float myColorBlack
Definition: RE_Types.h:670
RE_ShaderAttribLocation
Definition: RE_Types.h:355
float myGamma
Definition: RE_Types.h:674
RE_BlendDestFactor myAlphaDestFactor
Definition: RE_Types.h:750
float myColorScale
Definition: RE_Types.h:668
RE_BlendDestFactor myDestFactor
Definition: RE_Types.h:748
GLenum func
Definition: glcorearb.h:782
RE_BufferAccess
Definition: RE_Types.h:291
UT_GPUType REconvertToUTGPUType(RE_GPUType t)
Definition: RE_Types.h:65
RE_GPUType REconvertPXLType(PXL_DataFormat t)
Definition: RE_Types.h:142
float myAlphaScale
Definition: RE_Types.h:672
typedef int
Definition: png.h:1175
RE_SOperation
Definition: RE_Types.h:464
RE_VisualType
Definition: RE_Types.h:583
RE_BlendSourceFactor
Definition: RE_Types.h:476
RE_ArrayType
Definition: RE_Types.h:310
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
QGLWidget * OGLDrawable
Definition: RE_Types.h:872
RE_BufferUsageHint
Definition: RE_Types.h:273
UT_IntrusivePtr< RE_Material > RE_MaterialPtr
Definition: RE_Types.h:637
RE_RenderBuf
Definition: RE_Types.h:399
RE_WindowType
Definition: RE_Types.h:20
RE_ShaderTarget
Definition: RE_Types.h:248
RE_API RE_PrimType REgetREPrim(int gltype)
RE_API const char * REgetTypeName(RE_GPUType p)
RE_ShaderLanguage
Definition: RE_Types.h:240
RE_PrimType
Definition: RE_Types.h:191
RE_SFunction
Definition: RE_Types.h:452
bool REisConsumerDevice(RE_GraphicsDevice dev)
Definition: RE_Types.h:628
RE_PersistentBufferMode
Definition: RE_Types.h:501
float myAlphaShift
Definition: RE_Types.h:673
RE_SOperation myFailOperation
Definition: RE_Types.h:818
RE_API RE_ShaderTarget REgetShaderTargetForGLPrim(int gltype)
RE_BlendDestFactor
Definition: RE_Types.h:489