自学教程：C++ GR_GL_VER函数代码示例

GrGpuGLShaders::GrGpuGLShaders(const GrGLContextInfo& ctxInfo)    : GrGpuGL(ctxInfo) {    // Enable supported shader-related caps    if (kDesktop_GrGLBinding == this->glBinding()) {        fCaps.fDualSourceBlendingSupport =                            this->glVersion() >= GR_GL_VER(3,3) ||                            this->hasExtension("GL_ARB_blend_func_extended");        fCaps.fShaderDerivativeSupport = true;        // we don't support GL_ARB_geometry_shader4, just GL 3.2+ GS        fCaps.fGeometryShaderSupport =                                 this->glVersion() >= GR_GL_VER(3,2) &&                                this->glslGeneration() >= k150_GrGLSLGeneration;    } else {        fCaps.fShaderDerivativeSupport =                            this->hasExtension("GL_OES_standard_derivatives");    }    GR_GL_GetIntegerv(this->glInterface(),                      GR_GL_MAX_VERTEX_ATTRIBS,                      &fMaxVertexAttribs);    fProgramData = NULL;    fProgramCache = new ProgramCache(this->glContextInfo());#if 0    this->programUnitTest();#endif}

void GrGLCaps::initFSAASupport(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) {    fMSFBOType = kNone_MSFBOType;    if (kGL_GrGLStandard != ctxInfo.standard()) {        // We prefer the EXT/IMG extension over ES3 MSAA because we've observed        // ES3 driver bugs on at least one device with a tiled GPU (N10).        if (ctxInfo.hasExtension("GL_EXT_multisampled_render_to_texture")) {            fMSFBOType = kES_EXT_MsToTexture_MSFBOType;        } else if (ctxInfo.hasExtension("GL_IMG_multisampled_render_to_texture")) {            fMSFBOType = kES_IMG_MsToTexture_MSFBOType;        } else if (ctxInfo.version() >= GR_GL_VER(3,0)) {            fMSFBOType = GrGLCaps::kES_3_0_MSFBOType;        } else if (ctxInfo.hasExtension("GL_CHROMIUM_framebuffer_multisample")) {            // chrome's extension is equivalent to the EXT msaa            // and fbo_blit extensions.            fMSFBOType = kDesktop_EXT_MSFBOType;        } else if (ctxInfo.hasExtension("GL_APPLE_framebuffer_multisample")) {            fMSFBOType = kES_Apple_MSFBOType;        }    } else {        if ((ctxInfo.version() >= GR_GL_VER(3,0)) ||            ctxInfo.hasExtension("GL_ARB_framebuffer_object")) {            fMSFBOType = GrGLCaps::kDesktop_ARB_MSFBOType;        } else if (ctxInfo.hasExtension("GL_EXT_framebuffer_multisample") &&                   ctxInfo.hasExtension("GL_EXT_framebuffer_blit")) {            fMSFBOType = GrGLCaps::kDesktop_EXT_MSFBOType;        }    }}

GrGpuGLShaders::GrGpuGLShaders(const GrGLInterface* gl)    : GrGpuGL(gl, get_binding_in_use(gl)) {    GrGLSLGeneration glslGeneration =        GetGLSLGeneration(this->glBinding(), gl);    // Enable supported shader-releated caps    fCaps.fShaderSupport = true;    fCaps.fSupportPerVertexCoverage = true;    if (kDesktop_GrGLBinding == this->glBinding()) {        fCaps.fDualSourceBlendingSupport =            this->glVersion() >= GR_GL_VER(3,3) ||            this->hasExtension("GL_ARB_blend_func_extended");        fCaps.fShaderDerivativeSupport = true;        // we don't support GL_ARB_geometry_shader4, just GL 3.2+ GS        fCaps.fGeometryShaderSupport =            this->glVersion() >= GR_GL_VER(3,2) &&            glslGeneration >= k150_GLSLGeneration;    } else {        fCaps.fShaderDerivativeSupport =            this->hasExtension("GL_OES_standard_derivatives");    }    GR_GL_GetIntegerv(gl, GR_GL_MAX_VERTEX_ATTRIBS, &fMaxVertexAttribs);    fProgramData = NULL;    fProgramCache = new ProgramCache(gl, glslGeneration);#if 0    this->programUnitTest();#endif}

GrGLVersion GrGLGetVersionFromString(const char* versionString) {    if (NULL == versionString) {        GrAssert(!"NULL GL version string.");        return 0;    }    int major, minor;    int n = sscanf(versionString, "%d.%d", &major, &minor);    if (2 == n) {        return GR_GL_VER(major, minor);    }    char profile[2];    n = sscanf(versionString, "OpenGL ES-%c%c %d.%d", profile, profile+1,               &major, &minor);    if (4 == n) {        return GR_GL_VER(major, minor);    }    n = sscanf(versionString, "OpenGL ES %d.%d", &major, &minor);    if (2 == n) {        return GR_GL_VER(major, minor);    }    return 0;}

GrGLVersion GrGLGetVersionFromString(const char* versionString) {    if (nullptr == versionString) {        SkDebugf("nullptr GL version string.");        return GR_GL_INVALID_VER;    }    int major, minor;    // check for mesa    int mesaMajor, mesaMinor;    int n = sscanf(versionString, "%d.%d Mesa %d.%d", &major, &minor, &mesaMajor, &mesaMinor);    if (4 == n) {        return GR_GL_VER(major, minor);    }    n = sscanf(versionString, "%d.%d", &major, &minor);    if (2 == n) {        return GR_GL_VER(major, minor);    }    char profile[2];    n = sscanf(versionString, "OpenGL ES-%c%c %d.%d", profile, profile+1,               &major, &minor);    if (4 == n) {        return GR_GL_VER(major, minor);    }    n = sscanf(versionString, "OpenGL ES %d.%d", &major, &minor);    if (2 == n) {        return GR_GL_VER(major, minor);    }    return GR_GL_INVALID_VER;}

void GrGLCaps::initStencilFormats(const GrGLContextInfo& ctxInfo) {    // Build up list of legal stencil formats (though perhaps not supported on    // the particular gpu/driver) from most preferred to least.    // these consts are in order of most preferred to least preferred    // we don't bother with GL_STENCIL_INDEX1 or GL_DEPTH32F_STENCIL8    static const StencilFormat                  // internal Format      stencil bits      total bits        packed?        gS8    = {GR_GL_STENCIL_INDEX8,   8,                8,                false},        gS16   = {GR_GL_STENCIL_INDEX16,  16,               16,               false},        gD24S8 = {GR_GL_DEPTH24_STENCIL8, 8,                32,               true },        gS4    = {GR_GL_STENCIL_INDEX4,   4,                4,                false},    //  gS     = {GR_GL_STENCIL_INDEX,    kUnknownBitCount, kUnknownBitCount, false},        gDS    = {GR_GL_DEPTH_STENCIL,    kUnknownBitCount, kUnknownBitCount, true };    if (kGL_GrGLStandard == ctxInfo.standard()) {        bool supportsPackedDS =            ctxInfo.version() >= GR_GL_VER(3,0) ||            ctxInfo.hasExtension("GL_EXT_packed_depth_stencil") ||            ctxInfo.hasExtension("GL_ARB_framebuffer_object");        // S1 thru S16 formats are in GL 3.0+, EXT_FBO, and ARB_FBO since we        // require FBO support we can expect these are legal formats and don't        // check. These also all support the unsized GL_STENCIL_INDEX.        fStencilFormats.push_back() = gS8;        fStencilFormats.push_back() = gS16;        if (supportsPackedDS) {            fStencilFormats.push_back() = gD24S8;        }        fStencilFormats.push_back() = gS4;        if (supportsPackedDS) {            fStencilFormats.push_back() = gDS;        }    } else {        // ES2 has STENCIL_INDEX8 without extensions but requires extensions        // for other formats.        // ES doesn't support using the unsized format.        fStencilFormats.push_back() = gS8;        //fStencilFormats.push_back() = gS16;        if (ctxInfo.version() >= GR_GL_VER(3,0) ||            ctxInfo.hasExtension("GL_OES_packed_depth_stencil")) {            fStencilFormats.push_back() = gD24S8;        }        if (ctxInfo.hasExtension("GL_OES_stencil4")) {            fStencilFormats.push_back() = gS4;        }    }    SkASSERT(0 == fStencilVerifiedColorConfigs.count());    fStencilVerifiedColorConfigs.push_back_n(fStencilFormats.count());}

SkGLContext::GLFenceSync* SkGLContext::GLFenceSync::CreateIfSupported(const SkGLContext* ctx) {    SkAutoTDelete<GLFenceSync> ret(new GLFenceSync);    if (kGL_GrGLStandard == ctx->gl()->fStandard) {        const GrGLubyte* versionStr;        SK_GL_RET(*ctx, versionStr, GetString(GR_GL_VERSION));        GrGLVersion version = GrGLGetVersionFromString(reinterpret_cast<const char*>(versionStr));        if (version < GR_GL_VER(3,2) && !ctx->gl()->hasExtension("GL_ARB_sync")) {            return nullptr;        }        ret->fGLFenceSync = reinterpret_cast<GLFenceSyncProc>(            ctx->onPlatformGetProcAddress("glFenceSync"));        ret->fGLClientWaitSync = reinterpret_cast<GLClientWaitSyncProc>(            ctx->onPlatformGetProcAddress("glClientWaitSync"));        ret->fGLDeleteSync = reinterpret_cast<GLDeleteSyncProc>(            ctx->onPlatformGetProcAddress("glDeleteSync"));    } else {        if (!ctx->gl()->hasExtension("GL_APPLE_sync")) {            return nullptr;        }        ret->fGLFenceSync = reinterpret_cast<GLFenceSyncProc>(            ctx->onPlatformGetProcAddress("glFenceSyncAPPLE"));        ret->fGLClientWaitSync = reinterpret_cast<GLClientWaitSyncProc>(            ctx->onPlatformGetProcAddress("glClientWaitSyncAPPLE"));        ret->fGLDeleteSync = reinterpret_cast<GLDeleteSyncProc>(            ctx->onPlatformGetProcAddress("glDeleteSyncAPPLE"));    }    if (!ret->fGLFenceSync || !ret->fGLClientWaitSync || !ret->fGLDeleteSync) {        return nullptr;    }    return ret.detach();}

GrGLint GLTestContext::createTextureRectangle(int width, int height, GrGLenum internalFormat,                                          GrGLenum externalFormat, GrGLenum externalType,                                          GrGLvoid* data) {    if (!(kGL_GrGLStandard == fGL->fStandard && GrGLGetVersion(fGL) >= GR_GL_VER(3, 1)) &&        !fGL->fExtensions.has("GL_ARB_texture_rectangle")) {        return 0;    }    if  (GrGLGetGLSLVersion(fGL) < GR_GLSL_VER(1, 40)) {        return 0;    }    GrGLuint id;    GR_GL_CALL(fGL, GenTextures(1, &id));    GR_GL_CALL(fGL, BindTexture(GR_GL_TEXTURE_RECTANGLE, id));    GR_GL_CALL(fGL, TexParameteri(GR_GL_TEXTURE_RECTANGLE, GR_GL_TEXTURE_MAG_FILTER,                                  GR_GL_NEAREST));    GR_GL_CALL(fGL, TexParameteri(GR_GL_TEXTURE_RECTANGLE, GR_GL_TEXTURE_MIN_FILTER,                                  GR_GL_NEAREST));    GR_GL_CALL(fGL, TexParameteri(GR_GL_TEXTURE_RECTANGLE, GR_GL_TEXTURE_WRAP_S,                                  GR_GL_CLAMP_TO_EDGE));        GR_GL_CALL(fGL, TexParameteri(GR_GL_TEXTURE_RECTANGLE, GR_GL_TEXTURE_WRAP_T,                                  GR_GL_CLAMP_TO_EDGE));    GR_GL_CALL(fGL, TexImage2D(GR_GL_TEXTURE_RECTANGLE, 0, internalFormat, width, height, 0,                               externalFormat, externalType, data));    return id;}

bool GrGLExtensions::init(GrGLStandard standard,                          GrGLGetStringProc getString,                          GrGLGetStringiProc getStringi,                          GrGLGetIntegervProc getIntegerv) {    fInitialized = false;    fStrings->reset();    if (NULL == getString) {        return false;    }    // glGetStringi and indexed extensions were added in version 3.0 of desktop GL and ES.    const GrGLubyte* verString = getString(GR_GL_VERSION);    GrGLVersion version = GrGLGetVersionFromString((const char*) verString);    if (GR_GL_INVALID_VER == version) {        return false;    }    bool indexed = version >= GR_GL_VER(3, 0);    if (indexed) {        if (NULL == getStringi || NULL == getIntegerv) {            return false;        }        GrGLint extensionCnt = 0;        getIntegerv(GR_GL_NUM_EXTENSIONS, &extensionCnt);        fStrings->push_back_n(extensionCnt);        for (int i = 0; i < extensionCnt; ++i) {            const char* ext = (const char*) getStringi(GR_GL_EXTENSIONS, i);            (*fStrings)[i] = ext;        }    } else {        const char* extensions = (const char*) getString(GR_GL_EXTENSIONS);        if (NULL == extensions) {            return false;        }        while (true) {            // skip over multiple spaces between extensions            while (' ' == *extensions) {                ++extensions;            }            // quit once we reach the end of the string.            if ('/0' == *extensions) {                break;            }            // we found an extension            size_t length = strcspn(extensions, " ");            fStrings->push_back().set(extensions, length);            extensions += length;        }    }    if (!fStrings->empty()) {        SkTLessFunctionToFunctorAdaptor<SkString, extension_compare> cmp;        SkTQSort(&fStrings->front(), &fStrings->back(), cmp);    }    fInitialized = true;    return true;}

extern "C" boolSkiaGrGLInterfaceGLVersionGreaterThanOrEqualTo(SkiaGrGLInterfaceRef aGrGLInterface, int32_t major, int32_t minor) {    const GrGLubyte* versionUByte;    GR_GL_CALL_RET(static_cast<const GrGLInterface*>(aGrGLInterface), versionUByte, GetString(GR_GL_VERSION));    const char* version = reinterpret_cast<const char*>(versionUByte);    GrGLVersion glVersion = GrGLGetVersionFromString(version);    return GR_GL_INVALID_VER != glVersion && glVersion >= GR_GL_VER(major, minor);}

void GrGLContextInfo::reset() {    fBindingInUse = kNone_GrGLBinding;    fGLVersion = GR_GL_VER(0, 0);    fGLSLGeneration = static_cast<GrGLSLGeneration>(0);    fVendor = kOther_GrGLVendor;    fIsMesa = false;    fExtensions.reset();    fGLCaps->reset();}

void GrGLContextInfo::reset() {    fInterface.reset(NULL);    fGLVersion = GR_GL_VER(0, 0);    fGLSLGeneration = static_cast<GrGLSLGeneration>(0);    fVendor = kOther_GrGLVendor;    fRenderer = kOther_GrGLRenderer;    fIsMesa = false;    fIsChromium = false;    fGLCaps->reset();}

void GrGLSLCaps::initShaderPrecisionTable(const GrGLContextInfo& ctxInfo,        const GrGLInterface* intf) {    if (kGLES_GrGLStandard == ctxInfo.standard() || ctxInfo.version() >= GR_GL_VER(4, 1) ||            ctxInfo.hasExtension("GL_ARB_ES2_compatibility")) {        for (int s = 0; s < kGrShaderTypeCount; ++s) {            if (kGeometry_GrShaderType != s) {                GrShaderType shaderType = static_cast<GrShaderType>(s);                GrGLenum glShader = shader_type_to_gl_shader(shaderType);                PrecisionInfo* first = NULL;                fShaderPrecisionVaries = false;                for (int p = 0; p < kGrSLPrecisionCount; ++p) {                    GrSLPrecision precision = static_cast<GrSLPrecision>(p);                    GrGLenum glPrecision = precision_to_gl_float_type(precision);                    GrGLint range[2];                    GrGLint bits;                    GR_GL_GetShaderPrecisionFormat(intf, glShader, glPrecision, range, &bits);                    if (bits) {                        fFloatPrecisions[s][p].fLogRangeLow = range[0];                        fFloatPrecisions[s][p].fLogRangeHigh = range[1];                        fFloatPrecisions[s][p].fBits = bits;                        if (!first) {                            first = &fFloatPrecisions[s][p];                        }                        else if (!fShaderPrecisionVaries) {                            fShaderPrecisionVaries = (*first != fFloatPrecisions[s][p]);                        }                    }                }            }        }    }    else {        // We're on a desktop GL that doesn't have precision info. Assume they're all 32bit float.        fShaderPrecisionVaries = false;        for (int s = 0; s < kGrShaderTypeCount; ++s) {            if (kGeometry_GrShaderType != s) {                for (int p = 0; p < kGrSLPrecisionCount; ++p) {                    fFloatPrecisions[s][p].fLogRangeLow = 127;                    fFloatPrecisions[s][p].fLogRangeHigh = 127;                    fFloatPrecisions[s][p].fBits = 23;                }            }        }    }    // GetShaderPrecisionFormat doesn't accept GL_GEOMETRY_SHADER as a shader type. Assume they're    // the same as the vertex shader. Only fragment shaders were ever allowed to omit support for    // highp. GS was added after GetShaderPrecisionFormat was added to the list of features that    // are recommended against.    if (fGeometryShaderSupport) {        for (int p = 0; p < kGrSLPrecisionCount; ++p) {            fFloatPrecisions[kGeometry_GrShaderType][p] = fFloatPrecisions[kVertex_GrShaderType][p];        }    }}

bool GrGLExtensions::init(GrGLBinding binding,                          GrGLGetStringProc getString,                          GrGLGetStringiProc getStringi,                          GrGLGetIntegervProc getIntegerv) {    fStrings.reset();    if (NULL == getString) {        return false;    }    bool indexed = false;    if (kDesktop_GrGLBinding == binding) {        const GrGLubyte* verString = getString(GR_GL_VERSION);        if (NULL == verString) {            return false;        }        GrGLVersion version = GrGLGetVersionFromString((const char*) verString);        indexed = version >= GR_GL_VER(3, 0);    }    if (indexed) {        if (NULL == getStringi || NULL == getIntegerv) {            return false;        }        GrGLint extensionCnt = 0;        getIntegerv(GR_GL_NUM_EXTENSIONS, &extensionCnt);        fStrings.push_back_n(extensionCnt);        for (int i = 0; i < extensionCnt; ++i) {            const char* ext = (const char*) getStringi(GR_GL_EXTENSIONS, i);            fStrings[i] = ext;        }    } else {        const char* extensions = (const char*) getString(GR_GL_EXTENSIONS);        if (NULL == extensions) {            return false;        }        while (true) {            // skip over multiple spaces between extensions            while (' ' == *extensions) {                ++extensions;            }            // quit once we reach the end of the string.            if ('/0' == *extensions) {                break;            }            // we found an extension            size_t length = strcspn(extensions, " ");            fStrings.push_back().set(extensions, length);            extensions += length;        }    }    if (0 != fStrings.count()) {        SkTLessFunctionToFunctorAdaptor<SkString, extension_compare> cmp;        SkTQSort(&fStrings.front(), &fStrings.back(), cmp);    }    return true;}

bool GrGLExtensions::init(GrGLStandard standard,                          GrGLFunction<GrGLGetStringProc> getString,                          GrGLFunction<GrGLGetStringiProc> getStringi,                          GrGLFunction<GrGLGetIntegervProc> getIntegerv,                          GrGLFunction<GrEGLQueryStringProc> queryString,                          GrEGLDisplay eglDisplay) {    fInitialized = false;    fStrings->reset();    if (!getString) {        return false;    }    // glGetStringi and indexed extensions were added in version 3.0 of desktop GL and ES.    const GrGLubyte* verString = getString(GR_GL_VERSION);    GrGLVersion version = GrGLGetVersionFromString((const char*) verString);    if (GR_GL_INVALID_VER == version) {        return false;    }    bool indexed = version >= GR_GL_VER(3, 0);    if (indexed) {        if (!getStringi || !getIntegerv) {            return false;        }        GrGLint extensionCnt = 0;        getIntegerv(GR_GL_NUM_EXTENSIONS, &extensionCnt);        fStrings->push_back_n(extensionCnt);        for (int i = 0; i < extensionCnt; ++i) {            const char* ext = (const char*) getStringi(GR_GL_EXTENSIONS, i);            (*fStrings)[i] = ext;        }    } else {        const char* extensions = (const char*) getString(GR_GL_EXTENSIONS);        if (!extensions) {            return false;        }        eat_space_sep_strings(fStrings.get(), extensions);    }    if (queryString) {        const char* extensions = queryString(eglDisplay, GR_EGL_EXTENSIONS);        eat_space_sep_strings(fStrings.get(), extensions);    }    if (!fStrings->empty()) {        SkTLessFunctionToFunctorAdaptor<SkString, extension_compare> cmp;        SkTQSort(&fStrings->front(), &fStrings->back(), cmp);    }    fInitialized = true;    return true;}

GrGLVersion GrGLGetVersionFromString(const char* versionString) {    if (NULL == versionString) {        SkDEBUGFAIL("NULL GL version string.");        return 0;    }    int major, minor;    // check for mesa    int mesaMajor, mesaMinor;    int n = sscanf(versionString, "%d.%d Mesa %d.%d", &major, &minor, &mesaMajor, &mesaMinor);    if (4 == n) {        if (get_gl_version_for_mesa(mesaMajor, &major, &minor)) {            return GR_GL_VER(major, minor);        } else {            return 0;        }    }    n = sscanf(versionString, "%d.%d", &major, &minor);    if (2 == n) {        return GR_GL_VER(major, minor);    }    char profile[2];    n = sscanf(versionString, "OpenGL ES-%c%c %d.%d", profile, profile+1,               &major, &minor);    if (4 == n) {        return GR_GL_VER(major, minor);    }    n = sscanf(versionString, "OpenGL ES %d.%d", &major, &minor);    if (2 == n) {        return GR_GL_VER(major, minor);    }    return 0;}

void GrGLCaps::initFSAASupport(const GrGLContextInfo& ctxInfo) {    fMSFBOType = kNone_MSFBOType;    if (kDesktop_GrGLBinding != ctxInfo.binding()) {       if (ctxInfo.hasExtension("GL_CHROMIUM_framebuffer_multisample")) {           // chrome's extension is equivalent to the EXT msaa           // and fbo_blit extensions.           fMSFBOType = kDesktopEXT_MSFBOType;       } else if (ctxInfo.hasExtension("GL_APPLE_framebuffer_multisample")) {           fMSFBOType = kAppleES_MSFBOType;       }    } else {        if ((ctxInfo.version() >= GR_GL_VER(3,0)) ||            ctxInfo.hasExtension("GL_ARB_framebuffer_object")) {            fMSFBOType = GrGLCaps::kDesktopARB_MSFBOType;        } else if (ctxInfo.hasExtension("GL_EXT_framebuffer_multisample") &&                   ctxInfo.hasExtension("GL_EXT_framebuffer_blit")) {            fMSFBOType = GrGLCaps::kDesktopEXT_MSFBOType;        }        // TODO: We could populate fMSAACoverageModes using GetInternalformativ        // on GL 4.2+. It's format-specific, though. See also        // http://code.google.com/p/skia/issues/detail?id=470 about using actual        // rather than requested sample counts in cache key.        if (ctxInfo.hasExtension("GL_NV_framebuffer_multisample_coverage")) {            fCoverageAAType = kNVDesktop_CoverageAAType;            GrGLint count;            GR_GL_GetIntegerv(ctxInfo.interface(),                              GR_GL_MAX_MULTISAMPLE_COVERAGE_MODES,                              &count);            fMSAACoverageModes.setCount(count);            GR_GL_GetIntegerv(ctxInfo.interface(),                              GR_GL_MULTISAMPLE_COVERAGE_MODES,                              (int*)&fMSAACoverageModes[0]);            // The NV driver seems to return the modes already sorted but the            // spec doesn't require this. So we sort.            SkQSortCompareProc compareProc =                reinterpret_cast<SkQSortCompareProc>(&coverage_mode_compare);            SkQSort(&fMSAACoverageModes[0],                    count,                    sizeof(MSAACoverageMode),                    compareProc);        }    }    if (kNone_MSFBOType != fMSFBOType) {        GR_GL_GetIntegerv(ctxInfo.interface(),                          GR_GL_MAX_SAMPLES,                          &fMaxSampleCount);    }}

bool GrGLGetGLSLGeneration(const GrGLInterface* gl, GrGLSLGeneration* generation) {    SkASSERT(generation);    GrGLSLVersion ver = GrGLGetGLSLVersion(gl);    if (GR_GLSL_INVALID_VER == ver) {        return false;    }    switch (gl->fStandard) {        case kGL_GrGLStandard:            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;        case kGLES_GrGLStandard:            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;        default:            SK_ABORT("Unknown GL Standard");            return false;    }}

void GrGLCaps::initFSAASupport(const GrGLContextInfo& ctxInfo) {    fMSFBOType = kNone_MSFBOType;    if (kDesktop_GrGLBinding != ctxInfo.binding()) {       if (ctxInfo.hasExtension("GL_CHROMIUM_framebuffer_multisample")) {           // chrome's extension is equivalent to the EXT msaa           // and fbo_blit extensions.           fMSFBOType = kDesktopEXT_MSFBOType;       } else if (ctxInfo.hasExtension("GL_APPLE_framebuffer_multisample")) {            fMSFBOType = kAppleES_MSFBOType;        }    } else {        if ((ctxInfo.version() >= GR_GL_VER(3,0)) ||            ctxInfo.hasExtension("GL_ARB_framebuffer_object")) {            fMSFBOType = GrGLCaps::kDesktopARB_MSFBOType;        } else if (ctxInfo.hasExtension("GL_EXT_framebuffer_multisample") &&                   ctxInfo.hasExtension("GL_EXT_framebuffer_blit")) {            fMSFBOType = GrGLCaps::kDesktopEXT_MSFBOType;        }    }}

GrGLSLGeneration GrGetGLSLGeneration(GrGLBinding binding,                                     const GrGLInterface* gl) {    GrGLSLVersion ver = GrGLGetGLSLVersion(gl);    switch (binding) {    case kDesktop_GrGLBinding:        GrAssert(ver >= GR_GLSL_VER(1,10));        if (ver >= GR_GLSL_VER(1,50)) {            return k150_GrGLSLGeneration;        } else if (ver >= GR_GLSL_VER(1,30)) {            return k130_GrGLSLGeneration;        } else {            return k110_GrGLSLGeneration;        }    case kES2_GrGLBinding:        // version 1.00 of ES GLSL based on ver 1.20 of desktop GLSL        GrAssert(ver >= GR_GL_VER(1,00));        return k110_GrGLSLGeneration;    default:        GrCrash("Unknown GL Binding");        return k110_GrGLSLGeneration; // suppress warning    }}

const GrGLInterface* GrGLCreateNativeInterface() {    if (NULL != glXGetCurrentContext()) {        const char* versionString = (const char*) glGetString(GL_VERSION);        const char* extString = (const char*) glGetString(GL_EXTENSIONS);        GrGLVersion glVer = GrGLGetVersionFromString(versionString);        if (glVer < GR_GL_VER(1,5)) {            // We must have array and element_array buffer objects.            return NULL;        }        GrGLInterface* interface = new GrGLInterface();        interface->fActiveTexture = glActiveTexture;        GR_GL_GET_PROC(AttachShader);        GR_GL_GET_PROC(BindAttribLocation);        GR_GL_GET_PROC(BindBuffer);        GR_GL_GET_PROC(BindFragDataLocation);        GR_GL_GET_PROC(BeginQuery);        interface->fBindTexture = glBindTexture;        interface->fBlendFunc = glBlendFunc;        if (glVer >= GR_GL_VER(1,4) ||            GrGLHasExtensionFromString("GL_ARB_imaging", extString)) {            GR_GL_GET_PROC(BlendColor);            GR_GL_GET_PROC(BlendEquation);        } else {            if (GrGLHasExtensionFromString("GL_EXT_blend_color", extString)) {                GR_GL_GET_PROC_SUFFIX(BlendColor, EXT);            }             if (GrGLHasExtensionFromString("GL_EXT_blend_minmax", extString) ||                GrGLHasExtensionFromString("GL_EXT_blend_subtract", extString)) {                GR_GL_GET_PROC_SUFFIX(BlendEquation, EXT);            }         }         GR_GL_GET_PROC(BufferData);        GR_GL_GET_PROC(BufferSubData);        interface->fClear = glClear;        interface->fClearColor = glClearColor;        interface->fClearStencil = glClearStencil;        interface->fColorMask = glColorMask;        interface->fColorPointer = glColorPointer;        GR_GL_GET_PROC(CompileShader);        interface->fCompressedTexImage2D = glCompressedTexImage2D;        GR_GL_GET_PROC(CreateProgram);        GR_GL_GET_PROC(CreateShader);        interface->fCullFace = glCullFace;        GR_GL_GET_PROC(DeleteBuffers);        GR_GL_GET_PROC(DeleteProgram);        GR_GL_GET_PROC(DeleteQueries);        GR_GL_GET_PROC(DeleteShader);        interface->fDeleteTextures = glDeleteTextures;        interface->fDepthMask = glDepthMask;        interface->fDisable = glDisable;        GR_GL_GET_PROC(DisableVertexAttribArray);        interface->fDrawArrays = glDrawArrays;        interface->fDrawBuffer = glDrawBuffer;        GR_GL_GET_PROC(DrawBuffers);        interface->fDrawElements = glDrawElements;        interface->fEnable = glEnable;        GR_GL_GET_PROC(EnableVertexAttribArray);        GR_GL_GET_PROC(EndQuery);        interface->fFinish = glFinish;        interface->fFlush = glFlush;        interface->fFrontFace = glFrontFace;        GR_GL_GET_PROC(GenBuffers);        GR_GL_GET_PROC(GetBufferParameteriv);        interface->fGetError = glGetError;        interface->fGetIntegerv = glGetIntegerv;        GR_GL_GET_PROC(GetQueryObjectiv);        GR_GL_GET_PROC(GetQueryObjectuiv);        if (glVer >= GR_GL_VER(3,3) ||            GrGLHasExtensionFromString("GL_ARB_timer_query", extString)) {            GR_GL_GET_PROC(GetQueryObjecti64v);            GR_GL_GET_PROC(GetQueryObjectui64v);            GR_GL_GET_PROC(QueryCounter);        } else if (GrGLHasExtensionFromString("GL_EXT_timer_query", extString)) {            GR_GL_GET_PROC_SUFFIX(GetQueryObjecti64v, EXT);            GR_GL_GET_PROC_SUFFIX(GetQueryObjectui64v, EXT);        }        GR_GL_GET_PROC(GetQueryiv);        GR_GL_GET_PROC(GetProgramInfoLog);        GR_GL_GET_PROC(GetProgramiv);        GR_GL_GET_PROC(GetShaderInfoLog);        GR_GL_GET_PROC(GetShaderiv);        interface->fGetString = glGetString;        interface->fGetTexLevelParameteriv = glGetTexLevelParameteriv;        GR_GL_GET_PROC(GenQueries);        interface->fGenTextures = glGenTextures;        GR_GL_GET_PROC(GetUniformLocation);        interface->fLineWidth = glLineWidth;        GR_GL_GET_PROC(LinkProgram);        GR_GL_GET_PROC(MapBuffer);        interface->fPixelStorei = glPixelStorei;        interface->fReadBuffer = glReadBuffer;        interface->fReadPixels = glReadPixels;        if (GrGLHasExtensionFromString("GL_NV_framebuffer_multisample_coverage",                                       extString)) {            GR_GL_GET_PROC_SUFFIX(RenderbufferStorageMultisampleCoverage, NV);//.........这里部分代码省略.........

const GrGLInterface* GrGLCreateNativeInterface() {    // The gl functions are not context-specific so we create one global    // interface    static SkAutoTUnref<GrGLInterface> glInterface;    if (!glInterface.get()) {        GrGLInterface* interface = new GrGLInterface;        glInterface.reset(interface);        const char* verStr = (const char*) glGetString(GL_VERSION);        GrGLVersion ver = GrGLGetVersionFromString(verStr);        const char* extStr = (const char*) glGetString(GL_EXTENSIONS);        interface->fBindingsExported = kDesktop_GrGLBinding;        interface->fActiveTexture = glActiveTexture;        interface->fAttachShader = glAttachShader;        interface->fBeginQuery = glBeginQuery;        interface->fBindAttribLocation = glBindAttribLocation;        interface->fBindBuffer = glBindBuffer;        if (ver >= GR_GL_VER(3,0)) {            #if GL_VERSION_3_0                interface->fBindFragDataLocation = glBindFragDataLocation;            #else                interface->fBindFragDataLocation = GET_PROC(BindFragDataLocation);            #endif        }        interface->fBindTexture = glBindTexture;        interface->fBlendFunc = glBlendFunc;        if (ver >= GR_GL_VER(1,4)) {            interface->fBlendColor = glBlendColor;        } else if (GrGLHasExtensionFromString("GL_ARB_imaging", extStr) ||                   GrGLHasExtensionFromString("GL_EXT_blend_color", extStr)) {            GET_PROC(BlendColor);        }        interface->fBufferData = glBufferData;        interface->fBufferSubData = glBufferSubData;        interface->fClear = glClear;        interface->fClearColor = glClearColor;        interface->fClearStencil = glClearStencil;        interface->fColorMask = glColorMask;        interface->fCompileShader = glCompileShader;        interface->fCompressedTexImage2D = glCompressedTexImage2D;        interface->fCreateProgram = glCreateProgram;        interface->fCreateShader = glCreateShader;        interface->fCullFace = glCullFace;        interface->fDeleteBuffers = glDeleteBuffers;        interface->fDeleteProgram = glDeleteProgram;        interface->fDeleteQueries = glDeleteQueries;        interface->fDeleteShader = glDeleteShader;        interface->fDeleteTextures = glDeleteTextures;        interface->fDepthMask = glDepthMask;        interface->fDisable = glDisable;        interface->fDisableVertexAttribArray =                                            glDisableVertexAttribArray;        interface->fDrawArrays = glDrawArrays;        interface->fDrawBuffer = glDrawBuffer;        interface->fDrawBuffers = glDrawBuffers;        interface->fDrawElements = glDrawElements;        interface->fEnable = glEnable;        interface->fEnableVertexAttribArray = glEnableVertexAttribArray;        interface->fEndQuery = glEndQuery;        interface->fFinish = glFinish;        interface->fFlush = glFlush;        interface->fFrontFace = glFrontFace;        interface->fGenBuffers = glGenBuffers;        interface->fGenQueries = glGenQueries;        interface->fGetBufferParameteriv = glGetBufferParameteriv;        interface->fGetError = glGetError;        interface->fGetIntegerv = glGetIntegerv;        interface->fGetProgramInfoLog = glGetProgramInfoLog;        interface->fGetProgramiv = glGetProgramiv;        interface->fGetQueryiv = glGetQueryiv;        interface->fGetQueryObjectiv = glGetQueryObjectiv;        interface->fGetQueryObjectuiv = glGetQueryObjectuiv;        interface->fGetShaderInfoLog = glGetShaderInfoLog;        interface->fGetShaderiv = glGetShaderiv;        interface->fGetString = glGetString;        interface->fGetTexLevelParameteriv = glGetTexLevelParameteriv;        interface->fGenTextures = glGenTextures;        interface->fGetUniformLocation = glGetUniformLocation;        interface->fLineWidth = glLineWidth;        interface->fLinkProgram = glLinkProgram;        interface->fMapBuffer = glMapBuffer;        interface->fPixelStorei = glPixelStorei;        interface->fReadBuffer = glReadBuffer;        interface->fReadPixels = glReadPixels;        interface->fScissor = glScissor;        interface->fShaderSource = glShaderSource;        interface->fStencilFunc = glStencilFunc;        interface->fStencilFuncSeparate = glStencilFuncSeparate;        interface->fStencilMask = glStencilMask;        interface->fStencilMaskSeparate = glStencilMaskSeparate;        interface->fStencilOp = glStencilOp;        interface->fStencilOpSeparate = glStencilOpSeparate;        // mac uses GLenum for internalFormat param (non-standard)        // amounts to int vs. uint.        interface->fTexImage2D = (GrGLTexImage2DProc)glTexImage2D;        interface->fTexParameteri = glTexParameteri;        interface->fTexParameteriv = glTexParameteriv;    #if GL_ARB_texture_storage || GL_VERSION_4_2//.........这里部分代码省略.........

const GrGLInterface* GrGLAssembleGLInterface(void* ctx, GrGLGetProc get) {    GET_PROC_LOCAL(GetString);    GET_PROC_LOCAL(GetStringi);    GET_PROC_LOCAL(GetIntegerv);    // GetStringi may be nullptr depending on the GL version.    if (nullptr == GetString || nullptr == GetIntegerv) {        return nullptr;    }    const char* versionString = (const char*) GetString(GR_GL_VERSION);    GrGLVersion glVer = GrGLGetVersionFromString(versionString);    if (glVer < GR_GL_VER(1,5) || GR_GL_INVALID_VER == glVer) {        // We must have array and element_array buffer objects.        return nullptr;    }    GrEGLQueryStringProc queryString;    GrEGLDisplay display;    get_egl_query_and_display(&queryString, &display, ctx, get);    GrGLExtensions extensions;    if (!extensions.init(kGL_GrGLStandard, GetString, GetStringi, GetIntegerv, queryString,                         display)) {        return nullptr;    }    GrGLInterface* interface = new GrGLInterface();    GrGLInterface::Functions* functions = &interface->fFunctions;    GET_PROC(ActiveTexture);    GET_PROC(AttachShader);    GET_PROC(BindAttribLocation);    GET_PROC(BindBuffer);    if (glVer >= GR_GL_VER(3,0)) {        GET_PROC(BindFragDataLocation);    }    GET_PROC(BeginQuery);    GET_PROC(BindTexture);    if (extensions.has("GL_KHR_blend_equation_advanced")) {        GET_PROC_SUFFIX(BlendBarrier, KHR);    } else if (extensions.has("GL_NV_blend_equation_advanced")) {        GET_PROC_SUFFIX(BlendBarrier, NV);    }    if (glVer >= GR_GL_VER(1,4) ||        extensions.has("GL_ARB_imaging")) {        GET_PROC(BlendColor);    } else if (extensions.has("GL_EXT_blend_color")) {        GET_PROC_SUFFIX(BlendColor, EXT);    }    if (glVer >= GR_GL_VER(1,4) ||        extensions.has("GL_ARB_imaging")) {        GET_PROC(BlendEquation);    } else if (extensions.has("GL_EXT_blend_subtract")) {        GET_PROC_SUFFIX(BlendEquation, EXT);    }    GET_PROC(BlendFunc);    GET_PROC(BufferData);    GET_PROC(BufferSubData);    GET_PROC(Clear);    GET_PROC(ClearColor);    GET_PROC(ClearStencil);    GET_PROC(ColorMask);    GET_PROC(CompileShader);    GET_PROC(CompressedTexImage2D);    GET_PROC(CompressedTexSubImage2D);    GET_PROC(CopyTexSubImage2D);    GET_PROC(CreateProgram);    GET_PROC(CreateShader);    GET_PROC(CullFace);    GET_PROC(DeleteBuffers);    GET_PROC(DeleteProgram);    GET_PROC(DeleteQueries);    GET_PROC(DeleteShader);    GET_PROC(DeleteTextures);    GET_PROC(DepthMask);    GET_PROC(Disable);    GET_PROC(DisableVertexAttribArray);    GET_PROC(DrawArrays);    GET_PROC(DrawBuffer);    GET_PROC(DrawBuffers);    GET_PROC(DrawElements);    if (glVer >= GR_GL_VER(3,1) || extensions.has("GL_ARB_draw_instanced") ||        extensions.has("GL_EXT_draw_instanced")) {        GET_PROC(DrawArraysInstanced);        GET_PROC(DrawElementsInstanced);    }    if (glVer >= GR_GL_VER(4,0)) {        // We don't use ARB_draw_indirect because it does not support a base instance.        GET_PROC(DrawArraysIndirect);        GET_PROC(DrawElementsIndirect);    }    GET_PROC(Enable);//.........这里部分代码省略.........

//.........这里部分代码省略.........            NULL == fDeleteFramebuffers ||            NULL == fDeleteRenderbuffers ||            NULL == fFinish ||            NULL == fFlush ||            NULL == fFramebufferRenderbuffer ||            NULL == fFramebufferTexture2D ||            NULL == fGetFramebufferAttachmentParameteriv ||            NULL == fGetRenderbufferParameteriv ||            NULL == fGenFramebuffers ||            NULL == fGenRenderbuffers ||            NULL == fRenderbufferStorage) {        return false;    }    const char* ext;    GrGLVersion glVer = GrGLGetVersion(this);    ext = (const char*)fGetString(GR_GL_EXTENSIONS);    // Now check that baseline ES/Desktop fns not covered above are present    // and that we have fn pointers for any advertised extensions that we will    // try to use.    // these functions are part of ES2, we assume they are available    // On the desktop we assume they are available if the extension    // is present or GL version is high enough.    if (kES2_GrGLBinding == binding) {        if (NULL == fBlendColor ||                NULL == fStencilFuncSeparate ||                NULL == fStencilMaskSeparate ||                NULL == fStencilOpSeparate) {            return false;        }    } else if (kDesktop_GrGLBinding == binding) {        if (glVer >= GR_GL_VER(2,0)) {            if (NULL == fStencilFuncSeparate ||                    NULL == fStencilMaskSeparate ||                    NULL == fStencilOpSeparate) {                return false;            }        }        if (glVer >= GR_GL_VER(3,0) && NULL == fBindFragDataLocation) {            return false;        }        if (glVer >= GR_GL_VER(2,0) ||                GrGLHasExtensionFromString("GL_ARB_draw_buffers", ext)) {            if (NULL == fDrawBuffers) {                return false;            }        }        if (glVer >= GR_GL_VER(1,4) ||                GrGLHasExtensionFromString("GL_EXT_blend_color", ext)) {            if (NULL == fBlendColor) {                return false;            }        }        if (glVer >= GR_GL_VER(1,5) ||                GrGLHasExtensionFromString("GL_ARB_occlusion_query", ext)) {            if (NULL == fGenQueries ||                    NULL == fDeleteQueries ||                    NULL == fBeginQuery ||                    NULL == fEndQuery ||                    NULL == fGetQueryiv ||                    NULL == fGetQueryObjectiv ||                    NULL == fGetQueryObjectuiv) {                return false;            }

const GrGLInterface* GrGLAssembleGLESInterface(void* ctx, GrGLGetProc get) {    GET_PROC_LOCAL(GetString);    if (nullptr == GetString) {        return nullptr;    }    const char* verStr = reinterpret_cast<const char*>(GetString(GR_GL_VERSION));    GrGLVersion version = GrGLGetVersionFromString(verStr);    if (version < GR_GL_VER(2,0)) {        return nullptr;    }    GET_PROC_LOCAL(GetIntegerv);    GET_PROC_LOCAL(GetStringi);    GrEGLQueryStringProc queryString;    GrEGLDisplay display;    get_egl_query_and_display(&queryString, &display, ctx, get);    GrGLExtensions extensions;    if (!extensions.init(kGLES_GrGLStandard, GetString, GetStringi, GetIntegerv, queryString,                         display)) {        return nullptr;    }    GrGLInterface* interface = new GrGLInterface;    GrGLInterface::Functions* functions = &interface->fFunctions;    GET_PROC(ActiveTexture);    GET_PROC(AttachShader);    GET_PROC(BindAttribLocation);    GET_PROC(BindBuffer);    GET_PROC(BindTexture);    GET_PROC_SUFFIX(BindVertexArray, OES);    if (version >= GR_GL_VER(3,0) && extensions.has("GL_EXT_blend_func_extended")) {        GET_PROC_SUFFIX(BindFragDataLocation, EXT);        GET_PROC_SUFFIX(BindFragDataLocationIndexed, EXT);    }    if (extensions.has("GL_KHR_blend_equation_advanced")) {        GET_PROC_SUFFIX(BlendBarrier, KHR);    } else if (extensions.has("GL_NV_blend_equation_advanced")) {        GET_PROC_SUFFIX(BlendBarrier, NV);    }    GET_PROC(BlendColor);    GET_PROC(BlendEquation);    GET_PROC(BlendFunc);    GET_PROC(BufferData);    GET_PROC(BufferSubData);    GET_PROC(Clear);    GET_PROC(ClearColor);    GET_PROC(ClearStencil);    GET_PROC(ColorMask);    GET_PROC(CompileShader);    GET_PROC(CompressedTexImage2D);    GET_PROC(CompressedTexSubImage2D);    GET_PROC(CopyTexSubImage2D);    GET_PROC(CreateProgram);    GET_PROC(CreateShader);    GET_PROC(CullFace);    GET_PROC(DeleteBuffers);    GET_PROC(DeleteProgram);    GET_PROC(DeleteShader);    GET_PROC(DeleteTextures);    GET_PROC_SUFFIX(DeleteVertexArrays, OES);    GET_PROC(DepthMask);    GET_PROC(Disable);    GET_PROC(DisableVertexAttribArray);    GET_PROC(DrawArrays);    if (version >= GR_GL_VER(3,0)) {        GET_PROC(DrawArraysInstanced);        GET_PROC(DrawElementsInstanced);    } else if (extensions.has("GL_EXT_draw_instanced")) {        GET_PROC_SUFFIX(DrawArraysInstanced, EXT);        GET_PROC_SUFFIX(DrawElementsInstanced, EXT);    }    if (version >= GR_GL_VER(3,1)) {        GET_PROC(DrawArraysIndirect);        GET_PROC(DrawElementsIndirect);    }    GET_PROC(DrawElements);    GET_PROC(Enable);    GET_PROC(EnableVertexAttribArray);    GET_PROC(Finish);    GET_PROC(Flush);    GET_PROC(FrontFace);    GET_PROC(GenBuffers);    GET_PROC(GenerateMipmap);    GET_PROC(GenTextures);    GET_PROC_SUFFIX(GenVertexArrays, OES);    GET_PROC(GetBufferParameteriv);    GET_PROC(GetError);    GET_PROC(GetIntegerv);    GET_PROC(GetProgramInfoLog);    GET_PROC(GetProgramiv);    GET_PROC(GetShaderInfoLog);//.........这里部分代码省略.........

bool SkGLContextHelper::init(int width, int height) {    if (fGL) {        fGL->unref();        this->destroyGLContext();    }    fGL = this->createGLContext();    if (fGL) {        const GrGLubyte* temp;        GrGLBinding bindingInUse = GrGLGetBindingInUse(this->gl());        if (!fGL->validate(bindingInUse) || !fExtensions.init(bindingInUse, fGL)) {            fGL = NULL;            this->destroyGLContext();            return false;        }        SK_GL_RET(*this, temp, GetString(GR_GL_VERSION));        const char* versionStr = reinterpret_cast<const char*>(temp);        GrGLVersion version = GrGLGetVersionFromString(versionStr);        // clear any existing GL erorrs        GrGLenum error;        do {            SK_GL_RET(*this, error, GetError());        } while (GR_GL_NO_ERROR != error);        SK_GL(*this, GenFramebuffers(1, &fFBO));        SK_GL(*this, BindFramebuffer(GR_GL_FRAMEBUFFER, fFBO));        SK_GL(*this, GenRenderbuffers(1, &fColorBufferID));        SK_GL(*this, BindRenderbuffer(GR_GL_RENDERBUFFER, fColorBufferID));        if (kES_GrGLBinding == bindingInUse) {            SK_GL(*this, RenderbufferStorage(GR_GL_RENDERBUFFER,                                             GR_GL_RGBA8,                                             width, height));        } else {            SK_GL(*this, RenderbufferStorage(GR_GL_RENDERBUFFER,                                             GR_GL_RGBA,                                             width, height));        }        SK_GL(*this, FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,                                             GR_GL_COLOR_ATTACHMENT0,                                             GR_GL_RENDERBUFFER,                                             fColorBufferID));        SK_GL(*this, GenRenderbuffers(1, &fDepthStencilBufferID));        SK_GL(*this, BindRenderbuffer(GR_GL_RENDERBUFFER, fDepthStencilBufferID));        // Some drivers that support packed depth stencil will only succeed        // in binding a packed format an FBO. However, we can't rely on packed        // depth stencil being available.        bool supportsPackedDepthStencil;        if (kES_GrGLBinding == bindingInUse) {            supportsPackedDepthStencil = version >= GR_GL_VER(3,0) ||                                         this->hasExtension("GL_OES_packed_depth_stencil");        } else {            supportsPackedDepthStencil = version >= GR_GL_VER(3,0) ||                                         this->hasExtension("GL_EXT_packed_depth_stencil") ||                                         this->hasExtension("GL_ARB_framebuffer_object");        }        if (supportsPackedDepthStencil) {            // ES2 requires sized internal formats for RenderbufferStorage            // On Desktop we let the driver decide.            GrGLenum format = kES_GrGLBinding == bindingInUse ?                                    GR_GL_DEPTH24_STENCIL8 :                                    GR_GL_DEPTH_STENCIL;            SK_GL(*this, RenderbufferStorage(GR_GL_RENDERBUFFER,                                             format,                                             width, height));            SK_GL(*this, FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,                                                 GR_GL_DEPTH_ATTACHMENT,                                                 GR_GL_RENDERBUFFER,                                                 fDepthStencilBufferID));        } else {            GrGLenum format = kES_GrGLBinding == bindingInUse ?                                    GR_GL_STENCIL_INDEX8 :                                    GR_GL_STENCIL_INDEX;            SK_GL(*this, RenderbufferStorage(GR_GL_RENDERBUFFER,                                             format,                                             width, height));        }        SK_GL(*this, FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,                                             GR_GL_STENCIL_ATTACHMENT,                                             GR_GL_RENDERBUFFER,                                             fDepthStencilBufferID));        SK_GL(*this, Viewport(0, 0, width, height));        SK_GL(*this, ClearStencil(0));        SK_GL(*this, Clear(GR_GL_STENCIL_BUFFER_BIT));        SK_GL_RET(*this, error, GetError());        GrGLenum status;        SK_GL_RET(*this, status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER));        if (GR_GL_FRAMEBUFFER_COMPLETE != status ||            GR_GL_NO_ERROR != error) {            fFBO = 0;            fColorBufferID = 0;            fDepthStencilBufferID = 0;            fGL->unref();//.........这里部分代码省略.........

void GrGLCaps::init(const GrGLContextInfo& ctxInfo) {    this->reset();    if (!ctxInfo.isInitialized()) {        return;    }    const GrGLInterface* gli = ctxInfo.interface();    GrGLBinding binding = ctxInfo.binding();    GrGLVersion version = ctxInfo.version();    if (kES2_GrGLBinding == binding) {        GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS,                          &fMaxFragmentUniformVectors);    } else {        GrAssert(kDesktop_GrGLBinding == binding);        GrGLint max;        GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &max);        fMaxFragmentUniformVectors = max / 4;    }    if (kDesktop_GrGLBinding == binding) {        fRGBA8RenderbufferSupport = true;    } else {        fRGBA8RenderbufferSupport = ctxInfo.hasExtension("GL_OES_rgb8_rgba8") ||                                    ctxInfo.hasExtension("GL_ARM_rgba8");    }    if (kDesktop_GrGLBinding == binding) {        fBGRAFormatSupport = version >= GR_GL_VER(1,2) ||                             ctxInfo.hasExtension("GL_EXT_bgra");    } else {        bool hasBGRAExt = false;        if (ctxInfo.hasExtension("GL_APPLE_texture_format_BGRA8888")) {            fBGRAFormatSupport = true;        } else if (ctxInfo.hasExtension("GL_EXT_texture_format_BGRA8888")) {            fBGRAFormatSupport = true;            fBGRAIsInternalFormat = true;        }        GrAssert(fBGRAFormatSupport ||                 kSkia8888_PM_GrPixelConfig != kBGRA_8888_PM_GrPixelConfig);    }    if (kDesktop_GrGLBinding == binding) {        fTextureSwizzleSupport = version >= GR_GL_VER(3,3) ||                                 ctxInfo.hasExtension("GL_ARB_texture_swizzle");    } else {        fTextureSwizzleSupport = false;    }    if (kDesktop_GrGLBinding == binding) {        fUnpackRowLengthSupport = true;        fUnpackFlipYSupport = false;        fPackRowLengthSupport = true;        fPackFlipYSupport = false;    } else {        fUnpackRowLengthSupport =ctxInfo.hasExtension("GL_EXT_unpack_subimage");        fUnpackFlipYSupport = ctxInfo.hasExtension("GL_CHROMIUM_flipy");        // no extension for pack row length        fPackRowLengthSupport = false;        fPackFlipYSupport =            ctxInfo.hasExtension("GL_ANGLE_pack_reverse_row_order");    }    fTextureUsageSupport = (kES2_GrGLBinding == binding) &&                            ctxInfo.hasExtension("GL_ANGLE_texture_usage");    // Tex storage is in desktop 4.2 and can be an extension to desktop or ES.    fTexStorageSupport = (kDesktop_GrGLBinding == binding &&                          version >= GR_GL_VER(4,2)) ||                         ctxInfo.hasExtension("GL_ARB_texture_storage") ||                         ctxInfo.hasExtension("GL_EXT_texture_storage");    // ARB_texture_rg is part of OpenGL 3.0    if (kDesktop_GrGLBinding == binding) {        fTextureRedSupport = version >= GR_GL_VER(3,0) ||                             ctxInfo.hasExtension("GL_ARB_texture_rg");    } else {        fTextureRedSupport = ctxInfo.hasExtension("GL_ARB_texture_rg");    }    this->initFSAASupport(ctxInfo);    this->initStencilFormats(ctxInfo);}

//.........这里部分代码省略.........            }            break;        case kOpenGL_Fixed_GrEngine:            if (kES1_GrGLBinding == fBindingsExported) {                return false;            }            if (!this->validateFixedFunctions()) {                return false;            }            break;        default:            return false;    }    const char* ext;    GrGLVersion glVer = GrGLGetVersion(this);    ext = (const char*)fGetString(GR_GL_EXTENSIONS);    // Now check that baseline ES/Desktop fns not covered above are present    // and that we have fn pointers for any advertised extensions that we will    // try to use.    // these functions are part of ES2, we assume they are available    // On the desktop we assume they are available if the extension    // is present or GL version is high enough.    if ((kES2_GrGLBinding & fBindingsExported)) {        if (NULL == fBlendColor ||            NULL == fStencilFuncSeparate ||            NULL == fStencilMaskSeparate ||            NULL == fStencilOpSeparate) {            return false;        }    } else if (kDesktop_GrGLBinding == fBindingsExported) {        if (glVer >= GR_GL_VER(2,0)) {            if (NULL == fStencilFuncSeparate ||                NULL == fStencilMaskSeparate ||                NULL == fStencilOpSeparate) {                return false;            }        }        if (glVer >= GR_GL_VER(3,0) && NULL == fBindFragDataLocation) {            return false;        }        if (glVer >= GR_GL_VER(2,0) ||            GrGLHasExtensionFromString("GL_ARB_draw_buffers", ext)) {            if (NULL == fDrawBuffers) {                return false;            }        }        if (glVer >= GR_GL_VER(1,4) ||            GrGLHasExtensionFromString("GL_EXT_blend_color", ext)) {            if (NULL == fBlendColor) {                return false;            }        }    }    // optional function on desktop before 1.3    if (kDesktop_GrGLBinding != fBindingsExported ||        (glVer >= GR_GL_VER(1,3) ||        GrGLHasExtensionFromString("GL_ARB_texture_compression", ext))) {        if (NULL == fCompressedTexImage2D) {            return false;        }    }