From 0f31ca79bde088e6caac219734c35c1ae3e9e8b9 Mon Sep 17 00:00:00 2001 From: "twiz@google.com" Date: Fri, 18 Mar 2011 17:38:11 +0000 Subject: [PATCH] This CL removes all dependencies on GL headers across all of Ganesh. New GrGLint, etc. types are introduced, and new GR_GL_XXXX constants for use at all GL call-sites. Review: http://codereview.appspot.com/4272061/ git-svn-id: http://skia.googlecode.com/svn/trunk@959 2bbb7eff-a529-9590-31e7-b0007b416f81 --- gpu/include/GrGLConfig.h | 15 +- gpu/include/GrGLConfig_chrome.h | 6 +- gpu/include/GrGLDefines.h | 628 ++++++++++++++++++++++++ gpu/include/GrGLIRect.h | 31 +- gpu/include/GrGLIndexBuffer.h | 8 +- gpu/include/GrGLInterface.h | 200 ++++---- gpu/include/GrGLPlatformIncludes.h | 387 ++------------- gpu/include/GrGLTexture.h | 60 +-- gpu/include/GrGLVertexBuffer.h | 8 +- gpu/src/GrGLIndexBuffer.cpp | 28 +- gpu/src/GrGLInterface.cpp | 42 +- gpu/src/GrGLTexture.cpp | 22 +- gpu/src/GrGLUtil.cpp | 2 +- gpu/src/GrGLVertexBuffer.cpp | 28 +- gpu/src/GrGpuGL.cpp | 466 +++++++++--------- gpu/src/GrGpuGL.h | 10 +- gpu/src/GrGpuGLFixed.cpp | 98 ++-- gpu/src/GrGpuGLShaders2.cpp | 72 +-- gpu/src/GrGpuGLShaders2.h | 10 +- vs/SampleApp/SampleApp.vcxproj | 1 + vs/SampleApp/SampleApp.vcxproj.filters | 3 + xcode/gpu/gpu.xcodeproj/project.pbxproj | 4 + 22 files changed, 1247 insertions(+), 882 deletions(-) create mode 100644 gpu/include/GrGLDefines.h diff --git a/gpu/include/GrGLConfig.h b/gpu/include/GrGLConfig.h index 0a86e72e8e..3c1c5971fa 100644 --- a/gpu/include/GrGLConfig.h +++ b/gpu/include/GrGLConfig.h @@ -20,6 +20,7 @@ #include "GrTypes.h" #include "GrGLInterface.h" +#include "GrGLDefines.h" /** * The following are optional defines that can be enabled at the compiler @@ -66,19 +67,19 @@ #if GR_SCALAR_IS_FIXED #define GrGLType GL_FIXED #elif GR_SCALAR_IS_FLOAT - #define GrGLType GL_FLOAT + #define GrGLType GR_GL_FLOAT #else #error "unknown GR_SCALAR type" #endif #if GR_TEXT_SCALAR_IS_USHORT - #define GrGLTextType GL_UNSIGNED_SHORT + #define GrGLTextType GR_GL_UNSIGNED_SHORT #define GR_GL_TEXT_TEXTURE_NORMALIZED 1 #elif GR_TEXT_SCALAR_IS_FLOAT - #define GrGLTextType GL_FLOAT + #define GrGLTextType GR_GL_FLOAT #define GR_GL_TEXT_TEXTURE_NORMALIZED 0 #elif GR_TEXT_SCALAR_IS_FIXED - #define GrGLTextType GL_FIXED + #define GrGLTextType GR_GL_FIXED #define GR_GL_TEXT_TEXTURE_NORMALIZED 0 #else #error "unknown GR_TEXT_SCALAR type" @@ -90,7 +91,7 @@ #if GR_WIN32_BUILD #define GR_GL_32BPP_COLOR_FORMAT GR_BGRA //use GR prefix because this #else //may be an extension. - #define GR_GL_32BPP_COLOR_FORMAT GL_RGBA + #define GR_GL_32BPP_COLOR_FORMAT GR_GL_RGBA #endif #endif @@ -137,7 +138,7 @@ extern void GrGLCheckErr(const char* location, const char* call); static inline void GrGLClearErr() { - while (GL_NO_ERROR != GrGLGetGLInterface()->fGetError()) {} + while (GR_GL_NO_ERROR != GrGLGetGLInterface()->fGetError()) {} } #if GR_GL_CHECK_ERROR @@ -165,7 +166,7 @@ static inline void GrGLClearErr() { */ #if GR_SUPPORT_GLDESKTOP static inline void GrGL_RestoreResetRowLength() { - GR_GL(PixelStorei(GL_UNPACK_ROW_LENGTH, 0)); + GR_GL(PixelStorei(GR_GL_UNPACK_ROW_LENGTH, 0)); } #else #define GrGL_RestoreResetRowLength() diff --git a/gpu/include/GrGLConfig_chrome.h b/gpu/include/GrGLConfig_chrome.h index 6d5f21cea3..06a74d3a38 100644 --- a/gpu/include/GrGLConfig_chrome.h +++ b/gpu/include/GrGLConfig_chrome.h @@ -8,10 +8,10 @@ #define GL_OES_mapbuffer 0 #define GL_IMG_multisampled_render_to_texture 0 -#include -#include +#define GR_GL_PLATFORM_HEADER +#define GR_GL_PLATFORM_HEADER_EXT -#define GR_GL_FUNC +#define GR_GL_FUNCTION_TYPE #define GR_GL_PROC_ADDRESS(X) &X diff --git a/gpu/include/GrGLDefines.h b/gpu/include/GrGLDefines.h new file mode 100644 index 0000000000..4c36e74750 --- /dev/null +++ b/gpu/include/GrGLDefines.h @@ -0,0 +1,628 @@ +/* + Copyright 2011 Google Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + */ + + +#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 */ + +/* 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_PACK_ALIGNMENT 0x0D05 +#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_ALPHA 0x1906 +#define GR_GL_RGB 0x1907 +#define GR_GL_RGBA 0x1908 +#define GR_GL_LUMINANCE 0x1909 +#define GR_GL_LUMINANCE_ALPHA 0x190A + +/* 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_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 + +/* 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 + +/* 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 + +/* 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 + +/* 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 mapping */ +#define GR_GL_TEXTURE_ENV 0x2300 +#define GR_GL_TEXTURE_ENV_MODE 0x2200 +#define GR_GL_TEXTURE_1D 0x0DE0 +#define GR_GL_TEXTURE_2D 0x0DE1 +#define GR_GL_TEXTURE_WRAP_S 0x2802 +#define GR_GL_TEXTURE_WRAP_T 0x2803 +#define GR_GL_TEXTURE_MAG_FILTER 0x2800 +#define GR_GL_TEXTURE_MIN_FILTER 0x2801 +#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_NEAREST_MIPMAP_NEAREST 0x2700 +#define GR_GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GR_GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GR_GL_LINEAR_MIPMAP_LINEAR 0x2703 +#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 +#define GR_GL_NEAREST 0x2600 +#define GR_GL_REPEAT 0x2901 +#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 + +/* 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 + +/* Framebuffer Object. */ +#define GR_GL_FRAMEBUFFER 0x8D40 +#define GR_GL_RENDERBUFFER 0x8D41 + +#define GR_GL_RGBA4 0x8056 +#define GR_GL_RGB5_A1 0x8057 +#define GR_GL_RGB565 0x8D62 +#define GR_GL_DEPTH_COMPONENT16 0x81A5 +#define GR_GL_STENCIL_INDEX 0x1901 +#define GR_GL_STENCIL_INDEX8 0x8D48 + +#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_COLOR_ATTACHMENT0 0x8CE0 +#define GR_GL_DEPTH_ATTACHMENT 0x8D00 +#define GR_GL_STENCIL_ATTACHMENT 0x8D20 + +#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 \ No newline at end of file diff --git a/gpu/include/GrGLIRect.h b/gpu/include/GrGLIRect.h index 80237d9196..f9213e3f9d 100644 --- a/gpu/include/GrGLIRect.h +++ b/gpu/include/GrGLIRect.h @@ -1,17 +1,34 @@ -#include "GrGLConfig.h" +/* + Copyright 2011 Google Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + */ + #ifndef GrGLIRect_DEFINED #define GrGLIRect_DEFINED +#include "GrGLConfig.h" + /** * Helper struct for dealing with the fact that Ganesh and GL use different * window coordinate systems (top-down vs bottom-up) */ struct GrGLIRect { - GLint fLeft; - GLint fBottom; - GLsizei fWidth; - GLsizei fHeight; + GrGLint fLeft; + GrGLint fBottom; + GrGLsizei fWidth; + GrGLsizei fHeight; void pushToGLViewport() const { GR_GL(Viewport(fLeft, fBottom, fWidth, fHeight)); @@ -22,8 +39,8 @@ struct GrGLIRect { } void setFromGLViewport() { - GR_STATIC_ASSERT(sizeof(GrGLIRect) == 4*sizeof(GLint)); - GR_GL_GetIntegerv(GL_VIEWPORT, (GLint*) this); + GR_STATIC_ASSERT(sizeof(GrGLIRect) == 4*sizeof(GrGLint)); + GR_GL_GetIntegerv(GR_GL_VIEWPORT, (GrGLint*) this); } // sometimes we have a GrIRect from the client that we diff --git a/gpu/include/GrGLIndexBuffer.h b/gpu/include/GrGLIndexBuffer.h index 5755c073bc..0ecbe6d8a1 100644 --- a/gpu/include/GrGLIndexBuffer.h +++ b/gpu/include/GrGLIndexBuffer.h @@ -1,5 +1,5 @@ /* - Copyright 2010 Google Inc. + Copyright 2011 Google Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -25,14 +25,14 @@ class GrGpuGL; class GrGLIndexBuffer : public GrIndexBuffer { protected: - GrGLIndexBuffer(GLuint id, + GrGLIndexBuffer(GrGLuint id, GrGpuGL* gl, size_t sizeInBytes, bool dynamic); public: virtual ~GrGLIndexBuffer(); - GLuint bufferID() const; + GrGLuint bufferID() const; // overrides of GrIndexBuffer virtual void abandon(); @@ -48,7 +48,7 @@ private: void bind() const; GrGpuGL* fGL; - GLuint fBufferID; + GrGLuint fBufferID; void* fLockPtr; friend class GrGpuGL; diff --git a/gpu/include/GrGLInterface.h b/gpu/include/GrGLInterface.h index 0a41905361..7bee11191b 100644 --- a/gpu/include/GrGLInterface.h +++ b/gpu/include/GrGLInterface.h @@ -47,6 +47,22 @@ extern void GrGLSetGLInterface(GrGLInterface* gl_interface); */ extern void GrGLSetDefaultGLInterface(); +typedef unsigned int GrGLenum; +typedef unsigned char GrGLboolean; +typedef unsigned int GrGLbitfield; +typedef signed char GrGLbyte; +typedef short GrGLshort; +typedef int GrGLint; +typedef int GrGLsizei; +typedef unsigned char GrGLubyte; +typedef unsigned short GrGLushort; +typedef unsigned int GrGLuint; +typedef float GrGLfloat; +typedef float GrGLclampf; +typedef double GrGLdouble; +typedef double GrGLclampd; +typedef void GrGLvoid; + extern "C" { /* * The following interface exports the OpenGL entry points used by the system. @@ -58,109 +74,109 @@ extern "C" { * extension pointer will be valid across contexts. */ struct GrGLInterface { - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLActiveTextureProc)(GLenum texture); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLAttachShaderProc)(GLuint program, GLuint shader); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLBindAttribLocationProc)(GLuint program, GLuint index, const char* name); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLBindBufferProc)(GLenum target, GLuint buffer); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLBindTextureProc)(GLenum target, GLuint texture); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLBlendColorProc)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLBlendFuncProc)(GLenum sfactor, GLenum dfactor); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLBufferDataProc)(GLenum target, GLsizei size, const void* data, GLenum usage); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLBufferSubDataProc)(GLenum target, GLint offset, GLsizei size, const void* data); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLClearProc)(GLbitfield mask); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLClearColorProc)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLClearStencilProc)(GLint s); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLClientActiveTextureProc)(GLenum texture); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLColor4ubProc)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLColorMaskProc)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLColorPointerProc)(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLCompileShaderProc)(GLuint shader); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLCompressedTexImage2DProc)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data); - typedef GLuint (GR_GL_FUNCTION_TYPE *GrGLCreateProgramProc)(void); - typedef GLuint (GR_GL_FUNCTION_TYPE *GrGLCreateShaderProc)(GLenum type); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLCullFaceProc)(GLenum mode); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLDeleteBuffersProc)(GLsizei n, const GLuint* buffers); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLDeleteProgramProc)(GLuint program); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLDeleteShaderProc)(GLuint shader); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLDeleteTexturesProc)(GLsizei n, const GLuint* textures); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLDepthMaskProc)(GLboolean flag); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLDisableProc)(GLenum cap); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLDisableClientStateProc)(GLenum array); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLDisableVertexAttribArrayProc)(GLuint index); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLDrawArraysProc)(GLenum mode, GLint first, GLsizei count); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLDrawElementsProc)(GLenum mode, GLsizei count, GLenum type, const void* indices); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLEnableProc)(GLenum cap); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLEnableClientStateProc)(GLenum cap); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLEnableVertexAttribArrayProc)(GLuint index); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLFrontFaceProc)(GLenum mode); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLGenBuffersProc)(GLsizei n, GLuint* buffers); - typedef GLenum (GR_GL_FUNCTION_TYPE *GrGLGetErrorProc)(void); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLGenTexturesProc)(GLsizei n, GLuint* textures); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLGetBufferParameterivProc)(GLenum target, GLenum pname, GLint* params); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLGetIntegervProc)(GLenum pname, GLint* params); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLGetProgramInfoLogProc)(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLGetProgramivProc)(GLuint program, GLenum pname, GLint* params); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLGetShaderInfoLogProc)(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLGetShaderivProc)(GLuint shader, GLenum pname, GLint* params); - typedef const GLubyte* (GR_GL_FUNCTION_TYPE *GrGLGetStringProc)(GLenum name); - typedef GLint (GR_GL_FUNCTION_TYPE *GrGLGetUniformLocationProc)(GLuint program, const char* name); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLLineWidthProc)(GLfloat width); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLLinkProgramProc)(GLuint program); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLLoadMatrixfProc)(const GLfloat* m); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLMatrixModeProc)(GLenum mode); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLPixelStoreiProc)(GLenum pname, GLint param); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLPointSizeProc)(GLfloat size); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLReadPixelsProc)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLScissorProc)(GLint x, GLint y, GLsizei width, GLsizei height); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLShadeModelProc)(GLenum mode); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLShaderSourceProc)(GLuint shader, GLsizei count, const char** str, const GLint* length); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLStencilFuncProc)(GLenum func, GLint ref, GLuint mask); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLStencilFuncSeparateProc)(GLenum face, GLenum func, GLint ref, GLuint mask); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLStencilMaskProc)(GLuint mask); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLStencilMaskSeparateProc)(GLenum face, GLuint mask); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLStencilOpProc)(GLenum fail, GLenum zfail, GLenum zpass); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLStencilOpSeparateProc)(GLenum face, GLenum fail, GLenum zfail, GLenum zpass); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLTexCoordPointerProc)(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLTexEnviProc)(GLenum target, GLenum pname, GLint param); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLTexImage2DProc)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLTexParameteriProc)(GLenum target, GLenum pname, GLint param); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLTexSubImage2DProc)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform1fvProc)(GLint location, GLsizei count, const GLfloat* v); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform1iProc)(GLint location, GLint x); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform4fvProc)(GLint location, GLsizei count, const GLfloat* v); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLUniformMatrix3fvProc)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLUseProgramProc)(GLuint program); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLVertexAttrib4fvProc)(GLuint indx, const GLfloat* values); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLVertexAttribPointerProc)(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLVertexPointerProc)(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLViewportProc)(GLint x, GLint y, GLsizei width, GLsizei height); + 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 *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 *GrGLBlendFuncProc)(GrGLenum sfactor, GrGLenum dfactor); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLBufferDataProc)(GrGLenum target, GrGLsizei size, const GrGLvoid* data, GrGLenum usage); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLBufferSubDataProc)(GrGLenum target, GrGLint offset, GrGLsizei 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 *GrGLClientActiveTextureProc)(GrGLenum texture); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLColor4ubProc)(GrGLubyte red, GrGLubyte green, GrGLubyte blue, GrGLubyte alpha); + 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 *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 *GrGLDisableClientStateProc)(GrGLenum array); + 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 *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 *GrGLEnableClientStateProc)(GrGLenum cap); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLEnableVertexAttribArrayProc)(GrGLuint index); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLFrontFaceProc)(GrGLenum mode); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLGenBuffersProc)(GrGLsizei n, GrGLuint* buffers); + typedef GrGLenum (GR_GL_FUNCTION_TYPE *GrGLGetErrorProc)(void); + 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 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 *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 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 *GrGLLoadMatrixfProc)(const GrGLfloat* m); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLMatrixModeProc)(GrGLenum mode); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLPixelStoreiProc)(GrGLenum pname, GrGLint param); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLPointSizeProc)(GrGLfloat size); + 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 *GrGLShadeModelProc)(GrGLenum mode); + 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 *GrGLTexCoordPointerProc)(GrGLint size, GrGLenum type, GrGLsizei stride, const GrGLvoid* pointer); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLTexEnviProc)(GrGLenum target, GrGLenum pname, GrGLint param); + 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 *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 *GrGLUniform1fvProc)(GrGLint location, GrGLsizei count, const GrGLfloat* v); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform1iProc)(GrGLint location, GrGLint x); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniform4fvProc)(GrGLint location, GrGLsizei count, const GrGLfloat* v); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLUniformMatrix3fvProc)(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 *GrGLVertexPointerProc)(GrGLint size, GrGLenum type, GrGLsizei stride, const GrGLvoid* pointer); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLViewportProc)(GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height); // FBO Extension Functions - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLBindFramebufferProc)(GLenum target, GLuint framebuffer); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLBindRenderbufferProc)(GLenum target, GLuint renderbuffer); - typedef GLenum (GR_GL_FUNCTION_TYPE *GrGLCheckFramebufferStatusProc)(GLenum target); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLDeleteFramebuffersProc)(GLsizei n, const GLuint *framebuffers); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLDeleteRenderbuffersProc)(GLsizei n, const GLuint *renderbuffers); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLFramebufferRenderbufferProc)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLFramebufferTexture2DProc)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLGenFramebuffersProc)(GLsizei n, GLuint *framebuffers); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLGenRenderbuffersProc)(GLsizei n, GLuint *renderbuffers); - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLRenderbufferStorageProc)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); + 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 *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 GLvoid (GR_GL_FUNCTION_TYPE *GrGLRenderbufferStorageMultisampleProc)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); + 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 GLvoid (GR_GL_FUNCTION_TYPE *GrGLBlitFramebufferProc)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); + 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 GLvoid (GR_GL_FUNCTION_TYPE *GrGLResolveMultisampleFramebufferProc)(); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLResolveMultisampleFramebufferProc)(); // IMG'e es extension - typedef GLvoid (GR_GL_FUNCTION_TYPE *GrGLFramebufferTexture2DMultisampleProc)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples); + typedef GrGLvoid (GR_GL_FUNCTION_TYPE *GrGLFramebufferTexture2DMultisampleProc)(GrGLenum target, GrGLenum attachment, GrGLenum textarget, GrGLuint texture, GrGLint level, GrGLsizei samples); // Buffer mapping (extension in ES). - typedef GLvoid* (GR_GL_FUNCTION_TYPE *GrGLMapBufferProc)(GLenum target, GLenum access); - typedef GLboolean (GR_GL_FUNCTION_TYPE *GrGLUnmapBufferProc)(GLenum target); + typedef GrGLvoid* (GR_GL_FUNCTION_TYPE *GrGLMapBufferProc)(GrGLenum target, GrGLenum access); + typedef GrGLboolean (GR_GL_FUNCTION_TYPE *GrGLUnmapBufferProc)(GrGLenum target); GrGLActiveTextureProc fActiveTexture; GrGLAttachShaderProc fAttachShader; diff --git a/gpu/include/GrGLPlatformIncludes.h b/gpu/include/GrGLPlatformIncludes.h index 978a9926b5..54ae6bfeee 100644 --- a/gpu/include/GrGLPlatformIncludes.h +++ b/gpu/include/GrGLPlatformIncludes.h @@ -18,8 +18,6 @@ #ifndef GrGLPlatformIncludes_DEFINED #define GrGLPlatformIncludes_DEFINED -#include "GrConfig.h" - #if !defined(GR_GL_CUSTOM_SETUP) #define GR_GL_CUSTOM_SETUP 0 #endif @@ -48,8 +46,8 @@ * 2. If necessary, the name of a file that includes extension * definitions in GR_INCLUDE_GLES2ext. * - * Optionally, define GR_GL_FUNC to any qualifier needed on GL function - * pointer declarations (e.g. __stdcall). + * Optionally, define GR_GL_FUNCTION_TYPE to any qualifier needed on GL + * function pointer declarations (e.g. __stdcall). * * Define GR_GL_PROC_ADDRESS to take a gl function and produce a * function pointer. Two examples: @@ -66,7 +64,7 @@ * to a header that can be included. This file should: * 1. Define the approprate GR_SUPPORT_GL* macro(s) to 1 * 2. Includes all necessary GL headers. - * 3. Optionally define GR_GL_FUNC. + * 3. Optionally define GR_GL_FUNCTION_TYPE. * 4. Define GR_GL_PROC_ADDRESS. * 5. Optionally define GR_GL_PROC_ADDRESS_HEADER */ @@ -99,19 +97,19 @@ #include GR_GL_CUSTOM_SETUP_HEADER #else + #include "GrConfig.h" + #undef GR_GL_FUNCTION_TYPE #undef GR_GL_PROC_ADDRESS #undef GR_GL_PROC_ADDRESS_HEADER #if GR_WIN32_BUILD #define GR_SUPPORT_GLDESKTOP 1 - #include - #include - // remove stupid windows defines - #undef near - #undef far - #define GR_GL_EMIT_GL_CONSTANTS 1 - #define GR_GL_FUNCTION_TYPE __stdcall + + #define GR_GL_PLATFORM_HEADER_SUPPORT + #define GR_GL_PLATFORM_HEADER + + #define GR_GL_FUNCTION_TYPE __stdcall #define GR_GL_PROC_ADDRESS(X) wglGetProcAddress(#X) #define GR_GL_PROC_ADDRESS_HEADER @@ -124,24 +122,30 @@ #define GL_OES_mapbuffer 1 #elif GR_MAC_BUILD #define GR_SUPPORT_GLDESKTOP 1 - #include - #include + + #define GR_GL_PLATFORM_HEADER + #define GR_GL_PLATFORM_HEADER_EXT + #define GR_GL_PROC_ADDRESS(X) &X #elif GR_IOS_BUILD #define GR_SUPPORT_GLES1 1 - #include - #include #define GR_SUPPORT_GLES2 1 - #include - #include + + #define GR_GL_PLATFORM_HEADER + #define GR_GL_PLATFORM_HEADER_EXT + + #define GR_GL_PLATFORM_HEADER2 + #define GR_GL_PLATFORM_HEADER_EXT2 #define GR_GL_PROC_ADDRESS(X) &X #elif GR_ANDROID_BUILD #ifndef GL_GLEXT_PROTOTYPES #define GL_GLEXT_PROTOTYPES #endif #define GR_SUPPORT_GLES2 1 - #include - #include + + #define GR_GL_PLATFORM_HEADER + #define GR_GL_PLATFORM_HEADER_EXT + #define GR_GL_PROC_ADDRESS(X) eglGetProcAddress(#X) #define GR_GL_PROC_ADDRESS_HEADER #elif GR_QNX_BUILD @@ -151,16 +155,20 @@ #define GR_SUPPORT_GLES2 1 // This is needed by the QNX GLES2 headers #define GL_API_EXT - #include - #include + + #define GR_GL_PLATFORM_HEADER + #define GR_GL_PLATFORM_HEADER_EXT + #define GR_GL_PROC_ADDRESS(X) eglGetProcAddress(#X) #define GR_GL_PROC_ADDRESS_HEADER #elif GR_LINUX_BUILD #ifndef GL_GLEXT_PROTOTYPES #define GL_GLEXT_PROTOTYPES #endif - #include - #include + + #define GR_GL_PLATFORM_HEADER + #define GR_GL_PLATFORM_HEADER_EXT + #define GR_GL_PROC_ADDRESS(X) glXGetProcAddress(reinterpret_cast(#X)) #define GR_SUPPORT_GLDESKTOP 1 #define GR_GL_PROC_ADDRESS_HEADER @@ -188,335 +196,4 @@ #error "Cannot support both desktop and ES GL" #endif -#if GR_WIN32_BUILD && GR_GL_EMIT_GL_CONSTANTS - -// The windows GL headers do not provide the constants used for extensions and -// some versions of GL. Define them here. - -// OpenGL 1.2 Defines -#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 -#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 -#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 -#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 -#define GL_UNSIGNED_BYTE_3_3_2 0x8032 -#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 -#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 -#define GL_UNSIGNED_INT_8_8_8_8 0x8035 -#define GL_UNSIGNED_INT_10_10_10_2 0x8036 -#define GL_RESCALE_NORMAL 0x803A -#define GL_TEXTURE_BINDING_3D 0x806A -#define GL_PACK_SKIP_IMAGES 0x806B -#define GL_PACK_IMAGE_HEIGHT 0x806C -#define GL_UNPACK_SKIP_IMAGES 0x806D -#define GL_UNPACK_IMAGE_HEIGHT 0x806E -#define GL_TEXTURE_3D 0x806F -#define GL_PROXY_TEXTURE_3D 0x8070 -#define GL_TEXTURE_DEPTH 0x8071 -#define GL_TEXTURE_WRAP_R 0x8072 -#define GL_MAX_3D_TEXTURE_SIZE 0x8073 -#define GL_BGR 0x80E0 -#define GL_BGRA 0x80E1 -#define GL_MAX_ELEMENTS_VERTICES 0x80E8 -#define GL_MAX_ELEMENTS_INDICES 0x80E9 -#define GL_CLAMP_TO_EDGE 0x812F -#define GL_TEXTURE_MIN_LOD 0x813A -#define GL_TEXTURE_MAX_LOD 0x813B -#define GL_TEXTURE_BASE_LEVEL 0x813C -#define GL_TEXTURE_MAX_LEVEL 0x813D -#define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8 -#define GL_SINGLE_COLOR 0x81F9 -#define GL_SEPARATE_SPECULAR_COLOR 0x81FA -#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 -#define GL_UNSIGNED_SHORT_5_6_5 0x8363 -#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 -#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 -#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 -#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 -#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 -#define GL_ALIASED_POINT_SIZE_RANGE 0x846D -#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E - -// OpenGL 1.3 Multi-Sample Constant Values -#define GL_MULTISAMPLE 0x809D -#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E -#define GL_SAMPLE_ALPHA_TO_ONE 0x809F -#define GL_SAMPLE_COVERAGE 0x80A0 -#define GL_SAMPLE_BUFFERS 0x80A8 -#define GL_SAMPLES 0x80A9 -#define GL_SAMPLE_COVERAGE_VALUE 0x80AA -#define GL_SAMPLE_COVERAGE_INVERT 0x80AB -#define GL_CLAMP_TO_BORDER 0x812D -#define GL_TEXTURE0 0x84C0 -#define GL_TEXTURE1 0x84C1 -#define GL_TEXTURE2 0x84C2 -#define GL_TEXTURE3 0x84C3 -#define GL_TEXTURE4 0x84C4 -#define GL_TEXTURE5 0x84C5 -#define GL_TEXTURE6 0x84C6 -#define GL_TEXTURE7 0x84C7 -#define GL_TEXTURE8 0x84C8 -#define GL_TEXTURE9 0x84C9 -#define GL_TEXTURE10 0x84CA -#define GL_TEXTURE11 0x84CB -#define GL_TEXTURE12 0x84CC -#define GL_TEXTURE13 0x84CD -#define GL_TEXTURE14 0x84CE -#define GL_TEXTURE15 0x84CF -#define GL_TEXTURE16 0x84D0 -#define GL_TEXTURE17 0x84D1 -#define GL_TEXTURE18 0x84D2 -#define GL_TEXTURE19 0x84D3 -#define GL_TEXTURE20 0x84D4 -#define GL_TEXTURE21 0x84D5 -#define GL_TEXTURE22 0x84D6 -#define GL_TEXTURE23 0x84D7 -#define GL_TEXTURE24 0x84D8 -#define GL_TEXTURE25 0x84D9 -#define GL_TEXTURE26 0x84DA -#define GL_TEXTURE27 0x84DB -#define GL_TEXTURE28 0x84DC -#define GL_TEXTURE29 0x84DD -#define GL_TEXTURE30 0x84DE -#define GL_TEXTURE31 0x84DF -#define GL_ACTIVE_TEXTURE 0x84E0 -#define GL_CLIENT_ACTIVE_TEXTURE 0x84E1 -#define GL_MAX_TEXTURE_UNITS 0x84E2 -#define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3 -#define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4 -#define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5 -#define GL_TRANSPOSE_COLOR_MATRIX 0x84E6 -#define GL_SUBTRACT 0x84E7 -#define GL_COMPRESSED_ALPHA 0x84E9 -#define GL_COMPRESSED_LUMINANCE 0x84EA -#define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB -#define GL_COMPRESSED_INTENSITY 0x84EC -#define GL_COMPRESSED_RGB 0x84ED -#define GL_COMPRESSED_RGBA 0x84EE -#define GL_TEXTURE_COMPRESSION_HINT 0x84EF -#define GL_NORMAL_MAP 0x8511 -#define GL_REFLECTION_MAP 0x8512 -#define GL_TEXTURE_CUBE_MAP 0x8513 -#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 -#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 -#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 -#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 -#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 -#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 -#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A -#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B -#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C -#define GL_COMBINE 0x8570 -#define GL_COMBINE_RGB 0x8571 -#define GL_COMBINE_ALPHA 0x8572 -#define GL_RGB_SCALE 0x8573 -#define GL_ADD_SIGNED 0x8574 -#define GL_INTERPOLATE 0x8575 -#define GL_CONSTANT 0x8576 -#define GL_PRIMARY_COLOR 0x8577 -#define GL_PREVIOUS 0x8578 -#define GL_SOURCE0_RGB 0x8580 -#define GL_SOURCE1_RGB 0x8581 -#define GL_SOURCE2_RGB 0x8582 -#define GL_SOURCE0_ALPHA 0x8588 -#define GL_SOURCE1_ALPHA 0x8589 -#define GL_SOURCE2_ALPHA 0x858A -#define GL_OPERAND0_RGB 0x8590 -#define GL_OPERAND1_RGB 0x8591 -#define GL_OPERAND2_RGB 0x8592 -#define GL_OPERAND0_ALPHA 0x8598 -#define GL_OPERAND1_ALPHA 0x8599 -#define GL_OPERAND2_ALPHA 0x859A -#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 -#define GL_TEXTURE_COMPRESSED 0x86A1 -#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 -#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 -#define GL_DOT3_RGB 0x86AE -#define GL_DOT3_RGBA 0x86AF -#define GL_MULTISAMPLE_BIT 0x20000000 - -// OpenGL 1.4 Defines -#define GL_CONSTANT_COLOR 0x8001 -#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 -#define GL_CONSTANT_ALPHA 0x8003 -#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 -#define GL_BLEND_DST_RGB 0x80C8 -#define GL_BLEND_SRC_RGB 0x80C9 -#define GL_BLEND_DST_ALPHA 0x80CA -#define GL_BLEND_SRC_ALPHA 0x80CB -#define GL_POINT_SIZE_MIN 0x8126 -#define GL_POINT_SIZE_MAX 0x8127 -#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 -#define GL_POINT_DISTANCE_ATTENUATION 0x8129 -#define GL_GENERATE_MIPMAP 0x8191 -#define GL_GENERATE_MIPMAP_HINT 0x8192 -#define GL_DEPTH_COMPONENT16 0x81A5 -#define GL_DEPTH_COMPONENT24 0x81A6 -#define GL_DEPTH_COMPONENT32 0x81A7 -#define GL_MIRRORED_REPEAT 0x8370 -#define GL_FOG_COORDINATE_SOURCE 0x8450 -#define GL_FOG_COORDINATE 0x8451 -#define GL_FRAGMENT_DEPTH 0x8452 -#define GL_CURRENT_FOG_COORDINATE 0x8453 -#define GL_FOG_COORDINATE_ARRAY_TYPE 0x8454 -#define GL_FOG_COORDINATE_ARRAY_STRIDE 0x8455 -#define GL_FOG_COORDINATE_ARRAY_POINTER 0x8456 -#define GL_FOG_COORDINATE_ARRAY 0x8457 -#define GL_COLOR_SUM 0x8458 -#define GL_CURRENT_SECONDARY_COLOR 0x8459 -#define GL_SECONDARY_COLOR_ARRAY_SIZE 0x845A -#define GL_SECONDARY_COLOR_ARRAY_TYPE 0x845B -#define GL_SECONDARY_COLOR_ARRAY_STRIDE 0x845C -#define GL_SECONDARY_COLOR_ARRAY_POINTER 0x845D -#define GL_SECONDARY_COLOR_ARRAY 0x845E -#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD -#define GL_TEXTURE_FILTER_CONTROL 0x8500 -#define GL_TEXTURE_LOD_BIAS 0x8501 -#define GL_INCR_WRAP 0x8507 -#define GL_DECR_WRAP 0x8508 -#define GL_TEXTURE_DEPTH_SIZE 0x884A -#define GL_DEPTH_TEXTURE_MODE 0x884B -#define GL_TEXTURE_COMPARE_MODE 0x884C -#define GL_TEXTURE_COMPARE_FUNC 0x884D -#define GL_COMPARE_R_TO_TEXTURE 0x884E - -// OpenGL 1.5 Defines -#define GL_FOG_COORD_SRC GL_FOG_COORDINATE_SOURCE -#define GL_FOG_COORD GL_FOG_COORDINATE -#define GL_FOG_COORD_ARRAY GL_FOG_COORDINATE_ARRAY -#define GL_SRC0_RGB GL_SOURCE0_RGB -#define GL_FOG_COORD_ARRAY_POINTER GL_FOG_COORDINATE_ARRAY_POINTER -#define GL_FOG_COORD_ARRAY_TYPE GL_FOG_COORDINATE_ARRAY_TYPE -#define GL_SRC1_ALPHA GL_SOURCE1_ALPHA -#define GL_CURRENT_FOG_COORD GL_CURRENT_FOG_COORDINATE -#define GL_FOG_COORD_ARRAY_STRIDE GL_FOG_COORDINATE_ARRAY_STRIDE -#define GL_SRC0_ALPHA GL_SOURCE0_ALPHA -#define GL_SRC1_RGB GL_SOURCE1_RGB -#define GL_FOG_COORD_ARRAY_BUFFER_BINDING GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING -#define GL_SRC2_ALPHA GL_SOURCE2_ALPHA -#define GL_SRC2_RGB GL_SOURCE2_RGB -#define GL_BUFFER_SIZE 0x8764 -#define GL_BUFFER_USAGE 0x8765 -#define GL_QUERY_COUNTER_BITS 0x8864 -#define GL_CURRENT_QUERY 0x8865 -#define GL_QUERY_RESULT 0x8866 -#define GL_QUERY_RESULT_AVAILABLE 0x8867 -#define GL_ARRAY_BUFFER 0x8892 -#define GL_ELEMENT_ARRAY_BUFFER 0x8893 -#define GL_ARRAY_BUFFER_BINDING 0x8894 -#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 -#define GL_VERTEX_ARRAY_BUFFER_BINDING 0x8896 -#define GL_NORMAL_ARRAY_BUFFER_BINDING 0x8897 -#define GL_COLOR_ARRAY_BUFFER_BINDING 0x8898 -#define GL_INDEX_ARRAY_BUFFER_BINDING 0x8899 -#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING 0x889A -#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING 0x889B -#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING 0x889C -#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING 0x889D -#define GL_WEIGHT_ARRAY_BUFFER_BINDING 0x889E -#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F -#define GL_READ_ONLY 0x88B8 -#define GL_WRITE_ONLY 0x88B9 -#define GL_READ_WRITE 0x88BA -#define GL_BUFFER_ACCESS 0x88BB -#define GL_BUFFER_MAPPED 0x88BC -#define GL_BUFFER_MAP_POINTER 0x88BD -#define GL_STREAM_DRAW 0x88E0 -#define GL_STREAM_READ 0x88E1 -#define GL_STREAM_COPY 0x88E2 -#define GL_STATIC_DRAW 0x88E4 -#define GL_STATIC_READ 0x88E5 -#define GL_STATIC_COPY 0x88E6 -#define GL_DYNAMIC_DRAW 0x88E8 -#define GL_DYNAMIC_READ 0x88E9 -#define GL_DYNAMIC_COPY 0x88EA -#define GL_SAMPLES_PASSED 0x8914 - -// OpenGL 2.0 Defines -#define GL_BLEND_EQUATION_RGB GL_BLEND_EQUATION -#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 -#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 -#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 -#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 -#define GL_CURRENT_VERTEX_ATTRIB 0x8626 -#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 -#define GL_VERTEX_PROGRAM_TWO_SIDE 0x8643 -#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 -#define GL_STENCIL_BACK_FUNC 0x8800 -#define GL_STENCIL_BACK_FAIL 0x8801 -#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 -#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 -#define GL_MAX_DRAW_BUFFERS 0x8824 -#define GL_DRAW_BUFFER0 0x8825 -#define GL_DRAW_BUFFER1 0x8826 -#define GL_DRAW_BUFFER2 0x8827 -#define GL_DRAW_BUFFER3 0x8828 -#define GL_DRAW_BUFFER4 0x8829 -#define GL_DRAW_BUFFER5 0x882A -#define GL_DRAW_BUFFER6 0x882B -#define GL_DRAW_BUFFER7 0x882C -#define GL_DRAW_BUFFER8 0x882D -#define GL_DRAW_BUFFER9 0x882E -#define GL_DRAW_BUFFER10 0x882F -#define GL_DRAW_BUFFER11 0x8830 -#define GL_DRAW_BUFFER12 0x8831 -#define GL_DRAW_BUFFER13 0x8832 -#define GL_DRAW_BUFFER14 0x8833 -#define GL_DRAW_BUFFER15 0x8834 -#define GL_BLEND_EQUATION_ALPHA 0x883D -#define GL_POINT_SPRITE 0x8861 -#define GL_COORD_REPLACE 0x8862 -#define GL_MAX_VERTEX_ATTRIBS 0x8869 -#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A -#define GL_MAX_TEXTURE_COORDS 0x8871 -#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 -#define GL_FRAGMENT_SHADER 0x8B30 -#define GL_VERTEX_SHADER 0x8B31 -#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 -#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A -#define GL_MAX_VARYING_FLOATS 0x8B4B -#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C -#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D -#define GL_SHADER_TYPE 0x8B4F -#define GL_FLOAT_VEC2 0x8B50 -#define GL_FLOAT_VEC3 0x8B51 -#define GL_FLOAT_VEC4 0x8B52 -#define GL_INT_VEC2 0x8B53 -#define GL_INT_VEC3 0x8B54 -#define GL_INT_VEC4 0x8B55 -#define GL_BOOL 0x8B56 -#define GL_BOOL_VEC2 0x8B57 -#define GL_BOOL_VEC3 0x8B58 -#define GL_BOOL_VEC4 0x8B59 -#define GL_FLOAT_MAT2 0x8B5A -#define GL_FLOAT_MAT3 0x8B5B -#define GL_FLOAT_MAT4 0x8B5C -#define GL_SAMPLER_1D 0x8B5D -#define GL_SAMPLER_2D 0x8B5E -#define GL_SAMPLER_3D 0x8B5F -#define GL_SAMPLER_CUBE 0x8B60 -#define GL_SAMPLER_1D_SHADOW 0x8B61 -#define GL_SAMPLER_2D_SHADOW 0x8B62 -#define GL_DELETE_STATUS 0x8B80 -#define GL_COMPILE_STATUS 0x8B81 -#define GL_LINK_STATUS 0x8B82 -#define GL_VALIDATE_STATUS 0x8B83 -#define GL_INFO_LOG_LENGTH 0x8B84 -#define GL_ATTACHED_SHADERS 0x8B85 -#define GL_ACTIVE_UNIFORMS 0x8B86 -#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 -#define GL_SHADER_SOURCE_LENGTH 0x8B88 -#define GL_ACTIVE_ATTRIBUTES 0x8B89 -#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A -#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B -#define GL_SHADING_LANGUAGE_VERSION 0x8B8C -#define GL_CURRENT_PROGRAM 0x8B8D -#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 -#define GL_LOWER_LEFT 0x8CA1 -#define GL_UPPER_LEFT 0x8CA2 -#define GL_STENCIL_BACK_REF 0x8CA3 -#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 -#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 - -#endif // GR_WIN32_BUILD - #endif diff --git a/gpu/include/GrGLTexture.h b/gpu/include/GrGLTexture.h index 7b7480ca87..0a1c107469 100644 --- a/gpu/include/GrGLTexture.h +++ b/gpu/include/GrGLTexture.h @@ -30,7 +30,7 @@ class GrGLTexture; */ class GrGLTexID : public GrRefCnt { public: - GrGLTexID(GLuint texID) : fTexID(texID) {} + GrGLTexID(GrGLuint texID) : fTexID(texID) {} virtual ~GrGLTexID() { if (0 != fTexID) { @@ -39,10 +39,10 @@ public: } void abandon() { fTexID = 0; } - GLuint id() const { return fTexID; } + GrGLuint id() const { return fTexID; } private: - GLuint fTexID; + GrGLuint fTexID; }; class GrGLRenderTarget : public GrRenderTarget { @@ -53,24 +53,24 @@ public: bool needsResolve() const { return fNeedsResolve; } void setDirty(bool dirty) { fNeedsResolve = resolveable() && dirty; } - GLuint renderFBOID() const { return fRTFBOID; } - GLuint textureFBOID() const { return fTexFBOID; } + GrGLuint renderFBOID() const { return fRTFBOID; } + GrGLuint textureFBOID() const { return fTexFBOID; } void abandon(); protected: struct GLRenderTargetIDs { - GLuint fRTFBOID; - GLuint fTexFBOID; - GLuint fStencilRenderbufferID; - GLuint fMSColorRenderbufferID; + GrGLuint fRTFBOID; + GrGLuint fTexFBOID; + GrGLuint fStencilRenderbufferID; + GrGLuint fMSColorRenderbufferID; bool fOwnIDs; }; GrGLRenderTarget(const GLRenderTargetIDs& ids, GrGLTexID* texID, - GLuint stencilBits, + GrGLuint stencilBits, const GrGLIRect& fViewport, GrGLTexture* texture, GrGpuGL* gl); @@ -79,10 +79,10 @@ protected: const GrGLIRect& getViewport() const { return fViewport; } private: GrGpuGL* fGL; - GLuint fRTFBOID; - GLuint fTexFBOID; - GLuint fStencilRenderbufferID; - GLuint fMSColorRenderbufferID; + GrGLuint fRTFBOID; + GrGLuint fTexFBOID; + GrGLuint fStencilRenderbufferID; + GrGLuint fMSColorRenderbufferID; // Should this object delete IDs when it is destroyed or does someone // else own them. @@ -114,9 +114,9 @@ public: }; struct TexParams { - GLenum fFilter; - GLenum fWrapS; - GLenum fWrapT; + GrGLenum fFilter; + GrGLenum fWrapS; + GrGLenum fWrapT; }; protected: @@ -126,11 +126,11 @@ protected: uint32_t fAllocWidth; uint32_t fAllocHeight; PixelConfig fFormat; - GLuint fTextureID; - GLenum fUploadFormat; - GLenum fUploadByteCount; - GLenum fUploadType; - GLuint fStencilBits; + GrGLuint fTextureID; + GrGLenum fUploadFormat; + GrGLenum fUploadByteCount; + GrGLenum fUploadType; + GrGLuint fStencilBits; Orientation fOrientation; }; typedef GrGLRenderTarget::GLRenderTargetIDs GLRenderTargetIDs; @@ -155,11 +155,11 @@ public: const TexParams& getTexParams() const { return fTexParams; } void setTexParams(const TexParams& texParams) { fTexParams = texParams; } - GLuint textureID() const { return fTexIDObj->id(); } + GrGLuint textureID() const { return fTexIDObj->id(); } - GLenum uploadFormat() const { return fUploadFormat; } - GLenum uploadByteCount() const { return fUploadByteCount; } - GLenum uploadType() const { return fUploadType; } + GrGLenum uploadFormat() const { return fUploadFormat; } + GrGLenum uploadByteCount() const { return fUploadByteCount; } + GrGLenum uploadType() const { return fUploadType; } /** * Retrieves the texture width actually allocated in texels. @@ -198,9 +198,9 @@ public: private: TexParams fTexParams; GrGLTexID* fTexIDObj; - GLenum fUploadFormat; - GLenum fUploadByteCount; - GLenum fUploadType; + GrGLenum fUploadFormat; + GrGLenum fUploadByteCount; + GrGLenum fUploadType; int fAllocWidth; int fAllocHeight; // precomputed content / alloc ratios @@ -210,7 +210,7 @@ private: GrGLRenderTarget* fRenderTarget; GrGpuGL* fGpuGL; - static const GLenum gWrapMode2GLWrap[]; + static const GrGLenum gWrapMode2GLWrap[]; friend class GrGpuGL; diff --git a/gpu/include/GrGLVertexBuffer.h b/gpu/include/GrGLVertexBuffer.h index 30ae73492e..c4f62a0e4a 100644 --- a/gpu/include/GrGLVertexBuffer.h +++ b/gpu/include/GrGLVertexBuffer.h @@ -1,5 +1,5 @@ /* - Copyright 2010 Google Inc. + Copyright 2011 Google Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -25,7 +25,7 @@ class GrGpuGL; class GrGLVertexBuffer : public GrVertexBuffer { protected: - GrGLVertexBuffer(GLuint id, + GrGLVertexBuffer(GrGLuint id, GrGpuGL* gl, size_t sizeInBytes, bool dynamic); @@ -43,13 +43,13 @@ public: virtual bool updateSubData(const void* src, size_t srcSizeInBytes, size_t offset); - GLuint bufferID() const; + GrGLuint bufferID() const; private: void bind() const; GrGpuGL* fGL; - GLuint fBufferID; + GrGLuint fBufferID; void* fLockPtr; friend class GrGpuGL; diff --git a/gpu/src/GrGLIndexBuffer.cpp b/gpu/src/GrGLIndexBuffer.cpp index 9539c8a2a1..a272d271df 100644 --- a/gpu/src/GrGLIndexBuffer.cpp +++ b/gpu/src/GrGLIndexBuffer.cpp @@ -18,7 +18,7 @@ #include "GrGLIndexBuffer.h" #include "GrGpuGL.h" -GrGLIndexBuffer::GrGLIndexBuffer(GLuint id, GrGpuGL* gl, size_t sizeInBytes, +GrGLIndexBuffer::GrGLIndexBuffer(GrGLuint id, GrGpuGL* gl, size_t sizeInBytes, bool dynamic) : INHERITED(sizeInBytes, dynamic), fGL(gl), @@ -35,11 +35,11 @@ GrGLIndexBuffer::~GrGLIndexBuffer() { } void GrGLIndexBuffer::bind() const { - GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, fBufferID)); + GR_GL(BindBuffer(GR_GL_ELEMENT_ARRAY_BUFFER, fBufferID)); fGL->notifyIndexBufferBind(this); } -GLuint GrGLIndexBuffer::bufferID() const { +GrGLuint GrGLIndexBuffer::bufferID() const { return fBufferID; } @@ -55,9 +55,9 @@ void* GrGLIndexBuffer::lock() { if (fGL->supportsBufferLocking()) { bind(); // Let driver know it can discard the old data - GR_GL(BufferData(GL_ELEMENT_ARRAY_BUFFER, size(), NULL, - dynamic() ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW)); - fLockPtr = GR_GL(MapBuffer(GL_ELEMENT_ARRAY_BUFFER, GR_WRITE_ONLY)); + GR_GL(BufferData(GR_GL_ELEMENT_ARRAY_BUFFER, size(), NULL, + dynamic() ? GR_GL_DYNAMIC_DRAW : GR_GL_STATIC_DRAW)); + fLockPtr = GR_GL(MapBuffer(GR_GL_ELEMENT_ARRAY_BUFFER, GR_WRITE_ONLY)); return fLockPtr; } @@ -74,7 +74,7 @@ void GrGLIndexBuffer::unlock() { GrAssert(fGL->supportsBufferLocking()); bind(); - GR_GL(UnmapBuffer(GL_ELEMENT_ARRAY_BUFFER)); + GR_GL(UnmapBuffer(GR_GL_ELEMENT_ARRAY_BUFFER)); fLockPtr = NULL; } @@ -83,8 +83,8 @@ bool GrGLIndexBuffer::isLocked() const { #if GR_DEBUG if (fGL->supportsBufferLocking()) { bind(); - GLint mapped; - GR_GL(GetBufferParameteriv(GL_ELEMENT_ARRAY_BUFFER, + GrGLint mapped; + GR_GL(GetBufferParameteriv(GR_GL_ELEMENT_ARRAY_BUFFER, GR_BUFFER_MAPPED, &mapped)); GrAssert(!!mapped == !!fLockPtr); } @@ -99,12 +99,12 @@ bool GrGLIndexBuffer::updateData(const void* src, size_t srcSizeInBytes) { return false; } bind(); - GLenum usage = dynamic() ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW; + GrGLenum usage = dynamic() ? GR_GL_DYNAMIC_DRAW : GR_GL_STATIC_DRAW; if (size() == srcSizeInBytes) { - GR_GL(BufferData(GL_ELEMENT_ARRAY_BUFFER, srcSizeInBytes, src, usage)); + GR_GL(BufferData(GR_GL_ELEMENT_ARRAY_BUFFER, srcSizeInBytes, src, usage)); } else { - GR_GL(BufferData(GL_ELEMENT_ARRAY_BUFFER, size(), NULL, usage)); - GR_GL(BufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, srcSizeInBytes, src)); + GR_GL(BufferData(GR_GL_ELEMENT_ARRAY_BUFFER, size(), NULL, usage)); + GR_GL(BufferSubData(GR_GL_ELEMENT_ARRAY_BUFFER, 0, srcSizeInBytes, src)); } return true; } @@ -118,7 +118,7 @@ bool GrGLIndexBuffer::updateSubData(const void* src, return false; } bind(); - GR_GL(BufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, srcSizeInBytes, src)); + GR_GL(BufferSubData(GR_GL_ELEMENT_ARRAY_BUFFER, offset, srcSizeInBytes, src)); return true; } diff --git a/gpu/src/GrGLInterface.cpp b/gpu/src/GrGLInterface.cpp index fa6aa92f11..4d726047bb 100644 --- a/gpu/src/GrGLInterface.cpp +++ b/gpu/src/GrGLInterface.cpp @@ -18,8 +18,29 @@ #include "GrGLInterface.h" #include "GrTypes.h" +#include "GrGLPlatformIncludes.h" #include +#if defined(GR_GL_PLATFORM_HEADER_SUPPORT) + #include GR_GL_PLATFORM_HEADER_SUPPORT +#endif + +#if defined(GR_GL_PLATFORM_HEADER) + #include GR_GL_PLATFORM_HEADER +#endif + +#if defined(GR_GL_PLATFORM_HEADER_EXT) + #include GR_GL_PLATFORM_HEADER_EXT +#endif + +#if defined(GR_GL_PLATFORM_HEADER2) + #include GR_GL_PLATFORM_HEADER2 +#endif + +#if defined(GR_GL_PLATFORM_HEADER_EXT2) + #include GR_GL_PLATFORM_HEADER_EXT2 +#endif + #if defined(GR_GL_PROC_ADDRESS_HEADER) #include GR_GL_PROC_ADDRESS_HEADER #endif @@ -55,30 +76,27 @@ void gl_version_from_string(int* major, int* minor, *minor = 0; return; } -#if GR_SUPPORT_GLDESKTOP + int n = sscanf(versionString, "%d.%d", major, minor); - if (n != 2) { - GrAssert(0); - *major = 0; - *minor = 0; - return; + if (2 == n) { + return; } -#else + char profile[2]; - int n = sscanf(versionString, "OpenGL ES-%c%c %d.%d", profile, profile+1, - major, minor); + n = sscanf(versionString, "OpenGL ES-%c%c %d.%d", profile, profile+1, + major, minor); bool ok = 4 == n; if (!ok) { - int n = sscanf(versionString, "OpenGL ES %d.%d", major, minor); + n = sscanf(versionString, "OpenGL ES %d.%d", major, minor); ok = 2 == n; } + if (!ok) { GrAssert(0); *major = 0; *minor = 0; return; } -#endif } bool has_gl_extension_from_string(const char* ext, @@ -177,7 +195,7 @@ void InitializeGLInterfaceExtensions(GrGLInterface* glBindings) { } #endif - #if GL_OES_mapbuffer + #if GL_OES_framebuffer_object if (!fboFound && has_gl_extension_from_string("GL_OES_framebuffer_object", extensionString)) { diff --git a/gpu/src/GrGLTexture.cpp b/gpu/src/GrGLTexture.cpp index 7488d0f140..a57871b49b 100644 --- a/gpu/src/GrGLTexture.cpp +++ b/gpu/src/GrGLTexture.cpp @@ -20,7 +20,7 @@ GrGLRenderTarget::GrGLRenderTarget(const GLRenderTargetIDs& ids, GrGLTexID* texID, - GLuint stencilBits, + GrGLuint stencilBits, const GrGLIRect& viewport, GrGLTexture* texture, GrGpuGL* gl) : INHERITED(texture, @@ -71,13 +71,13 @@ void GrGLRenderTarget::abandon() { //////////////////////////////////////////////////////////////////////////////// -const GLenum GrGLTexture::gWrapMode2GLWrap[] = { - GL_CLAMP_TO_EDGE, - GL_REPEAT, -#ifdef GL_MIRRORED_REPEAT - GL_MIRRORED_REPEAT -#else - GL_REPEAT // GL_MIRRORED_REPEAT not supported :( +const GrGLenum GrGLTexture::gWrapMode2GLWrap[] = { + GR_GL_CLAMP_TO_EDGE, + GR_GL_REPEAT, +#if GR_SUPPORT_GLES1 && !GR_SUPPORT_GLES2 + GR_GL_REPEAT // GL_MIRRORED_REPEAT not supported :( +#else + GR_GL_MIRRORED_REPEAT #endif }; @@ -158,9 +158,9 @@ void GrGLTexture::uploadTextureData(uint32_t x, // If we need to update textures that are created upside down // then we have to modify this code to flip the srcData GrAssert(kTopDown_Orientation == fOrientation); - GR_GL(BindTexture(GL_TEXTURE_2D, fTexIDObj->id())); - GR_GL(PixelStorei(GL_UNPACK_ALIGNMENT, fUploadByteCount)); - GR_GL(TexSubImage2D(GL_TEXTURE_2D, 0, x, y, width, height, + GR_GL(BindTexture(GR_GL_TEXTURE_2D, fTexIDObj->id())); + GR_GL(PixelStorei(GR_GL_UNPACK_ALIGNMENT, fUploadByteCount)); + GR_GL(TexSubImage2D(GR_GL_TEXTURE_2D, 0, x, y, width, height, fUploadFormat, fUploadType, srcData)); } diff --git a/gpu/src/GrGLUtil.cpp b/gpu/src/GrGLUtil.cpp index 2cb887a363..8b68845df2 100644 --- a/gpu/src/GrGLUtil.cpp +++ b/gpu/src/GrGLUtil.cpp @@ -18,7 +18,7 @@ void GrGLCheckErr(const char* location, const char* call) { uint32_t err = GrGLGetGLInterface()->fGetError(); - if (GL_NO_ERROR != err) { + if (GR_GL_NO_ERROR != err) { GrPrintf("---- glGetError %x", err); if (NULL != location) { GrPrintf(" at\n\t%s", location); diff --git a/gpu/src/GrGLVertexBuffer.cpp b/gpu/src/GrGLVertexBuffer.cpp index 69913bf3eb..3acbd762db 100644 --- a/gpu/src/GrGLVertexBuffer.cpp +++ b/gpu/src/GrGLVertexBuffer.cpp @@ -18,7 +18,7 @@ #include "GrGLVertexBuffer.h" #include "GrGpuGL.h" -GrGLVertexBuffer::GrGLVertexBuffer(GLuint id, GrGpuGL* gl, size_t sizeInBytes, +GrGLVertexBuffer::GrGLVertexBuffer(GrGLuint id, GrGpuGL* gl, size_t sizeInBytes, bool dynamic) : INHERITED(sizeInBytes, dynamic), fGL(gl), @@ -35,11 +35,11 @@ GrGLVertexBuffer::~GrGLVertexBuffer() { } void GrGLVertexBuffer::bind() const { - GR_GL(BindBuffer(GL_ARRAY_BUFFER, fBufferID)); + GR_GL(BindBuffer(GR_GL_ARRAY_BUFFER, fBufferID)); fGL->notifyVertexBufferBind(this); } -GLuint GrGLVertexBuffer::bufferID() const { +GrGLuint GrGLVertexBuffer::bufferID() const { return fBufferID; } @@ -55,9 +55,9 @@ void* GrGLVertexBuffer::lock() { if (fGL->supportsBufferLocking()) { bind(); // Let driver know it can discard the old data - GR_GL(BufferData(GL_ARRAY_BUFFER, size(), NULL, - dynamic() ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW)); - fLockPtr = GR_GL(MapBuffer(GL_ARRAY_BUFFER, GR_WRITE_ONLY)); + GR_GL(BufferData(GR_GL_ARRAY_BUFFER, size(), NULL, + dynamic() ? GR_GL_DYNAMIC_DRAW : GR_GL_STATIC_DRAW)); + fLockPtr = GR_GL(MapBuffer(GR_GL_ARRAY_BUFFER, GR_WRITE_ONLY)); return fLockPtr; } return NULL; @@ -73,7 +73,7 @@ void GrGLVertexBuffer::unlock() { GrAssert(fGL->supportsBufferLocking()); bind(); - GR_GL(UnmapBuffer(GL_ARRAY_BUFFER)); + GR_GL(UnmapBuffer(GR_GL_ARRAY_BUFFER)); fLockPtr = NULL; } @@ -81,9 +81,9 @@ bool GrGLVertexBuffer::isLocked() const { GrAssert(fBufferID); #if GR_DEBUG if (fGL->supportsBufferLocking()) { - GLint mapped; + GrGLint mapped; bind(); - GR_GL(GetBufferParameteriv(GL_ARRAY_BUFFER, GR_BUFFER_MAPPED, &mapped)); + GR_GL(GetBufferParameteriv(GR_GL_ARRAY_BUFFER, GR_BUFFER_MAPPED, &mapped)); GrAssert(!!mapped == !!fLockPtr); } #endif @@ -97,12 +97,12 @@ bool GrGLVertexBuffer::updateData(const void* src, size_t srcSizeInBytes) { return false; } bind(); - GLenum usage = dynamic() ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW; + GrGLenum usage = dynamic() ? GR_GL_DYNAMIC_DRAW : GR_GL_STATIC_DRAW; if (size() == srcSizeInBytes) { - GR_GL(BufferData(GL_ARRAY_BUFFER, srcSizeInBytes, src, usage)); + GR_GL(BufferData(GR_GL_ARRAY_BUFFER, srcSizeInBytes, src, usage)); } else { - GR_GL(BufferData(GL_ARRAY_BUFFER, size(), NULL, usage)); - GR_GL(BufferSubData(GL_ARRAY_BUFFER, 0, srcSizeInBytes, src)); + GR_GL(BufferData(GR_GL_ARRAY_BUFFER, size(), NULL, usage)); + GR_GL(BufferSubData(GR_GL_ARRAY_BUFFER, 0, srcSizeInBytes, src)); } return true; } @@ -116,7 +116,7 @@ bool GrGLVertexBuffer::updateSubData(const void* src, return false; } bind(); - GR_GL(BufferSubData(GL_ARRAY_BUFFER, offset, srcSizeInBytes, src)); + GR_GL(BufferSubData(GR_GL_ARRAY_BUFFER, offset, srcSizeInBytes, src)); return true; } diff --git a/gpu/src/GrGpuGL.cpp b/gpu/src/GrGpuGL.cpp index f2a2a8f3b0..b7552d99c9 100644 --- a/gpu/src/GrGpuGL.cpp +++ b/gpu/src/GrGpuGL.cpp @@ -25,8 +25,8 @@ #endif -static const GLuint GR_MAX_GLUINT = ~0; -static const GLint GR_INVAL_GLINT = ~0; +static const GrGLuint GR_MAX_GLUINT = ~0; +static const GrGLint GR_INVAL_GLINT = ~0; // we use a spare texture unit to avoid // mucking with the state of any of the stages. @@ -34,21 +34,21 @@ static const int SPARE_TEX_UNIT = GrGpuGL::kNumStages; #define SKIP_CACHE_CHECK true -static const GLenum gXfermodeCoeff2Blend[] = { - GL_ZERO, - GL_ONE, - GL_SRC_COLOR, - GL_ONE_MINUS_SRC_COLOR, - GL_DST_COLOR, - GL_ONE_MINUS_DST_COLOR, - GL_SRC_ALPHA, - GL_ONE_MINUS_SRC_ALPHA, - GL_DST_ALPHA, - GL_ONE_MINUS_DST_ALPHA, - GL_CONSTANT_COLOR, - GL_ONE_MINUS_CONSTANT_COLOR, - GL_CONSTANT_ALPHA, - GL_ONE_MINUS_CONSTANT_ALPHA, +static const GrGLenum gXfermodeCoeff2Blend[] = { + GR_GL_ZERO, + GR_GL_ONE, + GR_GL_SRC_COLOR, + GR_GL_ONE_MINUS_SRC_COLOR, + GR_GL_DST_COLOR, + GR_GL_ONE_MINUS_DST_COLOR, + GR_GL_SRC_ALPHA, + GR_GL_ONE_MINUS_SRC_ALPHA, + GR_GL_DST_ALPHA, + GR_GL_ONE_MINUS_DST_ALPHA, + GR_GL_CONSTANT_COLOR, + GR_GL_ONE_MINUS_CONSTANT_COLOR, + GR_GL_CONSTANT_ALPHA, + GR_GL_ONE_MINUS_CONSTANT_ALPHA, }; bool GrGpuGL::BlendCoefReferencesConstant(GrBlendCoeff coeff) { @@ -147,28 +147,28 @@ static bool gPrintStartupSpew; static bool fbo_test(int w, int h) { - GLint savedFBO; - GLint savedTexUnit; - GR_GL_GetIntegerv(GL_ACTIVE_TEXTURE, &savedTexUnit); + GrGLint savedFBO; + GrGLint savedTexUnit; + GR_GL_GetIntegerv(GR_GL_ACTIVE_TEXTURE, &savedTexUnit); GR_GL_GetIntegerv(GR_FRAMEBUFFER_BINDING, &savedFBO); - GR_GL(ActiveTexture(GL_TEXTURE0 + SPARE_TEX_UNIT)); + GR_GL(ActiveTexture(GR_GL_TEXTURE0 + SPARE_TEX_UNIT)); - GLuint testFBO; + GrGLuint testFBO; GR_GL(GenFramebuffers(1, &testFBO)); GR_GL(BindFramebuffer(GR_FRAMEBUFFER, testFBO)); - GLuint testRTTex; + GrGLuint testRTTex; GR_GL(GenTextures(1, &testRTTex)); - GR_GL(BindTexture(GL_TEXTURE_2D, testRTTex)); + GR_GL(BindTexture(GR_GL_TEXTURE_2D, testRTTex)); // some implementations require texture to be mip-map complete before // FBO with level 0 bound as color attachment will be framebuffer complete. - GR_GL(TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)); - GR_GL(TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, - 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL)); - GR_GL(BindTexture(GL_TEXTURE_2D, 0)); + GR_GL(TexParameteri(GR_GL_TEXTURE_2D, GR_GL_TEXTURE_MIN_FILTER, GR_GL_NEAREST)); + GR_GL(TexImage2D(GR_GL_TEXTURE_2D, 0, GR_GL_RGBA, w, h, + 0, GR_GL_RGBA, GR_GL_UNSIGNED_BYTE, NULL)); + GR_GL(BindTexture(GR_GL_TEXTURE_2D, 0)); GR_GL(FramebufferTexture2D(GR_FRAMEBUFFER, GR_COLOR_ATTACHMENT0, - GL_TEXTURE_2D, testRTTex, 0)); - GLenum status = GR_GL(CheckFramebufferStatus(GR_FRAMEBUFFER)); + GR_GL_TEXTURE_2D, testRTTex, 0)); + GrGLenum status = GR_GL(CheckFramebufferStatus(GR_FRAMEBUFFER)); GR_GL(DeleteFramebuffers(1, &testFBO)); GR_GL(DeleteTextures(1, &testRTTex)); @@ -184,29 +184,29 @@ GrGpuGL::GrGpuGL() { GrPrintf("------------------------- create GrGpuGL %p --------------\n", this); GrPrintf("------ VENDOR %s\n", - GrGLGetGLInterface()->fGetString(GL_VENDOR)); + GrGLGetGLInterface()->fGetString(GR_GL_VENDOR)); GrPrintf("------ RENDERER %s\n", - GrGLGetGLInterface()->fGetString(GL_RENDERER)); + GrGLGetGLInterface()->fGetString(GR_GL_RENDERER)); GrPrintf("------ VERSION %s\n", - GrGLGetGLInterface()->fGetString(GL_VERSION)); + GrGLGetGLInterface()->fGetString(GR_GL_VERSION)); GrPrintf("------ EXTENSIONS\n %s \n", - GrGLGetGLInterface()->fGetString(GL_EXTENSIONS)); + GrGLGetGLInterface()->fGetString(GR_GL_EXTENSIONS)); } GrGLClearErr(); resetDirtyFlags(); - GLint maxTextureUnits; + GrGLint maxTextureUnits; // check FS and fixed-function texture unit limits // we only use textures in the fragment stage currently. // checks are > to make sure we have a spare unit. #if GR_SUPPORT_GLDESKTOP || GR_SUPPORT_GLES2 - GR_GL_GetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &maxTextureUnits); + GR_GL_GetIntegerv(GR_GL_MAX_TEXTURE_IMAGE_UNITS, &maxTextureUnits); GrAssert(maxTextureUnits > kNumStages); #endif #if GR_SUPPORT_GLDESKTOP || GR_SUPPORT_GLES1 - GR_GL_GetIntegerv(GL_MAX_TEXTURE_UNITS, &maxTextureUnits); + GR_GL_GetIntegerv(GR_GL_MAX_TEXTURE_UNITS, &maxTextureUnits); GrAssert(maxTextureUnits > kNumStages); #endif @@ -216,10 +216,10 @@ GrGpuGL::GrGpuGL() { int major, minor; gl_version(&major, &minor); - GLint numFormats; - GR_GL_GetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &numFormats); - GrAutoSTMalloc<10, GLint> formats(numFormats); - GR_GL_GetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, formats); + GrGLint numFormats; + GR_GL_GetIntegerv(GR_GL_NUM_COMPRESSED_TEXTURE_FORMATS, &numFormats); + GrAutoSTMalloc<10, GrGLint> formats(numFormats); + GR_GL_GetIntegerv(GR_GL_COMPRESSED_TEXTURE_FORMATS, formats); for (int i = 0; i < numFormats; ++i) { if (formats[i] == GR_PALETTE8_RGBA8) { f8bitPaletteSupport = true; @@ -268,8 +268,8 @@ GrGpuGL::GrGpuGL() { } if (kNone_MSFBO != fMSFBOType) { - GLint maxSamples; - GLenum maxSampleGetter = (kIMG_MSFBO == fMSFBOType) ? + GrGLint maxSamples; + GrGLenum maxSampleGetter = (kIMG_MSFBO == fMSFBOType) ? GR_MAX_SAMPLES_IMG : GR_MAX_SAMPLES; GR_GL_GetIntegerv(maxSampleGetter, &maxSamples); @@ -417,16 +417,16 @@ GrGpuGL::GrGpuGL() { we look for such a limitation. */ fMinRenderTargetHeight = GR_INVAL_GLINT; - GLint maxRenderSize; + GrGLint maxRenderSize; GR_GL_GetIntegerv(GR_MAX_RENDERBUFFER_SIZE, &maxRenderSize); if (gPrintStartupSpew) { GrPrintf("Small height FBO texture experiments\n"); } - for (GLuint i = 1; i <= 256; fNPOTRenderTargetSupport ? ++i : i *= 2) { - GLuint w = maxRenderSize; - GLuint h = i; + for (GrGLuint i = 1; i <= 256; fNPOTRenderTargetSupport ? ++i : i *= 2) { + GrGLuint w = maxRenderSize; + GrGLuint h = i; if (fbo_test(w, h)) { if (gPrintStartupSpew) { GrPrintf("\t[%d, %d]: PASSED\n", w, h); @@ -445,9 +445,9 @@ GrGpuGL::GrGpuGL() { GrPrintf("Small width FBO texture experiments\n"); } fMinRenderTargetWidth = GR_MAX_GLUINT; - for (GLuint i = 1; i <= 256; fNPOTRenderTargetSupport ? i *= 2 : ++i) { - GLuint w = i; - GLuint h = maxRenderSize; + for (GrGLuint i = 1; i <= 256; fNPOTRenderTargetSupport ? i *= 2 : ++i) { + GrGLuint w = i; + GrGLuint h = maxRenderSize; if (fbo_test(w, h)) { if (gPrintStartupSpew) { GrPrintf("\t[%d, %d]: PASSED\n", w, h); @@ -462,7 +462,7 @@ GrGpuGL::GrGpuGL() { } GrAssert(GR_INVAL_GLINT != fMinRenderTargetWidth); - GR_GL_GetIntegerv(GL_MAX_TEXTURE_SIZE, &fMaxTextureDimension); + GR_GL_GetIntegerv(GR_GL_MAX_TEXTURE_SIZE, &fMaxTextureDimension); } GrGpuGL::~GrGpuGL() { @@ -471,24 +471,24 @@ GrGpuGL::~GrGpuGL() { void GrGpuGL::resetContext() { // We detect cases when blending is effectively off fHWBlendDisabled = false; - GR_GL(Enable(GL_BLEND)); + GR_GL(Enable(GR_GL_BLEND)); // we don't use the zb at all - GR_GL(Disable(GL_DEPTH_TEST)); - GR_GL(DepthMask(GL_FALSE)); + GR_GL(Disable(GR_GL_DEPTH_TEST)); + GR_GL(DepthMask(GR_GL_FALSE)); - GR_GL(Disable(GL_CULL_FACE)); - GR_GL(FrontFace(GL_CCW)); + GR_GL(Disable(GR_GL_CULL_FACE)); + GR_GL(FrontFace(GR_GL_CCW)); fHWDrawState.fDrawFace = kBoth_DrawFace; - GR_GL(Disable(GL_DITHER)); + GR_GL(Disable(GR_GL_DITHER)); #if GR_SUPPORT_GLDESKTOP - GR_GL(Disable(GL_LINE_SMOOTH)); - GR_GL(Disable(GL_POINT_SMOOTH)); - GR_GL(Disable(GL_MULTISAMPLE)); + GR_GL(Disable(GR_GL_LINE_SMOOTH)); + GR_GL(Disable(GR_GL_POINT_SMOOTH)); + GR_GL(Disable(GR_GL_MULTISAMPLE)); #endif - GR_GL(ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE)); + GR_GL(ColorMask(GR_GL_TRUE, GR_GL_TRUE, GR_GL_TRUE, GR_GL_TRUE)); fHWDrawState.fFlagBits = 0; // we only ever use lines in hairline mode @@ -519,7 +519,7 @@ void GrGpuGL::resetContext() { fHWBounds.fScissorRect.invalidate(); fHWBounds.fScissorEnabled = false; - GR_GL(Disable(GL_SCISSOR_TEST)); + GR_GL(Disable(GR_GL_SCISSOR_TEST)); fHWBounds.fViewportRect.invalidate(); fHWDrawState.fStencilSettings.invalidate(); @@ -528,11 +528,11 @@ void GrGpuGL::resetContext() { fHWGeometryState.fIndexBuffer = NULL; fHWGeometryState.fVertexBuffer = NULL; - GR_GL(BindBuffer(GL_ARRAY_BUFFER, 0)); - GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)); + GR_GL(BindBuffer(GR_GL_ARRAY_BUFFER, 0)); + GR_GL(BindBuffer(GR_GL_ELEMENT_ARRAY_BUFFER, 0)); fHWGeometryState.fArrayPtrsDirty = true; - GR_GL(ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE)); + GR_GL(ColorMask(GR_GL_TRUE, GR_GL_TRUE, GR_GL_TRUE, GR_GL_TRUE)); fHWDrawState.fRenderTarget = NULL; } @@ -554,8 +554,8 @@ GrRenderTarget* GrGpuGL::createPlatformRenderTargetHelper( viewport.fWidth = width; viewport.fHeight = height; - rtIDs.fRTFBOID = (GLuint)platformRenderTarget; - rtIDs.fTexFBOID = (GLuint)platformRenderTarget; + rtIDs.fRTFBOID = (GrGLuint)platformRenderTarget; + rtIDs.fTexFBOID = (GrGLuint)platformRenderTarget; return new GrGLRenderTarget(rtIDs, NULL, stencilBits, viewport, NULL, this); } @@ -564,15 +564,15 @@ GrRenderTarget* GrGpuGL::createRenderTargetFrom3DApiStateHelper() { GrGLRenderTarget::GLRenderTargetIDs rtIDs; - GR_GL_GetIntegerv(GR_FRAMEBUFFER_BINDING, (GLint*)&rtIDs.fRTFBOID); + GR_GL_GetIntegerv(GR_FRAMEBUFFER_BINDING, (GrGLint*)&rtIDs.fRTFBOID); rtIDs.fTexFBOID = rtIDs.fRTFBOID; rtIDs.fMSColorRenderbufferID = 0; rtIDs.fStencilRenderbufferID = 0; GrGLIRect viewport; viewport.setFromGLViewport(); - GLuint stencilBits; - GR_GL_GetIntegerv(GL_STENCIL_BITS, (GLint*)&stencilBits); + GrGLuint stencilBits; + GR_GL_GetIntegerv(GR_GL_STENCIL_BITS, (GrGLint*)&stencilBits); rtIDs.fOwnIDs = false; @@ -581,12 +581,12 @@ GrRenderTarget* GrGpuGL::createRenderTargetFrom3DApiStateHelper() { /////////////////////////////////////////////////////////////////////////////// -static const GLuint UNKNOWN_BITS = ~0; +static const GrGLuint UNKNOWN_BITS = ~0; // defines stencil formats from more to less preferred static const struct { - GLenum fEnum; - GLuint fBits; + GrGLenum fEnum; + GrGLuint fBits; } gStencilFormats[] = { {GR_STENCIL_INDEX8, 8}, @@ -598,7 +598,7 @@ static const struct { {GR_STENCIL_INDEX4, 4}, #if GR_SUPPORT_GLDESKTOP - {GL_STENCIL_INDEX, UNKNOWN_BITS}, + {GR_GL_STENCIL_INDEX, UNKNOWN_BITS}, {GR_DEPTH_STENCIL, UNKNOWN_BITS} #endif }; @@ -626,13 +626,13 @@ GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc, setSpareTextureUnit(); static const GrGLTexture::TexParams DEFAULT_PARAMS = { - GL_NEAREST, - GL_CLAMP_TO_EDGE, - GL_CLAMP_TO_EDGE + GR_GL_NEAREST, + GR_GL_CLAMP_TO_EDGE, + GR_GL_CLAMP_TO_EDGE }; GrGLTexture::GLTextureDesc glDesc; - GLenum internalFormat; + GrGLenum internalFormat; glDesc.fContentWidth = desc.fWidth; glDesc.fContentHeight = desc.fHeight; @@ -650,7 +650,7 @@ GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc, } GrAssert(as_size_t(desc.fAALevel) < GR_ARRAY_COUNT(fAASamples)); - GLint samples = fAASamples[desc.fAALevel]; + GrGLint samples = fAASamples[desc.fAALevel]; if (kNone_MSFBO == fMSFBOType && desc.fAALevel != kNone_AALevel) { GrPrintf("AA RT requested but not supported on this platform."); } @@ -669,7 +669,7 @@ GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc, */ #if GR_SUPPORT_GLDESKTOP if (srcData) { - GR_GL(PixelStorei(GL_UNPACK_ROW_LENGTH, + GR_GL(PixelStorei(GR_GL_UNPACK_ROW_LENGTH, rowBytes / glDesc.fUploadByteCount)); } #else @@ -706,39 +706,39 @@ GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc, glDesc.fAllocHeight = GrNextPow2(desc.fHeight); } - GR_GL(BindTexture(GL_TEXTURE_2D, glDesc.fTextureID)); - GR_GL(TexParameteri(GL_TEXTURE_2D, - GL_TEXTURE_MAG_FILTER, + GR_GL(BindTexture(GR_GL_TEXTURE_2D, glDesc.fTextureID)); + GR_GL(TexParameteri(GR_GL_TEXTURE_2D, + GR_GL_TEXTURE_MAG_FILTER, DEFAULT_PARAMS.fFilter)); - GR_GL(TexParameteri(GL_TEXTURE_2D, - GL_TEXTURE_MIN_FILTER, + GR_GL(TexParameteri(GR_GL_TEXTURE_2D, + GR_GL_TEXTURE_MIN_FILTER, DEFAULT_PARAMS.fFilter)); - GR_GL(TexParameteri(GL_TEXTURE_2D, - GL_TEXTURE_WRAP_S, + GR_GL(TexParameteri(GR_GL_TEXTURE_2D, + GR_GL_TEXTURE_WRAP_S, DEFAULT_PARAMS.fWrapS)); - GR_GL(TexParameteri(GL_TEXTURE_2D, - GL_TEXTURE_WRAP_T, + GR_GL(TexParameteri(GR_GL_TEXTURE_2D, + GR_GL_TEXTURE_WRAP_T, DEFAULT_PARAMS.fWrapT)); - GR_GL(PixelStorei(GL_UNPACK_ALIGNMENT, glDesc.fUploadByteCount)); + GR_GL(PixelStorei(GR_GL_UNPACK_ALIGNMENT, glDesc.fUploadByteCount)); if (GrTexture::kIndex_8_PixelConfig == desc.fFormat && supports8BitPalette()) { // ES only supports CompressedTexImage2D, not CompressedTexSubimage2D GrAssert(desc.fWidth == glDesc.fAllocWidth); GrAssert(desc.fHeight == glDesc.fAllocHeight); - GLsizei imageSize = glDesc.fAllocWidth * glDesc.fAllocHeight + - kColorTableSize; - GR_GL(CompressedTexImage2D(GL_TEXTURE_2D, 0, glDesc.fUploadFormat, + GrGLsizei imageSize = glDesc.fAllocWidth * glDesc.fAllocHeight + + kColorTableSize; + GR_GL(CompressedTexImage2D(GR_GL_TEXTURE_2D, 0, glDesc.fUploadFormat, glDesc.fAllocWidth, glDesc.fAllocHeight, 0, imageSize, srcData)); GrGL_RestoreResetRowLength(); } else { if (NULL != srcData && (glDesc.fAllocWidth != desc.fWidth || glDesc.fAllocHeight != desc.fHeight)) { - GR_GL(TexImage2D(GL_TEXTURE_2D, 0, internalFormat, + GR_GL(TexImage2D(GR_GL_TEXTURE_2D, 0, internalFormat, glDesc.fAllocWidth, glDesc.fAllocHeight, 0, glDesc.fUploadFormat, glDesc.fUploadType, NULL)); - GR_GL(TexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, desc.fWidth, + GR_GL(TexSubImage2D(GR_GL_TEXTURE_2D, 0, 0, 0, desc.fWidth, desc.fHeight, glDesc.fUploadFormat, glDesc.fUploadType, srcData)); GrGL_RestoreResetRowLength(); @@ -761,7 +761,7 @@ GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc, memcpy(extraRowStart, lastRowStart, rowSize); extraRowStart += rowSize; } - GR_GL(TexSubImage2D(GL_TEXTURE_2D, 0, 0, desc.fHeight, desc.fWidth, + GR_GL(TexSubImage2D(GR_GL_TEXTURE_2D, 0, 0, desc.fHeight, desc.fWidth, extraH, glDesc.fUploadFormat, glDesc.fUploadType, texels.get())); } @@ -775,7 +775,7 @@ GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc, } edgeTexel += rowSize; } - GR_GL(TexSubImage2D(GL_TEXTURE_2D, 0, desc.fWidth, 0, extraW, + GR_GL(TexSubImage2D(GR_GL_TEXTURE_2D, 0, desc.fWidth, 0, extraW, desc.fHeight, glDesc.fUploadFormat, glDesc.fUploadType, texels.get())); } @@ -787,13 +787,13 @@ GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc, memcpy(extraTexel, cornerTexel, glDesc.fUploadByteCount); extraTexel += glDesc.fUploadByteCount; } - GR_GL(TexSubImage2D(GL_TEXTURE_2D, 0, desc.fWidth, desc.fHeight, + GR_GL(TexSubImage2D(GR_GL_TEXTURE_2D, 0, desc.fWidth, desc.fHeight, extraW, extraH, glDesc.fUploadFormat, glDesc.fUploadType, texels.get())); } } else { - GR_GL(TexImage2D(GL_TEXTURE_2D, 0, internalFormat, glDesc.fAllocWidth, + GR_GL(TexImage2D(GR_GL_TEXTURE_2D, 0, internalFormat, glDesc.fAllocWidth, glDesc.fAllocHeight, 0, glDesc.fUploadFormat, glDesc.fUploadType, srcData)); GrGL_RestoreResetRowLength(); @@ -808,15 +808,15 @@ GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc, rtIDs.fRTFBOID = 0; rtIDs.fTexFBOID = 0; rtIDs.fOwnIDs = true; - GLenum msColorRenderbufferFormat = -1; + GrGLenum msColorRenderbufferFormat = -1; if (renderTarget) { #if GR_COLLECT_STATS ++fStats.fRenderTargetCreateCnt; #endif bool failed = true; - GLenum status; - GLint err; + GrGLenum status; + GrGLint err; // If need have both RT flag and srcData we have // to invert the data before uploading because FBO @@ -856,9 +856,9 @@ GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc, // someone suggested that some systems might require // unbinding the texture before we call FramebufferTexture2D // (seems unlikely) - GR_GL(BindTexture(GL_TEXTURE_2D, 0)); + GR_GL(BindTexture(GR_GL_TEXTURE_2D, 0)); - err = ~GL_NO_ERROR; + err = ~GR_GL_NO_ERROR; for (int i = 0; i < attempts; ++i) { if (rtIDs.fStencilRenderbufferID) { GR_GL(BindRenderbuffer(GR_RENDERBUFFER, @@ -876,8 +876,8 @@ GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc, glDesc.fAllocWidth, glDesc.fAllocHeight)); } - err = glGetError(); - if (err != GL_NO_ERROR) { + err = GrGLGetGLInterface()->fGetError(); + if (err != GR_GL_NO_ERROR) { continue; } } @@ -891,8 +891,8 @@ GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc, msColorRenderbufferFormat, glDesc.fAllocWidth, glDesc.fAllocHeight)); - err = glGetError(); - if (err != GL_NO_ERROR) { + err = GrGLGetGLInterface()->fGetError(); + if (err != GR_GL_NO_ERROR) { continue; } } @@ -904,7 +904,7 @@ GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc, if (kIMG_MSFBO == fMSFBOType && samples > 1) { GR_GL(FramebufferTexture2DMultisample(GR_FRAMEBUFFER, GR_COLOR_ATTACHMENT0, - GL_TEXTURE_2D, + GR_GL_TEXTURE_2D, glDesc.fTextureID, 0, samples)); @@ -912,11 +912,11 @@ GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc, } else { GR_GL(FramebufferTexture2D(GR_FRAMEBUFFER, GR_COLOR_ATTACHMENT0, - GL_TEXTURE_2D, + GR_GL_TEXTURE_2D, glDesc.fTextureID, 0)); } if (rtIDs.fRTFBOID != rtIDs.fTexFBOID) { - GLenum status = GR_GL(CheckFramebufferStatus(GR_FRAMEBUFFER)); + GrGLenum status = GR_GL(CheckFramebufferStatus(GR_FRAMEBUFFER)); if (status != GR_FRAMEBUFFER_COMPLETE) { GrPrintf("-- glCheckFramebufferStatus %x %d %d\n", status, desc.fWidth, desc.fHeight); @@ -975,7 +975,7 @@ GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc, failed = false; if (rtIDs.fStencilRenderbufferID) { if (UNKNOWN_BITS == gStencilFormats[i].fBits) { - GR_GL_GetIntegerv(GL_STENCIL_BITS, (GLint*)&glDesc.fStencilBits); + GR_GL_GetIntegerv(GR_GL_STENCIL_BITS, (GrGLint*)&glDesc.fStencilBits); } else { glDesc.fStencilBits = gStencilFormats[i].fBits; } @@ -1023,16 +1023,16 @@ GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc, } GrVertexBuffer* GrGpuGL::createVertexBufferHelper(uint32_t size, bool dynamic) { - GLuint id; + GrGLuint id; GR_GL(GenBuffers(1, &id)); if (id) { - GR_GL(BindBuffer(GL_ARRAY_BUFFER, id)); + GR_GL(BindBuffer(GR_GL_ARRAY_BUFFER, id)); fHWGeometryState.fArrayPtrsDirty = true; GrGLClearErr(); // make sure driver can allocate memory for this buffer - GR_GL_NO_ERR(BufferData(GL_ARRAY_BUFFER, size, NULL, - dynamic ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW)); - if (glGetError() != GL_NO_ERROR) { + GR_GL_NO_ERR(BufferData(GR_GL_ARRAY_BUFFER, size, NULL, + dynamic ? GR_GL_DYNAMIC_DRAW : GR_GL_STATIC_DRAW)); + if (GrGLGetGLInterface()->fGetError() != GR_GL_NO_ERROR) { GR_GL(DeleteBuffers(1, &id)); // deleting bound buffer does implicit bind to 0 fHWGeometryState.fVertexBuffer = NULL; @@ -1047,15 +1047,15 @@ GrVertexBuffer* GrGpuGL::createVertexBufferHelper(uint32_t size, bool dynamic) { } GrIndexBuffer* GrGpuGL::createIndexBufferHelper(uint32_t size, bool dynamic) { - GLuint id; + GrGLuint id; GR_GL(GenBuffers(1, &id)); if (id) { - GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, id)); + GR_GL(BindBuffer(GR_GL_ELEMENT_ARRAY_BUFFER, id)); GrGLClearErr(); // make sure driver can allocate memory for this buffer - GR_GL_NO_ERR(BufferData(GL_ELEMENT_ARRAY_BUFFER, size, NULL, - dynamic ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW)); - if (glGetError() != GL_NO_ERROR) { + GR_GL_NO_ERR(BufferData(GR_GL_ELEMENT_ARRAY_BUFFER, size, NULL, + dynamic ? GR_GL_DYNAMIC_DRAW : GR_GL_STATIC_DRAW)); + if (GrGLGetGLInterface()->fGetError() != GR_GL_NO_ERROR) { GR_GL(DeleteBuffers(1, &id)); // deleting bound buffer does implicit bind to 0 fHWGeometryState.fIndexBuffer = NULL; @@ -1089,12 +1089,12 @@ void GrGpuGL::flushScissor(const GrIRect* rect) { fHWBounds.fScissorRect = scissor; } if (!fHWBounds.fScissorEnabled) { - GR_GL(Enable(GL_SCISSOR_TEST)); + GR_GL(Enable(GR_GL_SCISSOR_TEST)); fHWBounds.fScissorEnabled = true; } } else { if (fHWBounds.fScissorEnabled) { - GR_GL(Disable(GL_SCISSOR_TEST)); + GR_GL(Disable(GR_GL_SCISSOR_TEST)); fHWBounds.fScissorEnabled = false; } } @@ -1106,16 +1106,16 @@ void GrGpuGL::eraseColorHelper(GrColor color) { } flushRenderTarget(); if (fHWBounds.fScissorEnabled) { - GR_GL(Disable(GL_SCISSOR_TEST)); + GR_GL(Disable(GR_GL_SCISSOR_TEST)); fHWBounds.fScissorEnabled = false; } - GR_GL(ColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE)); + GR_GL(ColorMask(GR_GL_TRUE,GR_GL_TRUE,GR_GL_TRUE,GR_GL_TRUE)); fHWDrawState.fFlagBits &= ~kNoColorWrites_StateBit; GR_GL(ClearColor(GrColorUnpackR(color)/255.f, GrColorUnpackG(color)/255.f, GrColorUnpackB(color)/255.f, GrColorUnpackA(color)/255.f)); - GR_GL(Clear(GL_COLOR_BUFFER_BIT)); + GR_GL(Clear(GR_GL_COLOR_BUFFER_BIT)); } void GrGpuGL::eraseStencil(uint32_t value, uint32_t mask) { @@ -1124,34 +1124,34 @@ void GrGpuGL::eraseStencil(uint32_t value, uint32_t mask) { } flushRenderTarget(); if (fHWBounds.fScissorEnabled) { - GR_GL(Disable(GL_SCISSOR_TEST)); + GR_GL(Disable(GR_GL_SCISSOR_TEST)); fHWBounds.fScissorEnabled = false; } GR_GL(StencilMask(mask)); GR_GL(ClearStencil(value)); - GR_GL(Clear(GL_STENCIL_BUFFER_BIT)); + GR_GL(Clear(GR_GL_STENCIL_BUFFER_BIT)); fHWDrawState.fStencilSettings.invalidate(); } void GrGpuGL::eraseStencilClip(const GrIRect& rect) { GrAssert(NULL != fCurrDrawState.fRenderTarget); #if 0 - GLint stencilBitCount = fCurrDrawState.fRenderTarget->stencilBits(); + GrGLint stencilBitCount = fCurrDrawState.fRenderTarget->stencilBits(); GrAssert(stencilBitCount > 0); - GLint clipStencilMask = (1 << (stencilBitCount - 1)); + GrGLint clipStencilMask = (1 << (stencilBitCount - 1)); #else // we could just clear the clip bit but when we go through // angle a partial stencil mask will cause clears to be // turned into draws. Our contract on GrDrawTarget says that // changing the clip between stencil passes may or may not // zero the client's clip bits. So we just clear the whole thing. - static const GLint clipStencilMask = ~0; + static const GrGLint clipStencilMask = ~0; #endif flushRenderTarget(); flushScissor(&rect); GR_GL(StencilMask(clipStencilMask)); GR_GL(ClearStencil(0)); - GR_GL(Clear(GL_STENCIL_BUFFER_BIT)); + GR_GL(Clear(GR_GL_STENCIL_BUFFER_BIT)); fHWDrawState.fStencilSettings.invalidate(); } @@ -1161,9 +1161,9 @@ void GrGpuGL::forceRenderTargetFlushHelper() { bool GrGpuGL::readPixelsHelper(int left, int top, int width, int height, GrTexture::PixelConfig config, void* buffer) { - GLenum internalFormat; // we don't use this for glReadPixels - GLenum format; - GLenum type; + GrGLenum internalFormat; // we don't use this for glReadPixels + GrGLenum format; + GrGLenum type; if (!this->canBeTexture(config, &internalFormat, &format, &type)) { return false; } @@ -1215,7 +1215,7 @@ void GrGpuGL::flushRenderTarget() { #endif rt->setDirty(true); #if GR_DEBUG - GLenum status = GR_GL(CheckFramebufferStatus(GR_FRAMEBUFFER)); + GrGLenum status = GR_GL(CheckFramebufferStatus(GR_FRAMEBUFFER)); if (status != GR_FRAMEBUFFER_COMPLETE) { GrPrintf("-- glCheckFramebufferStatus %x\n", status); } @@ -1230,13 +1230,13 @@ void GrGpuGL::flushRenderTarget() { } } -GLenum gPrimitiveType2GLMode[] = { - GL_TRIANGLES, - GL_TRIANGLE_STRIP, - GL_TRIANGLE_FAN, - GL_POINTS, - GL_LINES, - GL_LINE_STRIP +GrGLenum gPrimitiveType2GLMode[] = { + GR_GL_TRIANGLES, + GR_GL_TRIANGLE_STRIP, + GR_GL_TRIANGLE_FAN, + GR_GL_POINTS, + GR_GL_LINES, + GR_GL_LINE_STRIP }; #define SWAP_PER_DRAW 0 @@ -1267,7 +1267,7 @@ void GrGpuGL::drawIndexedHelper(GrPrimitiveType type, uint32_t indexCount) { GrAssert((size_t)type < GR_ARRAY_COUNT(gPrimitiveType2GLMode)); - GLvoid* indices = (GLvoid*)(sizeof(uint16_t) * startIndex); + GrGLvoid* indices = (GrGLvoid*)(sizeof(uint16_t) * startIndex); GrAssert(NULL != fHWGeometryState.fIndexBuffer); GrAssert(NULL != fHWGeometryState.fVertexBuffer); @@ -1277,7 +1277,7 @@ void GrGpuGL::drawIndexedHelper(GrPrimitiveType type, GrAssert(0 == startVertex); GR_GL(DrawElements(gPrimitiveType2GLMode[type], indexCount, - GL_UNSIGNED_SHORT, indices)); + GR_GL_UNSIGNED_SHORT, indices)); #if SWAP_PER_DRAW glFlush(); #if GR_MAC_BUILD @@ -1337,13 +1337,13 @@ void GrGpuGL::resolveTextureRenderTarget(GrGLTexture* texture) { // make sure we go through set render target fHWDrawState.fRenderTarget = NULL; - GLint left = 0; - GLint right = texture->width(); + GrGLint left = 0; + GrGLint right = texture->width(); // we will have rendered to the top of the FBO. - GLint top = texture->allocHeight(); - GLint bottom = texture->allocHeight() - texture->height(); + GrGLint top = texture->allocHeight(); + GrGLint bottom = texture->allocHeight() - texture->height(); if (kApple_MSFBO == fMSFBOType) { - GR_GL(Enable(GL_SCISSOR_TEST)); + GR_GL(Enable(GR_GL_SCISSOR_TEST)); GR_GL(Scissor(left, bottom, right-left, top-bottom)); GR_GL(ResolveMultisampleFramebuffer()); fHWBounds.fScissorRect.invalidate(); @@ -1351,22 +1351,22 @@ void GrGpuGL::resolveTextureRenderTarget(GrGLTexture* texture) { } else { GR_GL(BlitFramebuffer(left, bottom, right, top, left, bottom, right, top, - GL_COLOR_BUFFER_BIT, GL_NEAREST)); + GR_GL_COLOR_BUFFER_BIT, GR_GL_NEAREST)); } rt->setDirty(false); } } -static const GLenum grToGLStencilFunc[] = { - GL_ALWAYS, // kAlways_StencilFunc - GL_NEVER, // kNever_StencilFunc - GL_GREATER, // kGreater_StencilFunc - GL_GEQUAL, // kGEqual_StencilFunc - GL_LESS, // kLess_StencilFunc - GL_LEQUAL, // kLEqual_StencilFunc, - GL_EQUAL, // kEqual_StencilFunc, - GL_NOTEQUAL, // kNotEqual_StencilFunc, +static const GrGLenum grToGLStencilFunc[] = { + GR_GL_ALWAYS, // kAlways_StencilFunc + GR_GL_NEVER, // kNever_StencilFunc + GR_GL_GREATER, // kGreater_StencilFunc + GR_GL_GEQUAL, // kGEqual_StencilFunc + GR_GL_LESS, // kLess_StencilFunc + GR_GL_LEQUAL, // kLEqual_StencilFunc, + GR_GL_EQUAL, // kEqual_StencilFunc, + GR_GL_NOTEQUAL, // kNotEqual_StencilFunc, }; GR_STATIC_ASSERT(GR_ARRAY_COUNT(grToGLStencilFunc) == kBasicStencilFuncCount); GR_STATIC_ASSERT(0 == kAlways_StencilFunc); @@ -1378,15 +1378,15 @@ GR_STATIC_ASSERT(5 == kLEqual_StencilFunc); GR_STATIC_ASSERT(6 == kEqual_StencilFunc); GR_STATIC_ASSERT(7 == kNotEqual_StencilFunc); -static const GLenum grToGLStencilOp[] = { - GL_KEEP, // kKeep_StencilOp - GL_REPLACE, // kReplace_StencilOp - GL_INCR_WRAP, // kIncWrap_StencilOp - GL_INCR, // kIncClamp_StencilOp - GL_DECR_WRAP, // kDecWrap_StencilOp - GL_DECR, // kDecClamp_StencilOp - GL_ZERO, // kZero_StencilOp - GL_INVERT, // kInvert_StencilOp +static const GrGLenum grToGLStencilOp[] = { + GR_GL_KEEP, // kKeep_StencilOp + GR_GL_REPLACE, // kReplace_StencilOp + GR_GL_INCR_WRAP, // kIncWrap_StencilOp + GR_GL_INCR, // kIncClamp_StencilOp + GR_GL_DECR_WRAP, // kDecWrap_StencilOp + GR_GL_DECR, // kDecClamp_StencilOp + GR_GL_ZERO, // kZero_StencilOp + GR_GL_INVERT, // kInvert_StencilOp }; GR_STATIC_ASSERT(GR_ARRAY_COUNT(grToGLStencilOp) == kStencilOpCount); GR_STATIC_ASSERT(0 == kKeep_StencilOp); @@ -1422,9 +1422,9 @@ void GrGpuGL::flushStencil() { } if (settings->isDisabled()) { - GR_GL(Disable(GL_STENCIL_TEST)); + GR_GL(Disable(GR_GL_STENCIL_TEST)); } else { - GR_GL(Enable(GL_STENCIL_TEST)); + GR_GL(Enable(GR_GL_STENCIL_TEST)); #if GR_DEBUG if (!fStencilWrapOpsSupport) { GrAssert(settings->fFrontPassOp != kIncWrap_StencilOp); @@ -1441,13 +1441,13 @@ void GrGpuGL::flushStencil() { GrAssert(stencilBits || (GrStencilSettings::gDisabled == fCurrDrawState.fStencilSettings)); - GLuint clipStencilMask = 1 << (stencilBits - 1); - GLuint userStencilMask = clipStencilMask - 1; + GrGLuint clipStencilMask = 1 << (stencilBits - 1); + GrGLuint userStencilMask = clipStencilMask - 1; unsigned int frontRef = settings->fFrontFuncRef; unsigned int frontMask = settings->fFrontFuncMask; unsigned int frontWriteMask = settings->fFrontWriteMask; - GLenum frontFunc; + GrGLenum frontFunc; if (fCurrDrawState.fFlagBits & kModifyStencilClip_StateBit) { @@ -1473,7 +1473,7 @@ void GrGpuGL::flushStencil() { GrAssert(settings->fBackPassOp >= 0 && settings->fBackPassOp < GR_ARRAY_COUNT(grToGLStencilOp)); if (fTwoSidedStencilSupport) { - GLenum backFunc; + GrGLenum backFunc; unsigned int backRef = settings->fBackFuncRef; unsigned int backMask = settings->fBackFuncMask; @@ -1494,15 +1494,15 @@ void GrGpuGL::flushStencil() { backWriteMask &= userStencilMask; } - GR_GL(StencilFuncSeparate(GL_FRONT, frontFunc, frontRef, frontMask)); - GR_GL(StencilMaskSeparate(GL_FRONT, frontWriteMask)); - GR_GL(StencilFuncSeparate(GL_BACK, backFunc, backRef, backMask)); - GR_GL(StencilMaskSeparate(GL_BACK, backWriteMask)); - GR_GL(StencilOpSeparate(GL_FRONT, grToGLStencilOp[settings->fFrontFailOp], + GR_GL(StencilFuncSeparate(GR_GL_FRONT, frontFunc, frontRef, frontMask)); + GR_GL(StencilMaskSeparate(GR_GL_FRONT, frontWriteMask)); + GR_GL(StencilFuncSeparate(GR_GL_BACK, backFunc, backRef, backMask)); + GR_GL(StencilMaskSeparate(GR_GL_BACK, backWriteMask)); + GR_GL(StencilOpSeparate(GR_GL_FRONT, grToGLStencilOp[settings->fFrontFailOp], grToGLStencilOp[settings->fFrontPassOp], grToGLStencilOp[settings->fFrontPassOp])); - GR_GL(StencilOpSeparate(GL_BACK, grToGLStencilOp[settings->fBackFailOp], + GR_GL(StencilOpSeparate(GR_GL_BACK, grToGLStencilOp[settings->fBackFailOp], grToGLStencilOp[settings->fBackPassOp], grToGLStencilOp[settings->fBackPassOp])); } else { @@ -1540,7 +1540,7 @@ bool GrGpuGL::flushGLStateCommon(GrPrimitiveType type) { if (fHWDrawState.fTextures[s] != nextTexture) { setTextureUnit(s); - GR_GL(BindTexture(GL_TEXTURE_2D, nextTexture->textureID())); + GR_GL(BindTexture(GR_GL_TEXTURE_2D, nextTexture->textureID())); #if GR_COLLECT_STATS ++fStats.fTextureChngCnt; #endif @@ -1553,8 +1553,8 @@ bool GrGpuGL::flushGLStateCommon(GrPrimitiveType type) { nextTexture->getTexParams(); GrGLTexture::TexParams newTexParams; - newTexParams.fFilter = sampler.isFilter() ? GL_LINEAR : - GL_NEAREST; + newTexParams.fFilter = sampler.isFilter() ? GR_GL_LINEAR : + GR_GL_NEAREST; newTexParams.fWrapS = GrGLTexture::gWrapMode2GLWrap[sampler.getWrapX()]; newTexParams.fWrapT = @@ -1562,23 +1562,23 @@ bool GrGpuGL::flushGLStateCommon(GrPrimitiveType type) { if (newTexParams.fFilter != oldTexParams.fFilter) { setTextureUnit(s); - GR_GL(TexParameteri(GL_TEXTURE_2D, - GL_TEXTURE_MAG_FILTER, + GR_GL(TexParameteri(GR_GL_TEXTURE_2D, + GR_GL_TEXTURE_MAG_FILTER, newTexParams.fFilter)); - GR_GL(TexParameteri(GL_TEXTURE_2D, - GL_TEXTURE_MIN_FILTER, + GR_GL(TexParameteri(GR_GL_TEXTURE_2D, + GR_GL_TEXTURE_MIN_FILTER, newTexParams.fFilter)); } if (newTexParams.fWrapS != oldTexParams.fWrapS) { setTextureUnit(s); - GR_GL(TexParameteri(GL_TEXTURE_2D, - GL_TEXTURE_WRAP_S, + GR_GL(TexParameteri(GR_GL_TEXTURE_2D, + GR_GL_TEXTURE_WRAP_S, newTexParams.fWrapS)); } if (newTexParams.fWrapT != oldTexParams.fWrapT) { setTextureUnit(s); - GR_GL(TexParameteri(GL_TEXTURE_2D, - GL_TEXTURE_WRAP_T, + GR_GL(TexParameteri(GR_GL_TEXTURE_2D, + GR_GL_TEXTURE_WRAP_T, newTexParams.fWrapT)); } nextTexture->setTexParams(newTexParams); @@ -1598,19 +1598,19 @@ bool GrGpuGL::flushGLStateCommon(GrPrimitiveType type) { if ((fCurrDrawState.fFlagBits & kDither_StateBit) != (fHWDrawState.fFlagBits & kDither_StateBit)) { if (fCurrDrawState.fFlagBits & kDither_StateBit) { - GR_GL(Enable(GL_DITHER)); + GR_GL(Enable(GR_GL_DITHER)); } else { - GR_GL(Disable(GL_DITHER)); + GR_GL(Disable(GR_GL_DITHER)); } } if ((fCurrDrawState.fFlagBits & kNoColorWrites_StateBit) != (fHWDrawState.fFlagBits & kNoColorWrites_StateBit)) { - GLenum mask; + GrGLenum mask; if (fCurrDrawState.fFlagBits & kNoColorWrites_StateBit) { - mask = GL_FALSE; + mask = GR_GL_FALSE; } else { - mask = GL_TRUE; + mask = GR_GL_TRUE; } GR_GL(ColorMask(mask, mask, mask, mask)); } @@ -1621,24 +1621,24 @@ bool GrGpuGL::flushGLStateCommon(GrPrimitiveType type) { if (fDirtyFlags.fRenderTargetChanged || (fCurrDrawState.fFlagBits & kAntialias_StateBit) != (fHWDrawState.fFlagBits & kAntialias_StateBit)) { - GLint msaa = 0; + GrGLint msaa = 0; // only perform query if we know MSAA is supported. // calling on non-MSAA target caused a crash in one environment, // though I don't think it should. if (fAASamples[kHigh_AALevel]) { - GR_GL_GetIntegerv(GL_SAMPLE_BUFFERS, &msaa); + GR_GL_GetIntegerv(GR_GL_SAMPLE_BUFFERS, &msaa); } if (fCurrDrawState.fFlagBits & kAntialias_StateBit) { if (msaa) { - GR_GL(Enable(GL_MULTISAMPLE)); + GR_GL(Enable(GR_GL_MULTISAMPLE)); } else { - GR_GL(Enable(GL_LINE_SMOOTH)); + GR_GL(Enable(GR_GL_LINE_SMOOTH)); } } else { if (msaa) { - GR_GL(Disable(GL_MULTISAMPLE)); + GR_GL(Disable(GR_GL_MULTISAMPLE)); } - GR_GL(Disable(GL_LINE_SMOOTH)); + GR_GL(Disable(GR_GL_LINE_SMOOTH)); } } #endif @@ -1646,9 +1646,9 @@ bool GrGpuGL::flushGLStateCommon(GrPrimitiveType type) { bool blendOff = canDisableBlend(); if (fHWBlendDisabled != blendOff) { if (blendOff) { - GR_GL(Disable(GL_BLEND)); + GR_GL(Disable(GR_GL_BLEND)); } else { - GR_GL(Enable(GL_BLEND)); + GR_GL(Enable(GR_GL_BLEND)); } fHWBlendDisabled = blendOff; } @@ -1679,15 +1679,15 @@ bool GrGpuGL::flushGLStateCommon(GrPrimitiveType type) { if (fHWDrawState.fDrawFace != fCurrDrawState.fDrawFace) { switch (fCurrDrawState.fDrawFace) { case kCCW_DrawFace: - glEnable(GL_CULL_FACE); - GR_GL(CullFace(GL_BACK)); + GR_GL(Enable(GR_GL_CULL_FACE)); + GR_GL(CullFace(GR_GL_BACK)); break; case kCW_DrawFace: - GR_GL(Enable(GL_CULL_FACE)); - GR_GL(CullFace(GL_FRONT)); + GR_GL(Enable(GR_GL_CULL_FACE)); + GR_GL(CullFace(GR_GL_FRONT)); break; case kBoth_DrawFace: - GR_GL(Disable(GL_CULL_FACE)); + GR_GL(Disable(GR_GL_CULL_FACE)); break; default: GrCrash("Unknown draw face."); @@ -1768,9 +1768,9 @@ void GrGpuGL::notifyTextureDelete(GrGLTexture* texture) { } bool GrGpuGL::canBeTexture(GrTexture::PixelConfig config, - GLenum* internalFormat, - GLenum* format, - GLenum* type) { + GrGLenum* internalFormat, + GrGLenum* format, + GrGLenum* type) { switch (config) { case GrTexture::kRGBA_8888_PixelConfig: case GrTexture::kRGBX_8888_PixelConfig: // todo: can we tell it our X? @@ -1780,33 +1780,33 @@ bool GrGpuGL::canBeTexture(GrTexture::PixelConfig config, // format for a BGRA is BGRA not RGBA (as on desktop) *internalFormat = GR_GL_32BPP_COLOR_FORMAT; #else - *internalFormat = GL_RGBA; + *internalFormat = GR_GL_RGBA; #endif - *type = GL_UNSIGNED_BYTE; + *type = GR_GL_UNSIGNED_BYTE; break; case GrTexture::kRGB_565_PixelConfig: - *format = GL_RGB; - *internalFormat = GL_RGB; - *type = GL_UNSIGNED_SHORT_5_6_5; + *format = GR_GL_RGB; + *internalFormat = GR_GL_RGB; + *type = GR_GL_UNSIGNED_SHORT_5_6_5; break; case GrTexture::kRGBA_4444_PixelConfig: - *format = GL_RGBA; - *internalFormat = GL_RGBA; - *type = GL_UNSIGNED_SHORT_4_4_4_4; + *format = GR_GL_RGBA; + *internalFormat = GR_GL_RGBA; + *type = GR_GL_UNSIGNED_SHORT_4_4_4_4; break; case GrTexture::kIndex_8_PixelConfig: if (this->supports8BitPalette()) { *format = GR_PALETTE8_RGBA8; *internalFormat = GR_PALETTE8_RGBA8; - *type = GL_UNSIGNED_BYTE; // unused I think + *type = GR_GL_UNSIGNED_BYTE; // unused I think } else { return false; } break; case GrTexture::kAlpha_8_PixelConfig: - *format = GL_ALPHA; - *internalFormat = GL_ALPHA; - *type = GL_UNSIGNED_BYTE; + *format = GR_GL_ALPHA; + *internalFormat = GR_GL_ALPHA; + *type = GR_GL_UNSIGNED_BYTE; break; default: return false; @@ -1817,14 +1817,14 @@ bool GrGpuGL::canBeTexture(GrTexture::PixelConfig config, void GrGpuGL::setTextureUnit(int unit) { GrAssert(unit >= 0 && unit < kNumStages); if (fActiveTextureUnitIdx != unit) { - GR_GL(ActiveTexture(GL_TEXTURE0 + unit)); + GR_GL(ActiveTexture(GR_GL_TEXTURE0 + unit)); fActiveTextureUnitIdx = unit; } } void GrGpuGL::setSpareTextureUnit() { - if (fActiveTextureUnitIdx != (GL_TEXTURE0 + SPARE_TEX_UNIT)) { - GR_GL(ActiveTexture(GL_TEXTURE0 + SPARE_TEX_UNIT)); + if (fActiveTextureUnitIdx != (GR_GL_TEXTURE0 + SPARE_TEX_UNIT)) { + GR_GL(ActiveTexture(GR_GL_TEXTURE0 + SPARE_TEX_UNIT)); fActiveTextureUnitIdx = SPARE_TEX_UNIT; } } @@ -1835,7 +1835,7 @@ void GrGpuGL::setSpareTextureUnit() { RenderBufferStorage* has to be a specific format (not a base format like GL_RGBA). */ -bool GrGpuGL::fboInternalFormat(GrTexture::PixelConfig config, GLenum* format) { +bool GrGpuGL::fboInternalFormat(GrTexture::PixelConfig config, GrGLenum* format) { switch (config) { case GrTexture::kRGBA_8888_PixelConfig: case GrTexture::kRGBX_8888_PixelConfig: @@ -1852,7 +1852,7 @@ bool GrGpuGL::fboInternalFormat(GrTexture::PixelConfig config, GLenum* format) { return true; #endif case GrTexture::kRGBA_4444_PixelConfig: - *format = GL_RGBA4; + *format = GR_GL_RGBA4; return true; default: return false; @@ -1889,7 +1889,7 @@ void GrGpuGL::setBuffers(bool indexed, GrAssert(NULL != vbuf); GrAssert(!vbuf->isLocked()); if (fHWGeometryState.fVertexBuffer != vbuf) { - GR_GL(BindBuffer(GL_ARRAY_BUFFER, vbuf->bufferID())); + GR_GL(BindBuffer(GR_GL_ARRAY_BUFFER, vbuf->bufferID())); fHWGeometryState.fArrayPtrsDirty = true; fHWGeometryState.fVertexBuffer = vbuf; } @@ -1917,7 +1917,7 @@ void GrGpuGL::setBuffers(bool indexed, GrAssert(NULL != ibuf); GrAssert(!ibuf->isLocked()); if (fHWGeometryState.fIndexBuffer != ibuf) { - GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibuf->bufferID())); + GR_GL(BindBuffer(GR_GL_ELEMENT_ARRAY_BUFFER, ibuf->bufferID())); fHWGeometryState.fIndexBuffer = ibuf; } } diff --git a/gpu/src/GrGpuGL.h b/gpu/src/GrGpuGL.h index ea0c081cd2..3e7d79d2a1 100644 --- a/gpu/src/GrGpuGL.h +++ b/gpu/src/GrGpuGL.h @@ -151,10 +151,10 @@ private: void resolveTextureRenderTarget(GrGLTexture* texture); bool canBeTexture(GrTexture::PixelConfig config, - GLenum* internalFormat, - GLenum* format, - GLenum* type); - bool fboInternalFormat(GrTexture::PixelConfig config, GLenum* format); + GrGLenum* internalFormat, + GrGLenum* format, + GrGLenum* type); + bool fboInternalFormat(GrTexture::PixelConfig config, GrGLenum* format); friend class GrGLVertexBuffer; friend class GrGLIndexBuffer; @@ -163,7 +163,7 @@ private: bool fHWBlendDisabled; - GLuint fAASamples[4]; + GrGLuint fAASamples[4]; enum { kNone_MSFBO = 0, kDesktop_MSFBO, diff --git a/gpu/src/GrGpuGLFixed.cpp b/gpu/src/GrGpuGLFixed.cpp index afd9bb6c73..5a053a0223 100644 --- a/gpu/src/GrGpuGLFixed.cpp +++ b/gpu/src/GrGpuGLFixed.cpp @@ -25,7 +25,7 @@ #define SKIP_CACHE_CHECK true struct GrGpuMatrix { - GLfloat fMat[16]; + GrGLfloat fMat[16]; void reset() { Gr_bzero(fMat, sizeof(fMat)); @@ -51,8 +51,8 @@ struct GrGpuMatrix { }; // these must match the order in the corresponding enum in GrGpu.h -static const GLenum gMatrixMode2Enum[] = { - GL_MODELVIEW, GL_TEXTURE +static const GrGLenum gMatrixMode2Enum[] = { + GR_GL_MODELVIEW, GR_GL_TEXTURE }; /////////////////////////////////////////////////////////////////////////////// @@ -66,22 +66,22 @@ GrGpuGLFixed::~GrGpuGLFixed() { void GrGpuGLFixed::resetContext() { INHERITED::resetContext(); - GR_GL(Disable(GL_TEXTURE_2D)); + GR_GL(Disable(GR_GL_TEXTURE_2D)); for (int s = 0; s < kNumStages; ++s) { setTextureUnit(s); - GR_GL(EnableClientState(GL_VERTEX_ARRAY)); - GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE)); - GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE)); - GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_TEXTURE0+s)); - GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_PREVIOUS)); - GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR)); + GR_GL(EnableClientState(GR_GL_VERTEX_ARRAY)); + GR_GL(TexEnvi(GR_GL_TEXTURE_ENV, GR_GL_TEXTURE_ENV_MODE, GR_GL_COMBINE)); + GR_GL(TexEnvi(GR_GL_TEXTURE_ENV, GR_GL_COMBINE_RGB, GR_GL_MODULATE)); + GR_GL(TexEnvi(GR_GL_TEXTURE_ENV, GR_GL_SRC0_RGB, GR_GL_TEXTURE0+s)); + GR_GL(TexEnvi(GR_GL_TEXTURE_ENV, GR_GL_SRC1_RGB, GR_GL_PREVIOUS)); + GR_GL(TexEnvi(GR_GL_TEXTURE_ENV, GR_GL_OPERAND1_RGB, GR_GL_SRC_COLOR)); - GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE)); - GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_TEXTURE0+s)); - GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA)); - GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_PREVIOUS)); - GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA)); + GR_GL(TexEnvi(GR_GL_TEXTURE_ENV, GR_GL_COMBINE_ALPHA, GR_GL_MODULATE)); + GR_GL(TexEnvi(GR_GL_TEXTURE_ENV, GR_GL_SRC0_ALPHA, GR_GL_TEXTURE0+s)); + GR_GL(TexEnvi(GR_GL_TEXTURE_ENV, GR_GL_OPERAND0_ALPHA, GR_GL_SRC_ALPHA)); + GR_GL(TexEnvi(GR_GL_TEXTURE_ENV, GR_GL_SRC1_ALPHA, GR_GL_PREVIOUS)); + GR_GL(TexEnvi(GR_GL_TEXTURE_ENV, GR_GL_OPERAND1_ALPHA, GR_GL_SRC_ALPHA)); // color oprand0 changes between GL_SRC_COLR and GL_SRC_ALPHA depending // upon whether we have a (premultiplied) RGBA texture or just an ALPHA @@ -92,10 +92,10 @@ void GrGpuGLFixed::resetContext() { fHWGeometryState.fVertexLayout = 0; fHWGeometryState.fVertexOffset = ~0; - GR_GL(EnableClientState(GL_VERTEX_ARRAY)); - GR_GL(DisableClientState(GL_TEXTURE_COORD_ARRAY)); - GR_GL(ShadeModel(GL_FLAT)); - GR_GL(DisableClientState(GL_COLOR_ARRAY)); + GR_GL(EnableClientState(GR_GL_VERTEX_ARRAY)); + GR_GL(DisableClientState(GR_GL_TEXTURE_COORD_ARRAY)); + GR_GL(ShadeModel(GR_GL_FLAT)); + GR_GL(DisableClientState(GR_GL_COLOR_ARRAY)); GR_GL(PointSize(1.f)); @@ -120,7 +120,7 @@ void GrGpuGLFixed::flushProjectionMatrix() { mat[12] = -1.f; mat[13] = 1.f; - GR_GL(MatrixMode(GL_PROJECTION)); + GR_GL(MatrixMode(GR_GL_PROJECTION)); GR_GL(LoadMatrixf(mat)); } @@ -158,9 +158,9 @@ bool GrGpuGLFixed::flushGraphicsState(GrPrimitiveType type) { if (usingTextures[s] != wasUsingTexture) { setTextureUnit(s); if (usingTextures[s]) { - GR_GL(Enable(GL_TEXTURE_2D)); + GR_GL(Enable(GR_GL_TEXTURE_2D)); } else { - GR_GL(Disable(GL_TEXTURE_2D)); + GR_GL(Disable(GR_GL_TEXTURE_2D)); } } } @@ -171,11 +171,11 @@ bool GrGpuGLFixed::flushGraphicsState(GrPrimitiveType type) { if (vertColor != prevVertColor) { if (vertColor) { - GR_GL(ShadeModel(GL_SMOOTH)); + GR_GL(ShadeModel(GR_GL_SMOOTH)); // invalidate the immediate mode color fHWDrawState.fColor = GrColor_ILLEGAL; } else { - GR_GL(ShadeModel(GL_FLAT)); + GR_GL(ShadeModel(GR_GL_FLAT)); } } @@ -199,11 +199,11 @@ bool GrGpuGLFixed::flushGraphicsState(GrPrimitiveType type) { kColor_TextureEnvRGBOperand; if (fHWRGBOperand0[s] != nextRGBOperand0) { setTextureUnit(s); - GR_GL(TexEnvi(GL_TEXTURE_ENV, - GL_OPERAND0_RGB, + GR_GL(TexEnvi(GR_GL_TEXTURE_ENV, + GR_GL_OPERAND0_RGB, (nextRGBOperand0==kAlpha_TextureEnvRGBOperand) ? - GL_SRC_ALPHA : - GL_SRC_COLOR)); + GR_GL_SRC_ALPHA : + GR_GL_SRC_COLOR)); fHWRGBOperand0[s] = nextRGBOperand0; } @@ -218,7 +218,7 @@ bool GrGpuGLFixed::flushGraphicsState(GrPrimitiveType type) { GrGpuMatrix glm; glm.set(texMat); setTextureUnit(s); - GR_GL(MatrixMode(GL_TEXTURE)); + GR_GL(MatrixMode(GR_GL_TEXTURE)); GR_GL(LoadMatrixf(glm.fMat)); recordHWSamplerMatrix(s, getSamplerMatrix(s)); } @@ -232,7 +232,7 @@ bool GrGpuGLFixed::flushGraphicsState(GrPrimitiveType type) { if (fHWDrawState.fViewMatrix != fCurrDrawState.fViewMatrix) { GrGpuMatrix glm; glm.set(fCurrDrawState.fViewMatrix); - GR_GL(MatrixMode(GL_MODELVIEW)); + GR_GL(MatrixMode(GR_GL_MODELVIEW)); GR_GL(LoadMatrixf(glm.fMat)); fHWDrawState.fViewMatrix = fCurrDrawState.fViewMatrix; @@ -249,14 +249,14 @@ void GrGpuGLFixed::setupGeometry(int* startVertex, int newColorOffset; int newTexCoordOffsets[kNumStages]; - GLsizei newStride = VertexSizeAndOffsetsByStage(fGeometrySrc.fVertexLayout, - newTexCoordOffsets, - &newColorOffset); + GrGLsizei newStride = VertexSizeAndOffsetsByStage(fGeometrySrc.fVertexLayout, + newTexCoordOffsets, + &newColorOffset); int oldColorOffset; int oldTexCoordOffsets[kNumStages]; - GLsizei oldStride = VertexSizeAndOffsetsByStage(fHWGeometryState.fVertexLayout, - oldTexCoordOffsets, - &oldColorOffset); + GrGLsizei oldStride = VertexSizeAndOffsetsByStage(fHWGeometryState.fVertexLayout, + oldTexCoordOffsets, + &oldColorOffset); bool indexed = NULL != startIndex; @@ -264,7 +264,7 @@ void GrGpuGLFixed::setupGeometry(int* startVertex, int extraIndexOffset; setBuffers(indexed, &extraVertexOffset, &extraIndexOffset); - GLenum scalarType; + GrGLenum scalarType; if (fGeometrySrc.fVertexLayout & kTextFormat_VertexLayoutBit) { scalarType = GrGLTextType; } else { @@ -291,7 +291,7 @@ void GrGpuGLFixed::setupGeometry(int* startVertex, fGeometrySrc.fVertexLayout))); if (posAndTexChange) { - GR_GL(VertexPointer(2, scalarType, newStride, (GLvoid*)vertexOffset)); + GR_GL(VertexPointer(2, scalarType, newStride, (GrGLvoid*)vertexOffset)); fHWGeometryState.fVertexOffset = vertexOffset; } @@ -299,32 +299,32 @@ void GrGpuGLFixed::setupGeometry(int* startVertex, // need to enable array if tex coord offset is 0 // (using positions as coords) if (newTexCoordOffsets[s] >= 0) { - GLvoid* texCoordOffset = (GLvoid*)(vertexOffset + newTexCoordOffsets[s]); + GrGLvoid* texCoordOffset = (GrGLvoid*)(vertexOffset + newTexCoordOffsets[s]); if (oldTexCoordOffsets[s] < 0) { - GR_GL(ClientActiveTexture(GL_TEXTURE0+s)); - GR_GL(EnableClientState(GL_TEXTURE_COORD_ARRAY)); + GR_GL(ClientActiveTexture(GR_GL_TEXTURE0+s)); + GR_GL(EnableClientState(GR_GL_TEXTURE_COORD_ARRAY)); GR_GL(TexCoordPointer(2, scalarType, newStride, texCoordOffset)); } else if (posAndTexChange || newTexCoordOffsets[s] != oldTexCoordOffsets[s]) { - GR_GL(ClientActiveTexture(GL_TEXTURE0+s)); + GR_GL(ClientActiveTexture(GR_GL_TEXTURE0+s)); GR_GL(TexCoordPointer(2, scalarType, newStride, texCoordOffset)); } } else if (oldTexCoordOffsets[s] >= 0) { - GR_GL(ClientActiveTexture(GL_TEXTURE0+s)); - GR_GL(DisableClientState(GL_TEXTURE_COORD_ARRAY)); + GR_GL(ClientActiveTexture(GR_GL_TEXTURE0+s)); + GR_GL(DisableClientState(GR_GL_TEXTURE_COORD_ARRAY)); } } if (newColorOffset > 0) { - GLvoid* colorOffset = (GLvoid*)(vertexOffset + newColorOffset); + GrGLvoid* colorOffset = (GrGLvoid*)(vertexOffset + newColorOffset); if (oldColorOffset <= 0) { - GR_GL(EnableClientState(GL_COLOR_ARRAY)); - GR_GL(ColorPointer(4, GL_UNSIGNED_BYTE, newStride, colorOffset)); + GR_GL(EnableClientState(GR_GL_COLOR_ARRAY)); + GR_GL(ColorPointer(4, GR_GL_UNSIGNED_BYTE, newStride, colorOffset)); } else if (allOffsetsChange || newColorOffset != oldColorOffset) { - GR_GL(ColorPointer(4, GL_UNSIGNED_BYTE, newStride, colorOffset)); + GR_GL(ColorPointer(4, GR_GL_UNSIGNED_BYTE, newStride, colorOffset)); } } else if (oldColorOffset > 0) { - GR_GL(DisableClientState(GL_COLOR_ARRAY)); + GR_GL(DisableClientState(GR_GL_COLOR_ARRAY)); } fHWGeometryState.fVertexLayout = fGeometrySrc.fVertexLayout; diff --git a/gpu/src/GrGpuGLShaders2.cpp b/gpu/src/GrGpuGLShaders2.cpp index f79e9c883a..972d8a3f7a 100644 --- a/gpu/src/GrGpuGLShaders2.cpp +++ b/gpu/src/GrGpuGLShaders2.cpp @@ -1,5 +1,5 @@ /* - Copyright 2010 Google Inc. + Copyright 2011 Google Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -52,13 +52,13 @@ #define GR_UINT32_MAX static_cast(-1) struct GrGpuGLShaders2::StageUniLocations { - GLint fTextureMatrixUni; - GLint fSamplerUni; - GLint fRadial2Uni; + GrGLint fTextureMatrixUni; + GrGLint fSamplerUni; + GrGLint fRadial2Uni; }; struct GrGpuGLShaders2::UniLocations { - GLint fViewMatrixUni; + GrGLint fViewMatrixUni; StageUniLocations fStages[kNumStages]; }; @@ -71,9 +71,9 @@ struct GrGpuGLShaders2::UniLocations { // previous uniform state after a program change. struct GrGpuGLShaders2::Program { // IDs - GLuint fVShaderID; - GLuint fFShaderID; - GLuint fProgramID; + GrGLuint fVShaderID; + GrGLuint fFShaderID; + GrGLuint fProgramID; // shader uniform locations (-1 if shader doesn't use them) UniLocations fUniLocations; @@ -814,7 +814,7 @@ void GrGpuGLShaders2::GenProgram(const ProgramDesc& desc, segments.fVaryings.cstr(), segments.fVSCode.cstr()); #endif - program->fVShaderID = CompileShader(GL_VERTEX_SHADER, + program->fVShaderID = CompileShader(GR_GL_VERTEX_SHADER, stringCnt, strings, lengths); @@ -849,13 +849,13 @@ void GrGpuGLShaders2::GenProgram(const ProgramDesc& desc, segments.fVaryings.cstr(), segments.fFSCode.cstr()); #endif - program->fFShaderID = CompileShader(GL_FRAGMENT_SHADER, + program->fFShaderID = CompileShader(GR_GL_FRAGMENT_SHADER, stringCnt, strings, lengths); program->fProgramID = GR_GL(CreateProgram()); - const GLint& progID = program->fProgramID; + const GrGLint& progID = program->fProgramID; GR_GL(AttachShader(progID, program->fVShaderID)); GR_GL(AttachShader(progID, program->fFShaderID)); @@ -896,11 +896,11 @@ void GrGpuGLShaders2::GenProgram(const ProgramDesc& desc, GR_GL(LinkProgram(progID)); - GLint linked = GR_GL_INIT_ZERO; - GR_GL(GetProgramiv(progID, GL_LINK_STATUS, &linked)); + GrGLint linked = GR_GL_INIT_ZERO; + GR_GL(GetProgramiv(progID, GR_GL_LINK_STATUS, &linked)); if (!linked) { - GLint infoLen = GR_GL_INIT_ZERO; - GR_GL(GetProgramiv(progID, GL_INFO_LOG_LENGTH, &infoLen)); + GrGLint infoLen = GR_GL_INIT_ZERO; + GR_GL(GetProgramiv(progID, GR_GL_INFO_LOG_LENGTH, &infoLen)); GrAutoMalloc log(sizeof(char)*(infoLen+1)); // outside if for debugger if (infoLen > 0) { GR_GL(GetProgramInfoLog(progID, @@ -1042,23 +1042,23 @@ void GrGpuGLShaders2::getProgramDesc(GrPrimitiveType primType, ProgramDesc* desc } } -GLuint GrGpuGLShaders2::CompileShader(GLenum type, - int stringCnt, - const char** strings, - int* stringLengths) { - GLuint shader = GR_GL(CreateShader(type)); +GrGLuint GrGpuGLShaders2::CompileShader(GrGLenum type, + int stringCnt, + const char** strings, + int* stringLengths) { + GrGLuint shader = GR_GL(CreateShader(type)); if (0 == shader) { return 0; } - GLint compiled = GR_GL_INIT_ZERO; + GrGLint compiled = GR_GL_INIT_ZERO; GR_GL(ShaderSource(shader, stringCnt, strings, stringLengths)); GR_GL(CompileShader(shader)); - GR_GL(GetShaderiv(shader, GL_COMPILE_STATUS, &compiled)); + GR_GL(GetShaderiv(shader, GR_GL_COMPILE_STATUS, &compiled)); if (!compiled) { - GLint infoLen = GR_GL_INIT_ZERO; - GR_GL(GetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen)); + GrGLint infoLen = GR_GL_INIT_ZERO; + GR_GL(GetShaderiv(shader, GR_GL_INFO_LOG_LENGTH, &infoLen)); GrAutoMalloc log(sizeof(char)*(infoLen+1)); // outside if for debugger if (infoLen > 0) { GR_GL(GetShaderInfoLog(shader, infoLen+1, NULL, (char*)log.get())); @@ -1316,21 +1316,21 @@ void GrGpuGLShaders2::setupGeometry(int* startVertex, int newColorOffset; int newTexCoordOffsets[kMaxTexCoords]; - GLsizei newStride = VertexSizeAndOffsetsByIdx(fGeometrySrc.fVertexLayout, - newTexCoordOffsets, - &newColorOffset); + GrGLsizei newStride = VertexSizeAndOffsetsByIdx(fGeometrySrc.fVertexLayout, + newTexCoordOffsets, + &newColorOffset); int oldColorOffset; int oldTexCoordOffsets[kMaxTexCoords]; - GLsizei oldStride = VertexSizeAndOffsetsByIdx(fHWGeometryState.fVertexLayout, - oldTexCoordOffsets, - &oldColorOffset); + GrGLsizei oldStride = VertexSizeAndOffsetsByIdx(fHWGeometryState.fVertexLayout, + oldTexCoordOffsets, + &oldColorOffset); bool indexed = NULL != startIndex; int extraVertexOffset; int extraIndexOffset; setBuffers(indexed, &extraVertexOffset, &extraIndexOffset); - GLenum scalarType; + GrGLenum scalarType; bool texCoordNorm; if (fGeometrySrc.fVertexLayout & kTextFormat_VertexLayoutBit) { scalarType = GrGLTextType; @@ -1361,13 +1361,13 @@ void GrGpuGLShaders2::setupGeometry(int* startVertex, if (posAndTexChange) { GR_GL(VertexAttribPointer(POS_ATTR_LOCATION, 2, scalarType, - false, newStride, (GLvoid*)vertexOffset)); + false, newStride, (GrGLvoid*)vertexOffset)); fHWGeometryState.fVertexOffset = vertexOffset; } for (int t = 0; t < kMaxTexCoords; ++t) { if (newTexCoordOffsets[t] > 0) { - GLvoid* texCoordOffset = (GLvoid*)(vertexOffset + newTexCoordOffsets[t]); + GrGLvoid* texCoordOffset = (GrGLvoid*)(vertexOffset + newTexCoordOffsets[t]); if (oldTexCoordOffsets[t] <= 0) { GR_GL(EnableVertexAttribArray(TEX_ATTR_LOCATION(t))); GR_GL(VertexAttribPointer(TEX_ATTR_LOCATION(t), 2, scalarType, @@ -1383,15 +1383,15 @@ void GrGpuGLShaders2::setupGeometry(int* startVertex, } if (newColorOffset > 0) { - GLvoid* colorOffset = (int8_t*)(vertexOffset + newColorOffset); + GrGLvoid* colorOffset = (int8_t*)(vertexOffset + newColorOffset); if (oldColorOffset <= 0) { GR_GL(EnableVertexAttribArray(COL_ATTR_LOCATION)); GR_GL(VertexAttribPointer(COL_ATTR_LOCATION, 4, - GL_UNSIGNED_BYTE, + GR_GL_UNSIGNED_BYTE, true, newStride, colorOffset)); } else if (allOffsetsChange || newColorOffset != oldColorOffset) { GR_GL(VertexAttribPointer(COL_ATTR_LOCATION, 4, - GL_UNSIGNED_BYTE, + GR_GL_UNSIGNED_BYTE, true, newStride, colorOffset)); } } else if (oldColorOffset > 0) { diff --git a/gpu/src/GrGpuGLShaders2.h b/gpu/src/GrGpuGLShaders2.h index 4c501be69e..b9a019b79b 100644 --- a/gpu/src/GrGpuGLShaders2.h +++ b/gpu/src/GrGpuGLShaders2.h @@ -1,5 +1,5 @@ /* - Copyright 2010 Google Inc. + Copyright 2011 Google Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -84,16 +84,16 @@ private: // Compiles a GL shader, returns shader ID or 0 if failed // params have same meaning as glShaderSource - static GLuint CompileShader(GLenum type, int stringCnt, - const char** strings, - int* stringLengths); + static GrGLuint CompileShader(GrGLenum type, int stringCnt, + const char** strings, + int* stringLengths); static void DeleteProgram(Program* program); void ProgramUnitTest(); ProgramCache* fProgramCache; Program* fProgram; - GLuint fHWProgramID; + GrGLuint fHWProgramID; typedef GrGpuGL INHERITED; }; diff --git a/vs/SampleApp/SampleApp.vcxproj b/vs/SampleApp/SampleApp.vcxproj index b742a96f77..319d0b9714 100644 --- a/vs/SampleApp/SampleApp.vcxproj +++ b/vs/SampleApp/SampleApp.vcxproj @@ -207,6 +207,7 @@ + diff --git a/vs/SampleApp/SampleApp.vcxproj.filters b/vs/SampleApp/SampleApp.vcxproj.filters index 9595b6c12a..64148438ea 100644 --- a/vs/SampleApp/SampleApp.vcxproj.filters +++ b/vs/SampleApp/SampleApp.vcxproj.filters @@ -725,6 +725,9 @@ Gr\include + + Gr\include + diff --git a/xcode/gpu/gpu.xcodeproj/project.pbxproj b/xcode/gpu/gpu.xcodeproj/project.pbxproj index b1485e07df..e85c7ab459 100644 --- a/xcode/gpu/gpu.xcodeproj/project.pbxproj +++ b/xcode/gpu/gpu.xcodeproj/project.pbxproj @@ -90,6 +90,7 @@ 7D669346132ABD5D003AC2F5 /* GrGLInterface.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7D669345132ABD5D003AC2F5 /* GrGLInterface.cpp */; }; 7D66934C132ABD8F003AC2F5 /* GrGLInterface.h in Headers */ = {isa = PBXBuildFile; fileRef = 7D66934B132ABD8F003AC2F5 /* GrGLInterface.h */; }; 7D66934E132ABDA7003AC2F5 /* GrGLPlatformIncludes.h in Headers */ = {isa = PBXBuildFile; fileRef = 7D66934D132ABDA7003AC2F5 /* GrGLPlatformIncludes.h */; }; + 7D6EBF5A13330E8400AEAADD /* GrGLDefines.h in Headers */ = {isa = PBXBuildFile; fileRef = 7D6EBF5913330E8400AEAADD /* GrGLDefines.h */; }; D539049B12EA01E30025F3D6 /* GrContext_impl.h in Headers */ = {isa = PBXBuildFile; fileRef = D539049A12EA01E30025F3D6 /* GrContext_impl.h */; }; D53904A112EA026E0025F3D6 /* GrPaint.h in Headers */ = {isa = PBXBuildFile; fileRef = D53904A012EA026E0025F3D6 /* GrPaint.h */; }; D542EAAD131C87E90065FC9D /* GrStencil.h in Headers */ = {isa = PBXBuildFile; fileRef = D542EAAC131C87E90065FC9D /* GrStencil.h */; }; @@ -187,6 +188,7 @@ 7D669345132ABD5D003AC2F5 /* GrGLInterface.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = GrGLInterface.cpp; path = ../../gpu/src/GrGLInterface.cpp; sourceTree = SOURCE_ROOT; }; 7D66934B132ABD8F003AC2F5 /* GrGLInterface.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GrGLInterface.h; path = ../../gpu/include/GrGLInterface.h; sourceTree = SOURCE_ROOT; }; 7D66934D132ABDA7003AC2F5 /* GrGLPlatformIncludes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GrGLPlatformIncludes.h; path = ../../gpu/include/GrGLPlatformIncludes.h; sourceTree = SOURCE_ROOT; }; + 7D6EBF5913330E8400AEAADD /* GrGLDefines.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GrGLDefines.h; path = ../../gpu/include/GrGLDefines.h; sourceTree = SOURCE_ROOT; }; D2AAC046055464E500DB518D /* libgpu.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libgpu.a; sourceTree = BUILT_PRODUCTS_DIR; }; D539049A12EA01E30025F3D6 /* GrContext_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GrContext_impl.h; path = ../../gpu/include/GrContext_impl.h; sourceTree = SOURCE_ROOT; }; D53904A012EA026E0025F3D6 /* GrPaint.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GrPaint.h; path = ../../gpu/include/GrPaint.h; sourceTree = SOURCE_ROOT; }; @@ -215,6 +217,7 @@ 00115E3712C116B7008296FE /* include */ = { isa = PBXGroup; children = ( + 7D6EBF5913330E8400AEAADD /* GrGLDefines.h */, 7D66934D132ABDA7003AC2F5 /* GrGLPlatformIncludes.h */, 7D66934B132ABD8F003AC2F5 /* GrGLInterface.h */, 00216E5D130F0B03009A2160 /* GrGLIRect.h */, @@ -419,6 +422,7 @@ D542EAAD131C87E90065FC9D /* GrStencil.h in Headers */, 7D66934C132ABD8F003AC2F5 /* GrGLInterface.h in Headers */, 7D66934E132ABDA7003AC2F5 /* GrGLPlatformIncludes.h in Headers */, + 7D6EBF5A13330E8400AEAADD /* GrGLDefines.h in Headers */, ); runOnlyForDeploymentPostprocessing = 0; };