diff options
author | tomhudson@google.com <tomhudson@google.com@2bbb7eff-a529-9590-31e7-b0007b416f81> | 2012-02-14 15:11:59 +0000 |
---|---|---|
committer | tomhudson@google.com <tomhudson@google.com@2bbb7eff-a529-9590-31e7-b0007b416f81> | 2012-02-14 15:11:59 +0000 |
commit | 6bf38b59c9de1cd35cd091cf8766117f4e1f66a0 (patch) | |
tree | 586fb0cb56795200f273f79eb29c858e8fbe8588 /include/gpu/gl | |
parent | 7bc13a62609149f0b535c2f3ff7210eb834d8b36 (diff) |
Move GL-specific include files to their own subdirectory, to better
coexist alongside D3D backend.
Requires gyp change.
http://codereview.appspot.com/5665045/
git-svn-id: http://skia.googlecode.com/svn/trunk@3185 2bbb7eff-a529-9590-31e7-b0007b416f81
Diffstat (limited to 'include/gpu/gl')
-rw-r--r-- | include/gpu/gl/GrGLConfig.h | 273 | ||||
-rw-r--r-- | include/gpu/gl/GrGLConfig_chrome.h | 37 | ||||
-rw-r--r-- | include/gpu/gl/GrGLDefines.h | 692 | ||||
-rw-r--r-- | include/gpu/gl/GrGLInterface.h | 429 | ||||
-rw-r--r-- | include/gpu/gl/SkGLContext.h | 63 | ||||
-rw-r--r-- | include/gpu/gl/SkMesaGLContext.h | 50 | ||||
-rw-r--r-- | include/gpu/gl/SkNativeGLContext.h | 81 | ||||
-rw-r--r-- | include/gpu/gl/SkNullGLContext.h | 27 |
8 files changed, 1652 insertions, 0 deletions
diff --git a/include/gpu/gl/GrGLConfig.h b/include/gpu/gl/GrGLConfig.h new file mode 100644 index 0000000000..5ae931c607 --- /dev/null +++ b/include/gpu/gl/GrGLConfig.h @@ -0,0 +1,273 @@ + +/* + * Copyright 2011 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + + + +#ifndef GrGLConfig_DEFINED +#define GrGLConfig_DEFINED + +#include "GrTypes.h" +#include "GrGLDefines.h" + +/** + * Optional GL config file. + */ +#ifdef GR_GL_CUSTOM_SETUP_HEADER + #include GR_GL_CUSTOM_SETUP_HEADER +#endif + +#if !defined(GR_GL_FUNCTION_TYPE) + #define GR_GL_FUNCTION_TYPE +#endif + +/** + * The following are optional defines that can be enabled at the compiler + * command line, in a IDE project, in a GrUserConfig.h file, or in a GL custom + * file (if one is in use). If a GR_GL_CUSTOM_SETUP_HEADER is used they can + * also be placed there. + * + * GR_GL_LOG_CALLS: if 1 Gr can print every GL call using GrPrintf. Defaults to + * 0. Logging can be enabled and disabled at runtime using a debugger via to + * global gLogCallsGL. The initial value of gLogCallsGL is controlled by + * GR_GL_LOG_CALLS_START. + * + * GR_GL_LOG_CALLS_START: controls the initial value of gLogCallsGL when + * GR_GL_LOG_CALLS is 1. Defaults to 0. + * + * GR_GL_CHECK_ERROR: if enabled Gr can do a glGetError() after every GL call. + * Defaults to 1 if GR_DEBUG is set, otherwise 0. When GR_GL_CHECK_ERROR is 1 + * this can be toggled in a debugger using the gCheckErrorGL global. The initial + * value of gCheckErrorGL is controlled by by GR_GL_CHECK_ERROR_START. + * + * GR_GL_CHECK_ERROR_START: controls the initial value of gCheckErrorGL + * when GR_GL_CHECK_ERROR is 1. Defaults to 1. + * + * GR_GL_NO_CONSTANT_ATTRIBUTES: if this evaluates to true then the GL backend + * will use uniforms instead of attributes in all cases when there is not + * per-vertex data. This is important when the underlying GL implementation + * doesn't actually support immediate style attribute values (e.g. when + * the GL stream is converted to DX as in ANGLE on Chrome). Defaults to 0. + * + * GR_GL_ATTRIBUTE_MATRICES: If changing uniforms is very expensive it may be + * faster to use vertex attributes for matrices (set via glVertexAttrib3fv). + * Setting this build flag enables this behavior. GR_GL_NO_CONSTANT_ATTRIBUTES + * must not be set since this uses constant attributes for the matrices. + * Defaults to 0. + * + * GR_GL_USE_BUFFER_DATA_NULL_HINT: When specifing new data for a vertex/index + * buffer that replaces old data Ganesh can give a hint to the driver that the + * previous data will not be used in future draws like this: + * glBufferData(GL_..._BUFFER, size, NULL, usage); //<--hint, NULL means + * glBufferSubData(GL_..._BUFFER, 0, lessThanSize, data) // old data can't be + * // used again. + * However, this can be an unoptimization on some platforms, esp. Chrome. + * Chrome's cmd buffer will create a new allocation and memset the whole thing + * to zero (for security reasons). Defaults to 1 (enabled). + * + * GR_GL_PER_GL_FUNC_CALLBACK: When set to 1 the GrGLInterface object provides + * a function pointer that is called just before every gl function. The ptr must + * be valid (i.e. there is no NULL check). However, by default the callback will + * be set to a function that does nothing. The signature of the function is: + * void function(const GrGLInterface*) + * It is not extern "C". + * The GrGLInterface field fCallback specifies the function ptr and there is an + * additional field fCallbackData of type intptr_t for client data. + * + * GR_GL_RGBA_8888_PIXEL_OPS_SLOW: Set this to 1 if it is known that performing + * glReadPixels / glTex(Sub)Image with format=GL_RGBA, type=GL_UNISIGNED_BYTE is + * significantly slower than format=GL_BGRA, type=GL_UNISIGNED_BYTE. + * + * GR_GL_FULL_READPIXELS_FASTER_THAN_PARTIAL: Set this to 1 if calling + * glReadPixels to read the entire framebuffer is faster than calling it with + * the same sized rectangle but with a framebuffer bound that is larger than + * the rectangle read. + * + * GR_GL_CHECK_ALLOC_WITH_GET_ERROR: If set to 1 this will then glTexImage, + * glBufferData, glRenderbufferStorage, etc will be checked for errors. This + * amounts to ensuring the error is GL_NO_ERROR, calling the allocating + * function, and then checking that the error is still GL_NO_ERROR. When the + * value is 0 we will assume no error was generated without checking. + * + * GR_GL_CHECK_FBO_STATUS_ONCE_PER_FORMAT: We will normally check the FBO status + * every time we bind a texture or renderbuffer to an FBO. However, in some + * environments CheckFrameBufferStatus is very expensive. If this is set we will + * check the first time we use a color format or a combination of color / + * stencil formats as attachments. If the FBO is complete we will assume + * subsequent attachments with the same formats are complete as well. + */ + +#if !defined(GR_GL_LOG_CALLS) + #define GR_GL_LOG_CALLS GR_DEBUG +#endif + +#if !defined(GR_GL_LOG_CALLS_START) + #define GR_GL_LOG_CALLS_START 0 +#endif + +#if !defined(GR_GL_CHECK_ERROR) + #define GR_GL_CHECK_ERROR GR_DEBUG +#endif + +#if !defined(GR_GL_CHECK_ERROR_START) + #define GR_GL_CHECK_ERROR_START 1 +#endif + +#if !defined(GR_GL_NO_CONSTANT_ATTRIBUTES) + #define GR_GL_NO_CONSTANT_ATTRIBUTES 0 +#endif + +#if !defined(GR_GL_ATTRIBUTE_MATRICES) + #define GR_GL_ATTRIBUTE_MATRICES 0 +#endif + +#if !defined(GR_GL_USE_BUFFER_DATA_NULL_HINT) + #define GR_GL_USE_BUFFER_DATA_NULL_HINT 1 +#endif + +#if !defined(GR_GL_PER_GL_FUNC_CALLBACK) + #define GR_GL_PER_GL_FUNC_CALLBACK 0 +#endif + +#if !defined(GR_GL_RGBA_8888_PIXEL_OPS_SLOW) + #define GR_GL_RGBA_8888_PIXEL_OPS_SLOW 0 +#endif + +#if !defined(GR_GL_FULL_READPIXELS_FASTER_THAN_PARTIAL) + #define GR_GL_FULL_READPIXELS_FASTER_THAN_PARTIAL 0 +#endif + +#if !defined(GR_GL_CHECK_ALLOC_WITH_GET_ERROR) + #define GR_GL_CHECK_ALLOC_WITH_GET_ERROR 1 +#endif + +#if !defined(GR_GL_CHECK_FBO_STATUS_ONCE_PER_FORMAT) + #define GR_GL_CHECK_FBO_STATUS_ONCE_PER_FORMAT 0 +#endif + +#if(GR_GL_NO_CONSTANT_ATTRIBUTES) && (GR_GL_ATTRIBUTE_MATRICES) + #error "Cannot combine GR_GL_NO_CONSTANT_ATTRIBUTES and GR_GL_ATTRIBUTE_MATRICES" +#endif + +//////////////////////////////////////////////////////////////////////////////// + +#if GR_SCALAR_IS_FIXED + #define GrGLType GL_FIXED +#elif GR_SCALAR_IS_FLOAT + #define GrGLType GR_GL_FLOAT +#else + #error "unknown GR_SCALAR type" +#endif + +#if GR_TEXT_SCALAR_IS_USHORT + #define GrGLTextType GR_GL_UNSIGNED_SHORT + #define GR_GL_TEXT_TEXTURE_NORMALIZED 1 +#elif GR_TEXT_SCALAR_IS_FLOAT + #define GrGLTextType GR_GL_FLOAT + #define GR_GL_TEXT_TEXTURE_NORMALIZED 0 +#elif GR_TEXT_SCALAR_IS_FIXED + #define GrGLTextType GR_GL_FIXED + #define GR_GL_TEXT_TEXTURE_NORMALIZED 0 +#else + #error "unknown GR_TEXT_SCALAR type" +#endif + +//////////////////////////////////////////////////////////////////////////////// + +struct GrGLInterface; + +extern void GrGLCheckErr(const GrGLInterface* gl, + const char* location, + const char* call); + +extern void GrGLClearErr(const GrGLInterface* gl); + +#if GR_GL_CHECK_ERROR + extern bool gCheckErrorGL; + #define GR_GL_CHECK_ERROR_IMPL(IFACE, X) \ + if (gCheckErrorGL) \ + GrGLCheckErr(IFACE, GR_FILE_AND_LINE_STR, #X) +#else + #define GR_GL_CHECK_ERROR_IMPL(IFACE, X) +#endif + +#if GR_GL_LOG_CALLS + extern bool gLogCallsGL; + #define GR_GL_LOG_CALLS_IMPL(X) \ + if (gLogCallsGL) \ + GrPrintf(GR_FILE_AND_LINE_STR "GL: " #X "\n") +#else + #define GR_GL_LOG_CALLS_IMPL(X) +#endif + +#if GR_GL_PER_GL_FUNC_CALLBACK + #define GR_GL_CALLBACK_IMPL(IFACE) (IFACE)->fCallback(IFACE) +#else + #define GR_GL_CALLBACK_IMPL(IFACE) +#endif + +#define GR_GL_CALL(IFACE, X) \ + do { \ + GR_GL_CALL_NOERRCHECK(IFACE, X); \ + GR_GL_CHECK_ERROR_IMPL(IFACE, X); \ + } while (false) + +#define GR_GL_CALL_NOERRCHECK(IFACE, X) \ + do { \ + GR_GL_CALLBACK_IMPL(IFACE); \ + (IFACE)->f##X; \ + GR_GL_LOG_CALLS_IMPL(X); \ + } while (false) + +#define GR_GL_CALL_RET(IFACE, RET, X) \ + do { \ + GR_GL_CALL_RET_NOERRCHECK(IFACE, RET, X); \ + GR_GL_CHECK_ERROR_IMPL(IFACE, X); \ + } while (false) + +#define GR_GL_CALL_RET_NOERRCHECK(IFACE, RET, X) \ + do { \ + GR_GL_CALLBACK_IMPL(IFACE); \ + (RET) = (IFACE)->f##X; \ + GR_GL_LOG_CALLS_IMPL(X); \ + } while (false) + +#define GR_GL_GET_ERROR(IFACE) (IFACE)->fGetError() + +//////////////////////////////////////////////////////////////////////////////// + +/** + * Some drivers want the var-int arg to be zero-initialized on input. + */ +#define GR_GL_INIT_ZERO 0 +#define GR_GL_GetIntegerv(gl, e, p) \ + do { \ + *(p) = GR_GL_INIT_ZERO; \ + GR_GL_CALL(gl, GetIntegerv(e, p)); \ + } while (0) + +#define GR_GL_GetFramebufferAttachmentParameteriv(gl, t, a, pname, p) \ + do { \ + *(p) = GR_GL_INIT_ZERO; \ + GR_GL_CALL(gl, GetFramebufferAttachmentParameteriv(t, a, pname, p)); \ + } while (0) + +#define GR_GL_GetRenderbufferParameteriv(gl, t, pname, p) \ + do { \ + *(p) = GR_GL_INIT_ZERO; \ + GR_GL_CALL(gl, GetRenderbufferParameteriv(t, pname, p)); \ + } while (0) + +#define GR_GL_GetTexLevelParameteriv(gl, t, l, pname, p) \ + do { \ + *(p) = GR_GL_INIT_ZERO; \ + GR_GL_CALL(gl, GetTexLevelParameteriv(t, l, pname, p)); \ + } while (0) + +//////////////////////////////////////////////////////////////////////////////// + +#endif diff --git a/include/gpu/gl/GrGLConfig_chrome.h b/include/gpu/gl/GrGLConfig_chrome.h new file mode 100644 index 0000000000..50ea34c6d3 --- /dev/null +++ b/include/gpu/gl/GrGLConfig_chrome.h @@ -0,0 +1,37 @@ + +/* + * Copyright 2011 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ +#ifndef GrGLConfig_chrome_DEFINED +#define GrGLConfig_chrome_DEFINED + +// glGetError() forces a sync with gpu process on chrome +#define GR_GL_CHECK_ERROR_START 0 + +// ANGLE creates a temp VB for vertex attributes not specified per-vertex. +#define GR_GL_NO_CONSTANT_ATTRIBUTES GR_WIN32_BUILD + +// For RGBA teximage/readpixels ANGLE will sw-convert to/from BGRA. +#define GR_GL_RGBA_8888_PIXEL_OPS_SLOW GR_WIN32_BUILD + +// ANGLE can go faster if the entire fbo is read rather than a subrect +#define GR_GL_FULL_READPIXELS_FASTER_THAN_PARTIAL GR_WIN32_BUILD + +// cmd buffer allocates memory and memsets it to zero when it sees glBufferData +// with NULL. +#define GR_GL_USE_BUFFER_DATA_NULL_HINT 0 + +// chrome uses this to set the context on each GL call. +#define GR_GL_PER_GL_FUNC_CALLBACK 1 + +// Check error is even more expensive in chrome (cmd buffer flush). The +// compositor also doesn't check its allocations. +#define GR_GL_CHECK_ALLOC_WITH_GET_ERROR 0 + +// CheckFramebufferStatus in chrome synchronizes the gpu and renderer processes. +#define GR_GL_CHECK_FBO_STATUS_ONCE_PER_FORMAT 1 + +#endif diff --git a/include/gpu/gl/GrGLDefines.h b/include/gpu/gl/GrGLDefines.h new file mode 100644 index 0000000000..e66eec4edf --- /dev/null +++ b/include/gpu/gl/GrGLDefines.h @@ -0,0 +1,692 @@ + +/* + * Copyright 2011 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + + + +#ifndef GrGLDefines_DEFINED +#define GrGLDefines_DEFINED + +// The following constants consist of the intersection of GL constants +// exported by GLES 1.0, GLES 2.0, and desktop GL required by the system. + +#define GR_GL_DEPTH_BUFFER_BIT 0x00000100 +#define GR_GL_STENCIL_BUFFER_BIT 0x00000400 +#define GR_GL_COLOR_BUFFER_BIT 0x00004000 + +/* Boolean */ +#define GR_GL_FALSE 0 +#define GR_GL_TRUE 1 + +/* BeginMode */ +#define GR_GL_POINTS 0x0000 +#define GR_GL_LINES 0x0001 +#define GR_GL_LINE_LOOP 0x0002 +#define GR_GL_LINE_STRIP 0x0003 +#define GR_GL_TRIANGLES 0x0004 +#define GR_GL_TRIANGLE_STRIP 0x0005 +#define GR_GL_TRIANGLE_FAN 0x0006 + +/* AlphaFunction (not supported in ES20) */ +/* GL_NEVER */ +/* GL_LESS */ +/* GL_EQUAL */ +/* GL_LEQUAL */ +/* GL_GREATER */ +/* GL_NOTEQUAL */ +/* GL_GEQUAL */ +/* GL_ALWAYS */ + +/* BlendingFactorDest */ +#define GR_GL_ZERO 0 +#define GR_GL_ONE 1 +#define GR_GL_SRC_COLOR 0x0300 +#define GR_GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GR_GL_SRC_ALPHA 0x0302 +#define GR_GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GR_GL_DST_ALPHA 0x0304 +#define GR_GL_ONE_MINUS_DST_ALPHA 0x0305 + +/* BlendingFactorSrc */ +/* GL_ZERO */ +/* GL_ONE */ +#define GR_GL_DST_COLOR 0x0306 +#define GR_GL_ONE_MINUS_DST_COLOR 0x0307 +#define GR_GL_SRC_ALPHA_SATURATE 0x0308 +/* GL_SRC_ALPHA */ +/* GL_ONE_MINUS_SRC_ALPHA */ +/* GL_DST_ALPHA */ +/* GL_ONE_MINUS_DST_ALPHA */ + +/* ExtendedBlendFactors */ +#define GR_GL_SRC1_COLOR 0x88F9 +#define GR_GL_ONE_MINUS_SRC1_COLOR 0x88FA +/* GL_SRC1_ALPHA */ +#define GR_GL_ONE_MINUS_SRC1_ALPHA 0x88FB + +/* BlendEquationSeparate */ +#define GR_GL_FUNC_ADD 0x8006 +#define GR_GL_BLEND_EQUATION 0x8009 +#define GR_GL_BLEND_EQUATION_RGB 0x8009 /* same as BLEND_EQUATION */ +#define GR_GL_BLEND_EQUATION_ALPHA 0x883D + +/* BlendSubtract */ +#define GR_GL_FUNC_SUBTRACT 0x800A +#define GR_GL_FUNC_REVERSE_SUBTRACT 0x800B + +/* Separate Blend Functions */ +#define GR_GL_BLEND_DST_RGB 0x80C8 +#define GR_GL_BLEND_SRC_RGB 0x80C9 +#define GR_GL_BLEND_DST_ALPHA 0x80CA +#define GR_GL_BLEND_SRC_ALPHA 0x80CB +#define GR_GL_CONSTANT_COLOR 0x8001 +#define GR_GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GR_GL_CONSTANT_ALPHA 0x8003 +#define GR_GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GR_GL_BLEND_COLOR 0x8005 + +/* Buffer Objects */ +#define GR_GL_ARRAY_BUFFER 0x8892 +#define GR_GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GR_GL_ARRAY_BUFFER_BINDING 0x8894 +#define GR_GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 + +#define GR_GL_STREAM_DRAW 0x88E0 +#define GR_GL_STATIC_DRAW 0x88E4 +#define GR_GL_DYNAMIC_DRAW 0x88E8 + +#define GR_GL_BUFFER_SIZE 0x8764 +#define GR_GL_BUFFER_USAGE 0x8765 + +#define GR_GL_CURRENT_VERTEX_ATTRIB 0x8626 + +/* CullFaceMode */ +#define GR_GL_FRONT 0x0404 +#define GR_GL_BACK 0x0405 +#define GR_GL_FRONT_AND_BACK 0x0408 + +/* DepthFunction */ +/* GL_NEVER */ +/* GL_LESS */ +/* GL_EQUAL */ +/* GL_LEQUAL */ +/* GL_GREATER */ +/* GL_NOTEQUAL */ +/* GL_GEQUAL */ +/* GL_ALWAYS */ + +/* EnableCap */ +#define GR_GL_TEXTURE_2D 0x0DE1 +#define GR_GL_CULL_FACE 0x0B44 +#define GR_GL_BLEND 0x0BE2 +#define GR_GL_DITHER 0x0BD0 +#define GR_GL_STENCIL_TEST 0x0B90 +#define GR_GL_DEPTH_TEST 0x0B71 +#define GR_GL_SCISSOR_TEST 0x0C11 +#define GR_GL_POLYGON_OFFSET_FILL 0x8037 +#define GR_GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GR_GL_SAMPLE_COVERAGE 0x80A0 + +/* ErrorCode */ +#define GR_GL_NO_ERROR 0 +#define GR_GL_INVALID_ENUM 0x0500 +#define GR_GL_INVALID_VALUE 0x0501 +#define GR_GL_INVALID_OPERATION 0x0502 +#define GR_GL_OUT_OF_MEMORY 0x0505 +#define GR_GL_CONTEXT_LOST 0x300E // TODO(gman): What value? + +/* FrontFaceDirection */ +#define GR_GL_CW 0x0900 +#define GR_GL_CCW 0x0901 + +/* GetPName */ +#define GR_GL_LINE_WIDTH 0x0B21 +#define GR_GL_ALIASED_POINT_SIZE_RANGE 0x846D +#define GR_GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#define GR_GL_CULL_FACE_MODE 0x0B45 +#define GR_GL_FRONT_FACE 0x0B46 +#define GR_GL_DEPTH_RANGE 0x0B70 +#define GR_GL_DEPTH_WRITEMASK 0x0B72 +#define GR_GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GR_GL_DEPTH_FUNC 0x0B74 +#define GR_GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GR_GL_STENCIL_FUNC 0x0B92 +#define GR_GL_STENCIL_FAIL 0x0B94 +#define GR_GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GR_GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GR_GL_STENCIL_REF 0x0B97 +#define GR_GL_STENCIL_VALUE_MASK 0x0B93 +#define GR_GL_STENCIL_WRITEMASK 0x0B98 +#define GR_GL_STENCIL_BACK_FUNC 0x8800 +#define GR_GL_STENCIL_BACK_FAIL 0x8801 +#define GR_GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GR_GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GR_GL_STENCIL_BACK_REF 0x8CA3 +#define GR_GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GR_GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#define GR_GL_VIEWPORT 0x0BA2 +#define GR_GL_SCISSOR_BOX 0x0C10 +/* GL_SCISSOR_TEST */ +#define GR_GL_COLOR_CLEAR_VALUE 0x0C22 +#define GR_GL_COLOR_WRITEMASK 0x0C23 +#define GR_GL_UNPACK_ALIGNMENT 0x0CF5 +#define GR_GL_UNPACK_FLIP_Y 0x9240 +#define GR_GL_PACK_ALIGNMENT 0x0D05 +#define GR_GL_PACK_REVERSE_ROW_ORDER 0x93A4 +#define GR_GL_MAX_TEXTURE_SIZE 0x0D33 +#define GR_GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GR_GL_SUBPIXEL_BITS 0x0D50 +#define GR_GL_RED_BITS 0x0D52 +#define GR_GL_GREEN_BITS 0x0D53 +#define GR_GL_BLUE_BITS 0x0D54 +#define GR_GL_ALPHA_BITS 0x0D55 +#define GR_GL_DEPTH_BITS 0x0D56 +#define GR_GL_STENCIL_BITS 0x0D57 +#define GR_GL_POLYGON_OFFSET_UNITS 0x2A00 +/* GL_POLYGON_OFFSET_FILL */ +#define GR_GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GR_GL_TEXTURE_BINDING_2D 0x8069 +#define GR_GL_SAMPLE_BUFFERS 0x80A8 +#define GR_GL_SAMPLES 0x80A9 +#define GR_GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GR_GL_SAMPLE_COVERAGE_INVERT 0x80AB + +/* GetTextureParameter */ +/* GL_TEXTURE_MAG_FILTER */ +/* GL_TEXTURE_MIN_FILTER */ +/* GL_TEXTURE_WRAP_S */ +/* GL_TEXTURE_WRAP_T */ + +#define GR_GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GR_GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 + +/* HintMode */ +#define GR_GL_DONT_CARE 0x1100 +#define GR_GL_FASTEST 0x1101 +#define GR_GL_NICEST 0x1102 + +/* HintTarget */ +#define GR_GL_GENERATE_MIPMAP_HINT 0x8192 + +/* DataType */ +#define GR_GL_BYTE 0x1400 +#define GR_GL_UNSIGNED_BYTE 0x1401 +#define GR_GL_SHORT 0x1402 +#define GR_GL_UNSIGNED_SHORT 0x1403 +#define GR_GL_INT 0x1404 +#define GR_GL_UNSIGNED_INT 0x1405 +#define GR_GL_FLOAT 0x1406 +#define GR_GL_FIXED 0x140C + +/* Lighting */ +#define GR_GL_LIGHTING 0x0B50 +#define GR_GL_LIGHT0 0x4000 +#define GR_GL_LIGHT1 0x4001 +#define GR_GL_LIGHT2 0x4002 +#define GR_GL_LIGHT3 0x4003 +#define GR_GL_LIGHT4 0x4004 +#define GR_GL_LIGHT5 0x4005 +#define GR_GL_LIGHT6 0x4006 +#define GR_GL_LIGHT7 0x4007 +#define GR_GL_SPOT_EXPONENT 0x1205 +#define GR_GL_SPOT_CUTOFF 0x1206 +#define GR_GL_CONSTANT_ATTENUATION 0x1207 +#define GR_GL_LINEAR_ATTENUATION 0x1208 +#define GR_GL_QUADRATIC_ATTENUATION 0x1209 +#define GR_GL_AMBIENT 0x1200 +#define GR_GL_DIFFUSE 0x1201 +#define GR_GL_SPECULAR 0x1202 +#define GR_GL_SHININESS 0x1601 +#define GR_GL_EMISSION 0x1600 +#define GR_GL_POSITION 0x1203 +#define GR_GL_SPOT_DIRECTION 0x1204 +#define GR_GL_AMBIENT_AND_DIFFUSE 0x1602 +#define GR_GL_COLOR_INDEXES 0x1603 +#define GR_GL_LIGHT_MODEL_TWO_SIDE 0x0B52 +#define GR_GL_LIGHT_MODEL_LOCAL_VIEWER 0x0B51 +#define GR_GL_LIGHT_MODEL_AMBIENT 0x0B53 +#define GR_GL_FRONT_AND_BACK 0x0408 +#define GR_GL_SHADE_MODEL 0x0B54 +#define GR_GL_FLAT 0x1D00 +#define GR_GL_SMOOTH 0x1D01 +#define GR_GL_COLOR_MATERIAL 0x0B57 +#define GR_GL_COLOR_MATERIAL_FACE 0x0B55 +#define GR_GL_COLOR_MATERIAL_PARAMETER 0x0B56 +#define GR_GL_NORMALIZE 0x0BA1 + +/* Matrix Mode */ +#define GR_GL_MATRIX_MODE 0x0BA0 +#define GR_GL_MODELVIEW 0x1700 +#define GR_GL_PROJECTION 0x1701 +#define GR_GL_TEXTURE 0x1702 + +/* multisample */ +#define GR_GL_MULTISAMPLE 0x809D + +/* Points */ +#define GR_GL_POINT_SMOOTH 0x0B10 +#define GR_GL_POINT_SIZE 0x0B11 +#define GR_GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GR_GL_POINT_SIZE_RANGE 0x0B12 + +/* Lines */ +#define GR_GL_LINE_SMOOTH 0x0B20 +#define GR_GL_LINE_STIPPLE 0x0B24 +#define GR_GL_LINE_STIPPLE_PATTERN 0x0B25 +#define GR_GL_LINE_STIPPLE_REPEAT 0x0B26 +#define GR_GL_LINE_WIDTH 0x0B21 +#define GR_GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GR_GL_LINE_WIDTH_RANGE 0x0B22 + +/* PixelFormat */ +#define GR_GL_DEPTH_COMPONENT 0x1902 +#define GR_GL_RED 0x1903 +#define GR_GL_GREEN 0x1904 +#define GR_GL_BLUE 0x1905 +#define GR_GL_ALPHA 0x1906 +#define GR_GL_RGB 0x1907 +#define GR_GL_RGBA 0x1908 +#define GR_GL_BGRA 0x80E1 +#define GR_GL_LUMINANCE 0x1909 +#define GR_GL_LUMINANCE_ALPHA 0x190A +#define GR_GL_PALETTE8_RGBA8 0x8B96 +#define GR_GL_ALPHA8 0x803C + +/* PixelType */ +/* GL_UNSIGNED_BYTE */ +#define GR_GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GR_GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GR_GL_UNSIGNED_SHORT_5_6_5 0x8363 + +/* Shaders */ +#define GR_GL_FRAGMENT_SHADER 0x8B30 +#define GR_GL_VERTEX_SHADER 0x8B31 +#define GR_GL_GEOMETRY_SHADER 0x8DD9 +#define GR_GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GR_GL_MAX_VERTEX_UNIFORM_VECTORS 0x8DFB +#define GR_GL_MAX_VARYING_VECTORS 0x8DFC +#define GR_GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GR_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GR_GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS 0x8DFD +#define GR_GL_SHADER_TYPE 0x8B4F +#define GR_GL_DELETE_STATUS 0x8B80 +#define GR_GL_LINK_STATUS 0x8B82 +#define GR_GL_VALIDATE_STATUS 0x8B83 +#define GR_GL_ATTACHED_SHADERS 0x8B85 +#define GR_GL_ACTIVE_UNIFORMS 0x8B86 +#define GR_GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GR_GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GR_GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GR_GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GR_GL_CURRENT_PROGRAM 0x8B8D +#define GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GR_GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A + +/* StencilFunction */ +#define GR_GL_NEVER 0x0200 +#define GR_GL_LESS 0x0201 +#define GR_GL_EQUAL 0x0202 +#define GR_GL_LEQUAL 0x0203 +#define GR_GL_GREATER 0x0204 +#define GR_GL_NOTEQUAL 0x0205 +#define GR_GL_GEQUAL 0x0206 +#define GR_GL_ALWAYS 0x0207 + +/* StencilOp */ +/* GL_ZERO */ +#define GR_GL_KEEP 0x1E00 +#define GR_GL_REPLACE 0x1E01 +#define GR_GL_INCR 0x1E02 +#define GR_GL_DECR 0x1E03 +#define GR_GL_INVERT 0x150A +#define GR_GL_INCR_WRAP 0x8507 +#define GR_GL_DECR_WRAP 0x8508 + +/* StringName */ +#define GR_GL_VENDOR 0x1F00 +#define GR_GL_RENDERER 0x1F01 +#define GR_GL_VERSION 0x1F02 +#define GR_GL_EXTENSIONS 0x1F03 + +/* Pixel Mode / Transfer */ +#define GR_GL_UNPACK_ROW_LENGTH 0x0CF2 +#define GR_GL_PACK_ROW_LENGTH 0x0D02 + + +/* TextureMagFilter */ +#define GR_GL_NEAREST 0x2600 +#define GR_GL_LINEAR 0x2601 + +/* TextureMinFilter */ +/* GL_NEAREST */ +/* GL_LINEAR */ +#define GR_GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GR_GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GR_GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GR_GL_LINEAR_MIPMAP_LINEAR 0x2703 + +/* TextureUsage */ +#define GR_GL_FRAMEBUFFER_ATTACHMENT 0x93A3 + +/* TextureParameterName */ +#define GR_GL_TEXTURE_MAG_FILTER 0x2800 +#define GR_GL_TEXTURE_MIN_FILTER 0x2801 +#define GR_GL_TEXTURE_WRAP_S 0x2802 +#define GR_GL_TEXTURE_WRAP_T 0x2803 +#define GR_GL_TEXTURE_USAGE 0x93A2 + +/* TextureTarget */ +/* GL_TEXTURE_2D */ +#define GR_GL_TEXTURE 0x1702 +#define GR_GL_TEXTURE_CUBE_MAP 0x8513 +#define GR_GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GR_GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GR_GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GR_GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GR_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GR_GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GR_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GR_GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C + +/* TextureUnit */ +#define GR_GL_TEXTURE0 0x84C0 +#define GR_GL_TEXTURE1 0x84C1 +#define GR_GL_TEXTURE2 0x84C2 +#define GR_GL_TEXTURE3 0x84C3 +#define GR_GL_TEXTURE4 0x84C4 +#define GR_GL_TEXTURE5 0x84C5 +#define GR_GL_TEXTURE6 0x84C6 +#define GR_GL_TEXTURE7 0x84C7 +#define GR_GL_TEXTURE8 0x84C8 +#define GR_GL_TEXTURE9 0x84C9 +#define GR_GL_TEXTURE10 0x84CA +#define GR_GL_TEXTURE11 0x84CB +#define GR_GL_TEXTURE12 0x84CC +#define GR_GL_TEXTURE13 0x84CD +#define GR_GL_TEXTURE14 0x84CE +#define GR_GL_TEXTURE15 0x84CF +#define GR_GL_TEXTURE16 0x84D0 +#define GR_GL_TEXTURE17 0x84D1 +#define GR_GL_TEXTURE18 0x84D2 +#define GR_GL_TEXTURE19 0x84D3 +#define GR_GL_TEXTURE20 0x84D4 +#define GR_GL_TEXTURE21 0x84D5 +#define GR_GL_TEXTURE22 0x84D6 +#define GR_GL_TEXTURE23 0x84D7 +#define GR_GL_TEXTURE24 0x84D8 +#define GR_GL_TEXTURE25 0x84D9 +#define GR_GL_TEXTURE26 0x84DA +#define GR_GL_TEXTURE27 0x84DB +#define GR_GL_TEXTURE28 0x84DC +#define GR_GL_TEXTURE29 0x84DD +#define GR_GL_TEXTURE30 0x84DE +#define GR_GL_TEXTURE31 0x84DF +#define GR_GL_ACTIVE_TEXTURE 0x84E0 +#define GR_GL_MAX_TEXTURE_UNITS 0x84E2 + +/* TextureWrapMode */ +#define GR_GL_REPEAT 0x2901 +#define GR_GL_CLAMP_TO_EDGE 0x812F +#define GR_GL_MIRRORED_REPEAT 0x8370 + +/* Texture Swizzle */ +#define GR_GL_TEXTURE_SWIZZLE_R 0x8E42 +#define GR_GL_TEXTURE_SWIZZLE_G 0x8E43 +#define GR_GL_TEXTURE_SWIZZLE_B 0x8E44 +#define GR_GL_TEXTURE_SWIZZLE_A 0x8E45 +#define GR_GL_TEXTURE_SWIZZLE_RGBA 0x8E46 + +/* Texture mapping */ +#define GR_GL_TEXTURE_ENV 0x2300 +#define GR_GL_TEXTURE_ENV_MODE 0x2200 +#define GR_GL_TEXTURE_1D 0x0DE0 +/* GL_TEXTURE_2D */ +/* GL_TEXTURE_WRAP_S */ +/* GL_TEXTURE_WRAP_T */ +/* GL_TEXTURE_MAG_FILTER */ +/* GL_TEXTURE_MIN_FILTER */ +#define GR_GL_TEXTURE_ENV_COLOR 0x2201 +#define GR_GL_TEXTURE_GEN_S 0x0C60 +#define GR_GL_TEXTURE_GEN_T 0x0C61 +#define GR_GL_TEXTURE_GEN_MODE 0x2500 +#define GR_GL_TEXTURE_BORDER_COLOR 0x1004 +#define GR_GL_TEXTURE_WIDTH 0x1000 +#define GR_GL_TEXTURE_HEIGHT 0x1001 +#define GR_GL_TEXTURE_BORDER 0x1005 +#define GR_GL_TEXTURE_COMPONENTS 0x1003 +#define GR_GL_TEXTURE_RED_SIZE 0x805C +#define GR_GL_TEXTURE_GREEN_SIZE 0x805D +#define GR_GL_TEXTURE_BLUE_SIZE 0x805E +#define GR_GL_TEXTURE_ALPHA_SIZE 0x805F +#define GR_GL_TEXTURE_LUMINANCE_SIZE 0x8060 +#define GR_GL_TEXTURE_INTENSITY_SIZE 0x8061 +#define GR_GL_TEXTURE_INTERNAL_FORMAT 0x1003 +/* GL_NEAREST_MIPMAP_NEAREST */ +/* GL_NEAREST_MIPMAP_LINEAR */ +/* GL_LINEAR_MIPMAP_NEAREST */ +/* GL_LINEAR_MIPMAP_LINEAR */ +#define GR_GL_OBJECT_LINEAR 0x2401 +#define GR_GL_OBJECT_PLANE 0x2501 +#define GR_GL_EYE_LINEAR 0x2400 +#define GR_GL_EYE_PLANE 0x2502 +#define GR_GL_SPHERE_MAP 0x2402 +#define GR_GL_DECAL 0x2101 +#define GR_GL_MODULATE 0x2100 +/* GL_NEAREST */ +/* GL_REPEAT */ +#define GR_GL_CLAMP 0x2900 +#define GR_GL_S 0x2000 +#define GR_GL_T 0x2001 +#define GR_GL_R 0x2002 +#define GR_GL_Q 0x2003 +#define GR_GL_TEXTURE_GEN_R 0x0C62 +#define GR_GL_TEXTURE_GEN_Q 0x0C63 + +/* texture_env_combine */ +#define GR_GL_COMBINE 0x8570 +#define GR_GL_COMBINE_RGB 0x8571 +#define GR_GL_COMBINE_ALPHA 0x8572 +#define GR_GL_SOURCE0_RGB 0x8580 +#define GR_GL_SOURCE1_RGB 0x8581 +#define GR_GL_SOURCE2_RGB 0x8582 +#define GR_GL_SOURCE0_ALPHA 0x8588 +#define GR_GL_SOURCE1_ALPHA 0x8589 +#define GR_GL_SOURCE2_ALPHA 0x858A +#define GR_GL_OPERAND0_RGB 0x8590 +#define GR_GL_OPERAND1_RGB 0x8591 +#define GR_GL_OPERAND2_RGB 0x8592 +#define GR_GL_OPERAND0_ALPHA 0x8598 +#define GR_GL_OPERAND1_ALPHA 0x8599 +#define GR_GL_OPERAND2_ALPHA 0x859A +#define GR_GL_RGB_SCALE 0x8573 +#define GR_GL_ADD_SIGNED 0x8574 +#define GR_GL_INTERPOLATE 0x8575 +#define GR_GL_SUBTRACT 0x84E7 +#define GR_GL_CONSTANT 0x8576 +#define GR_GL_PRIMARY_COLOR 0x8577 +#define GR_GL_PREVIOUS 0x8578 +#define GR_GL_SRC0_RGB 0x8580 +#define GR_GL_SRC1_RGB 0x8581 +#define GR_GL_SRC2_RGB 0x8582 +#define GR_GL_SRC0_ALPHA 0x8588 +#define GR_GL_SRC1_ALPHA 0x8589 +#define GR_GL_SRC2_ALPHA 0x858A + +/* Uniform Types */ +#define GR_GL_FLOAT_VEC2 0x8B50 +#define GR_GL_FLOAT_VEC3 0x8B51 +#define GR_GL_FLOAT_VEC4 0x8B52 +#define GR_GL_INT_VEC2 0x8B53 +#define GR_GL_INT_VEC3 0x8B54 +#define GR_GL_INT_VEC4 0x8B55 +#define GR_GL_BOOL 0x8B56 +#define GR_GL_BOOL_VEC2 0x8B57 +#define GR_GL_BOOL_VEC3 0x8B58 +#define GR_GL_BOOL_VEC4 0x8B59 +#define GR_GL_FLOAT_MAT2 0x8B5A +#define GR_GL_FLOAT_MAT3 0x8B5B +#define GR_GL_FLOAT_MAT4 0x8B5C +#define GR_GL_SAMPLER_2D 0x8B5E +#define GR_GL_SAMPLER_CUBE 0x8B60 + +/* Vertex Arrays */ +#define GR_GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GR_GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GR_GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GR_GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GR_GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GR_GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GR_GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GR_GL_VERTEX_ARRAY 0x8074 +#define GR_GL_NORMAL_ARRAY 0x8075 +#define GR_GL_COLOR_ARRAY 0x8076 +#define GR_GL_INDEX_ARRAY 0x8077 +#define GR_GL_TEXTURE_COORD_ARRAY 0x8078 +#define GR_GL_EDGE_FLAG_ARRAY 0x8079 +#define GR_GL_VERTEX_ARRAY_SIZE 0x807A +#define GR_GL_VERTEX_ARRAY_TYPE 0x807B +#define GR_GL_VERTEX_ARRAY_STRIDE 0x807C +#define GR_GL_NORMAL_ARRAY_TYPE 0x807E +#define GR_GL_NORMAL_ARRAY_STRIDE 0x807F +#define GR_GL_COLOR_ARRAY_SIZE 0x8081 +#define GR_GL_COLOR_ARRAY_TYPE 0x8082 +#define GR_GL_COLOR_ARRAY_STRIDE 0x8083 +#define GR_GL_INDEX_ARRAY_TYPE 0x8085 +#define GR_GL_INDEX_ARRAY_STRIDE 0x8086 +#define GR_GL_TEXTURE_COORD_ARRAY_SIZE 0x8088 +#define GR_GL_TEXTURE_COORD_ARRAY_TYPE 0x8089 +#define GR_GL_TEXTURE_COORD_ARRAY_STRIDE 0x808A +#define GR_GL_EDGE_FLAG_ARRAY_STRIDE 0x808C +#define GR_GL_VERTEX_ARRAY_POINTER 0x808E +#define GR_GL_NORMAL_ARRAY_POINTER 0x808F +#define GR_GL_COLOR_ARRAY_POINTER 0x8090 +#define GR_GL_INDEX_ARRAY_POINTER 0x8091 +#define GR_GL_TEXTURE_COORD_ARRAY_POINTER 0x8092 +#define GR_GL_EDGE_FLAG_ARRAY_POINTER 0x8093 +#define GR_GL_V2F 0x2A20 +#define GR_GL_V3F 0x2A21 +#define GR_GL_C4UB_V2F 0x2A22 +#define GR_GL_C4UB_V3F 0x2A23 +#define GR_GL_C3F_V3F 0x2A24 +#define GR_GL_N3F_V3F 0x2A25 +#define GR_GL_C4F_N3F_V3F 0x2A26 +#define GR_GL_T2F_V3F 0x2A27 +#define GR_GL_T4F_V4F 0x2A28 +#define GR_GL_T2F_C4UB_V3F 0x2A29 +#define GR_GL_T2F_C3F_V3F 0x2A2A +#define GR_GL_T2F_N3F_V3F 0x2A2B +#define GR_GL_T2F_C4F_N3F_V3F 0x2A2C +#define GR_GL_T4F_C4F_N3F_V4F 0x2A2D + +/* Vertex Buffer Object */ +#define GR_GL_WRITE_ONLY 0x88B9 +#define GR_GL_BUFFER_MAPPED 0x88BC +/* Read Format */ +#define GR_GL_IMPLEMENTATION_COLOR_READ_TYPE 0x8B9A +#define GR_GL_IMPLEMENTATION_COLOR_READ_FORMAT 0x8B9B + +/* Shader Source */ +#define GR_GL_COMPILE_STATUS 0x8B81 +#define GR_GL_INFO_LOG_LENGTH 0x8B84 +#define GR_GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GR_GL_SHADER_COMPILER 0x8DFA + +/* Shader Binary */ +#define GR_GL_SHADER_BINARY_FORMATS 0x8DF8 +#define GR_GL_NUM_SHADER_BINARY_FORMATS 0x8DF9 + +/* Shader Precision-Specified Types */ +#define GR_GL_LOW_FLOAT 0x8DF0 +#define GR_GL_MEDIUM_FLOAT 0x8DF1 +#define GR_GL_HIGH_FLOAT 0x8DF2 +#define GR_GL_LOW_INT 0x8DF3 +#define GR_GL_MEDIUM_INT 0x8DF4 +#define GR_GL_HIGH_INT 0x8DF5 + +/* Queries */ +#define GR_GL_QUERY_COUNTER_BITS 0x8864 +#define GR_GL_CURRENT_QUERY 0x8865 +#define GR_GL_QUERY_RESULT 0x8866 +#define GR_GL_QUERY_RESULT_AVAILABLE 0x8867 +#define GR_GL_SAMPLES_PASSED 0x8914 +#define GR_GL_ANY_SAMPLES_PASSED 0x8C2F +#define GR_GL_TIME_ELAPSED 0x88BF +#define GR_GL_TIMESTAMP 0x8E28 +#define GR_GL_PRIMITIVES_GENERATED 0x8C87 +#define GR_GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 + + +/* Framebuffer Object. */ +#define GR_GL_FRAMEBUFFER 0x8D40 +#define GR_GL_READ_FRAMEBUFFER 0x8CA8 +#define GR_GL_DRAW_FRAMEBUFFER 0x8CA9 + +#define GR_GL_RENDERBUFFER 0x8D41 + +#define GR_GL_RGBA4 0x8056 +#define GR_GL_RGB5_A1 0x8057 +#define GR_GL_RGB565 0x8D62 +#define GR_GL_RGBA8 0x8058 +#define GR_GL_RGB8 0x8051 +#define GR_GL_BGRA8 0x93A1 +#define GR_GL_SRGB 0x8C40 +#define GR_GL_SRGB8 0x8C41 +#define GR_GL_SRGB_ALPHA 0x8C42 +#define GR_GL_SRGB8_ALPHA8 0x8C43 +#define GR_GL_DEPTH_COMPONENT16 0x81A5 +#define GR_GL_STENCIL_INDEX 0x1901 +#define GR_GL_STENCIL_INDEX4 0x8D47 +#define GR_GL_STENCIL_INDEX8 0x8D48 +#define GR_GL_STENCIL_INDEX16 0x8D49 +#define GR_GL_DEPTH_STENCIL 0x84F9 +#define GR_GL_DEPTH24_STENCIL8 0x88F0 + +#define GR_GL_MAX_SAMPLES 0x8D57 + +#define GR_GL_RENDERBUFFER_WIDTH 0x8D42 +#define GR_GL_RENDERBUFFER_HEIGHT 0x8D43 +#define GR_GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 +#define GR_GL_RENDERBUFFER_RED_SIZE 0x8D50 +#define GR_GL_RENDERBUFFER_GREEN_SIZE 0x8D51 +#define GR_GL_RENDERBUFFER_BLUE_SIZE 0x8D52 +#define GR_GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 +#define GR_GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 +#define GR_GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 + +#define GR_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 +#define GR_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 +#define GR_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 +#define GR_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 +#define GR_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 +#define GR_GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 +#define GR_GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 +#define GR_GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 +#define GR_GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 +#define GR_GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 +#define GR_GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 + +#define GR_GL_COLOR_ATTACHMENT0 0x8CE0 +#define GR_GL_DEPTH_ATTACHMENT 0x8D00 +#define GR_GL_STENCIL_ATTACHMENT 0x8D20 +#define GR_GL_DEPTH_STENCIL_ATTACHMENT 0x821A + +#define GR_GL_NONE 0 + +#define GR_GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GR_GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GR_GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GR_GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS 0x8CD9 +#define GR_GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD + +#define GR_GL_FRAMEBUFFER_BINDING 0x8CA6 +#define GR_GL_RENDERBUFFER_BINDING 0x8CA7 +#define GR_GL_MAX_RENDERBUFFER_SIZE 0x84E8 + +#define GR_GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 + +#endif diff --git a/include/gpu/gl/GrGLInterface.h b/include/gpu/gl/GrGLInterface.h new file mode 100644 index 0000000000..968afab0d4 --- /dev/null +++ b/include/gpu/gl/GrGLInterface.h @@ -0,0 +1,429 @@ + +/* + * Copyright 2011 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + + + +#ifndef GrGLInterface_DEFINED +#define GrGLInterface_DEFINED + +#include "GrGLConfig.h" +#include "GrRefCnt.h" + +#if !defined(GR_GL_FUNCTION_TYPE) + #define GR_GL_FUNCTION_TYPE +#endif + +//////////////////////////////////////////////////////////////////////////////// + +/** + * Classifies GL contexts (currently as Desktop vs. ES2). This is a bitfield. + * A GrGLInterface (defined below) may support multiple bindings. + */ +enum GrGLBinding { + kNone_GrGLBinding = 0x0, + + kDesktop_GrGLBinding = 0x01, + kES2_GrGLBinding = 0x02, + + // for iteration of GrGLBindings + kFirstGrGLBinding = kDesktop_GrGLBinding, + kLastGrGLBinding = kES2_GrGLBinding +}; + +//////////////////////////////////////////////////////////////////////////////// + +/** + * Helpers for glGetString() + */ + +typedef uint32_t GrGLVersion; +typedef uint32_t GrGLSLVersion; + +#define GR_GL_VER(major, minor) ((static_cast<int>(major) << 16) | \ + static_cast<int>(minor)) +#define GR_GLSL_VER(major, minor) ((static_cast<int>(major) << 16) | \ + static_cast<int>(minor)) + +// these variants assume caller already has a string from glGetString() +GrGLVersion GrGLGetVersionFromString(const char* versionString); +GrGLBinding GrGLGetBindingInUseFromString(const char* versionString); +GrGLSLVersion GrGLGetGLSLVersionFromString(const char* versionString); +bool GrGLHasExtensionFromString(const char* ext, const char* extensionString); + +// these variants call glGetString() +bool GrGLHasExtension(const GrGLInterface*, const char* ext); +GrGLBinding GrGLGetBindingInUse(const GrGLInterface*); +GrGLVersion GrGLGetVersion(const GrGLInterface*); +GrGLSLVersion GrGLGetGLSLVersion(const GrGLInterface*); + +//////////////////////////////////////////////////////////////////////////////// + +/** + * Rather than depend on platform-specific GL headers and libraries, we require + * the client to provide a struct of GL function pointers. This struct can be + * specified per-GrContext as a parameter to GrContext::Create. If NULL is + * passed to Create then the "default" GL interface is used. If the default is + * also NULL GrContext creation will fail. + * + * The default interface is returned by GrGLDefaultInterface. This function's + * implementation is platform-specifc. Several have been provided, along with an + * implementation that simply returns NULL. It is implementation-specific + * whether the same GrGLInterface is returned or whether a new one is created + * at each call. Some platforms may not be able to use a single GrGLInterface + * because extension function ptrs vary across contexts. Note that GrGLInterface + * is ref-counted. So if the same object is returned by multiple calls to + * GrGLDefaultInterface, each should bump the ref count. + * + * By defining GR_GL_PER_GL_CALL_IFACE_CALLBACK to 1 the client can specify a + * callback function that will be called prior to each GL function call. See + * comments in GrGLConfig.h + */ + +struct GrGLInterface; + +const GrGLInterface* GrGLDefaultInterface(); + +/** + * Creates a GrGLInterface for a "native" GL context (e.g. WGL on windows, + * GLX on linux, AGL on Mac). On platforms that have context-specific function + * pointers for GL extensions (e.g. windows) the returned interface is only + * valid for the context that was current at creation. + */ +const GrGLInterface* GrGLCreateNativeInterface(); + +/** + * Creates a GrGLInterface for an OSMesa context. + */ +const GrGLInterface* GrGLCreateMesaInterface(); + +/** + * Creates a null GrGLInterface that doesn't draw anything. Used for measuring + * CPU overhead. + */ +const GrGLInterface* GrGLCreateNullInterface(); + +typedef unsigned int GrGLenum; +typedef unsigned char GrGLboolean; +typedef unsigned int GrGLbitfield; +typedef signed char GrGLbyte; +typedef char GrGLchar; +typedef short GrGLshort; +typedef int GrGLint; +typedef int GrGLsizei; +typedef int64_t GrGLint64; +typedef unsigned char GrGLubyte; +typedef unsigned short GrGLushort; +typedef unsigned int GrGLuint; +typedef uint64_t GrGLuint64; +typedef float GrGLfloat; +typedef float GrGLclampf; +typedef double GrGLdouble; +typedef double GrGLclampd; +typedef void GrGLvoid; +typedef long GrGLintptr; +typedef long GrGLsizeiptr; + +extern "C" { + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLActiveTextureProc)(GrGLenum texture); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLAttachShaderProc)(GrGLuint program, GrGLuint shader); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLBeginQueryProc)(GrGLenum target, GrGLuint id); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLBindAttribLocationProc)(GrGLuint program, GrGLuint index, const char* name); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLBindBufferProc)(GrGLenum target, GrGLuint buffer); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLBindTextureProc)(GrGLenum target, GrGLuint texture); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLBlendColorProc)(GrGLclampf red, GrGLclampf green, GrGLclampf blue, GrGLclampf alpha); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLBindFragDataLocationProc)(GrGLuint program, GrGLuint colorNumber, const GrGLchar* name); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLBlendFuncProc)(GrGLenum sfactor, GrGLenum dfactor); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLBufferDataProc)(GrGLenum target, GrGLsizeiptr size, const GrGLvoid* data, GrGLenum usage); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLBufferSubDataProc)(GrGLenum target, GrGLintptr offset, GrGLsizeiptr size, const GrGLvoid* data); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLClearProc)(GrGLbitfield mask); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLClearColorProc)(GrGLclampf red, GrGLclampf green, GrGLclampf blue, GrGLclampf alpha); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLClearStencilProc)(GrGLint s); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLColorMaskProc)(GrGLboolean red, GrGLboolean green, GrGLboolean blue, GrGLboolean alpha); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLColorPointerProc)(GrGLint size, GrGLenum type, GrGLsizei stride, const GrGLvoid* pointer); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLCompileShaderProc)(GrGLuint shader); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLCompressedTexImage2DProc)(GrGLenum target, GrGLint level, GrGLenum internalformat, GrGLsizei width, GrGLsizei height, GrGLint border, GrGLsizei imageSize, const GrGLvoid* data); + typedef GrGLuint (GR_GL_FUNCTION_TYPE *GrGLCreateProgramProc)(void); + typedef GrGLuint (GR_GL_FUNCTION_TYPE *GrGLCreateShaderProc)(GrGLenum type); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLCullFaceProc)(GrGLenum mode); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLDeleteBuffersProc)(GrGLsizei n, const GrGLuint* buffers); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLDeleteProgramProc)(GrGLuint program); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLDeleteQueriesProc)(GrGLsizei n, const GrGLuint *ids); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLDeleteShaderProc)(GrGLuint shader); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLDeleteTexturesProc)(GrGLsizei n, const GrGLuint* textures); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLDepthMaskProc)(GrGLboolean flag); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLDisableProc)(GrGLenum cap); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLDisableVertexAttribArrayProc)(GrGLuint index); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLDrawArraysProc)(GrGLenum mode, GrGLint first, GrGLsizei count); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLDrawBufferProc)(GrGLenum mode); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLDrawBuffersProc)(GrGLsizei n, const GrGLenum* bufs); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLDrawElementsProc)(GrGLenum mode, GrGLsizei count, GrGLenum type, const GrGLvoid* indices); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLEnableProc)(GrGLenum cap); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLEnableVertexAttribArrayProc)(GrGLuint index); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLEndQueryProc)(GrGLenum target); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLFinishProc)(); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLFlushProc)(); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLFrontFaceProc)(GrGLenum mode); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLGenBuffersProc)(GrGLsizei n, GrGLuint* buffers); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLGenQueriesProc)(GrGLsizei n, GrGLuint *ids); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLGenTexturesProc)(GrGLsizei n, GrGLuint* textures); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLGetBufferParameterivProc)(GrGLenum target, GrGLenum pname, GrGLint* params); + typedef GrGLenum (GR_GL_FUNCTION_TYPE *GrGLGetErrorProc)(); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLGetIntegervProc)(GrGLenum pname, GrGLint* params); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLGetProgramInfoLogProc)(GrGLuint program, GrGLsizei bufsize, GrGLsizei* length, char* infolog); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLGetProgramivProc)(GrGLuint program, GrGLenum pname, GrGLint* params); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLGetQueryivProc)(GrGLenum GLtarget, GrGLenum pname, GrGLint *params); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLGetQueryObjecti64vProc)(GrGLuint id, GrGLenum pname, GrGLint64 *params); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLGetQueryObjectivProc)(GrGLuint id, GrGLenum pname, GrGLint *params); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLGetQueryObjectui64vProc)(GrGLuint id, GrGLenum pname, GrGLuint64 *params); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLGetQueryObjectuivProc)(GrGLuint id, GrGLenum pname, GrGLuint *params); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLGetShaderInfoLogProc)(GrGLuint shader, GrGLsizei bufsize, GrGLsizei* length, char* infolog); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLGetShaderivProc)(GrGLuint shader, GrGLenum pname, GrGLint* params); + typedef const GrGLubyte* (GR_GL_FUNCTION_TYPE *GrGLGetStringProc)(GrGLenum name); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLGetTexLevelParameterivProc)(GrGLenum target, GrGLint level, GrGLenum pname, GrGLint* params); + typedef GrGLint (GR_GL_FUNCTION_TYPE *GrGLGetUniformLocationProc)(GrGLuint program, const char* name); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLLineWidthProc)(GrGLfloat width); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLLinkProgramProc)(GrGLuint program); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLPixelStoreiProc)(GrGLenum pname, GrGLint param); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLQueryCounterProc)(GrGLuint id, GrGLenum target); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLReadBufferProc)(GrGLenum src); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLReadPixelsProc)(GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height, GrGLenum format, GrGLenum type, GrGLvoid* pixels); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLScissorProc)(GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLShaderSourceProc)(GrGLuint shader, GrGLsizei count, const char** str, const GrGLint* length); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLStencilFuncProc)(GrGLenum func, GrGLint ref, GrGLuint mask); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLStencilFuncSeparateProc)(GrGLenum face, GrGLenum func, GrGLint ref, GrGLuint mask); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLStencilMaskProc)(GrGLuint mask); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLStencilMaskSeparateProc)(GrGLenum face, GrGLuint mask); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLStencilOpProc)(GrGLenum fail, GrGLenum zfail, GrGLenum zpass); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLStencilOpSeparateProc)(GrGLenum face, GrGLenum fail, GrGLenum zfail, GrGLenum zpass); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLTexImage2DProc)(GrGLenum target, GrGLint level, GrGLint internalformat, GrGLsizei width, GrGLsizei height, GrGLint border, GrGLenum format, GrGLenum type, const GrGLvoid* pixels); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLTexParameteriProc)(GrGLenum target, GrGLenum pname, GrGLint param); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLTexStorage2DProc)(GrGLenum target, GrGLsizei levels, GrGLenum internalformat, GrGLsizei width, GrGLsizei height); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLTexSubImage2DProc)(GrGLenum target, GrGLint level, GrGLint xoffset, GrGLint yoffset, GrGLsizei width, GrGLsizei height, GrGLenum format, GrGLenum type, const GrGLvoid* pixels); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform1fProc)(GrGLint location, GrGLfloat v0); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform1iProc)(GrGLint location, GrGLint v0); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform1fvProc)(GrGLint location, GrGLsizei count, const GrGLfloat* v); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform1ivProc)(GrGLint location, GrGLsizei count, const GrGLint* v); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform2fProc)(GrGLint location, GrGLfloat v0, GrGLfloat v1); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform2iProc)(GrGLint location, GrGLint v0, GrGLint v1); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform2fvProc)(GrGLint location, GrGLsizei count, const GrGLfloat* v); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform2ivProc)(GrGLint location, GrGLsizei count, const GrGLint* v); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform3fProc)(GrGLint location, GrGLfloat v0, GrGLfloat v1, GrGLfloat v2); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform3iProc)(GrGLint location, GrGLint v0, GrGLint v1, GrGLint v2); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform3fvProc)(GrGLint location, GrGLsizei count, const GrGLfloat* v); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform3ivProc)(GrGLint location, GrGLsizei count, const GrGLint* v); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform4fProc)(GrGLint location, GrGLfloat v0, GrGLfloat v1, GrGLfloat v2, GrGLfloat v3); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform4iProc)(GrGLint location, GrGLint v0, GrGLint v1, GrGLint v2, GrGLint v3); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform4fvProc)(GrGLint location, GrGLsizei count, const GrGLfloat* v); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform4ivProc)(GrGLint location, GrGLsizei count, const GrGLint* v); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniformMatrix2fvProc)(GrGLint location, GrGLsizei count, GrGLboolean transpose, const GrGLfloat* value); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniformMatrix3fvProc)(GrGLint location, GrGLsizei count, GrGLboolean transpose, const GrGLfloat* value); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniformMatrix4fvProc)(GrGLint location, GrGLsizei count, GrGLboolean transpose, const GrGLfloat* value); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUseProgramProc)(GrGLuint program); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLVertexAttrib4fvProc)(GrGLuint indx, const GrGLfloat* values); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLVertexAttribPointerProc)(GrGLuint indx, GrGLint size, GrGLenum type, GrGLboolean normalized, GrGLsizei stride, const GrGLvoid* ptr); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLViewportProc)(GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height); + + // FBO Extension Functions + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLBindFramebufferProc)(GrGLenum target, GrGLuint framebuffer); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLBindRenderbufferProc)(GrGLenum target, GrGLuint renderbuffer); + typedef GrGLenum (GR_GL_FUNCTION_TYPE *GrGLCheckFramebufferStatusProc)(GrGLenum target); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLDeleteFramebuffersProc)(GrGLsizei n, const GrGLuint *framebuffers); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLDeleteRenderbuffersProc)(GrGLsizei n, const GrGLuint *renderbuffers); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLFramebufferRenderbufferProc)(GrGLenum target, GrGLenum attachment, GrGLenum renderbuffertarget, GrGLuint renderbuffer); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLFramebufferTexture2DProc)(GrGLenum target, GrGLenum attachment, GrGLenum textarget, GrGLuint texture, GrGLint level); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLGenFramebuffersProc)(GrGLsizei n, GrGLuint *framebuffers); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLGenRenderbuffersProc)(GrGLsizei n, GrGLuint *renderbuffers); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLGetFramebufferAttachmentParameterivProc)(GrGLenum target, GrGLenum attachment, GrGLenum pname, GrGLint* params); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLGetRenderbufferParameterivProc)(GrGLenum target, GrGLenum pname, GrGLint* params); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLRenderbufferStorageProc)(GrGLenum target, GrGLenum internalformat, GrGLsizei width, GrGLsizei height); + + // Multisampling Extension Functions + // same prototype for ARB_FBO, EXT_FBO, GL 3.0, & Apple ES extension + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLRenderbufferStorageMultisampleProc)(GrGLenum target, GrGLsizei samples, GrGLenum internalformat, GrGLsizei width, GrGLsizei height); + // desktop: ext_fbo_blit, arb_fbo, gl 3.0 + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLBlitFramebufferProc)(GrGLint srcX0, GrGLint srcY0, GrGLint srcX1, GrGLint srcY1, GrGLint dstX0, GrGLint dstY0, GrGLint dstX1, GrGLint dstY1, GrGLbitfield mask, GrGLenum filter); + // apple's es extension + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLResolveMultisampleFramebufferProc)(); + + // Buffer mapping (extension in ES). + typedef GrGLvoid* (GR_GL_FUNCTION_TYPE *GrGLMapBufferProc)(GrGLenum target, GrGLenum access); + typedef GrGLboolean (GR_GL_FUNCTION_TYPE *GrGLUnmapBufferProc)(GrGLenum target); + + // Dual source blending + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLBindFragDataLocationIndexedProc)(GrGLuint program, GrGLuint colorNumber, GrGLuint index, const GrGLchar * name); +} // extern "C" + +#if GR_GL_PER_GL_FUNC_CALLBACK +typedef void (*GrGLInterfaceCallbackProc)(const GrGLInterface*); +typedef intptr_t GrGLInterfaceCallbackData; +#endif + + +enum GrGLCapability { + kProbe_GrGLCapability = -1 +}; + +/* + * The following interface exports the OpenGL entry points used by the system. + * Use of OpenGL calls is disallowed. All calls should be invoked through + * the global instance of this struct, defined above. + * + * IMPORTANT NOTE: The OpenGL entry points exposed here include both core GL + * functions, and extensions. The system assumes that the address of the + * extension pointer will be valid across contexts. + */ +struct GR_API GrGLInterface : public GrRefCnt { + + GrGLInterface(); + + // Validates that the GrGLInterface supports a binding. This means that + // the GrGLinterface advertises the binding in fBindingsExported and all + // the necessary function pointers have been initialized. + bool validate(GrGLBinding binding) const; + + // Indicator variable specifying the type of GL implementation + // exported: GLES{1|2} or Desktop. + GrGLBinding fBindingsExported; + + GrGLActiveTextureProc fActiveTexture; + GrGLAttachShaderProc fAttachShader; + GrGLBeginQueryProc fBeginQuery; + GrGLBindAttribLocationProc fBindAttribLocation; + GrGLBindBufferProc fBindBuffer; + GrGLBindFragDataLocationProc fBindFragDataLocation; + GrGLBindTextureProc fBindTexture; + GrGLBlendColorProc fBlendColor; + GrGLBlendFuncProc fBlendFunc; + GrGLBufferDataProc fBufferData; + GrGLBufferSubDataProc fBufferSubData; + GrGLClearProc fClear; + GrGLClearColorProc fClearColor; + GrGLClearStencilProc fClearStencil; + GrGLColorMaskProc fColorMask; + GrGLColorPointerProc fColorPointer; + GrGLCompileShaderProc fCompileShader; + GrGLCompressedTexImage2DProc fCompressedTexImage2D; + GrGLCreateProgramProc fCreateProgram; + GrGLCreateShaderProc fCreateShader; + GrGLCullFaceProc fCullFace; + GrGLDeleteBuffersProc fDeleteBuffers; + GrGLDeleteProgramProc fDeleteProgram; + GrGLDeleteQueriesProc fDeleteQueries; + GrGLDeleteShaderProc fDeleteShader; + GrGLDeleteTexturesProc fDeleteTextures; + GrGLDepthMaskProc fDepthMask; + GrGLDisableProc fDisable; + GrGLDisableVertexAttribArrayProc fDisableVertexAttribArray; + GrGLDrawArraysProc fDrawArrays; + GrGLDrawBufferProc fDrawBuffer; + GrGLDrawBuffersProc fDrawBuffers; + GrGLDrawElementsProc fDrawElements; + GrGLEnableProc fEnable; + GrGLEnableVertexAttribArrayProc fEnableVertexAttribArray; + GrGLEndQueryProc fEndQuery; + GrGLFinishProc fFinish; + GrGLFlushProc fFlush; + GrGLFrontFaceProc fFrontFace; + GrGLGenBuffersProc fGenBuffers; + GrGLGenQueriesProc fGenQueries; + GrGLGenTexturesProc fGenTextures; + GrGLGetBufferParameterivProc fGetBufferParameteriv; + GrGLGetErrorProc fGetError; + GrGLGetIntegervProc fGetIntegerv; + GrGLGetQueryObjecti64vProc fGetQueryObjecti64v; + GrGLGetQueryObjectivProc fGetQueryObjectiv; + GrGLGetQueryObjectui64vProc fGetQueryObjectui64v; + GrGLGetQueryObjectuivProc fGetQueryObjectuiv; + GrGLGetQueryivProc fGetQueryiv; + GrGLGetProgramInfoLogProc fGetProgramInfoLog; + GrGLGetProgramivProc fGetProgramiv; + GrGLGetShaderInfoLogProc fGetShaderInfoLog; + GrGLGetShaderivProc fGetShaderiv; + GrGLGetStringProc fGetString; + GrGLGetTexLevelParameterivProc fGetTexLevelParameteriv; + GrGLGetUniformLocationProc fGetUniformLocation; + GrGLLineWidthProc fLineWidth; + GrGLLinkProgramProc fLinkProgram; + GrGLPixelStoreiProc fPixelStorei; + GrGLQueryCounterProc fQueryCounter; + GrGLReadBufferProc fReadBuffer; + GrGLReadPixelsProc fReadPixels; + GrGLScissorProc fScissor; + GrGLShaderSourceProc fShaderSource; + GrGLStencilFuncProc fStencilFunc; + GrGLStencilFuncSeparateProc fStencilFuncSeparate; + GrGLStencilMaskProc fStencilMask; + GrGLStencilMaskSeparateProc fStencilMaskSeparate; + GrGLStencilOpProc fStencilOp; + GrGLStencilOpSeparateProc fStencilOpSeparate; + GrGLTexImage2DProc fTexImage2D; + GrGLTexParameteriProc fTexParameteri; + GrGLTexSubImage2DProc fTexSubImage2D; + GrGLTexStorage2DProc fTexStorage2D; + GrGLUniform1fProc fUniform1f; + GrGLUniform1iProc fUniform1i; + GrGLUniform1fvProc fUniform1fv; + GrGLUniform1ivProc fUniform1iv; + GrGLUniform2fProc fUniform2f; + GrGLUniform2iProc fUniform2i; + GrGLUniform2fvProc fUniform2fv; + GrGLUniform2ivProc fUniform2iv; + GrGLUniform3fProc fUniform3f; + GrGLUniform3iProc fUniform3i; + GrGLUniform3fvProc fUniform3fv; + GrGLUniform3ivProc fUniform3iv; + GrGLUniform4fProc fUniform4f; + GrGLUniform4iProc fUniform4i; + GrGLUniform4fvProc fUniform4fv; + GrGLUniform4ivProc fUniform4iv; + GrGLUniformMatrix2fvProc fUniformMatrix2fv; + GrGLUniformMatrix3fvProc fUniformMatrix3fv; + GrGLUniformMatrix4fvProc fUniformMatrix4fv; + GrGLUseProgramProc fUseProgram; + GrGLVertexAttrib4fvProc fVertexAttrib4fv; + GrGLVertexAttribPointerProc fVertexAttribPointer; + GrGLViewportProc fViewport; + + // FBO Extension Functions + GrGLBindFramebufferProc fBindFramebuffer; + GrGLBindRenderbufferProc fBindRenderbuffer; + GrGLCheckFramebufferStatusProc fCheckFramebufferStatus; + GrGLDeleteFramebuffersProc fDeleteFramebuffers; + GrGLDeleteRenderbuffersProc fDeleteRenderbuffers; + GrGLFramebufferRenderbufferProc fFramebufferRenderbuffer; + GrGLFramebufferTexture2DProc fFramebufferTexture2D; + GrGLGenFramebuffersProc fGenFramebuffers; + GrGLGenRenderbuffersProc fGenRenderbuffers; + GrGLGetFramebufferAttachmentParameterivProc fGetFramebufferAttachmentParameteriv; + GrGLGetRenderbufferParameterivProc fGetRenderbufferParameteriv; + GrGLRenderbufferStorageProc fRenderbufferStorage; + + // Multisampling Extension Functions + // same prototype for ARB_FBO, EXT_FBO, GL 3.0, & Apple ES extension + GrGLRenderbufferStorageMultisampleProc fRenderbufferStorageMultisample; + // desktop: ext_fbo_blit, arb_fbo, gl 3.0 + GrGLBlitFramebufferProc fBlitFramebuffer; + // apple's es extension + GrGLResolveMultisampleFramebufferProc fResolveMultisampleFramebuffer; + + // Buffer mapping (extension in ES). + GrGLMapBufferProc fMapBuffer; + GrGLUnmapBufferProc fUnmapBuffer; + + // Dual Source Blending + GrGLBindFragDataLocationIndexedProc fBindFragDataLocationIndexed; + + // Per-GL func callback +#if GR_GL_PER_GL_FUNC_CALLBACK + GrGLInterfaceCallbackProc fCallback; + GrGLInterfaceCallbackData fCallbackData; +#endif + +}; + +#endif diff --git a/include/gpu/gl/SkGLContext.h b/include/gpu/gl/SkGLContext.h new file mode 100644 index 0000000000..542d1bbc06 --- /dev/null +++ b/include/gpu/gl/SkGLContext.h @@ -0,0 +1,63 @@ + +/* + * Copyright 2011 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ +#ifndef SkGLContext_DEFINED +#define SkGLContext_DEFINED + +#include "GrGLInterface.h" +#include "SkString.h" + +/** + * Create an offscreen opengl context with an RGBA8 / 8bit stencil FBO. + * Provides a GrGLInterface struct of function pointers for the context. + */ + +class SkGLContext : public SkRefCnt { +public: + SkGLContext(); + virtual ~SkGLContext(); + + /** + * Initializes the context and makes it current. + */ + bool init(const int width, const int height); + + int getFBOID() const { return fFBO; } + + const GrGLInterface* gl() const { return fGL; } + + virtual void makeCurrent() const = 0; + + bool hasExtension(const char* extensionName) const; + +protected: + /** + * Subclass implements this to make a GL context. The returned GrGLInterface + * should be populated with functions compatible with the context. The + * format and size of backbuffers does not matter since an FBO will be + * created. + */ + virtual const GrGLInterface* createGLContext() = 0; + + /** + * Subclass should destroy the underlying GL context. + */ + virtual void destroyGLContext() = 0; + +private: + SkString fExtensionString; + GrGLuint fFBO; + const GrGLInterface* fGL; +}; + +/** + * Helper macro for using the GL context through the GrGLInterface. Example: + * SK_GL(glCtx, GenTextures(1, &texID)); + */ +#define SK_GL(ctx, X) (ctx).gl()->f ## X + +#endif diff --git a/include/gpu/gl/SkMesaGLContext.h b/include/gpu/gl/SkMesaGLContext.h new file mode 100644 index 0000000000..5c329ff120 --- /dev/null +++ b/include/gpu/gl/SkMesaGLContext.h @@ -0,0 +1,50 @@ + +/* + * Copyright 2011 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ +#ifndef SkMesaGLContext_DEFINED +#define SkMesaGLContext_DEFINED + +#include "SkGLContext.h" + +#if SK_MESA + +class SkMesaGLContext : public SkGLContext { +private: + typedef intptr_t Context; + +public: + SkMesaGLContext(); + + virtual ~SkMesaGLContext(); + + virtual void makeCurrent() const SK_OVERRIDE; + + class AutoContextRestore { + public: + AutoContextRestore(); + ~AutoContextRestore(); + + private: + Context fOldContext; + GLint fOldWidth; + GLint fOldHeight; + GLint fOldFormat; + void* fOldImage; + }; + +protected: + virtual const GrGLInterface* createGLContext() SK_OVERRIDE; + virtual void destroyGLContext() SK_OVERRIDE; + +private: + Context fContext; + GrGLubyte *fImage; +}; + +#endif + +#endif diff --git a/include/gpu/gl/SkNativeGLContext.h b/include/gpu/gl/SkNativeGLContext.h new file mode 100644 index 0000000000..36461ba7b2 --- /dev/null +++ b/include/gpu/gl/SkNativeGLContext.h @@ -0,0 +1,81 @@ + +/* + * Copyright 2011 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ +#ifndef SkNativeGLContext_DEFINED +#define SkNativeGLContext_DEFINED + +#include "SkGLContext.h" + +#if defined(SK_BUILD_FOR_MAC) + #include <AGL/agl.h> + +#elif defined(SK_BUILD_FOR_ANDROID) + #include <GLES2/gl2.h> + #include <EGL/egl.h> +#elif defined(SK_BUILD_FOR_UNIX) + #include <X11/Xlib.h> + #include <GL/glx.h> +#elif defined(SK_BUILD_FOR_WIN32) + #include <Windows.h> + #include <GL/GL.h> +#endif + +class SkNativeGLContext : public SkGLContext { +public: + SkNativeGLContext(); + + virtual ~SkNativeGLContext(); + + virtual void makeCurrent() const SK_OVERRIDE; + + class AutoContextRestore { + public: + AutoContextRestore(); + ~AutoContextRestore(); + + private: + #if defined(SK_BUILD_FOR_MAC) + AGLContext fOldAGLContext; + #elif defined(SK_BUILD_FOR_UNIX) + GLXContext fOldGLXContext; + Display* fOldDisplay; + GLXDrawable fOldDrawable; + #elif defined(SK_BUILD_FOR_WIN32) + HDC fOldHDC; + HGLRC fOldHGLRC; + #elif defined(SK_BUILD_FOR_ANDROID) + EGLContext fOldEGLContext; + EGLDisplay fOldDisplay; + EGLSurface fOldSurface; + #endif + }; + +protected: + virtual const GrGLInterface* createGLContext() SK_OVERRIDE; + virtual void destroyGLContext() SK_OVERRIDE; + +private: +#if defined(SK_BUILD_FOR_MAC) + AGLContext fContext; +#elif defined(SK_BUILD_FOR_UNIX) + GLXContext fContext; + Display* fDisplay; + Pixmap fPixmap; + GLXPixmap fGlxPixmap; +#elif defined(SK_BUILD_FOR_WIN32) + HWND fWindow; + HDC fDeviceContext; + HGLRC fGlRenderContext; + static ATOM gWC; +#elif defined(SK_BUILD_FOR_ANDROID) + EGLContext fContext; + EGLDisplay fDisplay; + EGLSurface fSurface; +#endif +}; + +#endif diff --git a/include/gpu/gl/SkNullGLContext.h b/include/gpu/gl/SkNullGLContext.h new file mode 100644 index 0000000000..9e16cee089 --- /dev/null +++ b/include/gpu/gl/SkNullGLContext.h @@ -0,0 +1,27 @@ + +/* + * Copyright 2011 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ +#ifndef SkNullGLContext_DEFINED +#define SkNullGLContext_DEFINED + +#include "SkGLContext.h" + +class SkNullGLContext : public SkGLContext { + +public: + SkNullGLContext() {}; + + virtual void makeCurrent() const SK_OVERRIDE {}; + +protected: + virtual const GrGLInterface* createGLContext() SK_OVERRIDE; + + virtual void destroyGLContext() SK_OVERRIDE {}; +}; + +#endif + |