1 /* 2 * Copyright 2011 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 9 #include "GrGLUtil.h" 10 #include "SkMatrix.h" 11 #include <stdio.h> 12 13 void GrGLClearErr(const GrGLInterface* gl) { 14 while (GR_GL_NO_ERROR != gl->fFunctions.fGetError()) {} 15 } 16 17 namespace { 18 const char *get_error_string(uint32_t err) { 19 switch (err) { 20 case GR_GL_NO_ERROR: 21 return ""; 22 case GR_GL_INVALID_ENUM: 23 return "Invalid Enum"; 24 case GR_GL_INVALID_VALUE: 25 return "Invalid Value"; 26 case GR_GL_INVALID_OPERATION: 27 return "Invalid Operation"; 28 case GR_GL_OUT_OF_MEMORY: 29 return "Out of Memory"; 30 case GR_GL_CONTEXT_LOST: 31 return "Context Lost"; 32 } 33 return "Unknown"; 34 } 35 } 36 37 void GrGLCheckErr(const GrGLInterface* gl, 38 const char* location, 39 const char* call) { 40 uint32_t err = GR_GL_GET_ERROR(gl); 41 if (GR_GL_NO_ERROR != err) { 42 GrPrintf("---- glGetError 0x%x(%s)", err, get_error_string(err)); 43 if (location) { 44 GrPrintf(" at\n\t%s", location); 45 } 46 if (call) { 47 GrPrintf("\n\t\t%s", call); 48 } 49 GrPrintf("\n"); 50 } 51 } 52 53 /////////////////////////////////////////////////////////////////////////////// 54 55 #if GR_GL_LOG_CALLS 56 bool gLogCallsGL = !!(GR_GL_LOG_CALLS_START); 57 #endif 58 59 #if GR_GL_CHECK_ERROR 60 bool gCheckErrorGL = !!(GR_GL_CHECK_ERROR_START); 61 #endif 62 63 /////////////////////////////////////////////////////////////////////////////// 64 65 GrGLStandard GrGLGetStandardInUseFromString(const char* versionString) { 66 if (NULL == versionString) { 67 SkDebugf("NULL GL version string."); 68 return kNone_GrGLStandard; 69 } 70 71 int major, minor; 72 73 // check for desktop 74 int n = sscanf(versionString, "%d.%d", &major, &minor); 75 if (2 == n) { 76 return kGL_GrGLStandard; 77 } 78 79 // check for ES 1 80 char profile[2]; 81 n = sscanf(versionString, "OpenGL ES-%c%c %d.%d", profile, profile+1, &major, &minor); 82 if (4 == n) { 83 // we no longer support ES1. 84 return kNone_GrGLStandard; 85 } 86 87 // check for ES2 88 n = sscanf(versionString, "OpenGL ES %d.%d", &major, &minor); 89 if (2 == n) { 90 return kGLES_GrGLStandard; 91 } 92 return kNone_GrGLStandard; 93 } 94 95 bool GrGLIsMesaFromVersionString(const char* versionString) { 96 int major, minor, mesaMajor, mesaMinor; 97 int n = sscanf(versionString, "%d.%d Mesa %d.%d", &major, &minor, &mesaMajor, &mesaMinor); 98 return 4 == n; 99 } 100 101 bool GrGLIsChromiumFromRendererString(const char* rendererString) { 102 return 0 == strcmp(rendererString, "Chromium"); 103 } 104 105 GrGLVersion GrGLGetVersionFromString(const char* versionString) { 106 if (NULL == versionString) { 107 SkDebugf("NULL GL version string."); 108 return GR_GL_INVALID_VER; 109 } 110 111 int major, minor; 112 113 // check for mesa 114 int mesaMajor, mesaMinor; 115 int n = sscanf(versionString, "%d.%d Mesa %d.%d", &major, &minor, &mesaMajor, &mesaMinor); 116 if (4 == n) { 117 return GR_GL_VER(major, minor); 118 } 119 120 n = sscanf(versionString, "%d.%d", &major, &minor); 121 if (2 == n) { 122 return GR_GL_VER(major, minor); 123 } 124 125 char profile[2]; 126 n = sscanf(versionString, "OpenGL ES-%c%c %d.%d", profile, profile+1, 127 &major, &minor); 128 if (4 == n) { 129 return GR_GL_VER(major, minor); 130 } 131 132 n = sscanf(versionString, "OpenGL ES %d.%d", &major, &minor); 133 if (2 == n) { 134 return GR_GL_VER(major, minor); 135 } 136 137 return GR_GL_INVALID_VER; 138 } 139 140 GrGLSLVersion GrGLGetGLSLVersionFromString(const char* versionString) { 141 if (NULL == versionString) { 142 SkDebugf("NULL GLSL version string."); 143 return GR_GLSL_INVALID_VER; 144 } 145 146 int major, minor; 147 148 int n = sscanf(versionString, "%d.%d", &major, &minor); 149 if (2 == n) { 150 return GR_GLSL_VER(major, minor); 151 } 152 153 n = sscanf(versionString, "OpenGL ES GLSL ES %d.%d", &major, &minor); 154 if (2 == n) { 155 return GR_GLSL_VER(major, minor); 156 } 157 158 #ifdef SK_BUILD_FOR_ANDROID 159 // android hack until the gpu vender updates their drivers 160 n = sscanf(versionString, "OpenGL ES GLSL %d.%d", &major, &minor); 161 if (2 == n) { 162 return GR_GLSL_VER(major, minor); 163 } 164 #endif 165 166 return GR_GLSL_INVALID_VER; 167 } 168 169 GrGLVendor GrGLGetVendorFromString(const char* vendorString) { 170 if (vendorString) { 171 if (0 == strcmp(vendorString, "ARM")) { 172 return kARM_GrGLVendor; 173 } 174 if (0 == strcmp(vendorString, "Imagination Technologies")) { 175 return kImagination_GrGLVendor; 176 } 177 if (0 == strncmp(vendorString, "Intel ", 6) || 0 == strcmp(vendorString, "Intel")) { 178 return kIntel_GrGLVendor; 179 } 180 if (0 == strcmp(vendorString, "Qualcomm")) { 181 return kQualcomm_GrGLVendor; 182 } 183 if (0 == strcmp(vendorString, "NVIDIA Corporation")) { 184 return kNVIDIA_GrGLVendor; 185 } 186 } 187 return kOther_GrGLVendor; 188 } 189 190 GrGLRenderer GrGLGetRendererFromString(const char* rendererString) { 191 if (rendererString) { 192 if (0 == strcmp(rendererString, "NVIDIA Tegra 3")) { 193 return kTegra3_GrGLRenderer; 194 } else if (0 == strcmp(rendererString, "NVIDIA Tegra")) { 195 return kTegra2_GrGLRenderer; 196 } 197 } 198 return kOther_GrGLRenderer; 199 } 200 201 GrGLVersion GrGLGetVersion(const GrGLInterface* gl) { 202 const GrGLubyte* v; 203 GR_GL_CALL_RET(gl, v, GetString(GR_GL_VERSION)); 204 return GrGLGetVersionFromString((const char*) v); 205 } 206 207 GrGLSLVersion GrGLGetGLSLVersion(const GrGLInterface* gl) { 208 const GrGLubyte* v; 209 GR_GL_CALL_RET(gl, v, GetString(GR_GL_SHADING_LANGUAGE_VERSION)); 210 return GrGLGetGLSLVersionFromString((const char*) v); 211 } 212 213 GrGLVendor GrGLGetVendor(const GrGLInterface* gl) { 214 const GrGLubyte* v; 215 GR_GL_CALL_RET(gl, v, GetString(GR_GL_VENDOR)); 216 return GrGLGetVendorFromString((const char*) v); 217 } 218 219 GrGLRenderer GrGLGetRenderer(const GrGLInterface* gl) { 220 const GrGLubyte* v; 221 GR_GL_CALL_RET(gl, v, GetString(GR_GL_RENDERER)); 222 return GrGLGetRendererFromString((const char*) v); 223 } 224 225 template<> void GrGLGetMatrix<3>(GrGLfloat* dest, const SkMatrix& src) { 226 // Col 0 227 dest[0] = SkScalarToFloat(src[SkMatrix::kMScaleX]); 228 dest[1] = SkScalarToFloat(src[SkMatrix::kMSkewY]); 229 dest[2] = SkScalarToFloat(src[SkMatrix::kMPersp0]); 230 231 // Col 1 232 dest[3] = SkScalarToFloat(src[SkMatrix::kMSkewX]); 233 dest[4] = SkScalarToFloat(src[SkMatrix::kMScaleY]); 234 dest[5] = SkScalarToFloat(src[SkMatrix::kMPersp1]); 235 236 // Col 2 237 dest[6] = SkScalarToFloat(src[SkMatrix::kMTransX]); 238 dest[7] = SkScalarToFloat(src[SkMatrix::kMTransY]); 239 dest[8] = SkScalarToFloat(src[SkMatrix::kMPersp2]); 240 } 241 242 template<> void GrGLGetMatrix<4>(GrGLfloat* dest, const SkMatrix& src) { 243 // Col 0 244 dest[0] = SkScalarToFloat(src[SkMatrix::kMScaleX]); 245 dest[1] = SkScalarToFloat(src[SkMatrix::kMSkewY]); 246 dest[2] = 0; 247 dest[3] = SkScalarToFloat(src[SkMatrix::kMPersp0]); 248 249 // Col 1 250 dest[4] = SkScalarToFloat(src[SkMatrix::kMSkewX]); 251 dest[5] = SkScalarToFloat(src[SkMatrix::kMScaleY]); 252 dest[6] = 0; 253 dest[7] = SkScalarToFloat(src[SkMatrix::kMPersp1]); 254 255 // Col 2 256 dest[8] = 0; 257 dest[9] = 0; 258 dest[10] = 1; 259 dest[11] = 0; 260 261 // Col 3 262 dest[12] = SkScalarToFloat(src[SkMatrix::kMTransX]); 263 dest[13] = SkScalarToFloat(src[SkMatrix::kMTransY]); 264 dest[14] = 0; 265 dest[15] = SkScalarToFloat(src[SkMatrix::kMPersp2]); 266 } 267 268 GrGLenum GrToGLStencilFunc(GrStencilFunc basicFunc) { 269 static const GrGLenum gTable[] = { 270 GR_GL_ALWAYS, // kAlways_StencilFunc 271 GR_GL_NEVER, // kNever_StencilFunc 272 GR_GL_GREATER, // kGreater_StencilFunc 273 GR_GL_GEQUAL, // kGEqual_StencilFunc 274 GR_GL_LESS, // kLess_StencilFunc 275 GR_GL_LEQUAL, // kLEqual_StencilFunc, 276 GR_GL_EQUAL, // kEqual_StencilFunc, 277 GR_GL_NOTEQUAL, // kNotEqual_StencilFunc, 278 }; 279 GR_STATIC_ASSERT(SK_ARRAY_COUNT(gTable) == kBasicStencilFuncCount); 280 GR_STATIC_ASSERT(0 == kAlways_StencilFunc); 281 GR_STATIC_ASSERT(1 == kNever_StencilFunc); 282 GR_STATIC_ASSERT(2 == kGreater_StencilFunc); 283 GR_STATIC_ASSERT(3 == kGEqual_StencilFunc); 284 GR_STATIC_ASSERT(4 == kLess_StencilFunc); 285 GR_STATIC_ASSERT(5 == kLEqual_StencilFunc); 286 GR_STATIC_ASSERT(6 == kEqual_StencilFunc); 287 GR_STATIC_ASSERT(7 == kNotEqual_StencilFunc); 288 SkASSERT((unsigned) basicFunc < kBasicStencilFuncCount); 289 290 return gTable[basicFunc]; 291 } 292
