diff options
Diffstat (limited to 'gpu')
33 files changed, 583 insertions, 1477 deletions
diff --git a/gpu/GrGpu.h b/gpu/GrGpu.h index bac92885..c051f912 100644 --- a/gpu/GrGpu.h +++ b/gpu/GrGpu.h @@ -323,7 +323,6 @@ public: void getPathStencilSettingsForFillType(SkPath::FillType fill, GrStencilSettings* outStencilSettings); -protected: enum DrawType { kDrawPoints_DrawType, kDrawLines_DrawType, @@ -333,6 +332,7 @@ protected: kDrawPaths_DrawType, }; +protected: DrawType PrimTypeToDrawType(GrPrimitiveType type) { switch (type) { case kTriangles_GrPrimitiveType: diff --git a/gpu/SkGpuDevice.cpp b/gpu/SkGpuDevice.cpp index 58dd030a..4af16109 100644 --- a/gpu/SkGpuDevice.cpp +++ b/gpu/SkGpuDevice.cpp @@ -239,7 +239,7 @@ SkGpuDevice* SkGpuDevice::Create(GrContext* context, const SkImageInfo& origInfo desc.fFlags = kRenderTarget_GrTextureFlagBit; desc.fWidth = info.width(); desc.fHeight = info.height(); - desc.fConfig = SkImageInfo2GrPixelConfig(info.colorType(), info.alphaType()); + desc.fConfig = SkImageInfo2GrPixelConfig(info); desc.fSampleCnt = sampleCount; SkAutoTUnref<GrTexture> texture(context->createUncachedTexture(desc, NULL, 0)); @@ -286,7 +286,7 @@ bool SkGpuDevice::onReadPixels(const SkImageInfo& dstInfo, void* dstPixels, size DO_DEFERRED_CLEAR(); // TODO: teach fRenderTarget to take ImageInfo directly to specify the src pixels - GrPixelConfig config = SkImageInfo2GrPixelConfig(dstInfo.colorType(), dstInfo.alphaType()); + GrPixelConfig config = SkImageInfo2GrPixelConfig(dstInfo); if (kUnknown_GrPixelConfig == config) { return false; } @@ -302,7 +302,7 @@ bool SkGpuDevice::onReadPixels(const SkImageInfo& dstInfo, void* dstPixels, size bool SkGpuDevice::onWritePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes, int x, int y) { // TODO: teach fRenderTarget to take ImageInfo directly to specify the src pixels - GrPixelConfig config = SkImageInfo2GrPixelConfig(info.colorType(), info.alphaType()); + GrPixelConfig config = SkImageInfo2GrPixelConfig(info); if (kUnknown_GrPixelConfig == config) { return false; } @@ -1202,8 +1202,7 @@ void SkGpuDevice::drawBitmapCommon(const SkDraw& draw, SkPaint paintWithShader(paint); paintWithShader.setShader(SkShader::CreateBitmapShader(*bitmapPtr, - SkShader::kClamp_TileMode, SkShader::kClamp_TileMode))->unref(); - paintWithShader.getShader()->setLocalMatrix(localM); + SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &localM))->unref(); SkRect dstRect = {0, 0, dstSize.fWidth, dstSize.fHeight}; this->drawRect(draw, dstRect, paintWithShader); diff --git a/gpu/SkGr.cpp b/gpu/SkGr.cpp index 754a7be9..2596e966 100644 --- a/gpu/SkGr.cpp +++ b/gpu/SkGr.cpp @@ -97,7 +97,7 @@ static void generate_bitmap_texture_desc(const SkBitmap& bitmap, GrTextureDesc* desc->fFlags = kNone_GrTextureFlags; desc->fWidth = bitmap.width(); desc->fHeight = bitmap.height(); - desc->fConfig = SkBitmapConfig2GrPixelConfig(bitmap.config()); + desc->fConfig = SkImageInfo2GrPixelConfig(bitmap.info()); desc->fSampleCnt = 0; } @@ -169,7 +169,7 @@ static GrTexture* sk_gr_create_bitmap_texture(GrContext* ctx, origBitmap.copyTo(&tmpBitmap, kN32_SkColorType); // now bitmap points to our temp, which has been promoted to 32bits bitmap = &tmpBitmap; - desc.fConfig = SkBitmapConfig2GrPixelConfig(bitmap->config()); + desc.fConfig = SkImageInfo2GrPixelConfig(bitmap->info()); } } diff --git a/gpu/effects/GrTextureStripAtlas.cpp b/gpu/effects/GrTextureStripAtlas.cpp index 877215ec..0aa9dc35 100644 --- a/gpu/effects/GrTextureStripAtlas.cpp +++ b/gpu/effects/GrTextureStripAtlas.cpp @@ -158,7 +158,7 @@ int GrTextureStripAtlas::lockRow(const SkBitmap& data) { fDesc.fContext->writeTexturePixels(fTexture, 0, rowNumber * fDesc.fRowHeight, fDesc.fWidth, fDesc.fRowHeight, - SkBitmapConfig2GrPixelConfig(data.config()), + SkImageInfo2GrPixelConfig(data.info()), data.getPixels(), data.rowBytes(), GrContext::kDontFlush_PixelOpsFlag); diff --git a/gpu/gl/GrGLAssembleInterface.cpp b/gpu/gl/GrGLAssembleInterface.cpp new file mode 100644 index 00000000..aed11e53 --- /dev/null +++ b/gpu/gl/GrGLAssembleInterface.cpp @@ -0,0 +1,289 @@ + +/* + * Copyright 2014 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + + +#include "GrGLAssembleInterface.h" +#include "GrGLUtil.h" + +#define GET_PROC(F) functions->f ## F = (GrGL ## F ## Proc) get(ctx, "gl" #F) +#define GET_PROC_SUFFIX(F, S) functions->f ## F = (GrGL ## F ## Proc) get(ctx, "gl" #F #S) +#define GET_PROC_LOCAL(F) GrGL ## F ## Proc F = (GrGL ## F ## Proc) get(ctx, "gl" #F) + +const GrGLInterface* GrGLAssembleGLInterface(void* ctx, GrGLGetProc get) { + GET_PROC_LOCAL(GetString); + GET_PROC_LOCAL(GetStringi); + GET_PROC_LOCAL(GetIntegerv); + + // GetStringi may be NULL depending on the GL version. + if (NULL == GetString || NULL == GetIntegerv) { + return NULL; + } + + 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 NULL; + } + + GrGLExtensions extensions; + if (!extensions.init(kGL_GrGLStandard, GetString, GetStringi, GetIntegerv)) { + return NULL; + } + + GrGLInterface* interface = SkNEW(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); + GET_PROC(BlendFunc); + + if (glVer >= GR_GL_VER(1,4) || + extensions.has("GL_ARB_imaging") || + extensions.has("GL_EXT_blend_color")) { + GET_PROC(BlendColor); + } + + 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(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); + GET_PROC(Enable); + GET_PROC(EnableVertexAttribArray); + GET_PROC(EndQuery); + GET_PROC(Finish); + GET_PROC(Flush); + GET_PROC(FrontFace); + GET_PROC(GenBuffers); + GET_PROC(GenerateMipmap); + GET_PROC(GetBufferParameteriv); + GET_PROC(GetError); + GET_PROC(GetIntegerv); + GET_PROC(GetQueryObjectiv); + GET_PROC(GetQueryObjectuiv); + if (glVer >= GR_GL_VER(3,3) || extensions.has("GL_ARB_timer_query")) { + GET_PROC(GetQueryObjecti64v); + GET_PROC(GetQueryObjectui64v); + GET_PROC(QueryCounter); + } else if (extensions.has("GL_EXT_timer_query")) { + GET_PROC_SUFFIX(GetQueryObjecti64v, EXT); + GET_PROC_SUFFIX(GetQueryObjectui64v, EXT); + } + GET_PROC(GetQueryiv); + GET_PROC(GetProgramInfoLog); + GET_PROC(GetProgramiv); + GET_PROC(GetShaderInfoLog); + GET_PROC(GetShaderiv); + GET_PROC(GetString); + GET_PROC(GetStringi); + GET_PROC(GetTexLevelParameteriv); + GET_PROC(GenQueries); + GET_PROC(GenTextures); + GET_PROC(GetUniformLocation); + GET_PROC(LineWidth); + GET_PROC(LinkProgram); + GET_PROC(MapBuffer); + if (extensions.has("GL_EXT_direct_state_access")) { + GET_PROC_SUFFIX(MatrixLoadf, EXT); + GET_PROC_SUFFIX(MatrixLoadIdentity, EXT); + } + GET_PROC(PixelStorei); + GET_PROC(ReadBuffer); + GET_PROC(ReadPixels); + GET_PROC(Scissor); + GET_PROC(ShaderSource); + GET_PROC(StencilFunc); + GET_PROC(StencilFuncSeparate); + GET_PROC(StencilMask); + GET_PROC(StencilMaskSeparate); + GET_PROC(StencilOp); + GET_PROC(StencilOpSeparate); + GET_PROC(TexImage2D); + GET_PROC(TexParameteri); + GET_PROC(TexParameteriv); + if (glVer >= GR_GL_VER(4,2) || extensions.has("GL_ARB_texture_storage")) { + GET_PROC(TexStorage2D); + } else if (extensions.has("GL_EXT_texture_storage")) { + GET_PROC_SUFFIX(TexStorage2D, EXT); + } + GET_PROC(TexSubImage2D); + GET_PROC(Uniform1f); + GET_PROC(Uniform1i); + GET_PROC(Uniform1fv); + GET_PROC(Uniform1iv); + GET_PROC(Uniform2f); + GET_PROC(Uniform2i); + GET_PROC(Uniform2fv); + GET_PROC(Uniform2iv); + GET_PROC(Uniform3f); + GET_PROC(Uniform3i); + GET_PROC(Uniform3fv); + GET_PROC(Uniform3iv); + GET_PROC(Uniform4f); + GET_PROC(Uniform4i); + GET_PROC(Uniform4fv); + GET_PROC(Uniform4iv); + GET_PROC(UniformMatrix2fv); + GET_PROC(UniformMatrix3fv); + GET_PROC(UniformMatrix4fv); + GET_PROC(UnmapBuffer); + GET_PROC(UseProgram); + GET_PROC(VertexAttrib4fv); + GET_PROC(VertexAttribPointer); + GET_PROC(Viewport); + GET_PROC(BindFragDataLocationIndexed); + + if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_vertex_array_object")) { + // no ARB suffix for GL_ARB_vertex_array_object + GET_PROC(BindVertexArray); + GET_PROC(GenVertexArrays); + GET_PROC(DeleteVertexArrays); + } + + // First look for GL3.0 FBO or GL_ARB_framebuffer_object (same since + // GL_ARB_framebuffer_object doesn't use ARB suffix.) + if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_framebuffer_object")) { + GET_PROC(GenFramebuffers); + GET_PROC(GetFramebufferAttachmentParameteriv); + GET_PROC(GetRenderbufferParameteriv); + GET_PROC(BindFramebuffer); + GET_PROC(FramebufferTexture2D); + GET_PROC(CheckFramebufferStatus); + GET_PROC(DeleteFramebuffers); + GET_PROC(RenderbufferStorage); + GET_PROC(GenRenderbuffers); + GET_PROC(DeleteRenderbuffers); + GET_PROC(FramebufferRenderbuffer); + GET_PROC(BindRenderbuffer); + GET_PROC(RenderbufferStorageMultisample); + GET_PROC(BlitFramebuffer); + } else if (extensions.has("GL_EXT_framebuffer_object")) { + GET_PROC_SUFFIX(GenFramebuffers, EXT); + GET_PROC_SUFFIX(GetFramebufferAttachmentParameteriv, EXT); + GET_PROC_SUFFIX(GetRenderbufferParameteriv, EXT); + GET_PROC_SUFFIX(BindFramebuffer, EXT); + GET_PROC_SUFFIX(FramebufferTexture2D, EXT); + GET_PROC_SUFFIX(CheckFramebufferStatus, EXT); + GET_PROC_SUFFIX(DeleteFramebuffers, EXT); + GET_PROC_SUFFIX(RenderbufferStorage, EXT); + GET_PROC_SUFFIX(GenRenderbuffers, EXT); + GET_PROC_SUFFIX(DeleteRenderbuffers, EXT); + GET_PROC_SUFFIX(FramebufferRenderbuffer, EXT); + GET_PROC_SUFFIX(BindRenderbuffer, EXT); + if (extensions.has("GL_EXT_framebuffer_multisample")) { + GET_PROC_SUFFIX(RenderbufferStorageMultisample, EXT); + } + if (extensions.has("GL_EXT_framebuffer_blit")) { + GET_PROC_SUFFIX(BlitFramebuffer, EXT); + } + } else { + // we must have FBOs + delete interface; + return NULL; + } + + if (extensions.has("GL_NV_path_rendering")) { + GET_PROC_SUFFIX(PathCommands, NV); + GET_PROC_SUFFIX(PathCoords, NV); + GET_PROC_SUFFIX(PathSubCommands, NV); + GET_PROC_SUFFIX(PathSubCoords, NV); + GET_PROC_SUFFIX(PathString, NV); + GET_PROC_SUFFIX(PathGlyphs, NV); + GET_PROC_SUFFIX(PathGlyphRange, NV); + GET_PROC_SUFFIX(WeightPaths, NV); + GET_PROC_SUFFIX(CopyPath, NV); + GET_PROC_SUFFIX(InterpolatePaths, NV); + GET_PROC_SUFFIX(TransformPath, NV); + GET_PROC_SUFFIX(PathParameteriv, NV); + GET_PROC_SUFFIX(PathParameteri, NV); + GET_PROC_SUFFIX(PathParameterfv, NV); + GET_PROC_SUFFIX(PathParameterf, NV); + GET_PROC_SUFFIX(PathDashArray, NV); + GET_PROC_SUFFIX(GenPaths, NV); + GET_PROC_SUFFIX(DeletePaths, NV); + GET_PROC_SUFFIX(IsPath, NV); + GET_PROC_SUFFIX(PathStencilFunc, NV); + GET_PROC_SUFFIX(PathStencilDepthOffset, NV); + GET_PROC_SUFFIX(StencilFillPath, NV); + GET_PROC_SUFFIX(StencilStrokePath, NV); + GET_PROC_SUFFIX(StencilFillPathInstanced, NV); + GET_PROC_SUFFIX(StencilStrokePathInstanced, NV); + GET_PROC_SUFFIX(PathCoverDepthFunc, NV); + GET_PROC_SUFFIX(PathColorGen, NV); + GET_PROC_SUFFIX(PathTexGen, NV); + GET_PROC_SUFFIX(PathFogGen, NV); + GET_PROC_SUFFIX(CoverFillPath, NV); + GET_PROC_SUFFIX(CoverStrokePath, NV); + GET_PROC_SUFFIX(CoverFillPathInstanced, NV); + GET_PROC_SUFFIX(CoverStrokePathInstanced, NV); + GET_PROC_SUFFIX(GetPathParameteriv, NV); + GET_PROC_SUFFIX(GetPathParameterfv, NV); + GET_PROC_SUFFIX(GetPathCommands, NV); + GET_PROC_SUFFIX(GetPathCoords, NV); + GET_PROC_SUFFIX(GetPathDashArray, NV); + GET_PROC_SUFFIX(GetPathMetrics, NV); + GET_PROC_SUFFIX(GetPathMetricRange, NV); + GET_PROC_SUFFIX(GetPathSpacing, NV); + GET_PROC_SUFFIX(GetPathColorGeniv, NV); + GET_PROC_SUFFIX(GetPathColorGenfv, NV); + GET_PROC_SUFFIX(GetPathTexGeniv, NV); + GET_PROC_SUFFIX(GetPathTexGenfv, NV); + GET_PROC_SUFFIX(IsPointInFillPath, NV); + GET_PROC_SUFFIX(IsPointInStrokePath, NV); + GET_PROC_SUFFIX(GetPathLength, NV); + GET_PROC_SUFFIX(PointAlongPath, NV); + } + + if (extensions.has("GL_EXT_debug_marker")) { + GET_PROC_SUFFIX(InsertEventMarker, EXT); + GET_PROC_SUFFIX(PushGroupMarker, EXT); + GET_PROC_SUFFIX(PopGroupMarker, EXT); + } + + if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_ARB_invalidate_subdata")) { + GET_PROC(InvalidateBufferData); + GET_PROC(InvalidateBufferSubData); + GET_PROC(InvalidateFramebuffer); + GET_PROC(InvalidateSubFramebuffer); + GET_PROC(InvalidateTexImage); + GET_PROC(InvalidateTexSubImage); + } + + interface->fStandard = kGL_GrGLStandard; + interface->fExtensions.swap(&extensions); + + return interface; +} diff --git a/gpu/gl/GrGLAssembleInterface.h b/gpu/gl/GrGLAssembleInterface.h new file mode 100644 index 00000000..36a45134 --- /dev/null +++ b/gpu/gl/GrGLAssembleInterface.h @@ -0,0 +1,18 @@ + +/* + * Copyright 2014 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#include "gl/GrGLInterface.h" + +typedef void(*GrGLFuncPtr)(); +typedef GrGLFuncPtr (*GrGLGetProc)(void* ctx, const char name[]); + +/** + * Generic function for creating a GrGLInterface for an OpenGL (but not GLES) context. It calls + * get() to get each function address. ctx is a generic ptr passed to and interpreted by get(). + */ +const GrGLInterface* GrGLAssembleGLInterface(void* ctx, GrGLGetProc get); diff --git a/gpu/gl/GrGLCaps.cpp b/gpu/gl/GrGLCaps.cpp index e20f932f..501411c0 100644 --- a/gpu/gl/GrGLCaps.cpp +++ b/gpu/gl/GrGLCaps.cpp @@ -45,7 +45,6 @@ void GrGLCaps::reset() { fVertexArrayObjectSupport = false; fUseNonVBOVertexAndIndexDynamicData = false; fIsCoreProfile = false; - fFixedFunctionSupport = false; fFullClearIsFree = false; fDropsTileOnZeroDivide = false; fMapSubSupport = false; @@ -84,7 +83,6 @@ GrGLCaps& GrGLCaps::operator= (const GrGLCaps& caps) { fVertexArrayObjectSupport = caps.fVertexArrayObjectSupport; fUseNonVBOVertexAndIndexDynamicData = caps.fUseNonVBOVertexAndIndexDynamicData; fIsCoreProfile = caps.fIsCoreProfile; - fFixedFunctionSupport = caps.fFixedFunctionSupport; fFullClearIsFree = caps.fFullClearIsFree; fDropsTileOnZeroDivide = caps.fDropsTileOnZeroDivide; fMapSubSupport = caps.fMapSubSupport; @@ -92,11 +90,11 @@ GrGLCaps& GrGLCaps::operator= (const GrGLCaps& caps) { return *this; } -void GrGLCaps::init(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) { +bool GrGLCaps::init(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) { this->reset(); if (!ctxInfo.isInitialized()) { - return; + return false; } GrGLStandard standard = ctxInfo.standard(); @@ -120,7 +118,6 @@ void GrGLCaps::init(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) { fIsCoreProfile = SkToBool(profileMask & GR_GL_CONTEXT_CORE_PROFILE_BIT); } if (!fIsCoreProfile) { - fFixedFunctionSupport = true; GR_GL_GetIntegerv(gli, GR_GL_MAX_TEXTURE_COORDS, &fMaxFixedFunctionTextureCoords); // Sanity check SkASSERT(fMaxFixedFunctionTextureCoords > 0 && fMaxFixedFunctionTextureCoords < 128); @@ -326,8 +323,8 @@ void GrGLCaps::init(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) { // attachment, hence this min: fMaxRenderTargetSize = SkTMin(fMaxTextureSize, fMaxRenderTargetSize); - fPathRenderingSupport = ctxInfo.hasExtension("GL_NV_path_rendering"); - SkASSERT(!fPathRenderingSupport || fFixedFunctionSupport); + fPathRenderingSupport = ctxInfo.hasExtension("GL_NV_path_rendering") && + ctxInfo.hasExtension("GL_EXT_direct_state_access"); fGpuTracingSupport = ctxInfo.hasExtension("GL_EXT_debug_marker"); @@ -356,6 +353,8 @@ void GrGLCaps::init(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) { } this->initConfigRenderableTable(ctxInfo); + + return true; } void GrGLCaps::initConfigRenderableTable(const GrGLContextInfo& ctxInfo) { @@ -657,13 +656,12 @@ SkString GrGLCaps::dump() const { GR_STATIC_ASSERT(SK_ARRAY_COUNT(kInvalidateFBTypeStr) == kLast_InvalidateFBType + 1); r.appendf("Core Profile: %s\n", (fIsCoreProfile ? "YES" : "NO")); - r.appendf("Fixed Function Support: %s\n", (fFixedFunctionSupport ? "YES" : "NO")); r.appendf("MSAA Type: %s\n", kMSFBOExtStr[fMSFBOType]); r.appendf("FB Fetch Type: %s\n", kFBFetchTypeStr[fFBFetchType]); r.appendf("Invalidate FB Type: %s\n", kInvalidateFBTypeStr[fInvalidateFBType]); r.appendf("Max FS Uniform Vectors: %d\n", fMaxFragmentUniformVectors); r.appendf("Max FS Texture Units: %d\n", fMaxFragmentTextureUnits); - if (fFixedFunctionSupport) { + if (!fIsCoreProfile) { r.appendf("Max Fixed Function Texture Coords: %d\n", fMaxFixedFunctionTextureCoords); } r.appendf("Max Vertex Attributes: %d\n", fMaxVertexAttributes); diff --git a/gpu/gl/GrGLCaps.h b/gpu/gl/GrGLCaps.h index 1ba21ec7..48925d48 100644 --- a/gpu/gl/GrGLCaps.h +++ b/gpu/gl/GrGLCaps.h @@ -105,7 +105,7 @@ public: * Initializes the GrGLCaps to the set of features supported in the current * OpenGL context accessible via ctxInfo. */ - void init(const GrGLContextInfo& ctxInfo, const GrGLInterface* interface); + bool init(const GrGLContextInfo& ctxInfo, const GrGLInterface* interface); /** * Call to note that a color config has been verified as a valid color @@ -253,7 +253,6 @@ public: bool isCoreProfile() const { return fIsCoreProfile; } - bool fixedFunctionSupport() const { return fFixedFunctionSupport; } bool fullClearIsFree() const { return fFullClearIsFree; } @@ -341,7 +340,6 @@ private: bool fVertexArrayObjectSupport : 1; bool fUseNonVBOVertexAndIndexDynamicData : 1; bool fIsCoreProfile : 1; - bool fFixedFunctionSupport : 1; bool fFullClearIsFree : 1; bool fDropsTileOnZeroDivide : 1; bool fMapSubSupport : 1; diff --git a/gpu/gl/GrGLContext.cpp b/gpu/gl/GrGLContext.cpp index 54deb323..5bc5b6f0 100644 --- a/gpu/gl/GrGLContext.cpp +++ b/gpu/gl/GrGLContext.cpp @@ -37,8 +37,13 @@ bool GrGLContextInfo::initialize(const GrGLInterface* interface) { if (interface->validate()) { fGLVersion = GrGLGetVersionFromString(ver); + if (GR_GL_INVALID_VER == fGLVersion) { + return false; + } - fGLSLGeneration = GrGetGLSLGeneration(interface); + if (!GrGetGLSLGeneration(interface, &fGLSLGeneration)) { + return false; + } fVendor = GrGLGetVendor(interface); @@ -51,9 +56,7 @@ bool GrGLContextInfo::initialize(const GrGLInterface* interface) { // This must occur before caps init. fInterface.reset(SkRef(interface)); - fGLCaps->init(*this, interface); - - return true; + return fGLCaps->init(*this, interface); } } return false; diff --git a/gpu/gl/GrGLCreateNullInterface.cpp b/gpu/gl/GrGLCreateNullInterface.cpp index 391aea27..18a9d726 100644 --- a/gpu/gl/GrGLCreateNullInterface.cpp +++ b/gpu/gl/GrGLCreateNullInterface.cpp @@ -327,11 +327,8 @@ const GrGLInterface* GrGLCreateNullInterface() { functions->fGetTexLevelParameteriv = noOpGLGetTexLevelParameteriv; functions->fGetUniformLocation = noOpGLGetUniformLocation; functions->fInsertEventMarker = noOpGLInsertEventMarker; - functions->fLoadIdentity = noOpGLLoadIdentity; - functions->fLoadMatrixf = noOpGLLoadMatrixf; functions->fLineWidth = noOpGLLineWidth; functions->fLinkProgram = noOpGLLinkProgram; - functions->fMatrixMode = noOpGLMatrixMode; functions->fPixelStorei = nullGLPixelStorei; functions->fPopGroupMarker = noOpGLPopGroupMarker; functions->fPushGroupMarker = noOpGLPushGroupMarker; @@ -346,8 +343,6 @@ const GrGLInterface* GrGLCreateNullInterface() { functions->fStencilMaskSeparate = noOpGLStencilMaskSeparate; functions->fStencilOp = noOpGLStencilOp; functions->fStencilOpSeparate = noOpGLStencilOpSeparate; - functions->fTexGenfv = noOpGLTexGenfv; - functions->fTexGeni = noOpGLTexGeni; functions->fTexImage2D = noOpGLTexImage2D; functions->fTexParameteri = noOpGLTexParameteri; functions->fTexParameteriv = noOpGLTexParameteriv; @@ -393,6 +388,8 @@ const GrGLInterface* GrGLCreateNullInterface() { functions->fBlitFramebuffer = noOpGLBlitFramebuffer; functions->fResolveMultisampleFramebuffer = noOpGLResolveMultisampleFramebuffer; functions->fMapBuffer = nullGLMapBuffer; + functions->fMatrixLoadf = noOpGLMatrixLoadf; + functions->fMatrixLoadIdentity = noOpGLMatrixLoadIdentity; functions->fUnmapBuffer = nullGLUnmapBuffer; functions->fBindFragDataLocationIndexed = noOpGLBindFragDataLocationIndexed; diff --git a/gpu/gl/GrGLExtensions.cpp b/gpu/gl/GrGLExtensions.cpp index 6d1b04d2..53013df6 100644 --- a/gpu/gl/GrGLExtensions.cpp +++ b/gpu/gl/GrGLExtensions.cpp @@ -54,10 +54,11 @@ bool GrGLExtensions::init(GrGLStandard standard, // glGetStringi and indexed extensions were added in version 3.0 of desktop GL and ES. const GrGLubyte* verString = getString(GR_GL_VERSION); - if (NULL == verString) { + GrGLVersion version = GrGLGetVersionFromString((const char*) verString); + if (GR_GL_INVALID_VER == version) { return false; } - GrGLVersion version = GrGLGetVersionFromString((const char*) verString); + bool indexed = version >= GR_GL_VER(3, 0); if (indexed) { diff --git a/gpu/gl/GrGLInterface.cpp b/gpu/gl/GrGLInterface.cpp index bfffdfb1..7efa067d 100644 --- a/gpu/gl/GrGLInterface.cpp +++ b/gpu/gl/GrGLInterface.cpp @@ -227,12 +227,8 @@ bool GrGLInterface::validate() const { } GrGLVersion glVer = GrGLGetVersion(this); - - bool isCoreProfile = false; - if (kGL_GrGLStandard == fStandard && glVer >= GR_GL_VER(3,2)) { - GrGLint profileMask; - GR_GL_GetIntegerv(this, GR_GL_CONTEXT_PROFILE_MASK, &profileMask); - isCoreProfile = SkToBool(profileMask & GR_GL_CONTEXT_CORE_PROFILE_BIT); + if (GR_GL_INVALID_VER == glVer) { + RETURN_FALSE_INTERFACE } // Now check that baseline ES/Desktop fns not covered above are present @@ -290,12 +286,9 @@ bool GrGLInterface::validate() const { RETURN_FALSE_INTERFACE } } - if (!isCoreProfile) { - if (NULL == fFunctions.fLoadIdentity || - NULL == fFunctions.fLoadMatrixf || - NULL == fFunctions.fMatrixMode || - NULL == fFunctions.fTexGenfv || - NULL == fFunctions.fTexGeni) { + if (fExtensions.has("GL_EXT_direct_state_access")) { + if (NULL == fFunctions.fMatrixLoadf || + NULL == fFunctions.fMatrixLoadIdentity) { RETURN_FALSE_INTERFACE } } diff --git a/gpu/gl/GrGLNoOpInterface.cpp b/gpu/gl/GrGLNoOpInterface.cpp index de38f6aa..2b84b280 100644 --- a/gpu/gl/GrGLNoOpInterface.cpp +++ b/gpu/gl/GrGLNoOpInterface.cpp @@ -164,13 +164,10 @@ GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLineWidth(GrGLfloat width) { GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLinkProgram(GrGLuint program) { } -GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLoadIdentity() { +GrGLvoid GR_GL_FUNCTION_TYPE noOpGLMatrixLoadf(GrGLenum, const GrGLfloat*) { } -GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLoadMatrixf(const GrGLfloat*) { -} - -GrGLvoid GR_GL_FUNCTION_TYPE noOpGLMatrixMode(GrGLenum) { +GrGLvoid GR_GL_FUNCTION_TYPE noOpGLMatrixLoadIdentity(GrGLenum) { } GrGLvoid GR_GL_FUNCTION_TYPE noOpGLQueryCounter(GrGLuint id, GrGLenum target) { @@ -219,15 +216,6 @@ GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilOpSeparate(GrGLenum face, GrGLenum zpass) { } -GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexGenf(GrGLenum, GrGLenum, float) { -} - -GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexGenfv(GrGLenum, GrGLenum, const float*) { -} - -GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexGeni(GrGLenum, GrGLenum, GrGLint) { -} - GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexImage2D(GrGLenum target, GrGLint level, GrGLint internalformat, diff --git a/gpu/gl/GrGLNoOpInterface.h b/gpu/gl/GrGLNoOpInterface.h index b5b681fe..2efc1138 100644 --- a/gpu/gl/GrGLNoOpInterface.h +++ b/gpu/gl/GrGLNoOpInterface.h @@ -96,16 +96,14 @@ GrGLvoid GR_GL_FUNCTION_TYPE noOpGLFlush(); GrGLvoid GR_GL_FUNCTION_TYPE noOpGLFrontFace(GrGLenum mode); -GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLoadIdentity(); +GrGLvoid GR_GL_FUNCTION_TYPE noOpGLMatrixLoadf(GrGLenum, const GrGLfloat*); -GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLoadMatrixf(const GrGLfloat*); +GrGLvoid GR_GL_FUNCTION_TYPE noOpGLMatrixLoadIdentity(GrGLenum); GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLineWidth(GrGLfloat width); GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLinkProgram(GrGLuint program); -GrGLvoid GR_GL_FUNCTION_TYPE noOpGLMatrixMode(GrGLenum); - GrGLvoid GR_GL_FUNCTION_TYPE noOpGLQueryCounter(GrGLuint id, GrGLenum target); @@ -165,12 +163,6 @@ GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexStorage2D(GrGLenum target, GrGLsizei width, GrGLsizei height); -GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexGenf(GrGLenum, GrGLenum, GrGLfloat); - -GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexGenfv(GrGLenum, GrGLenum, const GrGLfloat*); - -GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexGeni(GrGLenum, GrGLenum, GrGLint); - GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDiscardFramebuffer(GrGLenum target, GrGLsizei numAttachments, const GrGLenum* attachments); diff --git a/gpu/gl/GrGLProgram.cpp b/gpu/gl/GrGLProgram.cpp index 6e9878a9..9b997c85 100644 --- a/gpu/gl/GrGLProgram.cpp +++ b/gpu/gl/GrGLProgram.cpp @@ -229,10 +229,11 @@ void GrGLProgram::setData(GrDrawState::BlendOptFlags blendOpts, fCoverageEffects->setData(fGpu, fUniformManager, coverageStages); - // TexGen state applies to the the fixed function vertex shader. For custom shaders, it's - // ignored, so we don't need to change the texgen settings in that case. + // PathTexGen state applies to the the fixed function vertex shader. For + // custom shaders, it's ignored, so we don't need to change the texgen + // settings in that case. if (!fHasVertexShader) { - fGpu->flushTexGenSettings(fNumTexCoordSets); + fGpu->flushPathTexGenSettings(fNumTexCoordSets); } } diff --git a/gpu/gl/GrGLProgramDesc.cpp b/gpu/gl/GrGLProgramDesc.cpp index b6029fe4..4039eaf9 100644 --- a/gpu/gl/GrGLProgramDesc.cpp +++ b/gpu/gl/GrGLProgramDesc.cpp @@ -37,7 +37,7 @@ inline GrGLEffect::EffectKey get_key_and_update_stats(const GrEffectStage& stage } } void GrGLProgramDesc::Build(const GrDrawState& drawState, - bool isPoints, + GrGpu::DrawType drawType, GrDrawState::BlendOptFlags blendOpts, GrBlendCoeff srcCoeff, GrBlendCoeff dstCoeff, @@ -113,7 +113,10 @@ void GrGLProgramDesc::Build(const GrDrawState& drawState, int currEffectKey = 0; bool readsDst = false; bool readFragPosition = false; - bool hasVertexCode = false; + // We use vertexshader-less shader programs only when drawing paths. + bool hasVertexCode = !(GrGpu::kDrawPath_DrawType == drawType || + GrGpu::kDrawPaths_DrawType == drawType); + if (!skipColor) { for (int s = firstEffectiveColorStage; s < drawState.numColorStages(); ++s) { effectKeys[currEffectKey++] = @@ -132,7 +135,7 @@ void GrGLProgramDesc::Build(const GrDrawState& drawState, } header->fHasVertexCode = hasVertexCode || requiresLocalCoordAttrib; - header->fEmitsPointSize = isPoints; + header->fEmitsPointSize = GrGpu::kDrawPoints_DrawType == drawType; // Currently the experimental GS will only work with triangle prims (and it doesn't do anything // other than pass through values from the VS to the FS anyway). diff --git a/gpu/gl/GrGLProgramDesc.h b/gpu/gl/GrGLProgramDesc.h index 9116fdf6..9165f4eb 100644 --- a/gpu/gl/GrGLProgramDesc.h +++ b/gpu/gl/GrGLProgramDesc.h @@ -11,6 +11,7 @@ #include "GrGLEffect.h" #include "GrDrawState.h" #include "GrGLShaderBuilder.h" +#include "GrGpu.h" class GrGpuGL; @@ -64,7 +65,7 @@ public: * be treated as color stages in the output. */ static void Build(const GrDrawState&, - bool isPoints, + GrGpu::DrawType drawType, GrDrawState::BlendOptFlags, GrBlendCoeff srcCoeff, GrBlendCoeff dstCoeff, diff --git a/gpu/gl/GrGLProgramEffects.cpp b/gpu/gl/GrGLProgramEffects.cpp index 3bcf759b..1695a8e3 100644 --- a/gpu/gl/GrGLProgramEffects.cpp +++ b/gpu/gl/GrGLProgramEffects.cpp @@ -469,7 +469,7 @@ void GrGLVertexProgramEffectsBuilder::emitEffect(const GrEffectStage& stage, //////////////////////////////////////////////////////////////////////////////// -void GrGLTexGenProgramEffects::emitEffect(GrGLFragmentOnlyShaderBuilder* builder, +void GrGLPathTexGenProgramEffects::emitEffect(GrGLFragmentOnlyShaderBuilder* builder, const GrEffectStage& stage, EffectKey key, const char* outColor, @@ -481,7 +481,7 @@ void GrGLTexGenProgramEffects::emitEffect(GrGLFragmentOnlyShaderBuilder* builder SkSTArray<4, TextureSampler> samplers(effect->numTextures()); SkASSERT(0 == stage.getVertexAttribIndexCount()); - this->setupTexGen(builder, effect, key, &coords); + this->setupPathTexGen(builder, effect, key, &coords); this->emitSamplers(builder, effect, &samplers); GrGLEffect* glEffect = effect->getFactory().createGLInstance(drawEffect); @@ -498,7 +498,7 @@ void GrGLTexGenProgramEffects::emitEffect(GrGLFragmentOnlyShaderBuilder* builder builder->fsCodeAppend("\t}\n"); } -void GrGLTexGenProgramEffects::setupTexGen(GrGLFragmentOnlyShaderBuilder* builder, +void GrGLPathTexGenProgramEffects::setupPathTexGen(GrGLFragmentOnlyShaderBuilder* builder, const GrEffectRef& effect, EffectKey effectKey, TransformedCoordsArray* outCoords) { @@ -516,7 +516,7 @@ void GrGLTexGenProgramEffects::setupTexGen(GrGLFragmentOnlyShaderBuilder* builde } } -void GrGLTexGenProgramEffects::setData(GrGpuGL* gpu, +void GrGLPathTexGenProgramEffects::setData(GrGpuGL* gpu, const GrGLUniformManager& uniformManager, const GrEffectStage* effectStages[]) { int numEffects = fGLEffects.count(); @@ -525,12 +525,12 @@ void GrGLTexGenProgramEffects::setData(GrGpuGL* gpu, for (int e = 0; e < numEffects; ++e) { GrDrawEffect drawEffect(*effectStages[e], false); fGLEffects[e]->setData(uniformManager, drawEffect); - this->setTexGenState(gpu, drawEffect, e); + this->setPathTexGenState(gpu, drawEffect, e); this->bindTextures(gpu, *drawEffect.effect(), e); } } -void GrGLTexGenProgramEffects::setTexGenState(GrGpuGL* gpu, +void GrGLPathTexGenProgramEffects::setPathTexGenState(GrGpuGL* gpu, const GrDrawEffect& drawEffect, int effectIdx) { EffectKey totalKey = fTransforms[effectIdx].fTransformKey; @@ -542,7 +542,9 @@ void GrGLTexGenProgramEffects::setTexGenState(GrGpuGL* gpu, SkASSERT(get_transform_matrix(drawEffect, t).isIdentity()); GrGLfloat identity[] = {1, 0, 0, 0, 1, 0}; - gpu->enableTexGen(texCoordIndex++, GrGpuGL::kST_TexGenComponents, identity); + gpu->enablePathTexGen(texCoordIndex++, + GrGpuGL::kST_PathTexGenComponents, + identity); break; } case kTrans_MatrixType: { @@ -550,17 +552,23 @@ void GrGLTexGenProgramEffects::setTexGenState(GrGpuGL* gpu, get_transform_translation(drawEffect, t, &tx, &ty); GrGLfloat translate[] = {1, 0, tx, 0, 1, ty}; - gpu->enableTexGen(texCoordIndex++, GrGpuGL::kST_TexGenComponents, translate); + gpu->enablePathTexGen(texCoordIndex++, + GrGpuGL::kST_PathTexGenComponents, + translate); break; } case kNoPersp_MatrixType: { const SkMatrix& transform = get_transform_matrix(drawEffect, t); - gpu->enableTexGen(texCoordIndex++, GrGpuGL::kST_TexGenComponents, transform); + gpu->enablePathTexGen(texCoordIndex++, + GrGpuGL::kST_PathTexGenComponents, + transform); break; } case kGeneral_MatrixType: { const SkMatrix& transform = get_transform_matrix(drawEffect, t); - gpu->enableTexGen(texCoordIndex++, GrGpuGL::kSTR_TexGenComponents, transform); + gpu->enablePathTexGen(texCoordIndex++, + GrGpuGL::kSTR_PathTexGenComponents, + transform); break; } default: @@ -569,18 +577,18 @@ void GrGLTexGenProgramEffects::setTexGenState(GrGpuGL* gpu, } } -GrGLTexGenProgramEffectsBuilder::GrGLTexGenProgramEffectsBuilder( +GrGLPathTexGenProgramEffectsBuilder::GrGLPathTexGenProgramEffectsBuilder( GrGLFragmentOnlyShaderBuilder* builder, int reserveCount) : fBuilder(builder) - , fProgramEffects(SkNEW_ARGS(GrGLTexGenProgramEffects, (reserveCount))) { + , fProgramEffects(SkNEW_ARGS(GrGLPathTexGenProgramEffects, (reserveCount))) { } -void GrGLTexGenProgramEffectsBuilder::emitEffect(const GrEffectStage& stage, - GrGLProgramEffects::EffectKey key, - const char* outColor, - const char* inColor, - int stageIndex) { +void GrGLPathTexGenProgramEffectsBuilder::emitEffect(const GrEffectStage& stage, + GrGLProgramEffects::EffectKey key, + const char* outColor, + const char* inColor, + int stageIndex) { SkASSERT(NULL != fProgramEffects.get()); fProgramEffects->emitEffect(fBuilder, stage, key, outColor, inColor, stageIndex); } diff --git a/gpu/gl/GrGLProgramEffects.h b/gpu/gl/GrGLProgramEffects.h index 3320891b..0f38cdbe 100644 --- a/gpu/gl/GrGLProgramEffects.h +++ b/gpu/gl/GrGLProgramEffects.h @@ -237,19 +237,19 @@ private: //////////////////////////////////////////////////////////////////////////////// /** - * This is a GrGLProgramEffects implementation that does coord transforms with the the built-in GL - * TexGen functionality. + * This is a GrGLProgramEffects implementation that does coord transforms with + * the the NV_path_rendering PathTexGen functionality. */ -class GrGLTexGenProgramEffects : public GrGLProgramEffects { +class GrGLPathTexGenProgramEffects : public GrGLProgramEffects { public: virtual void setData(GrGpuGL*, const GrGLUniformManager&, const GrEffectStage* effectStages[]) SK_OVERRIDE; private: - friend class GrGLTexGenProgramEffectsBuilder; + friend class GrGLPathTexGenProgramEffectsBuilder; - GrGLTexGenProgramEffects(int reserveCount) + GrGLPathTexGenProgramEffects(int reserveCount) : INHERITED(reserveCount) , fTransforms(reserveCount) { } @@ -273,15 +273,15 @@ private: * types are appended to the TransformedCoordsArray* object, which is in turn passed to the * effect's emitCode() function. */ - void setupTexGen(GrGLFragmentOnlyShaderBuilder*, - const GrEffectRef&, - EffectKey, - TransformedCoordsArray*); + void setupPathTexGen(GrGLFragmentOnlyShaderBuilder*, + const GrEffectRef&, + EffectKey, + TransformedCoordsArray*); /** - * Helper for setData(). Sets the TexGen state for each transform in an effect. + * Helper for setData(). Sets the PathTexGen state for each transform in an effect. */ - void setTexGenState(GrGpuGL*, const GrDrawEffect&, int effectIdx); + void setPathTexGenState(GrGpuGL*, const GrDrawEffect&, int effectIdx); struct Transforms { Transforms(EffectKey transformKey, int texCoordIndex) @@ -296,12 +296,12 @@ private: }; /** - * This class is used to construct a GrGLTexGenProgramEffects* object. + * This class is used to construct a GrGLPathTexGenProgramEffects* object. */ -class GrGLTexGenProgramEffectsBuilder : public GrGLProgramEffectsBuilder { +class GrGLPathTexGenProgramEffectsBuilder : public GrGLProgramEffectsBuilder { public: - GrGLTexGenProgramEffectsBuilder(GrGLFragmentOnlyShaderBuilder*, int reserveCount); - virtual ~GrGLTexGenProgramEffectsBuilder() { } + GrGLPathTexGenProgramEffectsBuilder(GrGLFragmentOnlyShaderBuilder*, int reserveCount); + virtual ~GrGLPathTexGenProgramEffectsBuilder() { } virtual void emitEffect(const GrEffectStage&, GrGLProgramEffects::EffectKey, @@ -317,7 +317,7 @@ public: private: GrGLFragmentOnlyShaderBuilder* fBuilder; - SkAutoTDelete<GrGLTexGenProgramEffects> fProgramEffects; + SkAutoTDelete<GrGLPathTexGenProgramEffects> fProgramEffects; typedef GrGLProgramEffectsBuilder INHERITED; }; diff --git a/gpu/gl/GrGLSL.cpp b/gpu/gl/GrGLSL.cpp index 1ff0850a..7587fe8d 100644 --- a/gpu/gl/GrGLSL.cpp +++ b/gpu/gl/GrGLSL.cpp @@ -9,27 +9,33 @@ #include "GrGLShaderVar.h" #include "SkString.h" -GrGLSLGeneration GrGetGLSLGeneration(const GrGLInterface* gl) { +bool GrGetGLSLGeneration(const GrGLInterface* gl, GrGLSLGeneration* generation) { + SkASSERT(NULL != 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(1,50)) { - return k150_GrGLSLGeneration; + *generation = k150_GrGLSLGeneration; } else if (ver >= GR_GLSL_VER(1,40)) { - return k140_GrGLSLGeneration; + *generation = k140_GrGLSLGeneration; } else if (ver >= GR_GLSL_VER(1,30)) { - return k130_GrGLSLGeneration; + *generation = k130_GrGLSLGeneration; } else { - return k110_GrGLSLGeneration; + *generation = k110_GrGLSLGeneration; } + return true; case kGLES_GrGLStandard: // version 1.00 of ES GLSL based on ver 1.20 of desktop GLSL SkASSERT(ver >= GR_GL_VER(1,00)); - return k110_GrGLSLGeneration; + *generation = k110_GrGLSLGeneration; + return true; default: GrCrash("Unknown GL Standard"); - return k110_GrGLSLGeneration; // suppress warning + return false; } } diff --git a/gpu/gl/GrGLSL.h b/gpu/gl/GrGLSL.h index 5c0a170e..8234be9c 100644 --- a/gpu/gl/GrGLSL.h +++ b/gpu/gl/GrGLSL.h @@ -40,7 +40,7 @@ enum GrGLSLGeneration { /** * Gets the most recent GLSL Generation compatible with the OpenGL context. */ -GrGLSLGeneration GrGetGLSLGeneration(const GrGLInterface* gl); +bool GrGetGLSLGeneration(const GrGLInterface* gl, GrGLSLGeneration* generation); /** * Returns a string to include at the beginning of a shader to declare the GLSL diff --git a/gpu/gl/GrGLShaderBuilder.cpp b/gpu/gl/GrGLShaderBuilder.cpp index f20d9368..b72e23f9 100644 --- a/gpu/gl/GrGLShaderBuilder.cpp +++ b/gpu/gl/GrGLShaderBuilder.cpp @@ -970,7 +970,6 @@ GrGLFragmentOnlyShaderBuilder::GrGLFragmentOnlyShaderBuilder(GrGpuGL* gpu, , fNumTexCoordSets(0) { SkASSERT(!desc.getHeader().fHasVertexCode); - SkASSERT(gpu->glCaps().fixedFunctionSupport()); SkASSERT(gpu->glCaps().pathRenderingSupport()); SkASSERT(GrGLProgramDesc::kAttribute_ColorInput != desc.getHeader().fColorInput); SkASSERT(GrGLProgramDesc::kAttribute_ColorInput != desc.getHeader().fCoverageInput); @@ -989,11 +988,12 @@ GrGLProgramEffects* GrGLFragmentOnlyShaderBuilder::createAndEmitEffects( int effectCnt, GrGLSLExpr4* inOutFSColor) { - GrGLTexGenProgramEffectsBuilder texGenEffectsBuilder(this, effectCnt); - this->INHERITED::createAndEmitEffects(&texGenEffectsBuilder, + GrGLPathTexGenProgramEffectsBuilder pathTexGenEffectsBuilder(this, + effectCnt); + this->INHERITED::createAndEmitEffects(&pathTexGenEffectsBuilder, effectStages, effectKeys, effectCnt, inOutFSColor); - return texGenEffectsBuilder.finish(); + return pathTexGenEffectsBuilder.finish(); } diff --git a/gpu/gl/GrGLUtil.cpp b/gpu/gl/GrGLUtil.cpp index a479523b..ddfcfbf0 100644 --- a/gpu/gl/GrGLUtil.cpp +++ b/gpu/gl/GrGLUtil.cpp @@ -140,7 +140,7 @@ bool GrGLIsChromiumFromRendererString(const char* rendererString) { GrGLVersion GrGLGetVersionFromString(const char* versionString) { if (NULL == versionString) { SkDEBUGFAIL("NULL GL version string."); - return 0; + return GR_GL_INVALID_VER; } int major, minor; @@ -152,7 +152,7 @@ GrGLVersion GrGLGetVersionFromString(const char* versionString) { if (get_gl_version_for_mesa(mesaMajor, &major, &minor)) { return GR_GL_VER(major, minor); } else { - return 0; + return GR_GL_INVALID_VER; } } @@ -173,13 +173,13 @@ GrGLVersion GrGLGetVersionFromString(const char* versionString) { return GR_GL_VER(major, minor); } - return 0; + return GR_GL_INVALID_VER; } GrGLSLVersion GrGLGetGLSLVersionFromString(const char* versionString) { if (NULL == versionString) { SkDEBUGFAIL("NULL GLSL version string."); - return 0; + return GR_GLSL_INVALID_VER; } int major, minor; @@ -202,7 +202,7 @@ GrGLSLVersion GrGLGetGLSLVersionFromString(const char* versionString) { } #endif - return 0; + return GR_GLSL_INVALID_VER; } GrGLVendor GrGLGetVendorFromString(const char* vendorString) { diff --git a/gpu/gl/GrGLUtil.h b/gpu/gl/GrGLUtil.h index b99487a1..73fcec11 100644 --- a/gpu/gl/GrGLUtil.h +++ b/gpu/gl/GrGLUtil.h @@ -18,6 +18,14 @@ class SkMatrix; typedef uint32_t GrGLVersion; typedef uint32_t GrGLSLVersion; +#define GR_GL_VER(major, minor) ((static_cast<int>(major) << 16) | \ + static_cast<int>(minor)) +#define GR_GLSL_VER(major, minor) ((static_cast<int>(major) << 16) | \ + static_cast<int>(minor)) + +#define GR_GL_INVALID_VER GR_GL_VER(0, 0) +#define GR_GLSL_INVALID_VER GR_GL_VER(0, 0) + /** * The Vendor and Renderer enum values are lazily updated as required. */ @@ -37,11 +45,6 @@ enum GrGLRenderer { kOther_GrGLRenderer }; -#define GR_GL_VER(major, minor) ((static_cast<int>(major) << 16) | \ - static_cast<int>(minor)) -#define GR_GLSL_VER(major, minor) ((static_cast<int>(major) << 16) | \ - static_cast<int>(minor)) - //////////////////////////////////////////////////////////////////////////////// /** diff --git a/gpu/gl/GrGpuGL.cpp b/gpu/gl/GrGpuGL.cpp index a2a6ac3b..4b39a163 100644 --- a/gpu/gl/GrGpuGL.cpp +++ b/gpu/gl/GrGpuGL.cpp @@ -120,7 +120,7 @@ GrGpuGL::GrGpuGL(const GrGLContext& ctx, GrContext* context) fCaps.reset(SkRef(ctx.caps())); fHWBoundTextures.reset(this->glCaps().maxFragmentTextureUnits()); - fHWTexGenSettings.reset(this->glCaps().maxFixedFunctionTextureCoords()); + fHWPathTexGenSettings.reset(this->glCaps().maxFixedFunctionTextureCoords()); GrGLClearErr(fGLContext.interface()); if (gPrintStartupSpew) { @@ -300,30 +300,20 @@ void GrGpuGL::onResetContext(uint32_t resetBits) { fHWBoundRenderTarget = NULL; } - if (resetBits & (kFixedFunction_GrGLBackendState | kPathRendering_GrGLBackendState)) { - if (this->glCaps().fixedFunctionSupport()) { + if (resetBits & kPathRendering_GrGLBackendState) { + if (this->caps()->pathRenderingSupport()) { fHWProjectionMatrixState.invalidate(); // we don't use the model view matrix. - GL_CALL(MatrixMode(GR_GL_MODELVIEW)); - GL_CALL(LoadIdentity()); + GL_CALL(MatrixLoadIdentity(GR_GL_MODELVIEW)); for (int i = 0; i < this->glCaps().maxFixedFunctionTextureCoords(); ++i) { - GL_CALL(ActiveTexture(GR_GL_TEXTURE0 + i)); - GL_CALL(Disable(GR_GL_TEXTURE_GEN_S)); - GL_CALL(Disable(GR_GL_TEXTURE_GEN_T)); - GL_CALL(Disable(GR_GL_TEXTURE_GEN_Q)); - GL_CALL(Disable(GR_GL_TEXTURE_GEN_R)); - if (this->caps()->pathRenderingSupport()) { - GL_CALL(PathTexGen(GR_GL_TEXTURE0 + i, GR_GL_NONE, 0, NULL)); - } - fHWTexGenSettings[i].fMode = GR_GL_NONE; - fHWTexGenSettings[i].fNumComponents = 0; + GL_CALL(PathTexGen(GR_GL_TEXTURE0 + i, GR_GL_NONE, 0, NULL)); + fHWPathTexGenSettings[i].fMode = GR_GL_NONE; + fHWPathTexGenSettings[i].fNumComponents = 0; } - fHWActiveTexGenSets = 0; - } - if (this->caps()->pathRenderingSupport()) { - fHWPathStencilSettings.invalidate(); + fHWActivePathTexGenSets = 0; } + fHWPathStencilSettings.invalidate(); } // we assume these values @@ -2230,7 +2220,7 @@ void GrGpuGL::setProjectionMatrix(const SkMatrix& matrix, const SkISize& renderTargetSize, GrSurfaceOrigin renderTargetOrigin) { - SkASSERT(this->glCaps().fixedFunctionSupport()); + SkASSERT(this->glCaps().pathRenderingSupport()); if (renderTargetOrigin == fHWProjectionMatrixState.fRenderTargetOrigin && renderTargetSize == fHWProjectionMatrixState.fRenderTargetSize && @@ -2244,113 +2234,84 @@ void GrGpuGL::setProjectionMatrix(const SkMatrix& matrix, GrGLfloat glMatrix[4 * 4]; fHWProjectionMatrixState.getGLMatrix<4>(glMatrix); - GL_CALL(MatrixMode(GR_GL_PROJECTION)); - GL_CALL(LoadMatrixf(glMatrix)); + GL_CALL(MatrixLoadf(GR_GL_PROJECTION, glMatrix)); } -void GrGpuGL::enableTexGen(int unitIdx, - TexGenComponents components, - const GrGLfloat* coefficients) { - SkASSERT(this->glCaps().fixedFunctionSupport()); - SkASSERT(components >= kS_TexGenComponents && components <= kSTR_TexGenComponents); +void GrGpuGL::enablePathTexGen(int unitIdx, + PathTexGenComponents components, + const GrGLfloat* coefficients) { + SkASSERT(this->glCaps().pathRenderingSupport()); + SkASSERT(components >= kS_PathTexGenComponents && + components <= kSTR_PathTexGenComponents); SkASSERT(this->glCaps().maxFixedFunctionTextureCoords() >= unitIdx); - if (GR_GL_OBJECT_LINEAR == fHWTexGenSettings[unitIdx].fMode && - components == fHWTexGenSettings[unitIdx].fNumComponents && - !memcmp(coefficients, fHWTexGenSettings[unitIdx].fCoefficients, + if (GR_GL_OBJECT_LINEAR == fHWPathTexGenSettings[unitIdx].fMode && + components == fHWPathTexGenSettings[unitIdx].fNumComponents && + !memcmp(coefficients, fHWPathTexGenSettings[unitIdx].fCoefficients, 3 * components * sizeof(GrGLfloat))) { return; } this->setTextureUnit(unitIdx); - if (GR_GL_OBJECT_LINEAR != fHWTexGenSettings[unitIdx].fMode) { - for (int i = 0; i < 4; i++) { - GL_CALL(TexGeni(GR_GL_S + i, GR_GL_TEXTURE_GEN_MODE, GR_GL_OBJECT_LINEAR)); - } - fHWTexGenSettings[unitIdx].fMode = GR_GL_OBJECT_LINEAR; - } - - for (int i = fHWTexGenSettings[unitIdx].fNumComponents; i < components; i++) { - GL_CALL(Enable(GR_GL_TEXTURE_GEN_S + i)); - } - for (int i = components; i < fHWTexGenSettings[unitIdx].fNumComponents; i++) { - GL_CALL(Disable(GR_GL_TEXTURE_GEN_S + i)); - } - fHWTexGenSettings[unitIdx].fNumComponents = components; - - for (int i = 0; i < components; i++) { - GrGLfloat plane[] = {coefficients[0 + 3 * i], - coefficients[1 + 3 * i], - 0, - coefficients[2 + 3 * i]}; - GL_CALL(TexGenfv(GR_GL_S + i, GR_GL_OBJECT_PLANE, plane)); - } + fHWPathTexGenSettings[unitIdx].fNumComponents = components; + GL_CALL(PathTexGen(GR_GL_TEXTURE0 + unitIdx, + GR_GL_OBJECT_LINEAR, + components, + coefficients)); - if (this->caps()->pathRenderingSupport()) { - GL_CALL(PathTexGen(GR_GL_TEXTURE0 + unitIdx, - GR_GL_OBJECT_LINEAR, - components, - coefficients)); - } - - memcpy(fHWTexGenSettings[unitIdx].fCoefficients, coefficients, + memcpy(fHWPathTexGenSettings[unitIdx].fCoefficients, coefficients, 3 * components * sizeof(GrGLfloat)); } -void GrGpuGL::enableTexGen(int unitIdx, TexGenComponents components, const SkMatrix& matrix) { +void GrGpuGL::enablePathTexGen(int unitIdx, PathTexGenComponents components, + const SkMatrix& matrix) { GrGLfloat coefficients[3 * 3]; - SkASSERT(this->glCaps().fixedFunctionSupport()); - SkASSERT(components >= kS_TexGenComponents && components <= kSTR_TexGenComponents); + SkASSERT(this->glCaps().pathRenderingSupport()); + SkASSERT(components >= kS_PathTexGenComponents && + components <= kSTR_PathTexGenComponents); coefficients[0] = SkScalarToFloat(matrix[SkMatrix::kMScaleX]); coefficients[1] = SkScalarToFloat(matrix[SkMatrix::kMSkewX]); coefficients[2] = SkScalarToFloat(matrix[SkMatrix::kMTransX]); - if (components >= kST_TexGenComponents) { + if (components >= kST_PathTexGenComponents) { coefficients[3] = SkScalarToFloat(matrix[SkMatrix::kMSkewY]); coefficients[4] = SkScalarToFloat(matrix[SkMatrix::kMScaleY]); coefficients[5] = SkScalarToFloat(matrix[SkMatrix::kMTransY]); } - if (components >= kSTR_TexGenComponents) { + if (components >= kSTR_PathTexGenComponents) { coefficients[6] = SkScalarToFloat(matrix[SkMatrix::kMPersp0]); coefficients[7] = SkScalarToFloat(matrix[SkMatrix::kMPersp1]); coefficients[8] = SkScalarToFloat(matrix[SkMatrix::kMPersp2]); } - enableTexGen(unitIdx, components, coefficients); + enablePathTexGen(unitIdx, components, coefficients); } -void GrGpuGL::flushTexGenSettings(int numUsedTexCoordSets) { - SkASSERT(this->glCaps().fixedFunctionSupport()); +void GrGpuGL::flushPathTexGenSettings(int numUsedTexCoordSets) { + SkASSERT(this->glCaps().pathRenderingSupport()); SkASSERT(this->glCaps().maxFixedFunctionTextureCoords() >= numUsedTexCoordSets); - // Only write the inactive tex gens, since active tex gens were written - // when they were enabled. + // Only write the inactive path tex gens, since active path tex gens were + // written when they were enabled. SkDEBUGCODE( for (int i = 0; i < numUsedTexCoordSets; i++) { - SkASSERT(0 != fHWTexGenSettings[i].fNumComponents); + SkASSERT(0 != fHWPathTexGenSettings[i].fNumComponents); } ); - for (int i = numUsedTexCoordSets; i < fHWActiveTexGenSets; i++) { - SkASSERT(0 != fHWTexGenSettings[i].fNumComponents); + for (int i = numUsedTexCoordSets; i < fHWActivePathTexGenSets; i++) { + SkASSERT(0 != fHWPathTexGenSettings[i].fNumComponents); this->setTextureUnit(i); - for (int j = 0; j < fHWTexGenSettings[i].fNumComponents; j++) { - GL_CALL(Disable(GR_GL_TEXTURE_GEN_S + j)); - } - - if (this->caps()->pathRenderingSupport()) { - GL_CALL(PathTexGen(GR_GL_TEXTURE0 + i, GR_GL_NONE, 0, NULL)); - } - - fHWTexGenSettings[i].fNumComponents = 0; + GL_CALL(PathTexGen(GR_GL_TEXTURE0 + i, GR_GL_NONE, 0, NULL)); + fHWPathTexGenSettings[i].fNumComponents = 0; } - fHWActiveTexGenSets = numUsedTexCoordSets; + fHWActivePathTexGenSets = numUsedTexCoordSets; } void GrGpuGL::flushMiscFixedFunctionState() { diff --git a/gpu/gl/GrGpuGL.h b/gpu/gl/GrGpuGL.h index d75c3660..f548af5f 100644 --- a/gpu/gl/GrGpuGL.h +++ b/gpu/gl/GrGpuGL.h @@ -42,22 +42,22 @@ public: virtual void discard(GrRenderTarget*) SK_OVERRIDE; - // Used by GrGLProgram and GrGLTexGenProgramEffects to configure OpenGL state. + // Used by GrGLProgram and GrGLPathTexGenProgramEffects to configure OpenGL + // state. void bindTexture(int unitIdx, const GrTextureParams& params, GrGLTexture* texture); void setProjectionMatrix(const SkMatrix& matrix, const SkISize& renderTargetSize, GrSurfaceOrigin renderTargetOrigin); - enum TexGenComponents { - kS_TexGenComponents = 1, - kST_TexGenComponents = 2, - kSTR_TexGenComponents = 3 + enum PathTexGenComponents { + kS_PathTexGenComponents = 1, + kST_PathTexGenComponents = 2, + kSTR_PathTexGenComponents = 3 }; - void enableTexGen(int unitIdx, TexGenComponents, const GrGLfloat* coefficients); - void enableTexGen(int unitIdx, TexGenComponents, const SkMatrix& matrix); - void flushTexGenSettings(int numUsedTexCoordSets); + void enablePathTexGen(int unitIdx, PathTexGenComponents, const GrGLfloat* coefficients); + void enablePathTexGen(int unitIdx, PathTexGenComponents, const SkMatrix& matrix); + void flushPathTexGenSettings(int numUsedTexCoordSets); bool shouldUseFixedFunctionTexturing() const { - return this->glCaps().fixedFunctionSupport() && - this->glCaps().pathRenderingSupport(); + return this->glCaps().pathRenderingSupport(); } bool programUnitTest(int maxStages); @@ -446,13 +446,13 @@ private: GrRenderTarget* fHWBoundRenderTarget; SkTArray<GrTexture*, true> fHWBoundTextures; - struct TexGenData { + struct PathTexGenData { GrGLenum fMode; GrGLint fNumComponents; GrGLfloat fCoefficients[3 * 3]; }; - int fHWActiveTexGenSets; - SkTArray<TexGenData, true> fHWTexGenSettings; + int fHWActivePathTexGenSets; + SkTArray<PathTexGenData, true> fHWPathTexGenSettings; ///@} // we record what stencil format worked last time to hopefully exit early diff --git a/gpu/gl/GrGpuGL_program.cpp b/gpu/gl/GrGpuGL_program.cpp index 10f10393..0a7bb0e3 100644 --- a/gpu/gl/GrGpuGL_program.cpp +++ b/gpu/gl/GrGpuGL_program.cpp @@ -233,7 +233,7 @@ bool GrGpuGL::flushGraphicsState(DrawType type, const GrDeviceCoordTexture* dstC SkSTArray<8, const GrEffectStage*, true> coverageStages; GrGLProgramDesc desc; GrGLProgramDesc::Build(this->getDrawState(), - kDrawPoints_DrawType == type, + type, blendOpts, srcCoeff, dstCoeff, @@ -343,27 +343,7 @@ void GrGpuGL::setupGeometry(const DrawInfo& info, size_t* indexOffsetInBytes) { GrGLAttribArrayState* attribState = fHWGeometryState.bindArrayAndBuffersToDraw(this, vbuf, ibuf); - if (!fCurrentProgram->hasVertexShader()) { - int posIdx = this->getDrawState().positionAttributeIndex(); - const GrVertexAttrib* vertexAttrib = this->getDrawState().getVertexAttribs() + posIdx; - GrVertexAttribType attribType = vertexAttrib->fType; - SkASSERT(!GrGLAttribTypeToLayout(attribType).fNormalized); - SkASSERT(GrGLAttribTypeToLayout(attribType).fCount == 2); - - // Attrib at location 0 is defined to be bound to vertex in fixed-function pipe. Asserts - // above should make sure position attribute goes to location 0 when below code is executed. - - attribState->set(this, - 0, - vbuf, - GrGLAttribTypeToLayout(attribType).fCount, - GrGLAttribTypeToLayout(attribType).fType, - GrGLAttribTypeToLayout(attribType).fNormalized, - stride, - reinterpret_cast<GrGLvoid*>( - vertexOffsetInBytes + vertexAttrib->fOffset)); - attribState->disableUnusedArrays(this, 1); - } else { + if (fCurrentProgram->hasVertexShader()) { int vertexAttribCount = this->getDrawState().getVertexAttribCount(); uint32_t usedAttribArraysMask = 0; const GrVertexAttrib* vertexAttrib = this->getDrawState().getVertexAttribs(); diff --git a/gpu/gl/android/GrGLCreateNativeInterface_android.cpp b/gpu/gl/android/GrGLCreateNativeInterface_android.cpp index aa5b2243..b50063fb 100644 --- a/gpu/gl/android/GrGLCreateNativeInterface_android.cpp +++ b/gpu/gl/android/GrGLCreateNativeInterface_android.cpp @@ -4,8 +4,9 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "gl/GrGLExtensions.h" #include "gl/GrGLInterface.h" +#include "gl/GrGLAssembleInterface.h" +#include "gl/GrGLExtensions.h" #include "gl/GrGLUtil.h" #ifndef GL_GLEXT_PROTOTYPES @@ -218,236 +219,37 @@ static GrGLInterface* create_es_interface(GrGLVersion version, return interface; } -static GrGLInterface* create_desktop_interface(GrGLVersion version, - const GrGLExtensions& extensions) { - // Currently this assumes a 4.4 context or later. Supporting lower GL versions would require - // getting suffixed versions of pointers for supported extensions. - if (version < GR_GL_VER(4,4)) { - return NULL; - } - - GrGLInterface* interface = SkNEW(GrGLInterface); - interface->fStandard = kGL_GrGLStandard; - GrGLInterface::Functions* functions = &interface->fFunctions; - - functions->fActiveTexture = (GrGLActiveTextureProc) eglGetProcAddress("glActiveTexture"); - functions->fAttachShader = (GrGLAttachShaderProc) eglGetProcAddress("glAttachShader"); - functions->fBeginQuery = (GrGLBeginQueryProc) eglGetProcAddress("glBeginQuery"); - functions->fBindAttribLocation = (GrGLBindAttribLocationProc) eglGetProcAddress("glBindAttribLocation"); - functions->fBindBuffer = (GrGLBindBufferProc) eglGetProcAddress("glBindBuffer"); - functions->fBindFragDataLocation = (GrGLBindFragDataLocationProc) eglGetProcAddress("glBindFragDataLocation"); - functions->fBindFragDataLocationIndexed = (GrGLBindFragDataLocationIndexedProc) eglGetProcAddress("glBindFragDataLocationIndexed"); - functions->fBindFramebuffer = (GrGLBindFramebufferProc) eglGetProcAddress("glBindFramebuffer"); - functions->fBindRenderbuffer = (GrGLBindRenderbufferProc) eglGetProcAddress("glBindRenderbuffer"); - functions->fBindTexture = (GrGLBindTextureProc) eglGetProcAddress("glBindTexture"); - functions->fBindVertexArray = (GrGLBindVertexArrayProc) eglGetProcAddress("glBindVertexArray"); - functions->fBlendColor = (GrGLBlendColorProc) eglGetProcAddress("glBlendColor"); - functions->fBlendFunc = (GrGLBlendFuncProc) eglGetProcAddress("glBlendFunc"); - functions->fBlitFramebuffer = (GrGLBlitFramebufferProc) eglGetProcAddress("glBlitFramebuffer"); - functions->fBufferData = (GrGLBufferDataProc) eglGetProcAddress("glBufferData"); - functions->fBufferSubData = (GrGLBufferSubDataProc) eglGetProcAddress("glBufferSubData"); - functions->fCheckFramebufferStatus = (GrGLCheckFramebufferStatusProc) eglGetProcAddress("glCheckFramebufferStatus"); - functions->fClear = (GrGLClearProc) eglGetProcAddress("glClear"); - functions->fClearColor = (GrGLClearColorProc) eglGetProcAddress("glClearColor"); - functions->fClearStencil = (GrGLClearStencilProc) eglGetProcAddress("glClearStencil"); - functions->fColorMask = (GrGLColorMaskProc) eglGetProcAddress("glColorMask"); - functions->fCompileShader = (GrGLCompileShaderProc) eglGetProcAddress("glCompileShader"); - functions->fCompressedTexImage2D = (GrGLCompressedTexImage2DProc) eglGetProcAddress("glCompressedTexImage2D"); - functions->fCopyTexSubImage2D = (GrGLCopyTexSubImage2DProc) eglGetProcAddress("glCopyTexSubImage2D"); - functions->fCreateProgram = (GrGLCreateProgramProc) eglGetProcAddress("glCreateProgram"); - functions->fCreateShader = (GrGLCreateShaderProc) eglGetProcAddress("glCreateShader"); - functions->fCullFace = (GrGLCullFaceProc) eglGetProcAddress("glCullFace"); - functions->fDeleteBuffers = (GrGLDeleteBuffersProc) eglGetProcAddress("glDeleteBuffers"); - functions->fDeleteFramebuffers = (GrGLDeleteFramebuffersProc) eglGetProcAddress("glDeleteFramebuffers"); - functions->fDeleteProgram = (GrGLDeleteProgramProc) eglGetProcAddress("glDeleteProgram"); - functions->fDeleteQueries = (GrGLDeleteQueriesProc) eglGetProcAddress("glDeleteQueries"); - functions->fDeleteRenderbuffers = (GrGLDeleteRenderbuffersProc) eglGetProcAddress("glDeleteRenderbuffers"); - functions->fDeleteShader = (GrGLDeleteShaderProc) eglGetProcAddress("glDeleteShader"); - functions->fDeleteTextures = (GrGLDeleteTexturesProc) eglGetProcAddress("glDeleteTextures"); - functions->fDeleteVertexArrays = (GrGLDeleteVertexArraysProc) eglGetProcAddress("glDeleteVertexArrays"); - functions->fDepthMask = (GrGLDepthMaskProc) eglGetProcAddress("glDepthMask"); - functions->fDisable = (GrGLDisableProc) eglGetProcAddress("glDisable"); - functions->fDisableVertexAttribArray = (GrGLDisableVertexAttribArrayProc) eglGetProcAddress("glDisableVertexAttribArray"); - functions->fDrawArrays = (GrGLDrawArraysProc) eglGetProcAddress("glDrawArrays"); - functions->fDrawBuffer = (GrGLDrawBufferProc) eglGetProcAddress("glDrawBuffer"); - functions->fDrawBuffers = (GrGLDrawBuffersProc) eglGetProcAddress("glDrawBuffers"); - functions->fDrawElements = (GrGLDrawElementsProc) eglGetProcAddress("glDrawElements"); - functions->fEnable = (GrGLEnableProc) eglGetProcAddress("glEnable"); - functions->fEnableVertexAttribArray = (GrGLEnableVertexAttribArrayProc) eglGetProcAddress("glEnableVertexAttribArray"); - functions->fEndQuery = (GrGLEndQueryProc) eglGetProcAddress("glEndQuery"); - functions->fFinish = (GrGLFinishProc) eglGetProcAddress("glFinish"); - functions->fFlush = (GrGLFlushProc) eglGetProcAddress("glFlush"); - functions->fFramebufferRenderbuffer = (GrGLFramebufferRenderbufferProc) eglGetProcAddress("glFramebufferRenderbuffer"); - functions->fFramebufferTexture2D = (GrGLFramebufferTexture2DProc) eglGetProcAddress("glFramebufferTexture2D"); - functions->fFrontFace = (GrGLFrontFaceProc) eglGetProcAddress("glFrontFace"); - functions->fGenBuffers = (GrGLGenBuffersProc) eglGetProcAddress("glGenBuffers"); - functions->fGenFramebuffers = (GrGLGenFramebuffersProc) eglGetProcAddress("glGenFramebuffers"); - functions->fGenerateMipmap = (GrGLGenerateMipmapProc) eglGetProcAddress("glGenerateMipmap"); - functions->fGenQueries = (GrGLGenQueriesProc) eglGetProcAddress("glGenQueries"); - functions->fGenRenderbuffers = (GrGLGenRenderbuffersProc) eglGetProcAddress("glGenRenderbuffers"); - functions->fGenTextures = (GrGLGenTexturesProc) eglGetProcAddress("glGenTextures"); - functions->fGenVertexArrays = (GrGLGenVertexArraysProc) eglGetProcAddress("glGenVertexArrays"); - functions->fGetBufferParameteriv = (GrGLGetBufferParameterivProc) eglGetProcAddress("glGetBufferParameteriv"); - functions->fGetError = (GrGLGetErrorProc) eglGetProcAddress("glGetError"); - functions->fGetFramebufferAttachmentParameteriv = (GrGLGetFramebufferAttachmentParameterivProc) eglGetProcAddress("glGetFramebufferAttachmentParameteriv"); - functions->fGetIntegerv = (GrGLGetIntegervProc) eglGetProcAddress("glGetIntegerv"); - functions->fGetQueryObjecti64v = (GrGLGetQueryObjecti64vProc) eglGetProcAddress("glGetQueryObjecti64v"); - functions->fGetQueryObjectiv = (GrGLGetQueryObjectivProc) eglGetProcAddress("glGetQueryObjectiv"); - functions->fGetQueryObjectui64v = (GrGLGetQueryObjectui64vProc) eglGetProcAddress("glGetQueryObjectui64v"); - functions->fGetQueryObjectuiv = (GrGLGetQueryObjectuivProc) eglGetProcAddress("glGetQueryObjectuiv"); - functions->fGetQueryiv = (GrGLGetQueryivProc) eglGetProcAddress("glGetQueryiv"); - functions->fGetProgramInfoLog = (GrGLGetProgramInfoLogProc) eglGetProcAddress("glGetProgramInfoLog"); - functions->fGetProgramiv = (GrGLGetProgramivProc) eglGetProcAddress("glGetProgramiv"); - functions->fGetRenderbufferParameteriv = (GrGLGetRenderbufferParameterivProc) eglGetProcAddress("glGetRenderbufferParameteriv"); - functions->fGetShaderInfoLog = (GrGLGetShaderInfoLogProc) eglGetProcAddress("glGetShaderInfoLog"); - functions->fGetShaderiv = (GrGLGetShaderivProc) eglGetProcAddress("glGetShaderiv"); - functions->fGetString = (GrGLGetStringProc) eglGetProcAddress("glGetString"); - functions->fGetStringi = (GrGLGetStringiProc) eglGetProcAddress("glGetStringi"); - functions->fGetTexLevelParameteriv = (GrGLGetTexLevelParameterivProc) eglGetProcAddress("glGetTexLevelParameteriv"); - functions->fGetUniformLocation = (GrGLGetUniformLocationProc) eglGetProcAddress("glGetUniformLocation"); - functions->fLineWidth = (GrGLLineWidthProc) eglGetProcAddress("glLineWidth"); - functions->fLinkProgram = (GrGLLinkProgramProc) eglGetProcAddress("glLinkProgram"); - functions->fLoadIdentity = (GrGLLoadIdentityProc) eglGetProcAddress("glLoadIdentity"); - functions->fLoadMatrixf = (GrGLLoadMatrixfProc) eglGetProcAddress("glLoadMatrixf"); - functions->fMapBuffer = (GrGLMapBufferProc) eglGetProcAddress("glMapBuffer"); - functions->fMatrixMode = (GrGLMatrixModeProc) eglGetProcAddress("glMatrixMode"); - functions->fPixelStorei = (GrGLPixelStoreiProc) eglGetProcAddress("glPixelStorei"); - functions->fQueryCounter = (GrGLQueryCounterProc) eglGetProcAddress("glQueryCounter"); - functions->fReadBuffer = (GrGLReadBufferProc) eglGetProcAddress("glReadBuffer"); - functions->fReadPixels = (GrGLReadPixelsProc) eglGetProcAddress("glReadPixels"); - functions->fRenderbufferStorage = (GrGLRenderbufferStorageProc) eglGetProcAddress("glRenderbufferStorage"); - functions->fRenderbufferStorageMultisample = (GrGLRenderbufferStorageMultisampleProc) eglGetProcAddress("glRenderbufferStorageMultisample"); - functions->fScissor = (GrGLScissorProc) eglGetProcAddress("glScissor"); - functions->fShaderSource = (GrGLShaderSourceProc) eglGetProcAddress("glShaderSource"); - functions->fStencilFunc = (GrGLStencilFuncProc) eglGetProcAddress("glStencilFunc"); - functions->fStencilFuncSeparate = (GrGLStencilFuncSeparateProc) eglGetProcAddress("glStencilFuncSeparate"); - functions->fStencilMask = (GrGLStencilMaskProc) eglGetProcAddress("glStencilMask"); - functions->fStencilMaskSeparate = (GrGLStencilMaskSeparateProc) eglGetProcAddress("glStencilMaskSeparate"); - functions->fStencilOp = (GrGLStencilOpProc) eglGetProcAddress("glStencilOp"); - functions->fStencilOpSeparate = (GrGLStencilOpSeparateProc) eglGetProcAddress("glStencilOpSeparate"); - functions->fTexGenfv = (GrGLTexGenfvProc) eglGetProcAddress("glTexGenfv"); - functions->fTexGeni = (GrGLTexGeniProc) eglGetProcAddress("glTexGeni"); - functions->fTexImage2D = (GrGLTexImage2DProc) eglGetProcAddress("glTexImage2D"); - functions->fTexParameteri = (GrGLTexParameteriProc) eglGetProcAddress("glTexParameteri"); - functions->fTexParameteriv = (GrGLTexParameterivProc) eglGetProcAddress("glTexParameteriv"); - functions->fTexSubImage2D = (GrGLTexSubImage2DProc) eglGetProcAddress("glTexSubImage2D"); - functions->fTexStorage2D = (GrGLTexStorage2DProc) eglGetProcAddress("glTexStorage2D"); - functions->fUniform1f = (GrGLUniform1fProc) eglGetProcAddress("glUniform1f"); - functions->fUniform1i = (GrGLUniform1iProc) eglGetProcAddress("glUniform1i"); - functions->fUniform1fv = (GrGLUniform1fvProc) eglGetProcAddress("glUniform1fv"); - functions->fUniform1iv = (GrGLUniform1ivProc) eglGetProcAddress("glUniform1iv"); - functions->fUniform2f = (GrGLUniform2fProc) eglGetProcAddress("glUniform2f"); - functions->fUniform2i = (GrGLUniform2iProc) eglGetProcAddress("glUniform2i"); - functions->fUniform2fv = (GrGLUniform2fvProc) eglGetProcAddress("glUniform2fv"); - functions->fUniform2iv = (GrGLUniform2ivProc) eglGetProcAddress("glUniform2iv"); - functions->fUniform3f = (GrGLUniform3fProc) eglGetProcAddress("glUniform3f"); - functions->fUniform3i = (GrGLUniform3iProc) eglGetProcAddress("glUniform3i"); - functions->fUniform3fv = (GrGLUniform3fvProc) eglGetProcAddress("glUniform3fv"); - functions->fUniform3iv = (GrGLUniform3ivProc) eglGetProcAddress("glUniform3iv"); - functions->fUniform4f = (GrGLUniform4fProc) eglGetProcAddress("glUniform4f"); - functions->fUniform4i = (GrGLUniform4iProc) eglGetProcAddress("glUniform4i"); - functions->fUniform4fv = (GrGLUniform4fvProc) eglGetProcAddress("glUniform4fv"); - functions->fUniform4iv = (GrGLUniform4ivProc) eglGetProcAddress("glUniform4iv"); - functions->fUniformMatrix2fv = (GrGLUniformMatrix2fvProc) eglGetProcAddress("glUniformMatrix2fv"); - functions->fUniformMatrix3fv = (GrGLUniformMatrix3fvProc) eglGetProcAddress("glUniformMatrix3fv"); - functions->fUniformMatrix4fv = (GrGLUniformMatrix4fvProc) eglGetProcAddress("glUniformMatrix4fv"); - functions->fUnmapBuffer = (GrGLUnmapBufferProc) eglGetProcAddress("glUnmapBuffer"); - functions->fUseProgram = (GrGLUseProgramProc) eglGetProcAddress("glUseProgram"); - functions->fVertexAttrib4fv = (GrGLVertexAttrib4fvProc) eglGetProcAddress("glVertexAttrib4fv"); - functions->fVertexAttribPointer = (GrGLVertexAttribPointerProc) eglGetProcAddress("glVertexAttribPointer"); - functions->fViewport = (GrGLViewportProc) eglGetProcAddress("glViewport"); - - if (extensions.has("GL_NV_path_rendering")) { - functions->fPathCommands = (GrGLPathCommandsProc) eglGetProcAddress("glPathCommandsNV"); - functions->fPathCoords = (GrGLPathCoordsProc) eglGetProcAddress("glPathCoordsNV"); - functions->fPathSubCommands = (GrGLPathSubCommandsProc) eglGetProcAddress("glPathSubCommandsNV"); - functions->fPathSubCoords = (GrGLPathSubCoordsProc) eglGetProcAddress("glPathSubCoordsNV"); - functions->fPathString = (GrGLPathStringProc) eglGetProcAddress("glPathStringNV"); - functions->fPathGlyphs = (GrGLPathGlyphsProc) eglGetProcAddress("glPathGlyphsNV"); - functions->fPathGlyphRange = (GrGLPathGlyphRangeProc) eglGetProcAddress("glPathGlyphRangeNV"); - functions->fWeightPaths = (GrGLWeightPathsProc) eglGetProcAddress("glWeightPathsNV"); - functions->fCopyPath = (GrGLCopyPathProc) eglGetProcAddress("glCopyPathNV"); - functions->fInterpolatePaths = (GrGLInterpolatePathsProc) eglGetProcAddress("glInterpolatePathsNV"); - functions->fTransformPath = (GrGLTransformPathProc) eglGetProcAddress("glTransformPathNV"); - functions->fPathParameteriv = (GrGLPathParameterivProc) eglGetProcAddress("glPathParameterivNV"); - functions->fPathParameteri = (GrGLPathParameteriProc) eglGetProcAddress("glPathParameteriNV"); - functions->fPathParameterfv = (GrGLPathParameterfvProc) eglGetProcAddress("glPathParameterfvNV"); - functions->fPathParameterf = (GrGLPathParameterfProc) eglGetProcAddress("glPathParameterfNV"); - functions->fPathDashArray = (GrGLPathDashArrayProc) eglGetProcAddress("glPathDashArrayNV"); - functions->fGenPaths = (GrGLGenPathsProc) eglGetProcAddress("glGenPathsNV"); - functions->fDeletePaths = (GrGLDeletePathsProc) eglGetProcAddress("glDeletePathsNV"); - functions->fIsPath = (GrGLIsPathProc) eglGetProcAddress("glIsPathNV"); - functions->fPathStencilFunc = (GrGLPathStencilFuncProc) eglGetProcAddress("glPathStencilFuncNV"); - functions->fPathStencilDepthOffset = (GrGLPathStencilDepthOffsetProc) eglGetProcAddress("glPathStencilDepthOffsetNV"); - functions->fStencilFillPath = (GrGLStencilFillPathProc) eglGetProcAddress("glStencilFillPathNV"); - functions->fStencilStrokePath = (GrGLStencilStrokePathProc) eglGetProcAddress("glStencilStrokePathNV"); - functions->fStencilFillPathInstanced = (GrGLStencilFillPathInstancedProc) eglGetProcAddress("glStencilFillPathInstancedNV"); - functions->fStencilStrokePathInstanced = (GrGLStencilStrokePathInstancedProc) eglGetProcAddress("glStencilStrokePathInstancedNV"); - functions->fPathCoverDepthFunc = (GrGLPathCoverDepthFuncProc) eglGetProcAddress("glPathCoverDepthFuncNV"); - functions->fPathColorGen = (GrGLPathColorGenProc) eglGetProcAddress("glPathColorGenNV"); - functions->fPathTexGen = (GrGLPathTexGenProc) eglGetProcAddress("glPathTexGenNV"); - functions->fPathFogGen = (GrGLPathFogGenProc) eglGetProcAddress("glPathFogGenNV"); - functions->fCoverFillPath = (GrGLCoverFillPathProc) eglGetProcAddress("glCoverFillPathNV"); - functions->fCoverStrokePath = (GrGLCoverStrokePathProc) eglGetProcAddress("glCoverStrokePathNV"); - functions->fCoverFillPathInstanced = (GrGLCoverFillPathInstancedProc) eglGetProcAddress("glCoverFillPathInstancedNV"); - functions->fCoverStrokePathInstanced = (GrGLCoverStrokePathInstancedProc) eglGetProcAddress("glCoverStrokePathInstancedNV"); - functions->fGetPathParameteriv = (GrGLGetPathParameterivProc) eglGetProcAddress("glGetPathParameterivNV"); - functions->fGetPathParameterfv = (GrGLGetPathParameterfvProc) eglGetProcAddress("glGetPathParameterfvNV"); - functions->fGetPathCommands = (GrGLGetPathCommandsProc) eglGetProcAddress("glGetPathCommandsNV"); - functions->fGetPathCoords = (GrGLGetPathCoordsProc) eglGetProcAddress("glGetPathCoordsNV"); - functions->fGetPathDashArray = (GrGLGetPathDashArrayProc) eglGetProcAddress("glGetPathDashArrayNV"); - functions->fGetPathMetrics = (GrGLGetPathMetricsProc) eglGetProcAddress("glGetPathMetricsNV"); - functions->fGetPathMetricRange = (GrGLGetPathMetricRangeProc) eglGetProcAddress("glGetPathMetricRangeNV"); - functions->fGetPathSpacing = (GrGLGetPathSpacingProc) eglGetProcAddress("glGetPathSpacingNV"); - functions->fGetPathColorGeniv = (GrGLGetPathColorGenivProc) eglGetProcAddress("glGetPathColorGenivNV"); - functions->fGetPathColorGenfv = (GrGLGetPathColorGenfvProc) eglGetProcAddress("glGetPathColorGenfvNV"); - functions->fGetPathTexGeniv = (GrGLGetPathTexGenivProc) eglGetProcAddress("glGetPathTexGenivNV"); - functions->fGetPathTexGenfv = (GrGLGetPathTexGenfvProc) eglGetProcAddress("glGetPathTexGenfvNV"); - functions->fIsPointInFillPath = (GrGLIsPointInFillPathProc) eglGetProcAddress("glIsPointInFillPathNV"); - functions->fIsPointInStrokePath = (GrGLIsPointInStrokePathProc) eglGetProcAddress("glIsPointInStrokePathNV"); - functions->fGetPathLength = (GrGLGetPathLengthProc) eglGetProcAddress("glGetPathLengthNV"); - functions->fPointAlongPath = (GrGLPointAlongPathProc) eglGetProcAddress("glPointAlongPathNV"); - } - - if (extensions.has("GL_EXT_debug_marker")) { - functions->fInsertEventMarker = (GrGLInsertEventMarkerProc) eglGetProcAddress("glInsertEventMarkerEXT"); - functions->fPushGroupMarker = (GrGLInsertEventMarkerProc) eglGetProcAddress("glPushGroupMarkerEXT"); - functions->fPopGroupMarker = (GrGLPopGroupMarkerProc) eglGetProcAddress("glPopGroupMarkerEXT"); - } - - functions->fInvalidateBufferData = (GrGLInvalidateBufferDataProc) eglGetProcAddress("glInvalidateBufferData"); - functions->fInvalidateBufferSubData = (GrGLInvalidateBufferSubDataProc) eglGetProcAddress("glInvalidateBufferSubData"); - functions->fInvalidateFramebuffer = (GrGLInvalidateFramebufferProc) eglGetProcAddress("glInvalidateFramebuffer"); - functions->fInvalidateSubFramebuffer = (GrGLInvalidateSubFramebufferProc) eglGetProcAddress("glInvalidateSubFramebuffer"); - functions->fInvalidateTexImage = (GrGLInvalidateTexImageProc) eglGetProcAddress("glInvalidateTexImage"); - functions->fInvalidateTexSubImage = (GrGLInvalidateTexSubImageProc) eglGetProcAddress("glInvalidateTexSubImage"); +static GrGLFuncPtr android_get_gl_proc(void* ctx, const char name[]) { + SkASSERT(NULL == ctx); + return eglGetProcAddress(name); +} - return interface; +static const GrGLInterface* create_desktop_interface() { + return GrGLAssembleGLInterface(NULL, android_get_gl_proc); } const GrGLInterface* GrGLCreateNativeInterface() { - GrGLGetStringiProc getStringi = (GrGLGetStringiProc) eglGetProcAddress("glGetStringi"); - const char* verStr = reinterpret_cast<const char*>(glGetString(GR_GL_VERSION)); - GrGLVersion version = GrGLGetVersionFromString(verStr); GrGLStandard standard = GrGLGetStandardInUseFromString(verStr); - GrGLExtensions extensions; - if (!extensions.init(standard, glGetString, getStringi, glGetIntegerv)) { - return NULL; - } - - GrGLInterface* interface = NULL; if (kGLES_GrGLStandard == standard) { - interface = create_es_interface(version, &extensions); - } else if (kGL_GrGLStandard == standard) { - interface = create_desktop_interface(version, extensions); - } + GrGLVersion version = GrGLGetVersionFromString(verStr); + GrGLExtensions extensions; + GrGLGetStringiProc getStringi = (GrGLGetStringiProc) eglGetProcAddress("glGetStringi"); + if (!extensions.init(standard, glGetString, getStringi, glGetIntegerv)) { + return NULL; + } + GrGLInterface* interface = create_es_interface(version, &extensions); - if (NULL != interface) { - interface->fExtensions.swap(&extensions); + if (NULL != interface) { + interface->fExtensions.swap(&extensions); + } + + return interface; + } else if (kGL_GrGLStandard == standard) { + return create_desktop_interface(); } - return interface; + return NULL; } diff --git a/gpu/gl/debug/GrGLCreateDebugInterface.cpp b/gpu/gl/debug/GrGLCreateDebugInterface.cpp index cbfbb266..0a8333b8 100644 --- a/gpu/gl/debug/GrGLCreateDebugInterface.cpp +++ b/gpu/gl/debug/GrGLCreateDebugInterface.cpp @@ -848,11 +848,8 @@ const GrGLInterface* GrGLCreateDebugInterface() { functions->fGetTexLevelParameteriv = noOpGLGetTexLevelParameteriv; functions->fGetUniformLocation = noOpGLGetUniformLocation; functions->fGenVertexArrays = debugGLGenVertexArrays; - functions->fLoadIdentity = noOpGLLoadIdentity; - functions->fLoadMatrixf = noOpGLLoadMatrixf; functions->fLineWidth = noOpGLLineWidth; functions->fLinkProgram = noOpGLLinkProgram; - functions->fMatrixMode = noOpGLMatrixMode; functions->fPixelStorei = debugGLPixelStorei; functions->fQueryCounter = noOpGLQueryCounter; functions->fReadBuffer = noOpGLReadBuffer; @@ -865,8 +862,6 @@ const GrGLInterface* GrGLCreateDebugInterface() { functions->fStencilMaskSeparate = noOpGLStencilMaskSeparate; functions->fStencilOp = noOpGLStencilOp; functions->fStencilOpSeparate = noOpGLStencilOpSeparate; - functions->fTexGenfv = noOpGLTexGenfv; - functions->fTexGeni = noOpGLTexGeni; functions->fTexImage2D = noOpGLTexImage2D; functions->fTexParameteri = noOpGLTexParameteri; functions->fTexParameteriv = noOpGLTexParameteriv; @@ -915,6 +910,8 @@ const GrGLInterface* GrGLCreateDebugInterface() { functions->fResolveMultisampleFramebuffer = noOpGLResolveMultisampleFramebuffer; functions->fMapBuffer = debugGLMapBuffer; + functions->fMatrixLoadf = noOpGLMatrixLoadf; + functions->fMatrixLoadIdentity = noOpGLMatrixLoadIdentity; functions->fUnmapBuffer = debugGLUnmapBuffer; functions->fBindFragDataLocationIndexed = noOpGLBindFragDataLocationIndexed; diff --git a/gpu/gl/mac/GrGLCreateNativeInterface_mac.cpp b/gpu/gl/mac/GrGLCreateNativeInterface_mac.cpp index 04898d11..ab3f0ad2 100644 --- a/gpu/gl/mac/GrGLCreateNativeInterface_mac.cpp +++ b/gpu/gl/mac/GrGLCreateNativeInterface_mac.cpp @@ -8,12 +8,10 @@ #include "gl/GrGLInterface.h" -#include "../GrGLUtil.h" +#include "gl/GrGLAssembleInterface.h" #include <dlfcn.h> -// We get the proc addresss of all GL functions dynamically because we sometimes link against -// alternative GL implementations (e.g. MESA) in addition to the native GL implementation. class GLLoader { public: GLLoader() { @@ -21,236 +19,40 @@ public: "/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib", RTLD_LAZY); } + ~GLLoader() { if (NULL != fLibrary) { dlclose(fLibrary); } } - void* handle() { + + void* handle() const { return NULL == fLibrary ? RTLD_DEFAULT : fLibrary; } + private: void* fLibrary; }; -static void* GetProcAddress(const char* name) { - static GLLoader gLoader; - return dlsym(gLoader.handle(), name); -} - -#define GET_PROC(name) (interface->fFunctions.f ## name = ((GrGL ## name ## Proc) GetProcAddress("gl" #name))) -#define GET_PROC_SUFFIX(name, suffix) (interface->fFunctions.f ## name = ((GrGL ## name ## Proc) GetProcAddress("gl" #name #suffix))) - -const GrGLInterface* GrGLCreateNativeInterface() { - - GrGLGetStringProc glGetString = (GrGLGetStringProc) GetProcAddress("glGetString"); - GrGLGetStringiProc glGetStringi = (GrGLGetStringiProc) GetProcAddress("glGetStringi"); - GrGLGetIntegervProc glGetIntegerv = (GrGLGetIntegervProc) GetProcAddress("glGetIntegerv"); - - const char* verStr = (const char*) glGetString(GR_GL_VERSION); - GrGLVersion ver = GrGLGetVersionFromString(verStr); - GrGLExtensions extensions; - if (!extensions.init(kGL_GrGLStandard, glGetString, glGetStringi, glGetIntegerv)) { - return NULL; - } - - GrGLInterface* interface = SkNEW(GrGLInterface); - interface->fStandard = kGL_GrGLStandard; - - GET_PROC(ActiveTexture); - GET_PROC(AttachShader); - GET_PROC(BeginQuery); - GET_PROC(BindAttribLocation); - GET_PROC(BindBuffer); - if (ver >= GR_GL_VER(3,0)) { - GET_PROC(BindFragDataLocation); - } - GET_PROC(BindTexture); - GET_PROC(BlendFunc); - - if (ver >= GR_GL_VER(1,4) || - extensions.has("GL_ARB_imaging") || - extensions.has("GL_EXT_blend_color")) { - GET_PROC(BlendColor); - } - - 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(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); - GET_PROC(Enable); - GET_PROC(EnableVertexAttribArray); - GET_PROC(EndQuery); - GET_PROC(Finish); - GET_PROC(Flush); - GET_PROC(FrontFace); - GET_PROC(GenBuffers); - GET_PROC(GenerateMipmap); - GET_PROC(GenQueries); - GET_PROC(GetBufferParameteriv); - GET_PROC(GetError); - GET_PROC(GetIntegerv); - GET_PROC(GetProgramInfoLog); - GET_PROC(GetProgramiv); - GET_PROC(GetQueryiv); - GET_PROC(GetQueryObjectiv); - GET_PROC(GetQueryObjectuiv); - GET_PROC(GetShaderInfoLog); - GET_PROC(GetShaderiv); - GET_PROC(GetString); - GET_PROC(GetStringi); - GET_PROC(GetTexLevelParameteriv); - GET_PROC(GenTextures); - GET_PROC(GetUniformLocation); - GET_PROC(LineWidth); - GET_PROC(LinkProgram); - GET_PROC(LoadIdentity); - GET_PROC(LoadMatrixf); - GET_PROC(MapBuffer); - GET_PROC(MatrixMode); - GET_PROC(PixelStorei); - GET_PROC(ReadBuffer); - GET_PROC(ReadPixels); - GET_PROC(Scissor); - GET_PROC(ShaderSource); - GET_PROC(StencilFunc); - GET_PROC(StencilFuncSeparate); - GET_PROC(StencilMask); - GET_PROC(StencilMaskSeparate); - GET_PROC(StencilOp); - GET_PROC(StencilOpSeparate); - GET_PROC(TexGenfv); - GET_PROC(TexGeni); - GET_PROC(TexImage2D); - GET_PROC(TexParameteri); - GET_PROC(TexParameteriv); - if (ver >= GR_GL_VER(4,2) || extensions.has("GL_ARB_texture_storage")) { - GET_PROC(TexStorage2D); - } else if (extensions.has("GL_EXT_texture_storage")) { - GET_PROC_SUFFIX(TexStorage2D, EXT); - } - GET_PROC(TexSubImage2D); - GET_PROC(Uniform1f); - GET_PROC(Uniform1i); - GET_PROC(Uniform1fv); - GET_PROC(Uniform1iv); - GET_PROC(Uniform2f); - GET_PROC(Uniform2i); - GET_PROC(Uniform2fv); - GET_PROC(Uniform2iv); - GET_PROC(Uniform3f); - GET_PROC(Uniform3i); - GET_PROC(Uniform3fv); - GET_PROC(Uniform3iv); - GET_PROC(Uniform4f); - GET_PROC(Uniform4i); - GET_PROC(Uniform4fv); - GET_PROC(Uniform4iv); - GET_PROC(Uniform4fv); - GET_PROC(UniformMatrix2fv); - GET_PROC(UniformMatrix3fv); - GET_PROC(UniformMatrix4fv); - GET_PROC(UnmapBuffer); - GET_PROC(UseProgram); - GET_PROC(VertexAttrib4fv); - GET_PROC(VertexAttribPointer); - GET_PROC(Viewport); - - if (ver >= GR_GL_VER(3,0) || extensions.has("GL_ARB_vertex_array_object")) { - // no ARB suffix for GL_ARB_vertex_array_object - GET_PROC(BindVertexArray); - GET_PROC(DeleteVertexArrays); - GET_PROC(GenVertexArrays); - } - - if (ver >= GR_GL_VER(3,3) || extensions.has("GL_ARB_timer_query")) { - // ARB extension doesn't use the ARB suffix on the function name - GET_PROC(QueryCounter); - GET_PROC(GetQueryObjecti64v); - GET_PROC(GetQueryObjectui64v); - } else if (extensions.has("GL_EXT_timer_query")) { - GET_PROC_SUFFIX(GetQueryObjecti64v, EXT); - GET_PROC_SUFFIX(GetQueryObjectui64v, EXT); - } +class GLProcGetter { +public: + GLProcGetter() {} - if (ver >= GR_GL_VER(3,0) || extensions.has("GL_ARB_framebuffer_object")) { - // ARB extension doesn't use the ARB suffix on the function names - GET_PROC(GenFramebuffers); - GET_PROC(GetFramebufferAttachmentParameteriv); - GET_PROC(GetRenderbufferParameteriv); - GET_PROC(BindFramebuffer); - GET_PROC(FramebufferTexture2D); - GET_PROC(CheckFramebufferStatus); - GET_PROC(DeleteFramebuffers); - GET_PROC(RenderbufferStorage); - GET_PROC(GenRenderbuffers); - GET_PROC(DeleteRenderbuffers); - GET_PROC(FramebufferRenderbuffer); - GET_PROC(BindRenderbuffer); - GET_PROC(RenderbufferStorageMultisample); - GET_PROC(BlitFramebuffer); - } else { - if (extensions.has("GL_EXT_framebuffer_object")) { - GET_PROC_SUFFIX(GenFramebuffers, EXT); - GET_PROC_SUFFIX(GetFramebufferAttachmentParameteriv, EXT); - GET_PROC_SUFFIX(GetRenderbufferParameteriv, EXT); - GET_PROC_SUFFIX(BindFramebuffer, EXT); - GET_PROC_SUFFIX(FramebufferTexture2D, EXT); - GET_PROC_SUFFIX(CheckFramebufferStatus, EXT); - GET_PROC_SUFFIX(DeleteFramebuffers, EXT); - GET_PROC_SUFFIX(RenderbufferStorage, EXT); - GET_PROC_SUFFIX(GenRenderbuffers, EXT); - GET_PROC_SUFFIX(DeleteRenderbuffers, EXT); - GET_PROC_SUFFIX(FramebufferRenderbuffer, EXT); - GET_PROC_SUFFIX(BindRenderbuffer, EXT); - } - if (extensions.has("GL_EXT_framebuffer_multisample")) { - GET_PROC_SUFFIX(RenderbufferStorageMultisample, EXT); - } - if (extensions.has("GL_EXT_framebuffer_blit")) { - GET_PROC_SUFFIX(BlitFramebuffer, EXT); - } - } - if (ver >= GR_GL_VER(3,3) || extensions.has("GL_ARB_blend_func_extended")) { - // ARB extension doesn't use the ARB suffix on the function name - GET_PROC(BindFragDataLocationIndexed); + GrGLFuncPtr getProc(const char name[]) const { + return (GrGLFuncPtr) dlsym(fLoader.handle(), name); } - if (extensions.has("GL_EXT_debug_marker")) { - GET_PROC_SUFFIX(InsertEventMarker, EXT); - GET_PROC_SUFFIX(PushGroupMarker, EXT); - GET_PROC_SUFFIX(PopGroupMarker, EXT); - } +private: + GLLoader fLoader; +}; - if (ver >= GR_GL_VER(4,3) || extensions.has("GL_ARB_invalidate_subdata")) { - GET_PROC(InvalidateBufferData); - GET_PROC(InvalidateBufferSubData); - GET_PROC(InvalidateFramebuffer); - GET_PROC(InvalidateSubFramebuffer); - GET_PROC(InvalidateTexImage); - GET_PROC(InvalidateTexSubImage); - } +static GrGLFuncPtr mac_get_gl_proc(void* ctx, const char name[]) { + SkASSERT(NULL != ctx); + const GLProcGetter* getter = (const GLProcGetter*) ctx; + return getter->getProc(name); +} - interface->fExtensions.swap(&extensions); - return interface; +const GrGLInterface* GrGLCreateNativeInterface() { + GLProcGetter getter; + return GrGLAssembleGLInterface(&getter, mac_get_gl_proc); } diff --git a/gpu/gl/mesa/GrGLCreateMesaInterface.cpp b/gpu/gl/mesa/GrGLCreateMesaInterface.cpp index fd8be26f..a95b6fc8 100644 --- a/gpu/gl/mesa/GrGLCreateMesaInterface.cpp +++ b/gpu/gl/mesa/GrGLCreateMesaInterface.cpp @@ -6,235 +6,20 @@ * found in the LICENSE file. */ -#include "gl/GrGLExtensions.h" -#include "gl/GrGLInterface.h" +#include "gl/GrGLAssembleInterface.h" #include "../GrGLUtil.h" -#define GL_GLEXT_PROTOTYPES #include "osmesa_wrapper.h" -#define GR_GL_GET_PROC(F) interface->fFunctions.f ## F = (GrGL ## F ## Proc) \ - OSMesaGetProcAddress("gl" #F); -#define GR_GL_GET_PROC_SUFFIX(F, S) interface->fFunctions.f ## F = (GrGL ## F ## Proc) \ - OSMesaGetProcAddress("gl" #F #S); - -// We use OSMesaGetProcAddress for every gl function to avoid accidentally using -// non-Mesa gl functions. +static GrGLFuncPtr osmesa_get(void* ctx, const char name[]) { + SkASSERT(NULL == ctx); + SkASSERT(NULL != OSMesaGetCurrentContext()); + return OSMesaGetProcAddress(name); +} const GrGLInterface* GrGLCreateMesaInterface() { if (NULL == OSMesaGetCurrentContext()) { return NULL; } - - GrGLGetStringProc getString = (GrGLGetStringProc) OSMesaGetProcAddress("glGetString"); - GrGLGetStringiProc getStringi = (GrGLGetStringiProc) OSMesaGetProcAddress("glGetStringi"); - GrGLGetIntegervProc getIntegerv = - (GrGLGetIntegervProc) OSMesaGetProcAddress("glGetIntegerv"); - - GrGLExtensions extensions; - if (!extensions.init(kGL_GrGLStandard, getString, getStringi, getIntegerv)) { - return NULL; - } - - const char* versionString = (const char*) getString(GL_VERSION); - GrGLVersion glVer = GrGLGetVersionFromString(versionString); - - if (glVer < GR_GL_VER(1,5)) { - // We must have array and element_array buffer objects. - return NULL; - } - GrGLInterface* interface = SkNEW(GrGLInterface()); - - GR_GL_GET_PROC(ActiveTexture); - GR_GL_GET_PROC(BeginQuery); - GR_GL_GET_PROC(AttachShader); - GR_GL_GET_PROC(BindAttribLocation); - GR_GL_GET_PROC(BindBuffer); - GR_GL_GET_PROC(BindFragDataLocation); - GR_GL_GET_PROC(BindTexture); - GR_GL_GET_PROC(BlendFunc); - - if (glVer >= GR_GL_VER(1,4) || - extensions.has("GL_ARB_imaging") || - extensions.has("GL_EXT_blend_color")) { - GR_GL_GET_PROC(BlendColor); - } - - GR_GL_GET_PROC(BufferData); - GR_GL_GET_PROC(BufferSubData); - GR_GL_GET_PROC(Clear); - GR_GL_GET_PROC(ClearColor); - GR_GL_GET_PROC(ClearStencil); - GR_GL_GET_PROC(ColorMask); - GR_GL_GET_PROC(CompileShader); - GR_GL_GET_PROC(CompressedTexImage2D); - GR_GL_GET_PROC(CopyTexSubImage2D); - GR_GL_GET_PROC(CreateProgram); - GR_GL_GET_PROC(CreateShader); - GR_GL_GET_PROC(CullFace); - GR_GL_GET_PROC(DeleteBuffers); - GR_GL_GET_PROC(DeleteProgram); - GR_GL_GET_PROC(DeleteQueries); - GR_GL_GET_PROC(DeleteShader); - GR_GL_GET_PROC(DeleteTextures); - GR_GL_GET_PROC(DepthMask); - GR_GL_GET_PROC(Disable); - GR_GL_GET_PROC(DisableVertexAttribArray); - GR_GL_GET_PROC(DrawArrays); - GR_GL_GET_PROC(DrawBuffer); - GR_GL_GET_PROC(DrawBuffers); - GR_GL_GET_PROC(DrawElements); - GR_GL_GET_PROC(Enable); - GR_GL_GET_PROC(EnableVertexAttribArray); - GR_GL_GET_PROC(EndQuery); - GR_GL_GET_PROC(Finish); - GR_GL_GET_PROC(Flush); - GR_GL_GET_PROC(FrontFace); - GR_GL_GET_PROC(GenBuffers); - GR_GL_GET_PROC(GenerateMipmap); - GR_GL_GET_PROC(GenQueries); - GR_GL_GET_PROC(GetBufferParameteriv); - GR_GL_GET_PROC(GetError); - GR_GL_GET_PROC(GetIntegerv); - GR_GL_GET_PROC(GetProgramInfoLog); - GR_GL_GET_PROC(GetProgramiv); - if (glVer >= GR_GL_VER(3,3) || extensions.has("GL_ARB_timer_query")) { - GR_GL_GET_PROC(GetQueryObjecti64v); - GR_GL_GET_PROC(GetQueryObjectui64v) - GR_GL_GET_PROC(QueryCounter); - } else if (extensions.has("GL_EXT_timer_query")) { - GR_GL_GET_PROC_SUFFIX(GetQueryObjecti64v, EXT); - GR_GL_GET_PROC_SUFFIX(GetQueryObjectui64v, EXT); - } - GR_GL_GET_PROC(GetQueryObjectiv); - GR_GL_GET_PROC(GetQueryObjectuiv); - GR_GL_GET_PROC(GetQueryiv); - GR_GL_GET_PROC(GetShaderInfoLog); - GR_GL_GET_PROC(GetShaderiv); - GR_GL_GET_PROC(GetString); - GR_GL_GET_PROC(GetStringi); - GR_GL_GET_PROC(GetTexLevelParameteriv); - GR_GL_GET_PROC(GenTextures); - GR_GL_GET_PROC(GetUniformLocation); - GR_GL_GET_PROC(LineWidth); - GR_GL_GET_PROC(LinkProgram); - GR_GL_GET_PROC(LoadIdentity); - GR_GL_GET_PROC(LoadMatrixf); - GR_GL_GET_PROC(MatrixMode); - GR_GL_GET_PROC(MapBuffer); - GR_GL_GET_PROC(PixelStorei); - GR_GL_GET_PROC(ReadBuffer); - GR_GL_GET_PROC(ReadPixels); - GR_GL_GET_PROC(Scissor); - GR_GL_GET_PROC(ShaderSource); - GR_GL_GET_PROC(StencilFunc); - GR_GL_GET_PROC(StencilFuncSeparate); - GR_GL_GET_PROC(StencilMask); - GR_GL_GET_PROC(StencilMaskSeparate); - GR_GL_GET_PROC(StencilOp); - GR_GL_GET_PROC(StencilOpSeparate); - GR_GL_GET_PROC(TexGenfv); - GR_GL_GET_PROC(TexGeni); - GR_GL_GET_PROC(TexImage2D) - GR_GL_GET_PROC(TexParameteri); - GR_GL_GET_PROC(TexParameteriv); - GR_GL_GET_PROC(TexStorage2D); - if (NULL == interface->fFunctions.fTexStorage2D) { - GR_GL_GET_PROC_SUFFIX(TexStorage2D, EXT); - } - GR_GL_GET_PROC(TexSubImage2D); - GR_GL_GET_PROC(Uniform1f); - GR_GL_GET_PROC(Uniform1i); - GR_GL_GET_PROC(Uniform1fv); - GR_GL_GET_PROC(Uniform1iv); - GR_GL_GET_PROC(Uniform2f); - GR_GL_GET_PROC(Uniform2i); - GR_GL_GET_PROC(Uniform2fv); - GR_GL_GET_PROC(Uniform2iv); - GR_GL_GET_PROC(Uniform3f); - GR_GL_GET_PROC(Uniform3i); - GR_GL_GET_PROC(Uniform3fv); - GR_GL_GET_PROC(Uniform3iv); - GR_GL_GET_PROC(Uniform4f); - GR_GL_GET_PROC(Uniform4i); - GR_GL_GET_PROC(Uniform4fv); - GR_GL_GET_PROC(Uniform4iv); - GR_GL_GET_PROC(UniformMatrix2fv); - GR_GL_GET_PROC(UniformMatrix3fv); - GR_GL_GET_PROC(UniformMatrix4fv); - GR_GL_GET_PROC(UnmapBuffer); - GR_GL_GET_PROC(UseProgram); - GR_GL_GET_PROC(VertexAttrib4fv); - GR_GL_GET_PROC(VertexAttribPointer); - GR_GL_GET_PROC(Viewport); - - if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_vertex_array_object")) { - // no ARB suffix for GL_ARB_vertex_array_object - GR_GL_GET_PROC(BindVertexArray); - GR_GL_GET_PROC(DeleteVertexArrays); - GR_GL_GET_PROC(GenVertexArrays); - } - - // First look for GL3.0 FBO or GL_ARB_framebuffer_object (same since - // GL_ARB_framebuffer_object doesn't use ARB suffix.) - if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_framebuffer_object")) { - GR_GL_GET_PROC(GenFramebuffers); - GR_GL_GET_PROC(GetFramebufferAttachmentParameteriv); - GR_GL_GET_PROC(GetRenderbufferParameteriv); - GR_GL_GET_PROC(BindFramebuffer); - GR_GL_GET_PROC(FramebufferTexture2D); - GR_GL_GET_PROC(CheckFramebufferStatus); - GR_GL_GET_PROC(DeleteFramebuffers); - GR_GL_GET_PROC(RenderbufferStorage); - GR_GL_GET_PROC(GenRenderbuffers); - GR_GL_GET_PROC(DeleteRenderbuffers); - GR_GL_GET_PROC(FramebufferRenderbuffer); - GR_GL_GET_PROC(BindRenderbuffer); - GR_GL_GET_PROC(RenderbufferStorageMultisample); - GR_GL_GET_PROC(BlitFramebuffer); - } else if (extensions.has("GL_EXT_framebuffer_object")) { - GR_GL_GET_PROC_SUFFIX(GenFramebuffers, EXT); - GR_GL_GET_PROC_SUFFIX(GetFramebufferAttachmentParameteriv, EXT); - GR_GL_GET_PROC_SUFFIX(GetRenderbufferParameteriv, EXT); - GR_GL_GET_PROC_SUFFIX(BindFramebuffer, EXT); - GR_GL_GET_PROC_SUFFIX(FramebufferTexture2D, EXT); - GR_GL_GET_PROC_SUFFIX(CheckFramebufferStatus, EXT); - GR_GL_GET_PROC_SUFFIX(DeleteFramebuffers, EXT); - GR_GL_GET_PROC_SUFFIX(RenderbufferStorage, EXT); - GR_GL_GET_PROC_SUFFIX(GenRenderbuffers, EXT); - GR_GL_GET_PROC_SUFFIX(DeleteRenderbuffers, EXT); - GR_GL_GET_PROC_SUFFIX(FramebufferRenderbuffer, EXT); - GR_GL_GET_PROC_SUFFIX(BindRenderbuffer, EXT); - if (extensions.has("GL_EXT_framebuffer_multisample")) { - GR_GL_GET_PROC_SUFFIX(RenderbufferStorageMultisample, EXT); - } - if (extensions.has("GL_EXT_framebuffer_blit")) { - GR_GL_GET_PROC_SUFFIX(BlitFramebuffer, EXT); - } - } else { - // we must have FBOs - delete interface; - return NULL; - } - GR_GL_GET_PROC(BindFragDataLocationIndexed); - - if (extensions.has("GL_EXT_debug_marker")) { - GR_GL_GET_PROC_SUFFIX(InsertEventMarker, EXT); - GR_GL_GET_PROC_SUFFIX(PopGroupMarker, EXT); - GR_GL_GET_PROC_SUFFIX(PushGroupMarker, EXT); - } - - if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_ARB_invalidate_subdata")) { - GR_GL_GET_PROC(InvalidateBufferData); - GR_GL_GET_PROC(InvalidateBufferSubData); - GR_GL_GET_PROC(InvalidateFramebuffer); - GR_GL_GET_PROC(InvalidateSubFramebuffer); - GR_GL_GET_PROC(InvalidateTexImage); - GR_GL_GET_PROC(InvalidateTexSubImage); - } - - interface->fStandard = kGL_GrGLStandard; - interface->fExtensions.swap(&extensions); - - return interface; + return GrGLAssembleGLInterface(NULL, osmesa_get); } diff --git a/gpu/gl/unix/GrGLCreateNativeInterface_unix.cpp b/gpu/gl/unix/GrGLCreateNativeInterface_unix.cpp index 93807637..ddbfe5de 100644 --- a/gpu/gl/unix/GrGLCreateNativeInterface_unix.cpp +++ b/gpu/gl/unix/GrGLCreateNativeInterface_unix.cpp @@ -1,6 +1,5 @@ - /* - * Copyright 2011 Google Inc. + * Copyright 2014 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. @@ -8,287 +7,19 @@ #include "gl/GrGLInterface.h" -#include "../GrGLUtil.h" +#include "gl/GrGLAssembleInterface.h" #include <GL/glx.h> -#include <GL/gl.h> -#include <GL/glext.h> -#include <GL/glu.h> -#define GR_GL_GET_PROC(F) interface->fFunctions.f ## F = (GrGL ## F ## Proc) \ - glXGetProcAddress(reinterpret_cast<const GLubyte*>("gl" #F)); -#define GR_GL_GET_PROC_SUFFIX(F, S) interface->fFunctions.f ## F = (GrGL ## F ## Proc) \ - glXGetProcAddress(reinterpret_cast<const GLubyte*>("gl" #F #S)); +static GrGLFuncPtr glx_get(void* ctx, const char name[]) { + SkASSERT(NULL == ctx); + SkASSERT(NULL != glXGetCurrentContext()); + return glXGetProcAddress(reinterpret_cast<const GLubyte*>(name)); +} const GrGLInterface* GrGLCreateNativeInterface() { if (NULL == glXGetCurrentContext()) { return NULL; } - - const char* versionString = (const char*) glGetString(GL_VERSION); - GrGLVersion glVer = GrGLGetVersionFromString(versionString); - - // This may or may not succeed depending on the gl version. - GrGLGetStringiProc glGetStringi = - (GrGLGetStringiProc) glXGetProcAddress(reinterpret_cast<const GLubyte*>("glGetStringi")); - - GrGLExtensions extensions; - if (!extensions.init(kGL_GrGLStandard, glGetString, glGetStringi, glGetIntegerv)) { - return NULL; - } - - if (glVer < GR_GL_VER(1,5)) { - // We must have array and element_array buffer objects. - return NULL; - } - - GrGLInterface* interface = SkNEW(GrGLInterface()); - GrGLInterface::Functions* functions = &interface->fFunctions; - - functions->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); - functions->fBindTexture = glBindTexture; - functions->fBlendFunc = glBlendFunc; - - if (glVer >= GR_GL_VER(1,4) || - extensions.has("GL_ARB_imaging") || - extensions.has("GL_EXT_blend_color")) { - GR_GL_GET_PROC(BlendColor); - } - - GR_GL_GET_PROC(BufferData); - GR_GL_GET_PROC(BufferSubData); - functions->fClear = glClear; - functions->fClearColor = glClearColor; - functions->fClearStencil = glClearStencil; - functions->fColorMask = glColorMask; - GR_GL_GET_PROC(CompileShader); - functions->fCompressedTexImage2D = glCompressedTexImage2D; - functions->fCopyTexSubImage2D = glCopyTexSubImage2D; - GR_GL_GET_PROC(CreateProgram); - GR_GL_GET_PROC(CreateShader); - functions->fCullFace = glCullFace; - GR_GL_GET_PROC(DeleteBuffers); - GR_GL_GET_PROC(DeleteProgram); - GR_GL_GET_PROC(DeleteQueries); - GR_GL_GET_PROC(DeleteShader); - functions->fDeleteTextures = glDeleteTextures; - functions->fDepthMask = glDepthMask; - functions->fDisable = glDisable; - GR_GL_GET_PROC(DisableVertexAttribArray); - functions->fDrawArrays = glDrawArrays; - functions->fDrawBuffer = glDrawBuffer; - GR_GL_GET_PROC(DrawBuffers); - functions->fDrawElements = glDrawElements; - functions->fEnable = glEnable; - GR_GL_GET_PROC(EnableVertexAttribArray); - GR_GL_GET_PROC(EndQuery); - functions->fFinish = glFinish; - functions->fFlush = glFlush; - functions->fFrontFace = glFrontFace; - GR_GL_GET_PROC(GenBuffers); - GR_GL_GET_PROC(GenerateMipmap); - GR_GL_GET_PROC(GetBufferParameteriv); - functions->fGetError = glGetError; - functions->fGetIntegerv = glGetIntegerv; - GR_GL_GET_PROC(GetQueryObjectiv); - GR_GL_GET_PROC(GetQueryObjectuiv); - if (glVer >= GR_GL_VER(3,3) || extensions.has("GL_ARB_timer_query")) { - GR_GL_GET_PROC(GetQueryObjecti64v); - GR_GL_GET_PROC(GetQueryObjectui64v); - GR_GL_GET_PROC(QueryCounter); - } else if (extensions.has("GL_EXT_timer_query")) { - 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); - functions->fGetString = glGetString; - GR_GL_GET_PROC(GetStringi); - functions->fGetTexLevelParameteriv = glGetTexLevelParameteriv; - GR_GL_GET_PROC(GenQueries); - functions->fGenTextures = glGenTextures; - GR_GL_GET_PROC(GetUniformLocation); - functions->fLineWidth = glLineWidth; - GR_GL_GET_PROC(LinkProgram); - GR_GL_GET_PROC(MapBuffer); - functions->fPixelStorei = glPixelStorei; - functions->fReadBuffer = glReadBuffer; - functions->fReadPixels = glReadPixels; - functions->fScissor = glScissor; - GR_GL_GET_PROC(ShaderSource); - functions->fStencilFunc = glStencilFunc; - GR_GL_GET_PROC(StencilFuncSeparate); - functions->fStencilMask = glStencilMask; - GR_GL_GET_PROC(StencilMaskSeparate); - functions->fStencilOp = glStencilOp; - GR_GL_GET_PROC(StencilOpSeparate); - functions->fTexImage2D = glTexImage2D; - functions->fTexGenfv = glTexGenfv; - functions->fTexGeni = glTexGeni; - functions->fTexParameteri = glTexParameteri; - functions->fTexParameteriv = glTexParameteriv; - if (glVer >= GR_GL_VER(4,2) || extensions.has("GL_ARB_texture_storage")) { - GR_GL_GET_PROC(TexStorage2D); - } else if (extensions.has("GL_EXT_texture_storage")) { - GR_GL_GET_PROC_SUFFIX(TexStorage2D, EXT); - } - functions->fTexSubImage2D = glTexSubImage2D; - GR_GL_GET_PROC(Uniform1f); - GR_GL_GET_PROC(Uniform1i); - GR_GL_GET_PROC(Uniform1fv); - GR_GL_GET_PROC(Uniform1iv); - GR_GL_GET_PROC(Uniform2f); - GR_GL_GET_PROC(Uniform2i); - GR_GL_GET_PROC(Uniform2fv); - GR_GL_GET_PROC(Uniform2iv); - GR_GL_GET_PROC(Uniform3f); - GR_GL_GET_PROC(Uniform3i); - GR_GL_GET_PROC(Uniform3fv); - GR_GL_GET_PROC(Uniform3iv); - GR_GL_GET_PROC(Uniform4f); - GR_GL_GET_PROC(Uniform4i); - GR_GL_GET_PROC(Uniform4fv); - GR_GL_GET_PROC(Uniform4iv); - GR_GL_GET_PROC(UniformMatrix2fv); - GR_GL_GET_PROC(UniformMatrix3fv); - GR_GL_GET_PROC(UniformMatrix4fv); - GR_GL_GET_PROC(UnmapBuffer); - GR_GL_GET_PROC(UseProgram); - GR_GL_GET_PROC(VertexAttrib4fv); - GR_GL_GET_PROC(VertexAttribPointer); - functions->fViewport = glViewport; - GR_GL_GET_PROC(BindFragDataLocationIndexed); - - if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_vertex_array_object")) { - // no ARB suffix for GL_ARB_vertex_array_object - GR_GL_GET_PROC(BindVertexArray); - GR_GL_GET_PROC(GenVertexArrays); - GR_GL_GET_PROC(DeleteVertexArrays); - } - - // First look for GL3.0 FBO or GL_ARB_framebuffer_object (same since - // GL_ARB_framebuffer_object doesn't use ARB suffix.) - if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_framebuffer_object")) { - GR_GL_GET_PROC(GenFramebuffers); - GR_GL_GET_PROC(GetFramebufferAttachmentParameteriv); - GR_GL_GET_PROC(GetRenderbufferParameteriv); - GR_GL_GET_PROC(BindFramebuffer); - GR_GL_GET_PROC(FramebufferTexture2D); - GR_GL_GET_PROC(CheckFramebufferStatus); - GR_GL_GET_PROC(DeleteFramebuffers); - GR_GL_GET_PROC(RenderbufferStorage); - GR_GL_GET_PROC(GenRenderbuffers); - GR_GL_GET_PROC(DeleteRenderbuffers); - GR_GL_GET_PROC(FramebufferRenderbuffer); - GR_GL_GET_PROC(BindRenderbuffer); - GR_GL_GET_PROC(RenderbufferStorageMultisample); - GR_GL_GET_PROC(BlitFramebuffer); - } else if (extensions.has("GL_EXT_framebuffer_object")) { - GR_GL_GET_PROC_SUFFIX(GenFramebuffers, EXT); - GR_GL_GET_PROC_SUFFIX(GetFramebufferAttachmentParameteriv, EXT); - GR_GL_GET_PROC_SUFFIX(GetRenderbufferParameteriv, EXT); - GR_GL_GET_PROC_SUFFIX(BindFramebuffer, EXT); - GR_GL_GET_PROC_SUFFIX(FramebufferTexture2D, EXT); - GR_GL_GET_PROC_SUFFIX(CheckFramebufferStatus, EXT); - GR_GL_GET_PROC_SUFFIX(DeleteFramebuffers, EXT); - GR_GL_GET_PROC_SUFFIX(RenderbufferStorage, EXT); - GR_GL_GET_PROC_SUFFIX(GenRenderbuffers, EXT); - GR_GL_GET_PROC_SUFFIX(DeleteRenderbuffers, EXT); - GR_GL_GET_PROC_SUFFIX(FramebufferRenderbuffer, EXT); - GR_GL_GET_PROC_SUFFIX(BindRenderbuffer, EXT); - if (extensions.has("GL_EXT_framebuffer_multisample")) { - GR_GL_GET_PROC_SUFFIX(RenderbufferStorageMultisample, EXT); - } - if (extensions.has("GL_EXT_framebuffer_blit")) { - GR_GL_GET_PROC_SUFFIX(BlitFramebuffer, EXT); - } - } else { - // we must have FBOs - delete interface; - return NULL; - } - - GR_GL_GET_PROC(LoadIdentity); - GR_GL_GET_PROC(LoadMatrixf); - GR_GL_GET_PROC(MatrixMode); - - if (extensions.has("GL_NV_path_rendering")) { - GR_GL_GET_PROC_SUFFIX(PathCommands, NV); - GR_GL_GET_PROC_SUFFIX(PathCoords, NV); - GR_GL_GET_PROC_SUFFIX(PathSubCommands, NV); - GR_GL_GET_PROC_SUFFIX(PathSubCoords, NV); - GR_GL_GET_PROC_SUFFIX(PathString, NV); - GR_GL_GET_PROC_SUFFIX(PathGlyphs, NV); - GR_GL_GET_PROC_SUFFIX(PathGlyphRange, NV); - GR_GL_GET_PROC_SUFFIX(WeightPaths, NV); - GR_GL_GET_PROC_SUFFIX(CopyPath, NV); - GR_GL_GET_PROC_SUFFIX(InterpolatePaths, NV); - GR_GL_GET_PROC_SUFFIX(TransformPath, NV); - GR_GL_GET_PROC_SUFFIX(PathParameteriv, NV); - GR_GL_GET_PROC_SUFFIX(PathParameteri, NV); - GR_GL_GET_PROC_SUFFIX(PathParameterfv, NV); - GR_GL_GET_PROC_SUFFIX(PathParameterf, NV); - GR_GL_GET_PROC_SUFFIX(PathDashArray, NV); - GR_GL_GET_PROC_SUFFIX(GenPaths, NV); - GR_GL_GET_PROC_SUFFIX(DeletePaths, NV); - GR_GL_GET_PROC_SUFFIX(IsPath, NV); - GR_GL_GET_PROC_SUFFIX(PathStencilFunc, NV); - GR_GL_GET_PROC_SUFFIX(PathStencilDepthOffset, NV); - GR_GL_GET_PROC_SUFFIX(StencilFillPath, NV); - GR_GL_GET_PROC_SUFFIX(StencilStrokePath, NV); - GR_GL_GET_PROC_SUFFIX(StencilFillPathInstanced, NV); - GR_GL_GET_PROC_SUFFIX(StencilStrokePathInstanced, NV); - GR_GL_GET_PROC_SUFFIX(PathCoverDepthFunc, NV); - GR_GL_GET_PROC_SUFFIX(PathColorGen, NV); - GR_GL_GET_PROC_SUFFIX(PathTexGen, NV); - GR_GL_GET_PROC_SUFFIX(PathFogGen, NV); - GR_GL_GET_PROC_SUFFIX(CoverFillPath, NV); - GR_GL_GET_PROC_SUFFIX(CoverStrokePath, NV); - GR_GL_GET_PROC_SUFFIX(CoverFillPathInstanced, NV); - GR_GL_GET_PROC_SUFFIX(CoverStrokePathInstanced, NV); - GR_GL_GET_PROC_SUFFIX(GetPathParameteriv, NV); - GR_GL_GET_PROC_SUFFIX(GetPathParameterfv, NV); - GR_GL_GET_PROC_SUFFIX(GetPathCommands, NV); - GR_GL_GET_PROC_SUFFIX(GetPathCoords, NV); - GR_GL_GET_PROC_SUFFIX(GetPathDashArray, NV); - GR_GL_GET_PROC_SUFFIX(GetPathMetrics, NV); - GR_GL_GET_PROC_SUFFIX(GetPathMetricRange, NV); - GR_GL_GET_PROC_SUFFIX(GetPathSpacing, NV); - GR_GL_GET_PROC_SUFFIX(GetPathColorGeniv, NV); - GR_GL_GET_PROC_SUFFIX(GetPathColorGenfv, NV); - GR_GL_GET_PROC_SUFFIX(GetPathTexGeniv, NV); - GR_GL_GET_PROC_SUFFIX(GetPathTexGenfv, NV); - GR_GL_GET_PROC_SUFFIX(IsPointInFillPath, NV); - GR_GL_GET_PROC_SUFFIX(IsPointInStrokePath, NV); - GR_GL_GET_PROC_SUFFIX(GetPathLength, NV); - GR_GL_GET_PROC_SUFFIX(PointAlongPath, NV); - } - - if (extensions.has("GL_EXT_debug_marker")) { - GR_GL_GET_PROC_SUFFIX(InsertEventMarker, EXT); - GR_GL_GET_PROC_SUFFIX(PushGroupMarker, EXT); - GR_GL_GET_PROC_SUFFIX(PopGroupMarker, EXT); - } - - if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_ARB_invalidate_subdata")) { - GR_GL_GET_PROC(InvalidateBufferData); - GR_GL_GET_PROC(InvalidateBufferSubData); - GR_GL_GET_PROC(InvalidateFramebuffer); - GR_GL_GET_PROC(InvalidateSubFramebuffer); - GR_GL_GET_PROC(InvalidateTexImage); - GR_GL_GET_PROC(InvalidateTexSubImage); - } - - interface->fStandard = kGL_GrGLStandard; - interface->fExtensions.swap(&extensions); - - return interface; + return GrGLAssembleGLInterface(NULL, glx_get); } diff --git a/gpu/gl/win/GrGLCreateNativeInterface_win.cpp b/gpu/gl/win/GrGLCreateNativeInterface_win.cpp index 9a237825..6adaf196 100644 --- a/gpu/gl/win/GrGLCreateNativeInterface_win.cpp +++ b/gpu/gl/win/GrGLCreateNativeInterface_win.cpp @@ -7,20 +7,10 @@ */ #include "gl/GrGLInterface.h" -#include "gl/GrGLUtil.h" +#include "gl/GrGLAssembleInterface.h" #define WIN32_LEAN_AND_MEAN #include <windows.h> -/* - * Windows makes the GL funcs all be __stdcall instead of __cdecl :( - * This implementation will only work if GR_GL_FUNCTION_TYPE is __stdcall. - * Otherwise, a springboard would be needed that hides the calling convention. - */ - -#define SET_PROC(F) interface->fFunctions.f ## F = (GrGL ## F ## Proc) GetProcAddress(alu.get(), "gl" #F); -#define WGL_SET_PROC(F) interface->fFunctions.f ## F = (GrGL ## F ## Proc) wglGetProcAddress("gl" #F); -#define WGL_SET_PROC_SUFFIX(F, S) interface->fFunctions.f ## F = (GrGL ## F ## Proc) wglGetProcAddress("gl" #F #S); - class AutoLibraryUnload { public: AutoLibraryUnload(const char* moduleName) { @@ -37,288 +27,48 @@ private: HMODULE fModule; }; -const GrGLInterface* GrGLCreateNativeInterface() { - AutoLibraryUnload alu("opengl32.dll"); - if (NULL == alu.get()) { - return NULL; - } - - if (NULL != wglGetCurrentContext()) { - - // These should always be present and don't require wglGetProcAddress - GrGLGetStringProc glGetString = - (GrGLGetStringProc) GetProcAddress(alu.get(), "glGetString"); - GrGLGetIntegervProc glGetIntegerv = - (GrGLGetIntegervProc) GetProcAddress(alu.get(), "glGetIntegerv"); - if (NULL == glGetString || NULL == glGetIntegerv) { - return NULL; - } - - // This may or may not succeed depending on the gl version. - GrGLGetStringiProc glGetStringi = (GrGLGetStringiProc) wglGetProcAddress("glGetStringi"); - - GrGLExtensions extensions; - if (!extensions.init(kGL_GrGLStandard, glGetString, glGetStringi, glGetIntegerv)) { - return NULL; - } - const char* versionString = (const char*) glGetString(GR_GL_VERSION); - GrGLVersion glVer = GrGLGetVersionFromString(versionString); - - if (glVer < GR_GL_VER(1,5)) { - // We must have array and element_array buffer objects. - return NULL; - } - GrGLInterface* interface = SkNEW(GrGLInterface); - - // Functions that are part of GL 1.1 will return NULL in - // wglGetProcAddress - SET_PROC(BindTexture) - SET_PROC(BlendFunc) - - if (glVer >= GR_GL_VER(1,4) || - extensions.has("GL_ARB_imaging") || - extensions.has("GL_EXT_blend_color")) { - WGL_SET_PROC(BlendColor); - } - - SET_PROC(Clear) - SET_PROC(ClearColor) - SET_PROC(ClearStencil) - SET_PROC(ColorMask) - SET_PROC(CopyTexSubImage2D) - SET_PROC(CullFace) - SET_PROC(DeleteTextures) - SET_PROC(DepthMask) - SET_PROC(Disable) - SET_PROC(DrawArrays) - SET_PROC(DrawElements) - SET_PROC(DrawBuffer) - SET_PROC(Enable) - SET_PROC(FrontFace) - SET_PROC(Finish) - SET_PROC(Flush) - SET_PROC(GenTextures) - SET_PROC(GetError) - SET_PROC(GetIntegerv) - SET_PROC(GetString) - SET_PROC(GetTexLevelParameteriv) - SET_PROC(LineWidth) - SET_PROC(LoadIdentity) - SET_PROC(LoadMatrixf) - SET_PROC(MatrixMode) - SET_PROC(PixelStorei) - SET_PROC(ReadBuffer) - SET_PROC(ReadPixels) - SET_PROC(Scissor) - SET_PROC(StencilFunc) - SET_PROC(StencilMask) - SET_PROC(StencilOp) - SET_PROC(TexGenfv) - SET_PROC(TexGeni) - SET_PROC(TexImage2D) - SET_PROC(TexParameteri) - SET_PROC(TexParameteriv) - if (glVer >= GR_GL_VER(4,2) || extensions.has("GL_ARB_texture_storage")) { - WGL_SET_PROC(TexStorage2D); - } else if (extensions.has("GL_EXT_texture_storage")) { - WGL_SET_PROC_SUFFIX(TexStorage2D, EXT); - } - SET_PROC(TexSubImage2D) - SET_PROC(Viewport) - - WGL_SET_PROC(ActiveTexture); - WGL_SET_PROC(AttachShader); - WGL_SET_PROC(BeginQuery); - WGL_SET_PROC(BindAttribLocation); - WGL_SET_PROC(BindBuffer); - WGL_SET_PROC(BindFragDataLocation); - WGL_SET_PROC(BufferData); - WGL_SET_PROC(BufferSubData); - WGL_SET_PROC(CompileShader); - WGL_SET_PROC(CompressedTexImage2D); - WGL_SET_PROC(CreateProgram); - WGL_SET_PROC(CreateShader); - WGL_SET_PROC(DeleteBuffers); - WGL_SET_PROC(DeleteQueries); - WGL_SET_PROC(DeleteProgram); - WGL_SET_PROC(DeleteShader); - WGL_SET_PROC(DisableVertexAttribArray); - WGL_SET_PROC(DrawBuffers); - WGL_SET_PROC(EnableVertexAttribArray); - WGL_SET_PROC(EndQuery); - WGL_SET_PROC(GenBuffers); - WGL_SET_PROC(GenerateMipmap); - WGL_SET_PROC(GenQueries); - WGL_SET_PROC(GetBufferParameteriv); - WGL_SET_PROC(GetQueryiv); - WGL_SET_PROC(GetQueryObjectiv); - WGL_SET_PROC(GetQueryObjectuiv); - if (glVer > GR_GL_VER(3,3) || extensions.has("GL_ARB_timer_query")) { - WGL_SET_PROC(GetQueryObjecti64v); - WGL_SET_PROC(GetQueryObjectui64v); - WGL_SET_PROC(QueryCounter); - } else if (extensions.has("GL_EXT_timer_query")) { - WGL_SET_PROC_SUFFIX(GetQueryObjecti64v, EXT); - WGL_SET_PROC_SUFFIX(GetQueryObjectui64v, EXT); - } - WGL_SET_PROC(GetProgramInfoLog); - WGL_SET_PROC(GetProgramiv); - WGL_SET_PROC(GetShaderInfoLog); - WGL_SET_PROC(GetShaderiv); - WGL_SET_PROC(GetStringi) - WGL_SET_PROC(GetUniformLocation); - WGL_SET_PROC(LinkProgram); - WGL_SET_PROC(ShaderSource); - WGL_SET_PROC(StencilFuncSeparate); - WGL_SET_PROC(StencilMaskSeparate); - WGL_SET_PROC(StencilOpSeparate); - WGL_SET_PROC(Uniform1f); - WGL_SET_PROC(Uniform1i); - WGL_SET_PROC(Uniform1fv); - WGL_SET_PROC(Uniform1iv); - WGL_SET_PROC(Uniform2f); - WGL_SET_PROC(Uniform2i); - WGL_SET_PROC(Uniform2fv); - WGL_SET_PROC(Uniform2iv); - WGL_SET_PROC(Uniform3f); - WGL_SET_PROC(Uniform3i); - WGL_SET_PROC(Uniform3fv); - WGL_SET_PROC(Uniform3iv); - WGL_SET_PROC(Uniform4f); - WGL_SET_PROC(Uniform4i); - WGL_SET_PROC(Uniform4fv); - WGL_SET_PROC(Uniform4iv); - WGL_SET_PROC(UniformMatrix2fv); - WGL_SET_PROC(UniformMatrix3fv); - WGL_SET_PROC(UniformMatrix4fv); - WGL_SET_PROC(UseProgram); - WGL_SET_PROC(VertexAttrib4fv); - WGL_SET_PROC(VertexAttribPointer); - WGL_SET_PROC(BindFragDataLocationIndexed); +class GLProcGetter { +public: + GLProcGetter() : fGLLib("opengl32.dll") {} - if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_vertex_array_object")) { - // no ARB suffix for GL_ARB_vertex_array_object - WGL_SET_PROC(BindVertexArray); - WGL_SET_PROC(DeleteVertexArrays); - WGL_SET_PROC(GenVertexArrays); - } + bool isInitialized() const { return NULL != fGLLib.get(); } - // First look for GL3.0 FBO or GL_ARB_framebuffer_object (same since - // GL_ARB_framebuffer_object doesn't use ARB suffix.) - if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_framebuffer_object")) { - WGL_SET_PROC(GenFramebuffers); - WGL_SET_PROC(GetFramebufferAttachmentParameteriv); - WGL_SET_PROC(GetRenderbufferParameteriv); - WGL_SET_PROC(BindFramebuffer); - WGL_SET_PROC(FramebufferTexture2D); - WGL_SET_PROC(CheckFramebufferStatus); - WGL_SET_PROC(DeleteFramebuffers); - WGL_SET_PROC(RenderbufferStorage); - WGL_SET_PROC(GenRenderbuffers); - WGL_SET_PROC(DeleteRenderbuffers); - WGL_SET_PROC(FramebufferRenderbuffer); - WGL_SET_PROC(BindRenderbuffer); - WGL_SET_PROC(RenderbufferStorageMultisample); - WGL_SET_PROC(BlitFramebuffer); - } else if (extensions.has("GL_EXT_framebuffer_object")) { - WGL_SET_PROC_SUFFIX(GenFramebuffers, EXT); - WGL_SET_PROC_SUFFIX(GetFramebufferAttachmentParameteriv, EXT); - WGL_SET_PROC_SUFFIX(GetRenderbufferParameteriv, EXT); - WGL_SET_PROC_SUFFIX(BindFramebuffer, EXT); - WGL_SET_PROC_SUFFIX(FramebufferTexture2D, EXT); - WGL_SET_PROC_SUFFIX(CheckFramebufferStatus, EXT); - WGL_SET_PROC_SUFFIX(DeleteFramebuffers, EXT); - WGL_SET_PROC_SUFFIX(RenderbufferStorage, EXT); - WGL_SET_PROC_SUFFIX(GenRenderbuffers, EXT); - WGL_SET_PROC_SUFFIX(DeleteRenderbuffers, EXT); - WGL_SET_PROC_SUFFIX(FramebufferRenderbuffer, EXT); - WGL_SET_PROC_SUFFIX(BindRenderbuffer, EXT); - if (extensions.has("GL_EXT_framebuffer_multisample")) { - WGL_SET_PROC_SUFFIX(RenderbufferStorageMultisample, EXT); - } - if (extensions.has("GL_EXT_framebuffer_blit")) { - WGL_SET_PROC_SUFFIX(BlitFramebuffer, EXT); - } - } else { - // we must have FBOs - delete interface; - return NULL; + GrGLFuncPtr getProc(const char name[]) const { + GrGLFuncPtr proc; + if (NULL != (proc = (GrGLFuncPtr) GetProcAddress(fGLLib.get(), name))) { + return proc; } - WGL_SET_PROC(MapBuffer); - WGL_SET_PROC(UnmapBuffer); - - if (extensions.has("GL_NV_path_rendering")) { - WGL_SET_PROC_SUFFIX(PathCommands, NV); - WGL_SET_PROC_SUFFIX(PathCoords, NV); - WGL_SET_PROC_SUFFIX(PathSubCommands, NV); - WGL_SET_PROC_SUFFIX(PathSubCoords, NV); - WGL_SET_PROC_SUFFIX(PathString, NV); - WGL_SET_PROC_SUFFIX(PathGlyphs, NV); - WGL_SET_PROC_SUFFIX(PathGlyphRange, NV); - WGL_SET_PROC_SUFFIX(WeightPaths, NV); - WGL_SET_PROC_SUFFIX(CopyPath, NV); - WGL_SET_PROC_SUFFIX(InterpolatePaths, NV); - WGL_SET_PROC_SUFFIX(TransformPath, NV); - WGL_SET_PROC_SUFFIX(PathParameteriv, NV); - WGL_SET_PROC_SUFFIX(PathParameteri, NV); - WGL_SET_PROC_SUFFIX(PathParameterfv, NV); - WGL_SET_PROC_SUFFIX(PathParameterf, NV); - WGL_SET_PROC_SUFFIX(PathDashArray, NV); - WGL_SET_PROC_SUFFIX(GenPaths, NV); - WGL_SET_PROC_SUFFIX(DeletePaths, NV); - WGL_SET_PROC_SUFFIX(IsPath, NV); - WGL_SET_PROC_SUFFIX(PathStencilFunc, NV); - WGL_SET_PROC_SUFFIX(PathStencilDepthOffset, NV); - WGL_SET_PROC_SUFFIX(StencilFillPath, NV); - WGL_SET_PROC_SUFFIX(StencilStrokePath, NV); - WGL_SET_PROC_SUFFIX(StencilFillPathInstanced, NV); - WGL_SET_PROC_SUFFIX(StencilStrokePathInstanced, NV); - WGL_SET_PROC_SUFFIX(PathCoverDepthFunc, NV); - WGL_SET_PROC_SUFFIX(PathColorGen, NV); - WGL_SET_PROC_SUFFIX(PathTexGen, NV); - WGL_SET_PROC_SUFFIX(PathFogGen, NV); - WGL_SET_PROC_SUFFIX(CoverFillPath, NV); - WGL_SET_PROC_SUFFIX(CoverStrokePath, NV); - WGL_SET_PROC_SUFFIX(CoverFillPathInstanced, NV); - WGL_SET_PROC_SUFFIX(CoverStrokePathInstanced, NV); - WGL_SET_PROC_SUFFIX(GetPathParameteriv, NV); - WGL_SET_PROC_SUFFIX(GetPathParameterfv, NV); - WGL_SET_PROC_SUFFIX(GetPathCommands, NV); - WGL_SET_PROC_SUFFIX(GetPathCoords, NV); - WGL_SET_PROC_SUFFIX(GetPathDashArray, NV); - WGL_SET_PROC_SUFFIX(GetPathMetrics, NV); - WGL_SET_PROC_SUFFIX(GetPathMetricRange, NV); - WGL_SET_PROC_SUFFIX(GetPathSpacing, NV); - WGL_SET_PROC_SUFFIX(GetPathColorGeniv, NV); - WGL_SET_PROC_SUFFIX(GetPathColorGenfv, NV); - WGL_SET_PROC_SUFFIX(GetPathTexGeniv, NV); - WGL_SET_PROC_SUFFIX(GetPathTexGenfv, NV); - WGL_SET_PROC_SUFFIX(IsPointInFillPath, NV); - WGL_SET_PROC_SUFFIX(IsPointInStrokePath, NV); - WGL_SET_PROC_SUFFIX(GetPathLength, NV); - WGL_SET_PROC_SUFFIX(PointAlongPath, NV); + if (NULL != (proc = (GrGLFuncPtr) wglGetProcAddress(name))) { + return proc; } + return NULL; + } - if (extensions.has("GL_EXT_debug_marker")) { - WGL_SET_PROC_SUFFIX(InsertEventMarker, EXT); - WGL_SET_PROC_SUFFIX(PushGroupMarker, EXT); - WGL_SET_PROC_SUFFIX(PopGroupMarker, EXT); - } +private: + AutoLibraryUnload fGLLib; +}; - if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_ARB_invalidate_subdata")) { - WGL_SET_PROC(InvalidateBufferData); - WGL_SET_PROC(InvalidateBufferSubData); - WGL_SET_PROC(InvalidateFramebuffer); - WGL_SET_PROC(InvalidateSubFramebuffer); - WGL_SET_PROC(InvalidateTexImage); - WGL_SET_PROC(InvalidateTexSubImage); - } +static GrGLFuncPtr win_get_gl_proc(void* ctx, const char name[]) { + SkASSERT(NULL != ctx); + SkASSERT(NULL != wglGetCurrentContext()); + const GLProcGetter* getter = (const GLProcGetter*) ctx; + return getter->getProc(name); +} - interface->fStandard = kGL_GrGLStandard; - interface->fExtensions.swap(&extensions); +/* + * Windows makes the GL funcs all be __stdcall instead of __cdecl :( + * This implementation will only work if GR_GL_FUNCTION_TYPE is __stdcall. + * Otherwise, a springboard would be needed that hides the calling convention. + */ +const GrGLInterface* GrGLCreateNativeInterface() { + if (NULL == wglGetCurrentContext()) { + return NULL; + } - return interface; - } else { + GLProcGetter getter; + if (!getter.isInitialized()) { return NULL; } + + return GrGLAssembleGLInterface(&getter, win_get_gl_proc); } |