1 /* 2 * Copyright 2012 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #ifndef GrGLUtil_DEFINED 9 #define GrGLUtil_DEFINED 10 11 #include "gl/GrGLInterface.h" 12 #include "GrGLDefines.h" 13 #include "GrStencilSettings.h" 14 15 class SkMatrix; 16 17 //////////////////////////////////////////////////////////////////////////////// 18 19 typedef uint32_t GrGLVersion; 20 typedef uint32_t GrGLSLVersion; 21 typedef uint32_t GrGLDriverVersion; 22 23 #define GR_GL_VER(major, minor) ((static_cast<int>(major) << 16) | \ 24 static_cast<int>(minor)) 25 #define GR_GLSL_VER(major, minor) ((static_cast<int>(major) << 16) | \ 26 static_cast<int>(minor)) 27 #define GR_GL_DRIVER_VER(major, minor) ((static_cast<int>(major) << 16) | \ 28 static_cast<int>(minor)) 29 30 #define GR_GL_INVALID_VER GR_GL_VER(0, 0) 31 #define GR_GLSL_INVALID_VER GR_GLSL_VER(0, 0) 32 #define GR_GL_DRIVER_UNKNOWN_VER GR_GL_DRIVER_VER(0, 0) 33 34 /** 35 * The Vendor and Renderer enum values are lazily updated as required. 36 */ 37 enum GrGLVendor { 38 kARM_GrGLVendor, 39 kImagination_GrGLVendor, 40 kIntel_GrGLVendor, 41 kQualcomm_GrGLVendor, 42 kNVIDIA_GrGLVendor, 43 kATI_GrGLVendor, 44 45 kOther_GrGLVendor 46 }; 47 48 enum GrGLRenderer { 49 kTegra2_GrGLRenderer, 50 kTegra3_GrGLRenderer, 51 kPowerVR54x_GrGLRenderer, 52 kPowerVRRogue_GrGLRenderer, 53 kAdreno3xx_GrGLRenderer, 54 kAdreno4xx_GrGLRenderer, 55 kAdreno5xx_GrGLRenderer, 56 kOSMesa_GrGLRenderer, 57 kIntelIrisPro_GrGLRenderer, 58 /** Either HD 4xxx or Iris 4xxx */ 59 kIntel4xxx_GrGLRenderer, 60 /** Either HD 6xxx or Iris 6xxx */ 61 kIntel6xxx_GrGLRenderer, 62 kGalliumLLVM_GrGLRenderer, 63 /** T-6xx, T-7xx, or T-8xx */ 64 kMaliT_GrGLRenderer, 65 kANGLE_GrGLRenderer, 66 67 kAMDRadeonHD7xxx_GrGLRenderer, // AMD Radeon HD 7000 Series 68 kAMDRadeonR9M4xx_GrGLRenderer, // AMD Radeon R9 M400 Series 69 70 kOther_GrGLRenderer 71 }; 72 73 enum GrGLDriver { 74 kMesa_GrGLDriver, 75 kChromium_GrGLDriver, 76 kNVIDIA_GrGLDriver, 77 kIntel_GrGLDriver, 78 kANGLE_GrGLDriver, 79 kQualcomm_GrGLDriver, 80 kUnknown_GrGLDriver 81 }; 82 83 enum class GrGLANGLEBackend { 84 kUnknown, 85 kD3D9, 86 kD3D11, 87 kOpenGL 88 }; 89 90 enum class GrGLANGLEVendor { 91 kUnknown, 92 kIntel 93 }; 94 95 enum class GrGLANGLERenderer { 96 kUnknown, 97 kIvyBridge, 98 kSkylake 99 }; 100 101 //////////////////////////////////////////////////////////////////////////////// 102 103 /** 104 * Some drivers want the var-int arg to be zero-initialized on input. 105 */ 106 #define GR_GL_INIT_ZERO 0 107 #define GR_GL_GetIntegerv(gl, e, p) \ 108 do { \ 109 *(p) = GR_GL_INIT_ZERO; \ 110 GR_GL_CALL(gl, GetIntegerv(e, p)); \ 111 } while (0) 112 113 #define GR_GL_GetFramebufferAttachmentParameteriv(gl, t, a, pname, p) \ 114 do { \ 115 *(p) = GR_GL_INIT_ZERO; \ 116 GR_GL_CALL(gl, GetFramebufferAttachmentParameteriv(t, a, pname, p)); \ 117 } while (0) 118 119 #define GR_GL_GetInternalformativ(gl, t, f, n, s, p) \ 120 do { \ 121 *(p) = GR_GL_INIT_ZERO; \ 122 GR_GL_CALL(gl, GetInternalformativ(t, f, n, s, p)); \ 123 } while (0) 124 125 #define GR_GL_GetNamedFramebufferAttachmentParameteriv(gl, fb, a, pname, p) \ 126 do { \ 127 *(p) = GR_GL_INIT_ZERO; \ 128 GR_GL_CALL(gl, GetNamedFramebufferAttachmentParameteriv(fb, a, pname, p)); \ 129 } while (0) 130 131 #define GR_GL_GetRenderbufferParameteriv(gl, t, pname, p) \ 132 do { \ 133 *(p) = GR_GL_INIT_ZERO; \ 134 GR_GL_CALL(gl, GetRenderbufferParameteriv(t, pname, p)); \ 135 } while (0) 136 137 #define GR_GL_GetTexLevelParameteriv(gl, t, l, pname, p) \ 138 do { \ 139 *(p) = GR_GL_INIT_ZERO; \ 140 GR_GL_CALL(gl, GetTexLevelParameteriv(t, l, pname, p)); \ 141 } while (0) 142 143 #define GR_GL_GetShaderPrecisionFormat(gl, st, pt, range, precision) \ 144 do { \ 145 (range)[0] = GR_GL_INIT_ZERO; \ 146 (range)[1] = GR_GL_INIT_ZERO; \ 147 (*precision) = GR_GL_INIT_ZERO; \ 148 GR_GL_CALL(gl, GetShaderPrecisionFormat(st, pt, range, precision)); \ 149 } while (0) 150 151 //////////////////////////////////////////////////////////////////////////////// 152 153 /** 154 * Helpers for glGetString() 155 */ 156 157 // these variants assume caller already has a string from glGetString() 158 GrGLVersion GrGLGetVersionFromString(const char* versionString); 159 GrGLStandard GrGLGetStandardInUseFromString(const char* versionString); 160 GrGLSLVersion GrGLGetGLSLVersionFromString(const char* versionString); 161 GrGLVendor GrGLGetVendorFromString(const char* vendorString); 162 GrGLRenderer GrGLGetRendererFromString(const char* rendererString); 163 void GrGLGetANGLEInfoFromString(const char* rendererString, GrGLANGLEBackend*, 164 GrGLANGLEVendor*, GrGLANGLERenderer*); 165 166 void GrGLGetDriverInfo(GrGLStandard standard, 167 GrGLVendor vendor, 168 const char* rendererString, 169 const char* versionString, 170 GrGLDriver* outDriver, 171 GrGLDriverVersion* outVersion); 172 173 // these variants call glGetString() 174 GrGLVersion GrGLGetVersion(const GrGLInterface*); 175 GrGLSLVersion GrGLGetGLSLVersion(const GrGLInterface*); 176 GrGLVendor GrGLGetVendor(const GrGLInterface*); 177 GrGLRenderer GrGLGetRenderer(const GrGLInterface*); 178 179 /** 180 * Helpers for glGetError() 181 */ 182 183 void GrGLCheckErr(const GrGLInterface* gl, 184 const char* location, 185 const char* call); 186 187 void GrGLClearErr(const GrGLInterface* gl); 188 189 //////////////////////////////////////////////////////////////////////////////// 190 191 /** 192 * Macros for using GrGLInterface to make GL calls 193 */ 194 195 // internal macro to conditionally call glGetError based on compile-time and 196 // run-time flags. 197 #if GR_GL_CHECK_ERROR 198 extern bool gCheckErrorGL; 199 #define GR_GL_CHECK_ERROR_IMPL(IFACE, X) \ 200 if (gCheckErrorGL) \ 201 GrGLCheckErr(IFACE, GR_FILE_AND_LINE_STR, #X) 202 #else 203 #define GR_GL_CHECK_ERROR_IMPL(IFACE, X) 204 #endif 205 206 // internal macro to conditionally log the gl call using SkDebugf based on 207 // compile-time and run-time flags. 208 #if GR_GL_LOG_CALLS 209 extern bool gLogCallsGL; 210 #define GR_GL_LOG_CALLS_IMPL(X) \ 211 if (gLogCallsGL) \ 212 SkDebugf(GR_FILE_AND_LINE_STR "GL: " #X "\n") 213 #else 214 #define GR_GL_LOG_CALLS_IMPL(X) 215 #endif 216 217 // makes a GL call on the interface and does any error checking and logging 218 #define GR_GL_CALL(IFACE, X) \ 219 do { \ 220 GR_GL_CALL_NOERRCHECK(IFACE, X); \ 221 GR_GL_CHECK_ERROR_IMPL(IFACE, X); \ 222 } while (false) 223 224 // Variant of above that always skips the error check. This is useful when 225 // the caller wants to do its own glGetError() call and examine the error value. 226 #define GR_GL_CALL_NOERRCHECK(IFACE, X) \ 227 do { \ 228 (IFACE)->fFunctions.f##X; \ 229 GR_GL_LOG_CALLS_IMPL(X); \ 230 } while (false) 231 232 // same as GR_GL_CALL but stores the return value of the gl call in RET 233 #define GR_GL_CALL_RET(IFACE, RET, X) \ 234 do { \ 235 GR_GL_CALL_RET_NOERRCHECK(IFACE, RET, X); \ 236 GR_GL_CHECK_ERROR_IMPL(IFACE, X); \ 237 } while (false) 238 239 // same as GR_GL_CALL_RET but always skips the error check. 240 #define GR_GL_CALL_RET_NOERRCHECK(IFACE, RET, X) \ 241 do { \ 242 (RET) = (IFACE)->fFunctions.f##X; \ 243 GR_GL_LOG_CALLS_IMPL(X); \ 244 } while (false) 245 246 // call glGetError without doing a redundant error check or logging. 247 #define GR_GL_GET_ERROR(IFACE) (IFACE)->fFunctions.fGetError() 248 249 GrGLenum GrToGLStencilFunc(GrStencilTest test); 250 251 GrPixelConfig GrGLSizedFormatToPixelConfig(GrGLenum sizedFormat); 252 253 #endif 254
