bool GrGLGetGLSLGeneration(const GrGLInterface* gl, GrGLSLGeneration* generation) { SkASSERT(generation); GrGLSLVersion ver = GrGLGetGLSLVersion(gl); if (GR_GLSL_INVALID_VER == ver) { return false; } if (GR_IS_GR_GL(gl->fStandard)) { SkASSERT(ver >= GR_GLSL_VER(1,10)); if (ver >= GR_GLSL_VER(4,20)) { *generation = k420_GrGLSLGeneration; } else if (ver >= GR_GLSL_VER(4,00)) { *generation = k400_GrGLSLGeneration; } else if (ver >= GR_GLSL_VER(3,30)) { *generation = k330_GrGLSLGeneration; } else if (ver >= GR_GLSL_VER(1,50)) { *generation = k150_GrGLSLGeneration; } else if (ver >= GR_GLSL_VER(1,40)) { *generation = k140_GrGLSLGeneration; } else if (ver >= GR_GLSL_VER(1,30)) { *generation = k130_GrGLSLGeneration; } else { *generation = k110_GrGLSLGeneration; } return true; } else if (GR_IS_GR_GL_ES(gl->fStandard) || GR_IS_GR_WEBGL(gl->fStandard)) { SkASSERT(ver >= GR_GL_VER(1,00)); if (ver >= GR_GLSL_VER(3,20)) { *generation = k320es_GrGLSLGeneration; } else if (ver >= GR_GLSL_VER(3,10)) { *generation = k310es_GrGLSLGeneration; } else if (ver >= GR_GLSL_VER(3,00)) { *generation = k330_GrGLSLGeneration; } else { *generation = k110_GrGLSLGeneration; } return true; } SK_ABORT("Unknown GL Standard"); return false; }
std::unique_ptr<GrGLContext> GrGLContext::Make(sk_sp<const GrGLInterface> interface, const GrContextOptions& options) { if (!interface->validate()) { return nullptr; } const GrGLubyte* verUByte; GR_GL_CALL_RET(interface.get(), verUByte, GetString(GR_GL_VERSION)); const char* ver = reinterpret_cast<const char*>(verUByte); const GrGLubyte* rendererUByte; GR_GL_CALL_RET(interface.get(), rendererUByte, GetString(GR_GL_RENDERER)); const char* renderer = reinterpret_cast<const char*>(rendererUByte); ConstructorArgs args; args.fGLVersion = GrGLGetVersionFromString(ver); if (GR_GL_INVALID_VER == args.fGLVersion) { return nullptr; } if (!GrGLGetGLSLGeneration(interface.get(), &args.fGLSLGeneration)) { return nullptr; } args.fVendor = GrGLGetVendor(interface.get()); args.fRenderer = GrGLGetRendererFromStrings(renderer, interface->fExtensions); GrGLGetANGLEInfoFromString(renderer, &args.fANGLEBackend, &args.fANGLEVendor, &args.fANGLERenderer); /* * Qualcomm drivers for the 3xx series have a horrendous bug with some drivers. Though they * claim to support GLES 3.00, some perfectly valid GLSL300 shaders will only compile with * #version 100, and will fail to compile with #version 300 es. In the long term, we * need to lock this down to a specific driver version. * ?????/2015 - This bug is still present in Lollipop pre-mr1 * 06/18/2015 - This bug does not affect the nexus 6 (which has an Adreno 4xx). */ if (kAdreno3xx_GrGLRenderer == args.fRenderer) { args.fGLSLGeneration = k110_GrGLSLGeneration; } // Many ES3 drivers only advertise the ES2 image_external extension, but support the _essl3 // extension, and require that it be enabled to work with ESSL3. Other devices require the ES2 // extension to be enabled, even when using ESSL3. Some devices appear to only support the ES2 // extension. As an extreme (optional) solution, we can fallback to using ES2 shading language // if we want to prioritize external texture support. skbug.com/7713 if (GR_IS_GR_GL_ES(interface->fStandard) && options.fPreferExternalImagesOverES3 && !options.fDisableDriverCorrectnessWorkarounds && interface->hasExtension("GL_OES_EGL_image_external") && args.fGLSLGeneration >= k330_GrGLSLGeneration && !interface->hasExtension("GL_OES_EGL_image_external_essl3") && !interface->hasExtension("OES_EGL_image_external_essl3")) { args.fGLSLGeneration = k110_GrGLSLGeneration; } GrGLGetDriverInfo(interface->fStandard, args.fVendor, renderer, ver, &args.fDriver, &args.fDriverVersion); args.fContextOptions = &options; args.fInterface = std::move(interface); return std::unique_ptr<GrGLContext>(new GrGLContext(std::move(args))); }