Make the debug interface a GrGLTestInterface subclass.
The debug interface subsumes the GrDebugGL singleton which allows multiple instances.
Fixes a few issues that existed before this CL (pack alignment wasn't tracked or respected, and we weren't initializing a texture id to 0 in one GM). Apparently this is not currently run on the bots.
BUG=skia:
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1812323002
Review URL: https://codereview.chromium.org/1812323002
diff --git a/gm/rectangletexture.cpp b/gm/rectangletexture.cpp
index e00afe9..43d008a 100644
--- a/gm/rectangletexture.cpp
+++ b/gm/rectangletexture.cpp
@@ -87,7 +87,7 @@
// Useful for debugging whether errors result from use of RECTANGLE
// #define TARGET GR_GL_TEXTURE_2D
#define TARGET GR_GL_TEXTURE_RECTANGLE
- GrGLuint id;
+ GrGLuint id = 0;
GR_GL_CALL(gl, GenTextures(1, &id));
GR_GL_CALL(gl, BindTexture(TARGET, id));
GR_GL_CALL(gl, TexParameteri(TARGET, GR_GL_TEXTURE_MAG_FILTER,
diff --git a/gyp/gpu.gypi b/gyp/gpu.gypi
index 40def5a..e85b292 100644
--- a/gyp/gpu.gypi
+++ b/gyp/gpu.gypi
@@ -333,8 +333,6 @@
'<(skia_src_path)/gpu/gl/GrGLIndexBuffer.h',
'<(skia_src_path)/gpu/gl/GrGLInterface.cpp',
'<(skia_src_path)/gpu/gl/GrGLIRect.h',
- '<(skia_src_path)/gpu/gl/GrGLNoOpInterface.cpp',
- '<(skia_src_path)/gpu/gl/GrGLNoOpInterface.h',
'<(skia_src_path)/gpu/gl/GrGLPath.cpp',
'<(skia_src_path)/gpu/gl/GrGLPath.h',
'<(skia_src_path)/gpu/gl/GrGLPathRange.cpp',
@@ -552,8 +550,6 @@
'<(skia_src_path)/gpu/gl/debug/GrShaderObj.cpp',
'<(skia_src_path)/gpu/gl/debug/GrProgramObj.h',
'<(skia_src_path)/gpu/gl/debug/GrProgramObj.cpp',
- '<(skia_src_path)/gpu/gl/debug/GrDebugGL.h',
- '<(skia_src_path)/gpu/gl/debug/GrDebugGL.cpp',
'<(skia_src_path)/gpu/gl/debug/GrVertexArrayObj.h',
# Sk files
diff --git a/src/gpu/gl/GrGLCreateNullInterface.cpp b/src/gpu/gl/GrGLCreateNullInterface.cpp
index 57c840d..1768a26 100644
--- a/src/gpu/gl/GrGLCreateNullInterface.cpp
+++ b/src/gpu/gl/GrGLCreateNullInterface.cpp
@@ -324,19 +324,19 @@
}
GrGLvoid getQueryObjecti64v(GrGLuint id, GrGLenum pname, GrGLint64 *params) override {
- queryResult(id, pname, params);
+ this->queryResult(id, pname, params);
}
GrGLvoid getQueryObjectiv(GrGLuint id, GrGLenum pname, GrGLint *params) override {
- queryResult(id, pname, params);
+ this->queryResult(id, pname, params);
}
GrGLvoid getQueryObjectui64v(GrGLuint id, GrGLenum pname, GrGLuint64 *params) override {
- queryResult(id, pname, params);
+ this->queryResult(id, pname, params);
}
GrGLvoid getQueryObjectuiv(GrGLuint id, GrGLenum pname, GrGLuint *params) override {
- queryResult(id, pname, params);
+ this->queryResult(id, pname, params);
}
GrGLvoid getShaderiv(GrGLuint shader, GrGLenum pname, GrGLint* params) override {
@@ -353,13 +353,13 @@
case GR_GL_EXTENSIONS:
return CombinedExtensionString();
case GR_GL_VERSION:
- return (const GrGLubyte*)"4.0 Debug GL";
+ return (const GrGLubyte*)"4.0 Null GL";
case GR_GL_SHADING_LANGUAGE_VERSION:
- return (const GrGLubyte*)"4.20.8 Debug GLSL";
+ return (const GrGLubyte*)"4.20.8 Null GLSL";
case GR_GL_VENDOR:
- return (const GrGLubyte*)"Debug Vendor";
+ return (const GrGLubyte*)"Null Vendor";
case GR_GL_RENDERER:
- return (const GrGLubyte*)"The Debug (Non-)Renderer";
+ return (const GrGLubyte*)"The Null (Non-)Renderer";
default:
SkFAIL("Unexpected name passed to GetString");
return nullptr;
@@ -383,13 +383,6 @@
}
}
- GrGLvoid getTexLevelParameteriv(GrGLenum target, GrGLint level, GrGLenum pname,
- GrGLint* params) override {
- // we used to use this to query stuff about externally created textures,
- // now we just require clients to tell us everything about the texture.
- SkFAIL("Should never query texture parameters.");
- }
-
GrGLint getUniformLocation(GrGLuint program, const char* name) override {
return ++fCurrUniformLocation;
}
@@ -598,6 +591,8 @@
break;
}
}
+
+ typedef GrGLTestInterface INHERITED;
};
const char* NullInterface::kExtensions[] = {
diff --git a/src/gpu/gl/GrGLNoOpInterface.cpp b/src/gpu/gl/GrGLNoOpInterface.cpp
deleted file mode 100644
index 16a4fc6..0000000
--- a/src/gpu/gl/GrGLNoOpInterface.cpp
+++ /dev/null
@@ -1,703 +0,0 @@
-/*
- * Copyright 2013 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "GrGLNoOpInterface.h"
-#include "SkMutex.h"
-#include "SkString.h"
-
-// the OpenGLES 2.0 spec says this must be >= 128
-static const GrGLint kDefaultMaxVertexUniformVectors = 128;
-
-// the OpenGLES 2.0 spec says this must be >=16
-static const GrGLint kDefaultMaxFragmentUniformVectors = 16;
-
-// the OpenGLES 2.0 spec says this must be >= 8
-static const GrGLint kDefaultMaxVertexAttribs = 8;
-
-// the OpenGLES 2.0 spec says this must be >= 8
-static const GrGLint kDefaultMaxVaryingVectors = 8;
-
-static const char* kExtensions[] = {
- "GL_ARB_framebuffer_object",
- "GL_ARB_blend_func_extended",
- "GL_ARB_timer_query",
- "GL_ARB_draw_buffers",
- "GL_ARB_occlusion_query",
- "GL_EXT_stencil_wrap"
-};
-
-namespace {
-const GrGLubyte* combined_extensions_string() {
- static SkString gExtString;
- static SkMutex gMutex;
- gMutex.acquire();
- if (0 == gExtString.size()) {
- for (size_t i = 0; i < SK_ARRAY_COUNT(kExtensions) - 1; ++i) {
- gExtString.append(kExtensions[i]);
- gExtString.append(" ");
- }
- gExtString.append(kExtensions[SK_ARRAY_COUNT(kExtensions) - 1]);
- }
- gMutex.release();
- return (const GrGLubyte*) gExtString.c_str();
-}
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBindFragDataLocation(GrGLuint program,
- GrGLuint colorNumber,
- const GrGLchar* name) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlendColor(GrGLclampf red,
- GrGLclampf green,
- GrGLclampf blue,
- GrGLclampf alpha) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlendEquation(GrGLenum mode) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlendFunc(GrGLenum sfactor,
- GrGLenum dfactor) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBufferSubData(GrGLenum target,
- GrGLintptr offset,
- GrGLsizeiptr size,
- const GrGLvoid* data) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLClear(GrGLbitfield mask) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLClearColor(GrGLclampf red,
- GrGLclampf green,
- GrGLclampf blue,
- GrGLclampf alpha) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLClearStencil(GrGLint s) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLColorMask(GrGLboolean red,
- GrGLboolean green,
- GrGLboolean blue,
- GrGLboolean alpha) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCompileShader(GrGLuint shader) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCompressedTexImage2D(GrGLenum target,
- GrGLint level,
- GrGLenum internalformat,
- GrGLsizei width,
- GrGLsizei height,
- GrGLint border,
- GrGLsizei imageSize,
- const GrGLvoid* data) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCompressedTexSubImage2D(GrGLenum target,
- GrGLint level,
- GrGLint xoffset,
- GrGLint yoffset,
- GrGLsizei width,
- GrGLsizei height,
- GrGLenum format,
- GrGLsizei imageSize,
- const GrGLvoid* data) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCopyTexSubImage2D(GrGLenum target,
- GrGLint level,
- GrGLint xoffset,
- GrGLint yoffset,
- GrGLint x,
- GrGLint y,
- GrGLsizei width,
- GrGLsizei height) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCullFace(GrGLenum mode) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDepthMask(GrGLboolean flag) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDisable(GrGLenum cap) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDisableVertexAttribArray(GrGLuint index) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawArrays(GrGLenum mode,
- GrGLint first,
- GrGLsizei count) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawArraysInstanced(GrGLenum mode,
- GrGLint first,
- GrGLsizei count,
- GrGLsizei primcount) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawBuffer(GrGLenum mode) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawBuffers(GrGLsizei n,
- const GrGLenum* bufs) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawElements(GrGLenum mode,
- GrGLsizei count,
- GrGLenum type,
- const GrGLvoid* indices) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawElementsInstanced(GrGLenum mode,
- GrGLsizei count,
- GrGLenum type,
- const GrGLvoid* indices,
- GrGLsizei primcount) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLEnable(GrGLenum cap) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLEnableVertexAttribArray(GrGLuint index) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLEndQuery(GrGLenum target) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLFinish() {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLFlush() {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLFrontFace(GrGLenum mode) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLineWidth(GrGLfloat width) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLinkProgram(GrGLuint program) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLMatrixLoadf(GrGLenum, const GrGLfloat*) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLMatrixLoadIdentity(GrGLenum) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLQueryCounter(GrGLuint id, GrGLenum target) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLReadBuffer(GrGLenum src) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLScissor(GrGLint x,
- GrGLint y,
- GrGLsizei width,
- GrGLsizei height) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLShaderSource(GrGLuint shader,
- GrGLsizei count,
-#if GR_GL_USE_NEW_SHADER_SOURCE_SIGNATURE
- const char* const * str,
-#else
- const char** str,
-#endif
- const GrGLint* length) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilFunc(GrGLenum func, GrGLint ref, GrGLuint mask) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilFuncSeparate(GrGLenum face,
- GrGLenum func,
- GrGLint ref,
- GrGLuint mask) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilMask(GrGLuint mask) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilMaskSeparate(GrGLenum face, GrGLuint mask) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilOp(GrGLenum fail, GrGLenum zfail, GrGLenum zpass) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilOpSeparate(GrGLenum face,
- GrGLenum fail,
- GrGLenum zfail,
- GrGLenum zpass) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexBuffer(GrGLenum target,
- GrGLint internalformat,
- GrGLuint buffer) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexImage2D(GrGLenum target,
- GrGLint level,
- GrGLint internalformat,
- GrGLsizei width,
- GrGLsizei height,
- GrGLint border,
- GrGLenum format,
- GrGLenum type,
- const GrGLvoid* pixels) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexParameteri(GrGLenum target,
- GrGLenum pname,
- GrGLint param) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexParameteriv(GrGLenum target,
- GrGLenum pname,
- const GrGLint* params) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexStorage2D(GrGLenum target,
- GrGLsizei levels,
- GrGLenum internalformat,
- GrGLsizei width,
- GrGLsizei height) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDiscardFramebuffer(GrGLenum target,
- GrGLsizei numAttachments,
- const GrGLenum* attachments) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexSubImage2D(GrGLenum target,
- GrGLint level,
- GrGLint xoffset,
- GrGLint yoffset,
- GrGLsizei width,
- GrGLsizei height,
- GrGLenum format,
- GrGLenum type,
- const GrGLvoid* pixels) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1f(GrGLint location, GrGLfloat v0) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1i(GrGLint location, GrGLint v0) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1fv(GrGLint location,
- GrGLsizei count,
- const GrGLfloat* v) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1iv(GrGLint location,
- GrGLsizei count,
- const GrGLint* v) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2f(GrGLint location, GrGLfloat v0, GrGLfloat v1) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2i(GrGLint location, GrGLint v0, GrGLint v1) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2fv(GrGLint location,
- GrGLsizei count,
- const GrGLfloat* v) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2iv(GrGLint location,
- GrGLsizei count,
- const GrGLint* v) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3f(GrGLint location,
- GrGLfloat v0,
- GrGLfloat v1,
- GrGLfloat v2) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3i(GrGLint location,
- GrGLint v0,
- GrGLint v1,
- GrGLint v2) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3fv(GrGLint location,
- GrGLsizei count,
- const GrGLfloat* v) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3iv(GrGLint location,
- GrGLsizei count,
- const GrGLint* v) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4f(GrGLint location,
- GrGLfloat v0,
- GrGLfloat v1,
- GrGLfloat v2,
- GrGLfloat v3) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4i(GrGLint location,
- GrGLint v0,
- GrGLint v1,
- GrGLint v2,
- GrGLint v3) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4fv(GrGLint location,
- GrGLsizei count,
- const GrGLfloat* v) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4iv(GrGLint location,
- GrGLsizei count,
- const GrGLint* v) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniformMatrix2fv(GrGLint location,
- GrGLsizei count,
- GrGLboolean transpose,
- const GrGLfloat* value) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniformMatrix3fv(GrGLint location,
- GrGLsizei count,
- GrGLboolean transpose,
- const GrGLfloat* value) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniformMatrix4fv(GrGLint location,
- GrGLsizei count,
- GrGLboolean transpose,
- const GrGLfloat* value) {
-}
-
- GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttrib1f(GrGLuint indx, const GrGLfloat value) {
-}
-
- GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttrib2fv(GrGLuint indx, const GrGLfloat* values) {
-}
-
- GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttrib3fv(GrGLuint indx, const GrGLfloat* values) {
-}
-
- GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttrib4fv(GrGLuint indx, const GrGLfloat* values) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttribIPointer(GrGLuint indx,
- GrGLint size,
- GrGLenum type,
- GrGLsizei stride,
- const GrGLvoid* ptr) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttribPointer(GrGLuint indx,
- GrGLint size,
- GrGLenum type,
- GrGLboolean normalized,
- GrGLsizei stride,
- const GrGLvoid* ptr) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttribDivisor(GrGLuint index, GrGLuint divisor) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLViewport(GrGLint x,
- GrGLint y,
- GrGLsizei width,
- GrGLsizei height) {
-}
-
- GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetFramebufferAttachmentParameteriv(GrGLenum target,
- GrGLenum attachment,
- GrGLenum pname,
- GrGLint* params) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetRenderbufferParameteriv(GrGLenum target,
- GrGLenum pname,
- GrGLint* params) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLRenderbufferStorage(GrGLenum target,
- GrGLenum internalformat,
- GrGLsizei width,
- GrGLsizei height) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLRenderbufferStorageMultisample(GrGLenum target,
- GrGLsizei samples,
- GrGLenum internalformat,
- GrGLsizei width,
- GrGLsizei height) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlitFramebuffer(GrGLint srcX0,
- GrGLint srcY0,
- GrGLint srcX1,
- GrGLint srcY1,
- GrGLint dstX0,
- GrGLint dstY0,
- GrGLint dstX1,
- GrGLint dstY1,
- GrGLbitfield mask,
- GrGLenum filter) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLResolveMultisampleFramebuffer() {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBindFragDataLocationIndexed(GrGLuint program,
- GrGLuint colorNumber,
- GrGLuint index,
- const GrGLchar * name) {
-}
-
-GrGLenum GR_GL_FUNCTION_TYPE noOpGLCheckFramebufferStatus(GrGLenum target) {
-
- GrAlwaysAssert(GR_GL_FRAMEBUFFER == target);
-
- return GR_GL_FRAMEBUFFER_COMPLETE;
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGenIds(GrGLsizei n, GrGLuint* ids) {
- static int gCurrID = 1;
- for (int i = 0; i < n; ++i) {
- ids[i] = ++gCurrID;
- }
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDeleteIds(GrGLsizei n, const GrGLuint* ids) {
-}
-
-GrGLenum GR_GL_FUNCTION_TYPE noOpGLGetError() {
- return GR_GL_NO_ERROR;
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetIntegerv(GrGLenum pname, GrGLint* params) {
- // TODO: remove from Ganesh the #defines for gets we don't use.
- // We would like to minimize gets overall due to performance issues
- switch (pname) {
- case GR_GL_CONTEXT_PROFILE_MASK:
- *params = GR_GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;
- break;
- case GR_GL_STENCIL_BITS:
- *params = 8;
- break;
- case GR_GL_SAMPLES:
- *params = 1;
- break;
- case GR_GL_FRAMEBUFFER_BINDING:
- *params = 0;
- break;
- case GR_GL_VIEWPORT:
- params[0] = 0;
- params[1] = 0;
- params[2] = 800;
- params[3] = 600;
- break;
- case GR_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
- case GR_GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS:
- case GR_GL_MAX_TEXTURE_IMAGE_UNITS:
- case GR_GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
- *params = 8;
- break;
- case GR_GL_MAX_TEXTURE_COORDS:
- *params = 8;
- break;
- case GR_GL_MAX_VERTEX_UNIFORM_VECTORS:
- *params = kDefaultMaxVertexUniformVectors;
- break;
- case GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS:
- *params = kDefaultMaxFragmentUniformVectors;
- break;
- case GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS:
- *params = 16 * 4;
- break;
- case GR_GL_NUM_COMPRESSED_TEXTURE_FORMATS:
- *params = 0;
- break;
- case GR_GL_COMPRESSED_TEXTURE_FORMATS:
- break;
- case GR_GL_MAX_TEXTURE_SIZE:
- *params = 8192;
- break;
- case GR_GL_MAX_RENDERBUFFER_SIZE:
- *params = 8192;
- break;
- case GR_GL_MAX_SAMPLES:
- *params = 32;
- break;
- case GR_GL_MAX_VERTEX_ATTRIBS:
- *params = kDefaultMaxVertexAttribs;
- break;
- case GR_GL_MAX_VARYING_VECTORS:
- *params = kDefaultMaxVaryingVectors;
- break;
- case GR_GL_NUM_EXTENSIONS:
- *params = SK_ARRAY_COUNT(kExtensions);
- break;
- default:
- SkFAIL("Unexpected pname to GetIntegerv");
- }
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetInfoLog(GrGLuint program,
- GrGLsizei bufsize,
- GrGLsizei* length,
- char* infolog) {
- if (length) {
- *length = 0;
- }
- if (bufsize > 0) {
- *infolog = 0;
- }
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetMultisamplefv(GrGLenum pname,
- GrGLuint index,
- GrGLfloat* val) {
- val[0] = val[1] = 0.5f;
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetShaderOrProgramiv(GrGLuint program,
- GrGLenum pname,
- GrGLint* params) {
- switch (pname) {
- case GR_GL_LINK_STATUS: // fallthru
- case GR_GL_COMPILE_STATUS:
- *params = GR_GL_TRUE;
- break;
- case GR_GL_INFO_LOG_LENGTH:
- *params = 0;
- break;
- // we don't expect any other pnames
- default:
- SkFAIL("Unexpected pname to GetProgramiv");
- break;
- }
-}
-
-namespace {
-template <typename T>
-void query_result(GrGLenum GLtarget, GrGLenum pname, T *params) {
- switch (pname) {
- case GR_GL_QUERY_RESULT_AVAILABLE:
- *params = GR_GL_TRUE;
- break;
- case GR_GL_QUERY_RESULT:
- *params = 0;
- break;
- default:
- SkFAIL("Unexpected pname passed to GetQueryObject.");
- break;
- }
-}
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryiv(GrGLenum GLtarget,
- GrGLenum pname,
- GrGLint *params) {
- switch (pname) {
- case GR_GL_CURRENT_QUERY:
- *params = 0;
- break;
- case GR_GL_QUERY_COUNTER_BITS:
- *params = 32;
- break;
- default:
- SkFAIL("Unexpected pname passed GetQueryiv.");
- }
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjecti64v(GrGLuint id,
- GrGLenum pname,
- GrGLint64 *params) {
- query_result(id, pname, params);
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjectiv(GrGLuint id,
- GrGLenum pname,
- GrGLint *params) {
- query_result(id, pname, params);
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjectui64v(GrGLuint id,
- GrGLenum pname,
- GrGLuint64 *params) {
- query_result(id, pname, params);
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjectuiv(GrGLuint id,
- GrGLenum pname,
- GrGLuint *params) {
- query_result(id, pname, params);
-}
-
-const GrGLubyte* GR_GL_FUNCTION_TYPE noOpGLGetString(GrGLenum name) {
- switch (name) {
- case GR_GL_EXTENSIONS:
- return combined_extensions_string();
- case GR_GL_VERSION:
- return (const GrGLubyte*)"4.0 Debug GL";
- case GR_GL_SHADING_LANGUAGE_VERSION:
- return (const GrGLubyte*)"4.20.8 Debug GLSL";
- case GR_GL_VENDOR:
- return (const GrGLubyte*)"Debug Vendor";
- case GR_GL_RENDERER:
- return (const GrGLubyte*)"The Debug (Non-)Renderer";
- default:
- SkFAIL("Unexpected name passed to GetString");
- return nullptr;
- }
-}
-
-const GrGLubyte* GR_GL_FUNCTION_TYPE noOpGLGetStringi(GrGLenum name, GrGLuint i) {
- switch (name) {
- case GR_GL_EXTENSIONS:
- if (static_cast<size_t>(i) <= SK_ARRAY_COUNT(kExtensions)) {
- return (const GrGLubyte*) kExtensions[i];
- } else {
- return nullptr;
- }
- default:
- SkFAIL("Unexpected name passed to GetStringi");
- return nullptr;
- }
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetTexLevelParameteriv(GrGLenum target,
- GrGLint level,
- GrGLenum pname,
- GrGLint* params) {
- // we used to use this to query stuff about externally created textures,
- // now we just require clients to tell us everything about the texture.
- SkFAIL("Should never query texture parameters.");
-}
-
-GrGLint GR_GL_FUNCTION_TYPE noOpGLGetUniformLocation(GrGLuint program, const char* name) {
- static int gUniLocation = 0;
- return ++gUniLocation;
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLInsertEventMarker(GrGLsizei length, const char* marker) {
-}
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLPushGroupMarker(GrGLsizei length , const char* marker) {
-}
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLPopGroupMarker() {
-}
diff --git a/src/gpu/gl/GrGLNoOpInterface.h b/src/gpu/gl/GrGLNoOpInterface.h
deleted file mode 100644
index f81003b..0000000
--- a/src/gpu/gl/GrGLNoOpInterface.h
+++ /dev/null
@@ -1,411 +0,0 @@
-/*
- * Copyright 2013 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef GrGLNoOpInterface_DEFINED
-#define GrGLNoOpInterface_DEFINED
-
-#include "gl/GrGLDefines.h"
-#include "gl/GrGLTypes.h"
-
-// These are constants/functions that are common to the Null and Debug GL interface implementations.
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBindFragDataLocation(GrGLuint program,
- GrGLuint colorNumber,
- const GrGLchar* name);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlendColor(GrGLclampf red,
- GrGLclampf green,
- GrGLclampf blue,
- GrGLclampf alpha);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlendEquation(GrGLenum mode);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlendFunc(GrGLenum sfactor,
- GrGLenum dfactor);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBufferSubData(GrGLenum target,
- GrGLintptr offset,
- GrGLsizeiptr size,
- const GrGLvoid* data);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLClear(GrGLbitfield mask);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLClearColor(GrGLclampf red,
- GrGLclampf green,
- GrGLclampf blue,
- GrGLclampf alpha);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLClearStencil(GrGLint s);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLColorMask(GrGLboolean red,
- GrGLboolean green,
- GrGLboolean blue,
- GrGLboolean alpha);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCompileShader(GrGLuint shader);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCompressedTexImage2D(GrGLenum target,
- GrGLint level,
- GrGLenum internalformat,
- GrGLsizei width,
- GrGLsizei height,
- GrGLint border,
- GrGLsizei imageSize,
- const GrGLvoid* data);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCompressedTexSubImage2D(GrGLenum target,
- GrGLint level,
- GrGLint xoffset,
- GrGLint yoffset,
- GrGLsizei width,
- GrGLsizei height,
- GrGLenum format,
- GrGLsizei imageSize,
- const GrGLvoid* data);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCopyTexSubImage2D(GrGLenum target,
- GrGLint level,
- GrGLint xoffset,
- GrGLint yoffset,
- GrGLint x,
- GrGLint y,
- GrGLsizei width,
- GrGLsizei height);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCullFace(GrGLenum mode);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDepthMask(GrGLboolean flag);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDisable(GrGLenum cap);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDisableVertexAttribArray(GrGLuint index);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawArrays(GrGLenum mode, GrGLint first, GrGLsizei count);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawArraysInstanced(GrGLenum mode,
- GrGLint first,
- GrGLsizei count,
- GrGLsizei primcount);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawBuffer(GrGLenum mode);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawBuffers(GrGLsizei n,
- const GrGLenum* bufs);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawElements(GrGLenum mode,
- GrGLsizei count,
- GrGLenum type,
- const GrGLvoid* indices);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawElementsInstanced(GrGLenum mode,
- GrGLsizei count,
- GrGLenum type,
- const GrGLvoid* indices,
- GrGLsizei primcount);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLEnable(GrGLenum cap);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLEnableVertexAttribArray(GrGLuint index);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLEndQuery(GrGLenum target);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLFinish();
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLFlush();
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLFrontFace(GrGLenum mode);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLMatrixLoadf(GrGLenum, 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 noOpGLQueryCounter(GrGLuint id,
- GrGLenum target);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLReadBuffer(GrGLenum src);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLScissor(GrGLint x,
- GrGLint y,
- GrGLsizei width,
- GrGLsizei height);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLShaderSource(GrGLuint shader,
- GrGLsizei count,
-#if GR_GL_USE_NEW_SHADER_SOURCE_SIGNATURE
- const char* const * str,
-#else
- const char** str,
-#endif
- const GrGLint* length);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilFunc(GrGLenum func, GrGLint ref, GrGLuint mask);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilFuncSeparate(GrGLenum face,
- GrGLenum func,
- GrGLint ref,
- GrGLuint mask);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilMask(GrGLuint mask);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilMaskSeparate(GrGLenum face, GrGLuint mask);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilOp(GrGLenum fail, GrGLenum zfail, GrGLenum zpass);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilOpSeparate(GrGLenum face,
- GrGLenum fail,
- GrGLenum zfail,
- GrGLenum zpass);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexBuffer(GrGLenum target,
- GrGLint internalformat,
- GrGLuint buffer);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexImage2D(GrGLenum target,
- GrGLint level,
- GrGLint internalformat,
- GrGLsizei width,
- GrGLsizei height,
- GrGLint border,
- GrGLenum format,
- GrGLenum type,
- const GrGLvoid* pixels);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexParameteri(GrGLenum target, GrGLenum pname, GrGLint param);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexParameteriv(GrGLenum target,
- GrGLenum pname,
- const GrGLint* params);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexStorage2D(GrGLenum target,
- GrGLsizei levels,
- GrGLenum internalformat,
- GrGLsizei width,
- GrGLsizei height);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDiscardFramebuffer(GrGLenum target,
- GrGLsizei numAttachments,
- const GrGLenum* attachments);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexSubImage2D(GrGLenum target,
- GrGLint level,
- GrGLint xoffset,
- GrGLint yoffset,
- GrGLsizei width,
- GrGLsizei height,
- GrGLenum format,
- GrGLenum type,
- const GrGLvoid* pixels);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1f(GrGLint location, GrGLfloat v0);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1i(GrGLint location, GrGLint v0);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1fv(GrGLint location,
- GrGLsizei count,
- const GrGLfloat* v);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1iv(GrGLint location,
- GrGLsizei count,
- const GrGLint* v);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2f(GrGLint location,
- GrGLfloat v0,
- GrGLfloat v1);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2i(GrGLint location, GrGLint v0, GrGLint v1);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2fv(GrGLint location,
- GrGLsizei count,
- const GrGLfloat* v);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2iv(GrGLint location,
- GrGLsizei count,
- const GrGLint* v);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3f(GrGLint location,
- GrGLfloat v0,
- GrGLfloat v1,
- GrGLfloat v2);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3i(GrGLint location,
- GrGLint v0,
- GrGLint v1,
- GrGLint v2);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3fv(GrGLint location,
- GrGLsizei count,
- const GrGLfloat* v);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3iv(GrGLint location,
- GrGLsizei count,
- const GrGLint* v);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4f(GrGLint location,
- GrGLfloat v0,
- GrGLfloat v1,
- GrGLfloat v2,
- GrGLfloat v3);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4i(GrGLint location,
- GrGLint v0,
- GrGLint v1,
- GrGLint v2,
- GrGLint v3);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4fv(GrGLint location,
- GrGLsizei count,
- const GrGLfloat* v);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4iv(GrGLint location,
- GrGLsizei count,
- const GrGLint* v);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniformMatrix2fv(GrGLint location,
- GrGLsizei count,
- GrGLboolean transpose,
- const GrGLfloat* value);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniformMatrix3fv(GrGLint location,
- GrGLsizei count,
- GrGLboolean transpose,
- const GrGLfloat* value);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniformMatrix4fv(GrGLint location,
- GrGLsizei count,
- GrGLboolean transpose,
- const GrGLfloat* value);
-
- GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttrib1f(GrGLuint indx, const GrGLfloat value);
-
- GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttrib2fv(GrGLuint indx, const GrGLfloat* values);
-
- GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttrib3fv(GrGLuint indx, const GrGLfloat* values);
-
- GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttrib4fv(GrGLuint indx, const GrGLfloat* values);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttribIPointer(GrGLuint indx,
- GrGLint size,
- GrGLenum type,
- GrGLsizei stride,
- const GrGLvoid* ptr);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttribPointer(GrGLuint indx,
- GrGLint size,
- GrGLenum type,
- GrGLboolean normalized,
- GrGLsizei stride,
- const GrGLvoid* ptr);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttribDivisor(GrGLuint index, GrGLuint divisor);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLViewport(GrGLint x,
- GrGLint y,
- GrGLsizei width,
- GrGLsizei height);
-
- GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetFramebufferAttachmentParameteriv(GrGLenum target,
- GrGLenum attachment,
- GrGLenum pname,
- GrGLint* params);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetRenderbufferParameteriv(GrGLenum target,
- GrGLenum pname,
- GrGLint* params);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLRenderbufferStorage(GrGLenum target,
- GrGLenum internalformat,
- GrGLsizei width,
- GrGLsizei height);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLRenderbufferStorageMultisample(GrGLenum target,
- GrGLsizei samples,
- GrGLenum internalformat,
- GrGLsizei width,
- GrGLsizei height);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlitFramebuffer(GrGLint srcX0,
- GrGLint srcY0,
- GrGLint srcX1,
- GrGLint srcY1,
- GrGLint dstX0,
- GrGLint dstY0,
- GrGLint dstX1,
- GrGLint dstY1,
- GrGLbitfield mask,
- GrGLenum filter);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLResolveMultisampleFramebuffer();
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBindFragDataLocationIndexed(GrGLuint program,
- GrGLuint colorNumber,
- GrGLuint index,
- const GrGLchar * name);
-
-GrGLenum GR_GL_FUNCTION_TYPE noOpGLCheckFramebufferStatus(GrGLenum target);
-
-// this function can be used for all glGen*(GLsize i, GLuint*) functions
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGenIds(GrGLsizei n, GrGLuint* ids);
-
-// this function function can be used for all glDelete*(GLsize i, const GLuint*)
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDeleteIds(GrGLsizei n, const GrGLuint* ids);
-
-GrGLenum GR_GL_FUNCTION_TYPE noOpGLGetError();
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetIntegerv(GrGLenum pname, GrGLint* params);
-
-// can be used for both the program and shader info logs
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetInfoLog(GrGLuint program,
- GrGLsizei bufsize,
- GrGLsizei* length,
- char* infolog);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetMultisamplefv(GrGLenum pname, GrGLuint index, GrGLfloat* val);
-
-// can be used for both the program and shader params
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetShaderOrProgramiv(GrGLuint program,
- GrGLenum pname,
- GrGLint* params);
-
-// Queries on bogus GLs just don't do anything at all. We could potentially make the timers work.
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryiv(GrGLenum GLtarget,
- GrGLenum pname,
- GrGLint *params);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjecti64v(GrGLuint id,
- GrGLenum pname,
- GrGLint64 *params);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjectiv(GrGLuint id, GrGLenum pname, GrGLint *params);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjectui64v(GrGLuint id,
- GrGLenum pname,
- GrGLuint64 *params);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjectuiv(GrGLuint id,
- GrGLenum pname,
- GrGLuint *params);
-
-const GrGLubyte* GR_GL_FUNCTION_TYPE noOpGLGetString(GrGLenum name);
-
-const GrGLubyte* GR_GL_FUNCTION_TYPE noOpGLGetStringi(GrGLenum name, GrGLuint i);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetTexLevelParameteriv(GrGLenum target,
- GrGLint level,
- GrGLenum pname,
- GrGLint* params);
-
-GrGLint GR_GL_FUNCTION_TYPE noOpGLGetUniformLocation(GrGLuint program, const char* name);
-
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLInsertEventMarker(GrGLsizei length, const char* marker);
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLPushGroupMarker(GrGLsizei length , const char* marker);
-GrGLvoid GR_GL_FUNCTION_TYPE noOpGLPopGroupMarker();
-
-#endif
diff --git a/src/gpu/gl/debug/GrDebugGL.cpp b/src/gpu/gl/debug/GrDebugGL.cpp
deleted file mode 100644
index 2de349b..0000000
--- a/src/gpu/gl/debug/GrDebugGL.cpp
+++ /dev/null
@@ -1,213 +0,0 @@
-
-/*
- * Copyright 2012 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "GrDebugGL.h"
-#include "GrTextureObj.h"
-#include "GrBufferObj.h"
-#include "GrRenderBufferObj.h"
-#include "GrFrameBufferObj.h"
-#include "GrShaderObj.h"
-#include "GrProgramObj.h"
-#include "GrTextureUnitObj.h"
-#include "GrVertexArrayObj.h"
-
-GrDebugGL* GrDebugGL::gObj = nullptr;
-int GrDebugGL::gStaticRefCount = 0;
-GrDebugGL::Create GrDebugGL::gFactoryFunc[kObjTypeCount] = {
- GrTextureObj::createGrTextureObj,
- GrBufferObj::createGrBufferObj,
- GrRenderBufferObj::createGrRenderBufferObj,
- GrFrameBufferObj::createGrFrameBufferObj,
- GrShaderObj::createGrShaderObj,
- GrProgramObj::createGrProgramObj,
- GrTextureUnitObj::createGrTextureUnitObj,
- GrVertexArrayObj::createGrVertexArrayObj,
-};
-
-
-GrDebugGL::GrDebugGL()
- : fPackRowLength(0)
- , fUnPackRowLength(0)
- , fCurTextureUnit(0)
- , fArrayBuffer(nullptr)
- , fElementArrayBuffer(nullptr)
- , fFrameBuffer(nullptr)
- , fRenderBuffer(nullptr)
- , fProgram(nullptr)
- , fTexture(nullptr)
- , fVertexArray(nullptr)
- , fAbandoned(false) {
-
- for (int i = 0; i < kDefaultMaxTextureUnits; ++i) {
-
- fTextureUnits[i] = reinterpret_cast<GrTextureUnitObj *>(
- createObj(GrDebugGL::kTextureUnit_ObjTypes));
- fTextureUnits[i]->ref();
-
- fTextureUnits[i]->setNumber(i);
- }
-}
-
-GrDebugGL::~GrDebugGL() {
- // unref & delete the texture units first so they don't show up on the leak report
- for (int i = 0; i < kDefaultMaxTextureUnits; ++i) {
- fTextureUnits[i]->unref();
- fTextureUnits[i]->deleteAction();
- }
-
- this->report();
-
- for (int i = 0; i < fObjects.count(); ++i) {
- delete fObjects[i];
- }
- fObjects.reset();
-
- fArrayBuffer = nullptr;
- fElementArrayBuffer = nullptr;
- fFrameBuffer = nullptr;
- fRenderBuffer = nullptr;
- fProgram = nullptr;
- fTexture = nullptr;
- fVertexArray = nullptr;
-}
-
-GrFakeRefObj *GrDebugGL::findObject(GrGLuint ID, GrObjTypes type) {
- for (int i = 0; i < fObjects.count(); ++i) {
- if (fObjects[i]->getID() == ID) { // && fObjects[i]->getType() == type) {
- // The application shouldn't be accessing objects
- // that (as far as OpenGL knows) were already deleted
- GrAlwaysAssert(!fObjects[i]->getDeleted());
- GrAlwaysAssert(!fObjects[i]->getMarkedForDeletion());
- return fObjects[i];
- }
- }
-
- return nullptr;
-}
-
-void GrDebugGL::setArrayBuffer(GrBufferObj *arrayBuffer) {
- if (fArrayBuffer) {
- // automatically break the binding of the old buffer
- GrAlwaysAssert(fArrayBuffer->getBound());
- fArrayBuffer->resetBound();
-
- GrAlwaysAssert(!fArrayBuffer->getDeleted());
- fArrayBuffer->unref();
- }
-
- fArrayBuffer = arrayBuffer;
-
- if (fArrayBuffer) {
- GrAlwaysAssert(!fArrayBuffer->getDeleted());
- fArrayBuffer->ref();
-
- GrAlwaysAssert(!fArrayBuffer->getBound());
- fArrayBuffer->setBound();
- }
-}
-
-void GrDebugGL::setVertexArray(GrVertexArrayObj* vertexArray) {
- if (vertexArray) {
- SkASSERT(!vertexArray->getDeleted());
- }
- SkRefCnt_SafeAssign(fVertexArray, vertexArray);
-}
-
-void GrDebugGL::setElementArrayBuffer(GrBufferObj *elementArrayBuffer) {
- if (fElementArrayBuffer) {
- // automatically break the binding of the old buffer
- GrAlwaysAssert(fElementArrayBuffer->getBound());
- fElementArrayBuffer->resetBound();
-
- GrAlwaysAssert(!fElementArrayBuffer->getDeleted());
- fElementArrayBuffer->unref();
- }
-
- fElementArrayBuffer = elementArrayBuffer;
-
- if (fElementArrayBuffer) {
- GrAlwaysAssert(!fElementArrayBuffer->getDeleted());
- fElementArrayBuffer->ref();
-
- GrAlwaysAssert(!fElementArrayBuffer->getBound());
- fElementArrayBuffer->setBound();
- }
-}
-
-void GrDebugGL::setTexture(GrTextureObj *texture) {
- fTextureUnits[fCurTextureUnit]->setTexture(texture);
-}
-
-void GrDebugGL::setFrameBuffer(GrFrameBufferObj *frameBuffer) {
- if (fFrameBuffer) {
- GrAlwaysAssert(fFrameBuffer->getBound());
- fFrameBuffer->resetBound();
-
- GrAlwaysAssert(!fFrameBuffer->getDeleted());
- fFrameBuffer->unref();
- }
-
- fFrameBuffer = frameBuffer;
-
- if (fFrameBuffer) {
- GrAlwaysAssert(!fFrameBuffer->getDeleted());
- fFrameBuffer->ref();
-
- GrAlwaysAssert(!fFrameBuffer->getBound());
- fFrameBuffer->setBound();
- }
-}
-
-void GrDebugGL::setRenderBuffer(GrRenderBufferObj *renderBuffer) {
- if (fRenderBuffer) {
- GrAlwaysAssert(fRenderBuffer->getBound());
- fRenderBuffer->resetBound();
-
- GrAlwaysAssert(!fRenderBuffer->getDeleted());
- fRenderBuffer->unref();
- }
-
- fRenderBuffer = renderBuffer;
-
- if (fRenderBuffer) {
- GrAlwaysAssert(!fRenderBuffer->getDeleted());
- fRenderBuffer->ref();
-
- GrAlwaysAssert(!fRenderBuffer->getBound());
- fRenderBuffer->setBound();
- }
-}
-
-void GrDebugGL::useProgram(GrProgramObj *program) {
- if (fProgram) {
- GrAlwaysAssert(fProgram->getInUse());
- fProgram->resetInUse();
-
- GrAlwaysAssert(!fProgram->getDeleted());
- fProgram->unref();
- }
-
- fProgram = program;
-
- if (fProgram) {
- GrAlwaysAssert(!fProgram->getDeleted());
- fProgram->ref();
-
- GrAlwaysAssert(!fProgram->getInUse());
- fProgram->setInUse();
- }
-}
-
-void GrDebugGL::report() const {
- for (int i = 0; i < fObjects.count(); ++i) {
- if (!fAbandoned) {
- GrAlwaysAssert(0 == fObjects[i]->getRefCount());
- GrAlwaysAssert(fObjects[i]->getDeleted());
- }
- }
-}
diff --git a/src/gpu/gl/debug/GrDebugGL.h b/src/gpu/gl/debug/GrDebugGL.h
deleted file mode 100644
index 2560879..0000000
--- a/src/gpu/gl/debug/GrDebugGL.h
+++ /dev/null
@@ -1,167 +0,0 @@
-
-/*
- * Copyright 2012 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef GrDebugGL_DEFINED
-#define GrDebugGL_DEFINED
-
-#include "SkTArray.h"
-#include "gl/GrGLInterface.h"
-
-class GrBufferObj;
-class GrFakeRefObj;
-class GrFrameBufferObj;
-class GrProgramObj;
-class GrRenderBufferObj;
-class GrTextureObj;
-class GrTextureUnitObj;
-class GrVertexArrayObj;
-
-////////////////////////////////////////////////////////////////////////////////
-// This is the main debugging object. It is a singleton and keeps track of
-// all the other debug objects.
-class GrDebugGL {
-public:
- enum GrObjTypes {
- kTexture_ObjTypes = 0,
- kBuffer_ObjTypes,
- kRenderBuffer_ObjTypes,
- kFrameBuffer_ObjTypes,
- kShader_ObjTypes,
- kProgram_ObjTypes,
- kTextureUnit_ObjTypes,
- kVertexArray_ObjTypes,
- kObjTypeCount
- };
-
- GrFakeRefObj *createObj(GrObjTypes type) {
- GrFakeRefObj *temp = (*gFactoryFunc[type])();
-
- fObjects.push_back(temp);
-
- return temp;
- }
-
- GrFakeRefObj *findObject(GrGLuint ID, GrObjTypes type);
-
- GrGLuint getMaxTextureUnits() const { return kDefaultMaxTextureUnits; }
-
- void setCurTextureUnit(GrGLuint curTextureUnit) { fCurTextureUnit = curTextureUnit; }
- GrGLuint getCurTextureUnit() const { return fCurTextureUnit; }
-
- GrTextureUnitObj *getTextureUnit(int iUnit) {
- GrAlwaysAssert(0 <= iUnit && kDefaultMaxTextureUnits > iUnit);
-
- return fTextureUnits[iUnit];
- }
-
- void setArrayBuffer(GrBufferObj *arrayBuffer);
- GrBufferObj *getArrayBuffer() { return fArrayBuffer; }
-
- void setElementArrayBuffer(GrBufferObj *elementArrayBuffer);
- GrBufferObj *getElementArrayBuffer() { return fElementArrayBuffer; }
-
- void setVertexArray(GrVertexArrayObj* vertexArray);
- GrVertexArrayObj* getVertexArray() { return fVertexArray; }
-
- void setTexture(GrTextureObj *texture);
-
- void setFrameBuffer(GrFrameBufferObj *frameBuffer);
- GrFrameBufferObj *getFrameBuffer() { return fFrameBuffer; }
-
- void setRenderBuffer(GrRenderBufferObj *renderBuffer);
- GrRenderBufferObj *getRenderBuffer() { return fRenderBuffer; }
-
- void useProgram(GrProgramObj *program);
-
- void setPackRowLength(GrGLint packRowLength) {
- fPackRowLength = packRowLength;
- }
- GrGLint getPackRowLength() const { return fPackRowLength; }
-
- void setUnPackRowLength(GrGLint unPackRowLength) {
- fUnPackRowLength = unPackRowLength;
- }
- GrGLint getUnPackRowLength() const { return fUnPackRowLength; }
-
- static GrDebugGL *getInstance() {
- // someone should admit to actually using this class
- SkASSERT(0 < gStaticRefCount);
-
- if (nullptr == gObj) {
- gObj = new GrDebugGL;
- }
-
- return gObj;
- }
-
- void report() const;
-
- static void staticRef() {
- gStaticRefCount++;
- }
-
- static void staticUnRef() {
- SkASSERT(gStaticRefCount > 0);
- gStaticRefCount--;
- if (0 == gStaticRefCount) {
- delete gObj;
- gObj = nullptr;
- }
- }
-
- static void abandon() {
- SkASSERT(gStaticRefCount > 0);
- gObj->fAbandoned = true;
- }
-
-protected:
-
-private:
- // the OpenGLES 2.0 spec says this must be >= 2
- static const GrGLint kDefaultMaxTextureUnits = 8;
-
- GrGLint fPackRowLength;
- GrGLint fUnPackRowLength;
- GrGLuint fCurTextureUnit;
- GrBufferObj* fArrayBuffer;
- GrBufferObj* fElementArrayBuffer;
- GrFrameBufferObj* fFrameBuffer;
- GrRenderBufferObj* fRenderBuffer;
- GrProgramObj* fProgram;
- GrTextureObj* fTexture;
- GrTextureUnitObj *fTextureUnits[kDefaultMaxTextureUnits];
- GrVertexArrayObj *fVertexArray;
-
- bool fAbandoned;
-
- typedef GrFakeRefObj *(*Create)();
-
- static Create gFactoryFunc[kObjTypeCount];
-
- static GrDebugGL* gObj;
- static int gStaticRefCount;
-
- // global store of all objects
- SkTArray<GrFakeRefObj *> fObjects;
-
- GrDebugGL();
- ~GrDebugGL();
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// Helper macro to make creating an object (where you need to get back a derived
-// type) easier
-#define GR_CREATE(className, classEnum) \
- reinterpret_cast<className *>(GrDebugGL::getInstance()->createObj(classEnum))
-
-////////////////////////////////////////////////////////////////////////////////
-// Helper macro to make finding objects less painful
-#define GR_FIND(id, className, classEnum) \
- reinterpret_cast<className *>(GrDebugGL::getInstance()->findObject(id, classEnum))
-
-#endif // GrDebugGL_DEFINED
diff --git a/src/gpu/gl/debug/GrGLCreateDebugInterface.cpp b/src/gpu/gl/debug/GrGLCreateDebugInterface.cpp
index d8418fd..43fc8df 100644
--- a/src/gpu/gl/debug/GrGLCreateDebugInterface.cpp
+++ b/src/gpu/gl/debug/GrGLCreateDebugInterface.cpp
@@ -8,986 +8,1230 @@
#include "gl/GrGLInterface.h"
-#include "GrDebugGL.h"
-#include "GrShaderObj.h"
-#include "GrProgramObj.h"
+
#include "GrBufferObj.h"
-#include "GrTextureUnitObj.h"
-#include "GrTextureObj.h"
#include "GrFrameBufferObj.h"
+#include "GrProgramObj.h"
#include "GrRenderBufferObj.h"
+#include "GrShaderObj.h"
+#include "GrTextureObj.h"
+#include "GrTextureUnitObj.h"
#include "GrVertexArrayObj.h"
-#include "SkFloatingPoint.h"
-#include "../GrGLNoOpInterface.h"
+#include "gl/GrGLTestInterface.h"
-namespace { // suppress no previous prototype warning
+#include "SkMutex.h"
-////////////////////////////////////////////////////////////////////////////////
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLActiveTexture(GrGLenum texture) {
+namespace {
- // Ganesh offsets the texture unit indices
- texture -= GR_GL_TEXTURE0;
- GrAlwaysAssert(texture < GrDebugGL::getInstance()->getMaxTextureUnits());
+// Helper macro to make creating an object (where you need to get back a derived type) easier
+#define CREATE(className, classEnum) \
+ reinterpret_cast<className *>(this->createObj(classEnum))
- GrDebugGL::getInstance()->setCurTextureUnit(texture);
-}
+// Helper macro to make creating an object (where you need to get back a derived type) easier
+#define FIND(id, className, classEnum) \
+ reinterpret_cast<className *>(this->findObject(id, classEnum))
-////////////////////////////////////////////////////////////////////////////////
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLAttachShader(GrGLuint programID,
- GrGLuint shaderID) {
-
- GrProgramObj *program = GR_FIND(programID, GrProgramObj,
- GrDebugGL::kProgram_ObjTypes);
- GrAlwaysAssert(program);
-
- GrShaderObj *shader = GR_FIND(shaderID,
- GrShaderObj,
- GrDebugGL::kShader_ObjTypes);
- GrAlwaysAssert(shader);
-
- program->AttachShader(shader);
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLBeginQuery(GrGLenum target, GrGLuint id) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindAttribLocation(GrGLuint program,
- GrGLuint index,
- const char* name) {
-}
-
-////////////////////////////////////////////////////////////////////////////////
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindTexture(GrGLenum target,
- GrGLuint textureID) {
-
- // we don't use cube maps
- GrAlwaysAssert(target == GR_GL_TEXTURE_2D);
- // || target == GR_GL_TEXTURE_CUBE_MAP);
-
- // a textureID of 0 is acceptable - it binds to the default texture target
- GrTextureObj *texture = GR_FIND(textureID, GrTextureObj,
- GrDebugGL::kTexture_ObjTypes);
-
- GrDebugGL::getInstance()->setTexture(texture);
-}
-
-
-////////////////////////////////////////////////////////////////////////////////
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLBufferData(GrGLenum target,
- GrGLsizeiptr size,
- const GrGLvoid* data,
- GrGLenum usage) {
- GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
- GR_GL_ELEMENT_ARRAY_BUFFER == target);
- GrAlwaysAssert(size >= 0);
- GrAlwaysAssert(GR_GL_STREAM_DRAW == usage ||
- GR_GL_STATIC_DRAW == usage ||
- GR_GL_DYNAMIC_DRAW == usage);
-
- GrBufferObj *buffer = nullptr;
- switch (target) {
- case GR_GL_ARRAY_BUFFER:
- buffer = GrDebugGL::getInstance()->getArrayBuffer();
- break;
- case GR_GL_ELEMENT_ARRAY_BUFFER:
- buffer = GrDebugGL::getInstance()->getElementArrayBuffer();
- break;
- default:
- SkFAIL("Unexpected target to glBufferData");
- break;
+class DebugInterface : public GrGLTestInterface {
+public:
+ DebugInterface()
+ : fCurrGenericID(0)
+ , fCurrTextureUnit(0)
+ , fArrayBuffer(nullptr)
+ , fElementArrayBuffer(nullptr)
+ , fVertexArray(nullptr)
+ , fPackRowLength(0)
+ , fUnpackRowLength(0)
+ , fPackAlignment(4)
+ , fFrameBuffer(nullptr)
+ , fRenderBuffer(nullptr)
+ , fProgram(nullptr)
+ , fAbandoned(false) {
+ for (int i = 0; i < kDefaultMaxTextureUnits; ++i) {
+ fTextureUnits[i] =
+ reinterpret_cast<GrTextureUnitObj*>(this->createObj(kTextureUnit_ObjTypes));
+ fTextureUnits[i]->ref();
+ fTextureUnits[i]->setNumber(i);
+ }
+ this->init(kGL_GrGLStandard);
}
- GrAlwaysAssert(buffer);
- GrAlwaysAssert(buffer->getBound());
+ ~DebugInterface() override {
+ // unref & delete the texture units first so they don't show up on the leak report
+ for (int i = 0; i < kDefaultMaxTextureUnits; ++i) {
+ fTextureUnits[i]->unref();
+ fTextureUnits[i]->deleteAction();
+ }
+ for (int i = 0; i < fObjects.count(); ++i) {
+ delete fObjects[i];
+ }
+ fObjects.reset();
- buffer->allocate(size, reinterpret_cast<const GrGLchar *>(data));
- buffer->setUsage(usage);
-}
+ fArrayBuffer = nullptr;
+ fElementArrayBuffer = nullptr;
+ fVertexArray = nullptr;
-
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLPixelStorei(GrGLenum pname,
- GrGLint param) {
-
- switch (pname) {
- case GR_GL_UNPACK_ROW_LENGTH:
- GrDebugGL::getInstance()->setUnPackRowLength(param);
- break;
- case GR_GL_PACK_ROW_LENGTH:
- GrDebugGL::getInstance()->setPackRowLength(param);
- break;
- case GR_GL_UNPACK_ALIGNMENT:
- break;
- case GR_GL_PACK_ALIGNMENT:
- GrAlwaysAssert(false);
- break;
- default:
- GrAlwaysAssert(false);
- break;
- }
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLReadPixels(GrGLint x,
- GrGLint y,
- GrGLsizei width,
- GrGLsizei height,
- GrGLenum format,
- GrGLenum type,
- GrGLvoid* pixels) {
-
- GrGLint pixelsInRow = width;
- if (0 < GrDebugGL::getInstance()->getPackRowLength()) {
- pixelsInRow = GrDebugGL::getInstance()->getPackRowLength();
+ this->report();
}
- GrGLint componentsPerPixel = 0;
+ void abandon() const override { fAbandoned = true; }
- switch (format) {
- case GR_GL_RGBA:
- // fallthrough
- case GR_GL_BGRA:
- componentsPerPixel = 4;
- break;
- case GR_GL_RGB:
- componentsPerPixel = 3;
- break;
- case GR_GL_RED:
- componentsPerPixel = 1;
- break;
- default:
- GrAlwaysAssert(false);
- break;
+ GrGLvoid activeTexture(GrGLenum texture) override {
+ // Ganesh offsets the texture unit indices
+ texture -= GR_GL_TEXTURE0;
+ GrAlwaysAssert(texture < kDefaultMaxTextureUnits);
+ fCurrTextureUnit = texture;
}
- GrGLint alignment = 4; // the pack alignment (one of 1, 2, 4 or 8)
- // Ganesh currently doesn't support setting GR_GL_PACK_ALIGNMENT
+ GrGLvoid attachShader(GrGLuint programID, GrGLuint shaderID) override {
- GrGLint componentSize = 0; // size (in bytes) of a single component
+ GrProgramObj *program = FIND(programID, GrProgramObj, kProgram_ObjTypes);
+ GrAlwaysAssert(program);
- switch (type) {
- case GR_GL_UNSIGNED_BYTE:
- componentSize = 1;
- break;
- default:
- GrAlwaysAssert(false);
- break;
+ GrShaderObj *shader = FIND(shaderID, GrShaderObj, kShader_ObjTypes);
+ GrAlwaysAssert(shader);
+
+ program->AttachShader(shader);
}
- GrGLint rowStride = 0; // number of components (not bytes) to skip
- if (componentSize >= alignment) {
- rowStride = componentsPerPixel * pixelsInRow;
- } else {
- float fTemp =
- sk_float_ceil(componentSize * componentsPerPixel * pixelsInRow /
- static_cast<float>(alignment));
- rowStride = static_cast<GrGLint>(alignment * fTemp / componentSize);
+ ////////////////////////////////////////////////////////////////////////////////
+ GrGLvoid bindTexture(GrGLenum target, GrGLuint textureID) override {
+ GrAlwaysAssert(target == GR_GL_TEXTURE_2D ||
+ target == GR_GL_TEXTURE_RECTANGLE ||
+ target == GR_GL_TEXTURE_EXTERNAL);
+
+ // a textureID of 0 is acceptable - it binds to the default texture target
+ GrTextureObj *texture = FIND(textureID, GrTextureObj, kTexture_ObjTypes);
+
+ this->setTexture(texture);
}
- GrGLchar *scanline = static_cast<GrGLchar *>(pixels);
- for (int y = 0; y < height; ++y) {
- memset(scanline, 0, componentsPerPixel * componentSize * width);
- scanline += rowStride;
+ ////////////////////////////////////////////////////////////////////////////////
+ GrGLvoid bufferData(GrGLenum target, GrGLsizeiptr size, const GrGLvoid* data,
+ GrGLenum usage) override {
+ GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
+ GR_GL_ELEMENT_ARRAY_BUFFER == target);
+ GrAlwaysAssert(size >= 0);
+ GrAlwaysAssert(GR_GL_STREAM_DRAW == usage ||
+ GR_GL_STATIC_DRAW == usage ||
+ GR_GL_DYNAMIC_DRAW == usage);
+
+ GrBufferObj *buffer = nullptr;
+ switch (target) {
+ case GR_GL_ARRAY_BUFFER:
+ buffer = this->getArrayBuffer();
+ break;
+ case GR_GL_ELEMENT_ARRAY_BUFFER:
+ buffer = this->getElementArrayBuffer();
+ break;
+ default:
+ SkFAIL("Unexpected target to glBufferData");
+ break;
+ }
+
+ GrAlwaysAssert(buffer);
+ GrAlwaysAssert(buffer->getBound());
+
+ buffer->allocate(size, reinterpret_cast<const GrGLchar *>(data));
+ buffer->setUsage(usage);
}
-}
- GrGLvoid GR_GL_FUNCTION_TYPE debugGLUseProgram(GrGLuint programID) {
- // A programID of 0 is legal
- GrProgramObj *program = GR_FIND(programID,
- GrProgramObj,
- GrDebugGL::kProgram_ObjTypes);
+ GrGLvoid pixelStorei(GrGLenum pname, GrGLint param) override {
- GrDebugGL::getInstance()->useProgram(program);
- }
+ switch (pname) {
+ case GR_GL_UNPACK_ROW_LENGTH:
+ fUnpackRowLength = param;
+ break;
+ case GR_GL_PACK_ROW_LENGTH:
+ fPackRowLength = param;
+ break;
+ case GR_GL_UNPACK_ALIGNMENT:
+ break;
+ case GR_GL_PACK_ALIGNMENT:
+ fPackAlignment = param;
+ break;
+ default:
+ GrAlwaysAssert(false);
+ break;
+ }
+ }
- GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindFramebuffer(GrGLenum target,
- GrGLuint frameBufferID) {
+ GrGLvoid readPixels(GrGLint x,
+ GrGLint y,
+ GrGLsizei width,
+ GrGLsizei height,
+ GrGLenum format,
+ GrGLenum type,
+ GrGLvoid* pixels) override {
- GrAlwaysAssert(GR_GL_FRAMEBUFFER == target ||
- GR_GL_READ_FRAMEBUFFER == target ||
- GR_GL_DRAW_FRAMEBUFFER);
+ GrGLint pixelsInRow = width;
+ if (fPackRowLength > 0) {
+ pixelsInRow = fPackRowLength;
+ }
- // a frameBufferID of 0 is acceptable - it binds to the default
- // frame buffer
- GrFrameBufferObj *frameBuffer = GR_FIND(frameBufferID,
- GrFrameBufferObj,
- GrDebugGL::kFrameBuffer_ObjTypes);
+ GrGLint componentsPerPixel = 0;
- GrDebugGL::getInstance()->setFrameBuffer(frameBuffer);
- }
+ switch (format) {
+ case GR_GL_RGBA:
+ // fallthrough
+ case GR_GL_BGRA:
+ componentsPerPixel = 4;
+ break;
+ case GR_GL_RGB:
+ componentsPerPixel = 3;
+ break;
+ case GR_GL_RED:
+ componentsPerPixel = 1;
+ break;
+ default:
+ GrAlwaysAssert(false);
+ break;
+ }
- GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindRenderbuffer(GrGLenum target, GrGLuint renderBufferID) {
+ GrGLint alignment = fPackAlignment;
- GrAlwaysAssert(GR_GL_RENDERBUFFER == target);
+ GrGLint componentSize = 0; // size (in bytes) of a single component
- // a renderBufferID of 0 is acceptable - it unbinds the bound render buffer
- GrRenderBufferObj *renderBuffer = GR_FIND(renderBufferID,
- GrRenderBufferObj,
- GrDebugGL::kRenderBuffer_ObjTypes);
+ switch (type) {
+ case GR_GL_UNSIGNED_BYTE:
+ componentSize = 1;
+ break;
+ default:
+ GrAlwaysAssert(false);
+ break;
+ }
- GrDebugGL::getInstance()->setRenderBuffer(renderBuffer);
- }
+ GrGLint rowStride = 0; // number of components (not bytes) to skip
+ if (componentSize >= alignment) {
+ rowStride = componentsPerPixel * pixelsInRow;
+ } else {
+ float fTemp =
+ sk_float_ceil(componentSize * componentsPerPixel * pixelsInRow /
+ static_cast<float>(alignment));
+ rowStride = static_cast<GrGLint>(alignment * fTemp / componentSize);
+ }
- GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteTextures(GrGLsizei n, const GrGLuint* textures) {
+ GrGLchar *scanline = static_cast<GrGLchar *>(pixels);
+ for (int y = 0; y < height; ++y) {
+ memset(scanline, 0, componentsPerPixel * componentSize * width);
+ scanline += rowStride;
+ }
+ }
- // first potentially unbind the texture
- // TODO: move this into GrDebugGL as unBindTexture?
- for (unsigned int i = 0;
- i < GrDebugGL::getInstance()->getMaxTextureUnits();
- ++i) {
- GrTextureUnitObj *pTU = GrDebugGL::getInstance()->getTextureUnit(i);
+ GrGLvoid useProgram(GrGLuint programID) override {
- if (pTU->getTexture()) {
- for (int j = 0; j < n; ++j) {
+ // A programID of 0 is legal
+ GrProgramObj *program = FIND(programID, GrProgramObj, kProgram_ObjTypes);
- if (textures[j] == pTU->getTexture()->getID()) {
- // this ID is the current texture - revert the binding to 0
- pTU->setTexture(nullptr);
+ this->useProgram(program);
+ }
+
+ GrGLvoid bindFramebuffer(GrGLenum target, GrGLuint frameBufferID) override {
+
+ GrAlwaysAssert(GR_GL_FRAMEBUFFER == target ||
+ GR_GL_READ_FRAMEBUFFER == target ||
+ GR_GL_DRAW_FRAMEBUFFER);
+
+ // a frameBufferID of 0 is acceptable - it binds to the default
+ // frame buffer
+ GrFrameBufferObj *frameBuffer = FIND(frameBufferID, GrFrameBufferObj,
+ kFrameBuffer_ObjTypes);
+
+ this->setFrameBuffer(frameBuffer);
+ }
+
+ GrGLvoid bindRenderbuffer(GrGLenum target, GrGLuint renderBufferID) override {
+
+ GrAlwaysAssert(GR_GL_RENDERBUFFER == target);
+
+ // a renderBufferID of 0 is acceptable - it unbinds the bound render buffer
+ GrRenderBufferObj *renderBuffer = FIND(renderBufferID, GrRenderBufferObj,
+ kRenderBuffer_ObjTypes);
+
+ this->setRenderBuffer(renderBuffer);
+ }
+
+ GrGLvoid deleteTextures(GrGLsizei n, const GrGLuint* textures) override {
+ // first potentially unbind the texture
+ for (unsigned int i = 0; i < kDefaultMaxTextureUnits; ++i) {
+ GrTextureUnitObj *pTU = this->getTextureUnit(i);
+
+ if (pTU->getTexture()) {
+ for (int j = 0; j < n; ++j) {
+
+ if (textures[j] == pTU->getTexture()->getID()) {
+ // this ID is the current texture - revert the binding to 0
+ pTU->setTexture(nullptr);
+ }
}
}
}
+
+ // TODO: fuse the following block with DeleteRenderBuffers?
+ // Open GL will remove a deleted render buffer from the active
+ // frame buffer but not from any other frame buffer
+ if (this->getFrameBuffer()) {
+
+ GrFrameBufferObj *frameBuffer = this->getFrameBuffer();
+
+ for (int i = 0; i < n; ++i) {
+
+ if (frameBuffer->getColor() &&
+ textures[i] == frameBuffer->getColor()->getID()) {
+ frameBuffer->setColor(nullptr);
+ }
+ if (frameBuffer->getDepth() &&
+ textures[i] == frameBuffer->getDepth()->getID()) {
+ frameBuffer->setDepth(nullptr);
+ }
+ if (frameBuffer->getStencil() &&
+ textures[i] == frameBuffer->getStencil()->getID()) {
+ frameBuffer->setStencil(nullptr);
+ }
+ }
+ }
+
+ // then actually "delete" the buffers
+ for (int i = 0; i < n; ++i) {
+ GrTextureObj *buffer = FIND(textures[i], GrTextureObj, kTexture_ObjTypes);
+ GrAlwaysAssert(buffer);
+
+ // OpenGL gives no guarantees if a texture is deleted while attached to
+ // something other than the currently bound frame buffer
+ GrAlwaysAssert(!buffer->getBound());
+
+ GrAlwaysAssert(!buffer->getDeleted());
+ buffer->deleteAction();
+ }
+
}
- // TODO: fuse the following block with DeleteRenderBuffers?
- // Open GL will remove a deleted render buffer from the active
- // frame buffer but not from any other frame buffer
- if (GrDebugGL::getInstance()->getFrameBuffer()) {
+ GrGLvoid deleteFramebuffers(GrGLsizei n, const GrGLuint *frameBuffers) override {
- GrFrameBufferObj *frameBuffer = GrDebugGL::getInstance()->getFrameBuffer();
+ // first potentially unbind the buffers
+ if (this->getFrameBuffer()) {
+ for (int i = 0; i < n; ++i) {
+ if (frameBuffers[i] ==
+ this->getFrameBuffer()->getID()) {
+ // this ID is the current frame buffer - rebind to the default
+ this->setFrameBuffer(nullptr);
+ }
+ }
+ }
+
+ // then actually "delete" the buffers
for (int i = 0; i < n; ++i) {
+ GrFrameBufferObj *buffer = FIND(frameBuffers[i], GrFrameBufferObj,
+ kFrameBuffer_ObjTypes);
+ GrAlwaysAssert(buffer);
- if (frameBuffer->getColor() &&
- textures[i] == frameBuffer->getColor()->getID()) {
- frameBuffer->setColor(nullptr);
- }
- if (frameBuffer->getDepth() &&
- textures[i] == frameBuffer->getDepth()->getID()) {
- frameBuffer->setDepth(nullptr);
- }
- if (frameBuffer->getStencil() &&
- textures[i] == frameBuffer->getStencil()->getID()) {
- frameBuffer->setStencil(nullptr);
- }
+ GrAlwaysAssert(!buffer->getDeleted());
+ buffer->deleteAction();
}
}
- // then actually "delete" the buffers
- for (int i = 0; i < n; ++i) {
- GrTextureObj *buffer = GR_FIND(textures[i],
- GrTextureObj,
- GrDebugGL::kTexture_ObjTypes);
- GrAlwaysAssert(buffer);
+ GrGLvoid deleteRenderbuffers(GrGLsizei n,const GrGLuint *renderBuffers) override {
- // OpenGL gives no guarantees if a texture is deleted while attached to
- // something other than the currently bound frame buffer
- GrAlwaysAssert(!buffer->getBound());
+ // first potentially unbind the buffers
+ if (this->getRenderBuffer()) {
+ for (int i = 0; i < n; ++i) {
- GrAlwaysAssert(!buffer->getDeleted());
- buffer->deleteAction();
- }
-
- }
-
- GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteFramebuffers(GrGLsizei n,
- const GrGLuint *frameBuffers) {
-
- // first potentially unbind the buffers
- if (GrDebugGL::getInstance()->getFrameBuffer()) {
- for (int i = 0; i < n; ++i) {
-
- if (frameBuffers[i] ==
- GrDebugGL::getInstance()->getFrameBuffer()->getID()) {
- // this ID is the current frame buffer - rebind to the default
- GrDebugGL::getInstance()->setFrameBuffer(nullptr);
+ if (renderBuffers[i] ==
+ this->getRenderBuffer()->getID()) {
+ // this ID is the current render buffer - make no
+ // render buffer be bound
+ this->setRenderBuffer(nullptr);
+ }
}
}
+
+ // TODO: fuse the following block with DeleteTextures?
+ // Open GL will remove a deleted render buffer from the active frame
+ // buffer but not from any other frame buffer
+ if (this->getFrameBuffer()) {
+
+ GrFrameBufferObj *frameBuffer = this->getFrameBuffer();
+
+ for (int i = 0; i < n; ++i) {
+
+ if (frameBuffer->getColor() &&
+ renderBuffers[i] == frameBuffer->getColor()->getID()) {
+ frameBuffer->setColor(nullptr);
+ }
+ if (frameBuffer->getDepth() &&
+ renderBuffers[i] == frameBuffer->getDepth()->getID()) {
+ frameBuffer->setDepth(nullptr);
+ }
+ if (frameBuffer->getStencil() &&
+ renderBuffers[i] == frameBuffer->getStencil()->getID()) {
+ frameBuffer->setStencil(nullptr);
+ }
+ }
+ }
+
+ // then actually "delete" the buffers
+ for (int i = 0; i < n; ++i) {
+ GrRenderBufferObj *buffer = FIND(renderBuffers[i], GrRenderBufferObj,
+ kRenderBuffer_ObjTypes);
+ GrAlwaysAssert(buffer);
+
+ // OpenGL gives no guarantees if a render buffer is deleted
+ // while attached to something other than the currently
+ // bound frame buffer
+ GrAlwaysAssert(!buffer->getColorBound());
+ GrAlwaysAssert(!buffer->getDepthBound());
+ // However, at GrContext destroy time we release all GrRsources and so stencil buffers
+ // may get deleted before FBOs that refer to them.
+ //GrAlwaysAssert(!buffer->getStencilBound());
+
+ GrAlwaysAssert(!buffer->getDeleted());
+ buffer->deleteAction();
+ }
}
- // then actually "delete" the buffers
- for (int i = 0; i < n; ++i) {
- GrFrameBufferObj *buffer = GR_FIND(frameBuffers[i],
- GrFrameBufferObj,
- GrDebugGL::kFrameBuffer_ObjTypes);
- GrAlwaysAssert(buffer);
+ GrGLvoid framebufferRenderbuffer(GrGLenum target,
+ GrGLenum attachment,
+ GrGLenum renderbuffertarget,
+ GrGLuint renderBufferID) override {
- GrAlwaysAssert(!buffer->getDeleted());
- buffer->deleteAction();
+ GrAlwaysAssert(GR_GL_FRAMEBUFFER == target);
+ GrAlwaysAssert(GR_GL_COLOR_ATTACHMENT0 == attachment ||
+ GR_GL_DEPTH_ATTACHMENT == attachment ||
+ GR_GL_STENCIL_ATTACHMENT == attachment);
+ GrAlwaysAssert(GR_GL_RENDERBUFFER == renderbuffertarget);
+
+ GrFrameBufferObj *framebuffer = this->getFrameBuffer();
+ // A render buffer cannot be attached to the default framebuffer
+ GrAlwaysAssert(framebuffer);
+
+ // a renderBufferID of 0 is acceptable - it unbinds the current
+ // render buffer
+ GrRenderBufferObj *renderbuffer = FIND(renderBufferID, GrRenderBufferObj,
+ kRenderBuffer_ObjTypes);
+
+ switch (attachment) {
+ case GR_GL_COLOR_ATTACHMENT0:
+ framebuffer->setColor(renderbuffer);
+ break;
+ case GR_GL_DEPTH_ATTACHMENT:
+ framebuffer->setDepth(renderbuffer);
+ break;
+ case GR_GL_STENCIL_ATTACHMENT:
+ framebuffer->setStencil(renderbuffer);
+ break;
+ default:
+ GrAlwaysAssert(false);
+ break;
+ };
+
}
- }
- GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteRenderbuffers(GrGLsizei n,
- const GrGLuint *renderBuffers) {
+ ////////////////////////////////////////////////////////////////////////////////
+ GrGLvoid framebufferTexture2D(GrGLenum target, GrGLenum attachment, GrGLenum textarget,
+ GrGLuint textureID, GrGLint level) override {
- // first potentially unbind the buffers
- if (GrDebugGL::getInstance()->getRenderBuffer()) {
- for (int i = 0; i < n; ++i) {
+ GrAlwaysAssert(GR_GL_FRAMEBUFFER == target);
+ GrAlwaysAssert(GR_GL_COLOR_ATTACHMENT0 == attachment ||
+ GR_GL_DEPTH_ATTACHMENT == attachment ||
+ GR_GL_STENCIL_ATTACHMENT == attachment);
+ GrAlwaysAssert(GR_GL_TEXTURE_2D == textarget);
- if (renderBuffers[i] ==
- GrDebugGL::getInstance()->getRenderBuffer()->getID()) {
- // this ID is the current render buffer - make no
- // render buffer be bound
- GrDebugGL::getInstance()->setRenderBuffer(nullptr);
- }
+ GrFrameBufferObj *framebuffer = this->getFrameBuffer();
+ // A texture cannot be attached to the default framebuffer
+ GrAlwaysAssert(framebuffer);
+
+ // A textureID of 0 is allowed - it unbinds the currently bound texture
+ GrTextureObj *texture = FIND(textureID, GrTextureObj, kTexture_ObjTypes);
+ if (texture) {
+ // The texture shouldn't be bound to a texture unit - this
+ // could lead to a feedback loop
+ GrAlwaysAssert(!texture->getBound());
}
+
+ GrAlwaysAssert(0 == level);
+
+ switch (attachment) {
+ case GR_GL_COLOR_ATTACHMENT0:
+ framebuffer->setColor(texture);
+ break;
+ case GR_GL_DEPTH_ATTACHMENT:
+ framebuffer->setDepth(texture);
+ break;
+ case GR_GL_STENCIL_ATTACHMENT:
+ framebuffer->setStencil(texture);
+ break;
+ default:
+ GrAlwaysAssert(false);
+ break;
+ };
}
- // TODO: fuse the following block with DeleteTextures?
- // Open GL will remove a deleted render buffer from the active frame
- // buffer but not from any other frame buffer
- if (GrDebugGL::getInstance()->getFrameBuffer()) {
+ GrGLuint createProgram() override {
- GrFrameBufferObj *frameBuffer =
- GrDebugGL::getInstance()->getFrameBuffer();
+ GrProgramObj *program = CREATE(GrProgramObj, kProgram_ObjTypes);
- for (int i = 0; i < n; ++i) {
-
- if (frameBuffer->getColor() &&
- renderBuffers[i] == frameBuffer->getColor()->getID()) {
- frameBuffer->setColor(nullptr);
- }
- if (frameBuffer->getDepth() &&
- renderBuffers[i] == frameBuffer->getDepth()->getID()) {
- frameBuffer->setDepth(nullptr);
- }
- if (frameBuffer->getStencil() &&
- renderBuffers[i] == frameBuffer->getStencil()->getID()) {
- frameBuffer->setStencil(nullptr);
- }
- }
- }
-
- // then actually "delete" the buffers
- for (int i = 0; i < n; ++i) {
- GrRenderBufferObj *buffer = GR_FIND(renderBuffers[i],
- GrRenderBufferObj,
- GrDebugGL::kRenderBuffer_ObjTypes);
- GrAlwaysAssert(buffer);
-
- // OpenGL gives no guarantees if a render buffer is deleted
- // while attached to something other than the currently
- // bound frame buffer
- GrAlwaysAssert(!buffer->getColorBound());
- GrAlwaysAssert(!buffer->getDepthBound());
- // However, at GrContext destroy time we release all GrRsources and so stencil buffers
- // may get deleted before FBOs that refer to them.
- //GrAlwaysAssert(!buffer->getStencilBound());
-
- GrAlwaysAssert(!buffer->getDeleted());
- buffer->deleteAction();
- }
- }
-
- GrGLvoid GR_GL_FUNCTION_TYPE debugGLFramebufferRenderbuffer(GrGLenum target,
- GrGLenum attachment,
- GrGLenum renderbuffertarget,
- GrGLuint renderBufferID) {
-
- GrAlwaysAssert(GR_GL_FRAMEBUFFER == target);
- GrAlwaysAssert(GR_GL_COLOR_ATTACHMENT0 == attachment ||
- GR_GL_DEPTH_ATTACHMENT == attachment ||
- GR_GL_STENCIL_ATTACHMENT == attachment);
- GrAlwaysAssert(GR_GL_RENDERBUFFER == renderbuffertarget);
-
- GrFrameBufferObj *framebuffer = GrDebugGL::getInstance()->getFrameBuffer();
- // A render buffer cannot be attached to the default framebuffer
- GrAlwaysAssert(framebuffer);
-
- // a renderBufferID of 0 is acceptable - it unbinds the current
- // render buffer
- GrRenderBufferObj *renderbuffer = GR_FIND(renderBufferID,
- GrRenderBufferObj,
- GrDebugGL::kRenderBuffer_ObjTypes);
-
- switch (attachment) {
- case GR_GL_COLOR_ATTACHMENT0:
- framebuffer->setColor(renderbuffer);
- break;
- case GR_GL_DEPTH_ATTACHMENT:
- framebuffer->setDepth(renderbuffer);
- break;
- case GR_GL_STENCIL_ATTACHMENT:
- framebuffer->setStencil(renderbuffer);
- break;
- default:
- GrAlwaysAssert(false);
- break;
- };
-
- }
-
- ////////////////////////////////////////////////////////////////////////////////
- GrGLvoid GR_GL_FUNCTION_TYPE debugGLFramebufferTexture2D(GrGLenum target,
- GrGLenum attachment,
- GrGLenum textarget,
- GrGLuint textureID,
- GrGLint level) {
-
- GrAlwaysAssert(GR_GL_FRAMEBUFFER == target);
- GrAlwaysAssert(GR_GL_COLOR_ATTACHMENT0 == attachment ||
- GR_GL_DEPTH_ATTACHMENT == attachment ||
- GR_GL_STENCIL_ATTACHMENT == attachment);
- GrAlwaysAssert(GR_GL_TEXTURE_2D == textarget);
-
- GrFrameBufferObj *framebuffer = GrDebugGL::getInstance()->getFrameBuffer();
- // A texture cannot be attached to the default framebuffer
- GrAlwaysAssert(framebuffer);
-
- // A textureID of 0 is allowed - it unbinds the currently bound texture
- GrTextureObj *texture = GR_FIND(textureID, GrTextureObj,
- GrDebugGL::kTexture_ObjTypes);
- if (texture) {
- // The texture shouldn't be bound to a texture unit - this
- // could lead to a feedback loop
- GrAlwaysAssert(!texture->getBound());
- }
-
- GrAlwaysAssert(0 == level);
-
- switch (attachment) {
- case GR_GL_COLOR_ATTACHMENT0:
- framebuffer->setColor(texture);
- break;
- case GR_GL_DEPTH_ATTACHMENT:
- framebuffer->setDepth(texture);
- break;
- case GR_GL_STENCIL_ATTACHMENT:
- framebuffer->setStencil(texture);
- break;
- default:
- GrAlwaysAssert(false);
- break;
- };
- }
-
-GrGLuint GR_GL_FUNCTION_TYPE debugGLCreateProgram() {
-
- GrProgramObj *program = GR_CREATE(GrProgramObj,
- GrDebugGL::kProgram_ObjTypes);
-
- return program->getID();
-}
-
-GrGLuint GR_GL_FUNCTION_TYPE debugGLCreateShader(GrGLenum type) {
-
- GrAlwaysAssert(GR_GL_VERTEX_SHADER == type ||
- GR_GL_FRAGMENT_SHADER == type);
-
- GrShaderObj *shader = GR_CREATE(GrShaderObj, GrDebugGL::kShader_ObjTypes);
- shader->setType(type);
-
- return shader->getID();
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteProgram(GrGLuint programID) {
-
- GrProgramObj *program = GR_FIND(programID,
- GrProgramObj,
- GrDebugGL::kProgram_ObjTypes);
- GrAlwaysAssert(program);
-
- if (program->getRefCount()) {
- // someone is still using this program so we can't delete it here
- program->setMarkedForDeletion();
- } else {
- program->deleteAction();
+ return program->getID();
}
-}
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteShader(GrGLuint shaderID) {
+ GrGLuint createShader(GrGLenum type) override {
- GrShaderObj *shader = GR_FIND(shaderID,
- GrShaderObj,
- GrDebugGL::kShader_ObjTypes);
- GrAlwaysAssert(shader);
+ GrAlwaysAssert(GR_GL_VERTEX_SHADER == type ||
+ GR_GL_FRAGMENT_SHADER == type);
- if (shader->getRefCount()) {
- // someone is still using this shader so we can't delete it here
- shader->setMarkedForDeletion();
- } else {
- shader->deleteAction();
+ GrShaderObj *shader = CREATE(GrShaderObj, kShader_ObjTypes);
+ shader->setType(type);
+
+ return shader->getID();
}
-}
-GrGLvoid debugGenObjs(GrDebugGL::GrObjTypes type,
- GrGLsizei n,
- GrGLuint* ids) {
+ GrGLenum checkFramebufferStatus(GrGLenum target) override { return GR_GL_FRAMEBUFFER_COMPLETE; }
- for (int i = 0; i < n; ++i) {
- GrAlwaysAssert(ids[i] == 0);
- GrFakeRefObj *obj = GrDebugGL::getInstance()->createObj(type);
- GrAlwaysAssert(obj);
- ids[i] = obj->getID();
- }
-}
+ GrGLvoid deleteProgram(GrGLuint programID) override {
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLGenBuffers(GrGLsizei n, GrGLuint* ids) {
- debugGenObjs(GrDebugGL::kBuffer_ObjTypes, n, ids);
-}
+ GrProgramObj *program = FIND(programID, GrProgramObj, kProgram_ObjTypes);
+ GrAlwaysAssert(program);
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLGenerateMipmap(GrGLenum level) {
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLGenFramebuffers(GrGLsizei n,
- GrGLuint* ids) {
- debugGenObjs(GrDebugGL::kFrameBuffer_ObjTypes, n, ids);
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLGenRenderbuffers(GrGLsizei n,
- GrGLuint* ids) {
- debugGenObjs(GrDebugGL::kRenderBuffer_ObjTypes, n, ids);
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLGenTextures(GrGLsizei n, GrGLuint* ids) {
- debugGenObjs(GrDebugGL::kTexture_ObjTypes, n, ids);
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLGenVertexArrays(GrGLsizei n, GrGLuint* ids) {
- debugGenObjs(GrDebugGL::kVertexArray_ObjTypes, n, ids);
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteVertexArrays(GrGLsizei n, const GrGLuint* ids) {
- for (GrGLsizei i = 0; i < n; ++i) {
- GrVertexArrayObj* array =
- GR_FIND(ids[i], GrVertexArrayObj, GrDebugGL::kVertexArray_ObjTypes);
- GrAlwaysAssert(array);
-
- // Deleting the current vertex array binds object 0
- if (GrDebugGL::getInstance()->getVertexArray() == array) {
- GrDebugGL::getInstance()->setVertexArray(nullptr);
- }
-
- if (array->getRefCount()) {
- // someone is still using this vertex array so we can't delete it here
- array->setMarkedForDeletion();
+ if (program->getRefCount()) {
+ // someone is still using this program so we can't delete it here
+ program->setMarkedForDeletion();
} else {
- array->deleteAction();
- }
- }
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindVertexArray(GrGLuint id) {
- GrVertexArrayObj* array = GR_FIND(id, GrVertexArrayObj, GrDebugGL::kVertexArray_ObjTypes);
- GrAlwaysAssert((0 == id) || array);
- GrDebugGL::getInstance()->setVertexArray(array);
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindBuffer(GrGLenum target, GrGLuint bufferID) {
- GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target || GR_GL_ELEMENT_ARRAY_BUFFER == target);
-
- GrBufferObj *buffer = GR_FIND(bufferID,
- GrBufferObj,
- GrDebugGL::kBuffer_ObjTypes);
- // 0 is a permissible bufferID - it unbinds the current buffer
-
- switch (target) {
- case GR_GL_ARRAY_BUFFER:
- GrDebugGL::getInstance()->setArrayBuffer(buffer);
- break;
- case GR_GL_ELEMENT_ARRAY_BUFFER:
- GrDebugGL::getInstance()->setElementArrayBuffer(buffer);
- break;
- default:
- SkFAIL("Unexpected target to glBindBuffer");
- break;
- }
-}
-
-// deleting a bound buffer has the side effect of binding 0
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteBuffers(GrGLsizei n, const GrGLuint* ids) {
- // first potentially unbind the buffers
- for (int i = 0; i < n; ++i) {
-
- if (GrDebugGL::getInstance()->getArrayBuffer() &&
- ids[i] == GrDebugGL::getInstance()->getArrayBuffer()->getID()) {
- // this ID is the current array buffer
- GrDebugGL::getInstance()->setArrayBuffer(nullptr);
- }
- if (GrDebugGL::getInstance()->getElementArrayBuffer() &&
- ids[i] ==
- GrDebugGL::getInstance()->getElementArrayBuffer()->getID()) {
- // this ID is the current element array buffer
- GrDebugGL::getInstance()->setElementArrayBuffer(nullptr);
+ program->deleteAction();
}
}
- // then actually "delete" the buffers
- for (int i = 0; i < n; ++i) {
- GrBufferObj *buffer = GR_FIND(ids[i],
- GrBufferObj,
- GrDebugGL::kBuffer_ObjTypes);
+ GrGLvoid deleteShader(GrGLuint shaderID) override {
+
+ GrShaderObj *shader = FIND(shaderID, GrShaderObj, kShader_ObjTypes);
+ GrAlwaysAssert(shader);
+
+ if (shader->getRefCount()) {
+ // someone is still using this shader so we can't delete it here
+ shader->setMarkedForDeletion();
+ } else {
+ shader->deleteAction();
+ }
+ }
+
+ GrGLvoid genBuffers(GrGLsizei n, GrGLuint* ids) override {
+ this->genObjs(kBuffer_ObjTypes, n, ids);
+ }
+
+ GrGLvoid genFramebuffers(GrGLsizei n, GrGLuint* ids) override {
+ this->genObjs(kFrameBuffer_ObjTypes, n, ids);
+ }
+
+ GrGLvoid genRenderbuffers(GrGLsizei n, GrGLuint* ids) override {
+ this->genObjs(kRenderBuffer_ObjTypes, n, ids);
+ }
+
+ GrGLvoid genTextures(GrGLsizei n, GrGLuint* ids) override {
+ this->genObjs(kTexture_ObjTypes, n, ids);
+ }
+
+ GrGLvoid genVertexArrays(GrGLsizei n, GrGLuint* ids) override {
+ this->genObjs(kVertexArray_ObjTypes, n, ids);
+ }
+
+ GrGLvoid genQueries(GrGLsizei n, GrGLuint *ids) override { this->genGenericIds(n, ids); }
+
+ GrGLenum getError() override { return GR_GL_NO_ERROR; }
+
+ GrGLvoid getIntegerv(GrGLenum pname, GrGLint* params) override {
+ // TODO: remove from Ganesh the #defines for gets we don't use.
+ // We would like to minimize gets overall due to performance issues
+ switch (pname) {
+ case GR_GL_CONTEXT_PROFILE_MASK:
+ *params = GR_GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;
+ break;
+ case GR_GL_STENCIL_BITS:
+ *params = 8;
+ break;
+ case GR_GL_SAMPLES:
+ *params = 1;
+ break;
+ case GR_GL_FRAMEBUFFER_BINDING:
+ *params = 0;
+ break;
+ case GR_GL_VIEWPORT:
+ params[0] = 0;
+ params[1] = 0;
+ params[2] = 800;
+ params[3] = 600;
+ break;
+ case GR_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
+ case GR_GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS:
+ case GR_GL_MAX_TEXTURE_IMAGE_UNITS:
+ case GR_GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
+ *params = 8;
+ break;
+ case GR_GL_MAX_TEXTURE_COORDS:
+ *params = 8;
+ break;
+ case GR_GL_MAX_VERTEX_UNIFORM_VECTORS:
+ *params = kDefaultMaxVertexUniformVectors;
+ break;
+ case GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS:
+ *params = kDefaultMaxFragmentUniformVectors;
+ break;
+ case GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS:
+ *params = 16 * 4;
+ break;
+ case GR_GL_NUM_COMPRESSED_TEXTURE_FORMATS:
+ *params = 0;
+ break;
+ case GR_GL_COMPRESSED_TEXTURE_FORMATS:
+ break;
+ case GR_GL_MAX_TEXTURE_SIZE:
+ *params = 8192;
+ break;
+ case GR_GL_MAX_RENDERBUFFER_SIZE:
+ *params = 8192;
+ break;
+ case GR_GL_MAX_SAMPLES:
+ *params = 32;
+ break;
+ case GR_GL_MAX_VERTEX_ATTRIBS:
+ *params = kDefaultMaxVertexAttribs;
+ break;
+ case GR_GL_MAX_VARYING_VECTORS:
+ *params = kDefaultMaxVaryingVectors;
+ break;
+ case GR_GL_NUM_EXTENSIONS: {
+ GrGLint i = 0;
+ while (kExtensions[i++]);
+ *params = i;
+ break;
+ }
+ default:
+ SkFAIL("Unexpected pname to GetIntegerv");
+ }
+ }
+
+ GrGLvoid getMultisamplefv(GrGLenum pname, GrGLuint index, GrGLfloat* val) override {
+ val[0] = val[1] = 0.5f;
+ }
+
+ GrGLvoid getProgramiv(GrGLuint program, GrGLenum pname, GrGLint* params) override {
+ this->getShaderOrProgramiv(program, pname, params);
+ }
+
+ GrGLvoid getProgramInfoLog(GrGLuint program, GrGLsizei bufsize, GrGLsizei* length,
+ char* infolog) override {
+ this->getInfoLog(program, bufsize, length, infolog);
+ }
+
+ GrGLvoid getQueryiv(GrGLenum GLtarget, GrGLenum pname, GrGLint *params) override {
+ switch (pname) {
+ case GR_GL_CURRENT_QUERY:
+ *params = 0;
+ break;
+ case GR_GL_QUERY_COUNTER_BITS:
+ *params = 32;
+ break;
+ default:
+ SkFAIL("Unexpected pname passed GetQueryiv.");
+ }
+ }
+
+ GrGLvoid getQueryObjecti64v(GrGLuint id, GrGLenum pname, GrGLint64 *params) override {
+ this->queryResult(id, pname, params);
+ }
+
+ GrGLvoid getQueryObjectiv(GrGLuint id, GrGLenum pname, GrGLint *params) override {
+ this->queryResult(id, pname, params);
+ }
+
+ GrGLvoid getQueryObjectui64v(GrGLuint id, GrGLenum pname, GrGLuint64 *params) override {
+ this->queryResult(id, pname, params);
+ }
+
+ GrGLvoid getQueryObjectuiv(GrGLuint id, GrGLenum pname, GrGLuint *params) override {
+ this->queryResult(id, pname, params);
+ }
+
+ GrGLvoid getShaderiv(GrGLuint shader, GrGLenum pname, GrGLint* params) override {
+ this->getShaderOrProgramiv(shader, pname, params);
+ }
+
+ GrGLvoid getShaderInfoLog(GrGLuint shader, GrGLsizei bufsize, GrGLsizei* length,
+ char* infolog) override {
+ this->getInfoLog(shader, bufsize, length, infolog);
+ }
+
+ const GrGLubyte* getString(GrGLenum name) override {
+ switch (name) {
+ case GR_GL_EXTENSIONS:
+ return CombinedExtensionString();
+ case GR_GL_VERSION:
+ return (const GrGLubyte*)"4.0 Debug GL";
+ case GR_GL_SHADING_LANGUAGE_VERSION:
+ return (const GrGLubyte*)"4.20.8 Debug GLSL";
+ case GR_GL_VENDOR:
+ return (const GrGLubyte*)"Debug Vendor";
+ case GR_GL_RENDERER:
+ return (const GrGLubyte*)"The Debug (Non-)Renderer";
+ default:
+ SkFAIL("Unexpected name passed to GetString");
+ return nullptr;
+ }
+ }
+
+ const GrGLubyte* getStringi(GrGLenum name, GrGLuint i) override {
+ switch (name) {
+ case GR_GL_EXTENSIONS: {
+ GrGLint count;
+ this->getIntegerv(GR_GL_NUM_EXTENSIONS, &count);
+ if ((GrGLint)i <= count) {
+ return (const GrGLubyte*) kExtensions[i];
+ } else {
+ return nullptr;
+ }
+ }
+ default:
+ SkFAIL("Unexpected name passed to GetStringi");
+ return nullptr;
+ }
+ }
+
+ GrGLvoid getTexLevelParameteriv(GrGLenum target, GrGLint level, GrGLenum pname,
+ GrGLint* params) override {
+ // we used to use this to query stuff about externally created textures,
+ // now we just require clients to tell us everything about the texture.
+ SkFAIL("Should never query texture parameters.");
+ }
+
+ GrGLvoid deleteVertexArrays(GrGLsizei n, const GrGLuint* ids) override {
+ for (GrGLsizei i = 0; i < n; ++i) {
+ GrVertexArrayObj* array = FIND(ids[i], GrVertexArrayObj, kVertexArray_ObjTypes);
+ GrAlwaysAssert(array);
+
+ // Deleting the current vertex array binds object 0
+ if (this->getVertexArray() == array) {
+ this->setVertexArray(nullptr);
+ }
+
+ if (array->getRefCount()) {
+ // someone is still using this vertex array so we can't delete it here
+ array->setMarkedForDeletion();
+ } else {
+ array->deleteAction();
+ }
+ }
+ }
+
+ GrGLvoid bindVertexArray(GrGLuint id) override {
+ GrVertexArrayObj* array = FIND(id, GrVertexArrayObj, kVertexArray_ObjTypes);
+ GrAlwaysAssert((0 == id) || array);
+ this->setVertexArray(array);
+ }
+
+ GrGLvoid bindBuffer(GrGLenum target, GrGLuint bufferID) override {
+ GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target || GR_GL_ELEMENT_ARRAY_BUFFER == target);
+
+ GrBufferObj *buffer = FIND(bufferID, GrBufferObj, kBuffer_ObjTypes);
+ // 0 is a permissible bufferID - it unbinds the current buffer
+
+ switch (target) {
+ case GR_GL_ARRAY_BUFFER:
+ this->setArrayBuffer(buffer);
+ break;
+ case GR_GL_ELEMENT_ARRAY_BUFFER:
+ this->setElementArrayBuffer(buffer);
+ break;
+ default:
+ SkFAIL("Unexpected target to glBindBuffer");
+ break;
+ }
+ }
+
+ // deleting a bound buffer has the side effect of binding 0
+ GrGLvoid deleteBuffers(GrGLsizei n, const GrGLuint* ids) override {
+ // first potentially unbind the buffers
+ for (int i = 0; i < n; ++i) {
+
+ if (this->getArrayBuffer() &&
+ ids[i] == this->getArrayBuffer()->getID()) {
+ // this ID is the current array buffer
+ this->setArrayBuffer(nullptr);
+ }
+ if (this->getElementArrayBuffer() &&
+ ids[i] == this->getElementArrayBuffer()->getID()) {
+ // this ID is the current element array buffer
+ this->setElementArrayBuffer(nullptr);
+ }
+ }
+
+ // then actually "delete" the buffers
+ for (int i = 0; i < n; ++i) {
+ GrBufferObj *buffer = FIND(ids[i], GrBufferObj, kBuffer_ObjTypes);
+ GrAlwaysAssert(buffer);
+
+ GrAlwaysAssert(!buffer->getDeleted());
+ buffer->deleteAction();
+ }
+ }
+
+ // map a buffer to the caller's address space
+ GrGLvoid* mapBufferRange(GrGLenum target, GrGLintptr offset, GrGLsizeiptr length,
+ GrGLbitfield access) override {
+ GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
+ GR_GL_ELEMENT_ARRAY_BUFFER == target);
+
+ // We only expect read access and we expect that the buffer or range is always invalidated.
+ GrAlwaysAssert(!SkToBool(GR_GL_MAP_READ_BIT & access));
+ GrAlwaysAssert((GR_GL_MAP_INVALIDATE_BUFFER_BIT | GR_GL_MAP_INVALIDATE_RANGE_BIT) & access);
+
+ GrBufferObj *buffer = nullptr;
+ switch (target) {
+ case GR_GL_ARRAY_BUFFER:
+ buffer = this->getArrayBuffer();
+ break;
+ case GR_GL_ELEMENT_ARRAY_BUFFER:
+ buffer = this->getElementArrayBuffer();
+ break;
+ default:
+ SkFAIL("Unexpected target to glMapBufferRange");
+ break;
+ }
+
+ if (buffer) {
+ GrAlwaysAssert(offset >= 0 && offset + length <= buffer->getSize());
+ GrAlwaysAssert(!buffer->getMapped());
+ buffer->setMapped(offset, length);
+ return buffer->getDataPtr() + offset;
+ }
+
+ GrAlwaysAssert(false);
+ return nullptr; // no buffer bound to the target
+ }
+
+ GrGLvoid* mapBuffer(GrGLenum target, GrGLenum access) override {
+ GrAlwaysAssert(GR_GL_WRITE_ONLY == access);
+
+ GrBufferObj *buffer = nullptr;
+ switch (target) {
+ case GR_GL_ARRAY_BUFFER:
+ buffer = this->getArrayBuffer();
+ break;
+ case GR_GL_ELEMENT_ARRAY_BUFFER:
+ buffer = this->getElementArrayBuffer();
+ break;
+ default:
+ SkFAIL("Unexpected target to glMapBuffer");
+ break;
+ }
+
+ return this->mapBufferRange(target, 0, buffer->getSize(),
+ GR_GL_MAP_WRITE_BIT | GR_GL_MAP_INVALIDATE_BUFFER_BIT);
+ }
+
+ // remove a buffer from the caller's address space
+ // TODO: check if the "access" method from "glMapBuffer" was honored
+ GrGLboolean unmapBuffer(GrGLenum target) override {
+ GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
+ GR_GL_ELEMENT_ARRAY_BUFFER == target);
+
+ GrBufferObj *buffer = nullptr;
+ switch (target) {
+ case GR_GL_ARRAY_BUFFER:
+ buffer = this->getArrayBuffer();
+ break;
+ case GR_GL_ELEMENT_ARRAY_BUFFER:
+ buffer = this->getElementArrayBuffer();
+ break;
+ default:
+ SkFAIL("Unexpected target to glUnmapBuffer");
+ break;
+ }
+
+ if (buffer) {
+ GrAlwaysAssert(buffer->getMapped());
+ buffer->resetMapped();
+ return GR_GL_TRUE;
+ }
+
+ GrAlwaysAssert(false);
+ return GR_GL_FALSE; // GR_GL_INVALID_OPERATION;
+ }
+
+ GrGLvoid flushMappedBufferRange(GrGLenum target, GrGLintptr offset,
+ GrGLsizeiptr length) override {
+ GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
+ GR_GL_ELEMENT_ARRAY_BUFFER == target);
+
+ GrBufferObj *buffer = nullptr;
+ switch (target) {
+ case GR_GL_ARRAY_BUFFER:
+ buffer = this->getArrayBuffer();
+ break;
+ case GR_GL_ELEMENT_ARRAY_BUFFER:
+ buffer = this->getElementArrayBuffer();
+ break;
+ default:
+ SkFAIL("Unexpected target to glUnmapBuffer");
+ break;
+ }
+
+ if (buffer) {
+ GrAlwaysAssert(buffer->getMapped());
+ GrAlwaysAssert(offset >= 0 && (offset + length) <= buffer->getMappedLength());
+ } else {
+ GrAlwaysAssert(false);
+ }
+ }
+
+ GrGLvoid getBufferParameteriv(GrGLenum target, GrGLenum value, GrGLint* params) override {
+
+ GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
+ GR_GL_ELEMENT_ARRAY_BUFFER == target);
+ GrAlwaysAssert(GR_GL_BUFFER_SIZE == value ||
+ GR_GL_BUFFER_USAGE == value);
+
+ GrBufferObj *buffer = nullptr;
+ switch (target) {
+ case GR_GL_ARRAY_BUFFER:
+ buffer = this->getArrayBuffer();
+ break;
+ case GR_GL_ELEMENT_ARRAY_BUFFER:
+ buffer = this->getElementArrayBuffer();
+ break;
+ }
+
GrAlwaysAssert(buffer);
- GrAlwaysAssert(!buffer->getDeleted());
- buffer->deleteAction();
- }
-}
-
-// map a buffer to the caller's address space
-GrGLvoid* GR_GL_FUNCTION_TYPE debugGLMapBufferRange(GrGLenum target, GrGLintptr offset,
- GrGLsizeiptr length, GrGLbitfield access) {
- GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
- GR_GL_ELEMENT_ARRAY_BUFFER == target);
-
- // We only expect read access and we expect that the buffer or range is always invalidated.
- GrAlwaysAssert(!SkToBool(GR_GL_MAP_READ_BIT & access));
- GrAlwaysAssert((GR_GL_MAP_INVALIDATE_BUFFER_BIT | GR_GL_MAP_INVALIDATE_RANGE_BIT) & access);
-
- GrBufferObj *buffer = nullptr;
- switch (target) {
- case GR_GL_ARRAY_BUFFER:
- buffer = GrDebugGL::getInstance()->getArrayBuffer();
- break;
- case GR_GL_ELEMENT_ARRAY_BUFFER:
- buffer = GrDebugGL::getInstance()->getElementArrayBuffer();
- break;
- default:
- SkFAIL("Unexpected target to glMapBufferRange");
- break;
+ switch (value) {
+ case GR_GL_BUFFER_MAPPED:
+ *params = GR_GL_FALSE;
+ if (buffer)
+ *params = buffer->getMapped() ? GR_GL_TRUE : GR_GL_FALSE;
+ break;
+ case GR_GL_BUFFER_SIZE:
+ *params = 0;
+ if (buffer)
+ *params = SkToInt(buffer->getSize());
+ break;
+ case GR_GL_BUFFER_USAGE:
+ *params = GR_GL_STATIC_DRAW;
+ if (buffer)
+ *params = buffer->getUsage();
+ break;
+ default:
+ SkFAIL("Unexpected value to glGetBufferParamateriv");
+ break;
+ }
}
- if (buffer) {
- GrAlwaysAssert(offset >= 0 && offset + length <= buffer->getSize());
- GrAlwaysAssert(!buffer->getMapped());
- buffer->setMapped(offset, length);
- return buffer->getDataPtr() + offset;
- }
-
- GrAlwaysAssert(false);
- return nullptr; // no buffer bound to the target
-}
-
-GrGLvoid* GR_GL_FUNCTION_TYPE debugGLMapBuffer(GrGLenum target, GrGLenum access) {
- GrAlwaysAssert(GR_GL_WRITE_ONLY == access);
-
- GrBufferObj *buffer = nullptr;
- switch (target) {
- case GR_GL_ARRAY_BUFFER:
- buffer = GrDebugGL::getInstance()->getArrayBuffer();
- break;
- case GR_GL_ELEMENT_ARRAY_BUFFER:
- buffer = GrDebugGL::getInstance()->getElementArrayBuffer();
- break;
- default:
- SkFAIL("Unexpected target to glMapBuffer");
- break;
- }
-
- return debugGLMapBufferRange(target, 0, buffer->getSize(),
- GR_GL_MAP_WRITE_BIT | GR_GL_MAP_INVALIDATE_BUFFER_BIT);
-}
-
-// remove a buffer from the caller's address space
-// TODO: check if the "access" method from "glMapBuffer" was honored
-GrGLboolean GR_GL_FUNCTION_TYPE debugGLUnmapBuffer(GrGLenum target) {
-
- GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
- GR_GL_ELEMENT_ARRAY_BUFFER == target);
-
- GrBufferObj *buffer = nullptr;
- switch (target) {
- case GR_GL_ARRAY_BUFFER:
- buffer = GrDebugGL::getInstance()->getArrayBuffer();
- break;
- case GR_GL_ELEMENT_ARRAY_BUFFER:
- buffer = GrDebugGL::getInstance()->getElementArrayBuffer();
- break;
- default:
- SkFAIL("Unexpected target to glUnmapBuffer");
- break;
- }
-
- if (buffer) {
- GrAlwaysAssert(buffer->getMapped());
- buffer->resetMapped();
- return GR_GL_TRUE;
- }
-
- GrAlwaysAssert(false);
- return GR_GL_FALSE; // GR_GL_INVALID_OPERATION;
-}
-
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLFlushMappedBufferRange(GrGLenum target,
- GrGLintptr offset,
- GrGLsizeiptr length) {
- GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
- GR_GL_ELEMENT_ARRAY_BUFFER == target);
-
- GrBufferObj *buffer = nullptr;
- switch (target) {
- case GR_GL_ARRAY_BUFFER:
- buffer = GrDebugGL::getInstance()->getArrayBuffer();
- break;
- case GR_GL_ELEMENT_ARRAY_BUFFER:
- buffer = GrDebugGL::getInstance()->getElementArrayBuffer();
- break;
- default:
- SkFAIL("Unexpected target to glUnmapBuffer");
- break;
- }
-
- if (buffer) {
- GrAlwaysAssert(buffer->getMapped());
- GrAlwaysAssert(offset >= 0 && (offset + length) <= buffer->getMappedLength());
- } else {
- GrAlwaysAssert(false);
- }
-}
-
-
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLGetBufferParameteriv(GrGLenum target,
- GrGLenum value,
- GrGLint* params) {
-
- GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
- GR_GL_ELEMENT_ARRAY_BUFFER == target);
- GrAlwaysAssert(GR_GL_BUFFER_SIZE == value ||
- GR_GL_BUFFER_USAGE == value);
-
- GrBufferObj *buffer = nullptr;
- switch (target) {
- case GR_GL_ARRAY_BUFFER:
- buffer = GrDebugGL::getInstance()->getArrayBuffer();
- break;
- case GR_GL_ELEMENT_ARRAY_BUFFER:
- buffer = GrDebugGL::getInstance()->getElementArrayBuffer();
- break;
- }
-
- GrAlwaysAssert(buffer);
-
- switch (value) {
- case GR_GL_BUFFER_MAPPED:
- *params = GR_GL_FALSE;
- if (buffer)
- *params = buffer->getMapped() ? GR_GL_TRUE : GR_GL_FALSE;
- break;
- case GR_GL_BUFFER_SIZE:
- *params = 0;
- if (buffer)
- *params = SkToInt(buffer->getSize());
- break;
- case GR_GL_BUFFER_USAGE:
- *params = GR_GL_STATIC_DRAW;
- if (buffer)
- *params = buffer->getUsage();
- break;
- default:
- SkFAIL("Unexpected value to glGetBufferParamateriv");
- break;
- }
-};
-} // end of namespace
-
-////////////////////////////////////////////////////////////////////////////////
-struct GrDebugGLInterface : public GrGLInterface {
-
-public:
-
-
- GrDebugGLInterface()
- : fWrapped(nullptr) {
- GrDebugGL::staticRef();
- }
-
- virtual ~GrDebugGLInterface() {
- GrDebugGL::staticUnRef();
- }
-
- void setWrapped(GrGLInterface *interface) {
- fWrapped.reset(interface);
- }
-
- void abandon() const override {
- GrDebugGL::abandon();
- }
-
- // TODO: there are some issues w/ wrapping another GL interface inside the
- // debug interface:
- // Since none of the "gl" methods are member functions they don't get
- // a "this" pointer through which to access "fWrapped"
- // This could be worked around by having all of them access the
- // "glInterface" pointer - i.e., treating the debug interface as a
- // true singleton
- //
- // The problem with this is that we also want to handle OpenGL
- // contexts. The natural way to do this is to have multiple debug
- // interfaces. Each of which represents a separate context. The
- // static ID count would still uniquify IDs across all of them.
- // The problem then is that we couldn't treat the debug GL
- // interface as a singleton (since there would be one for each
- // context).
- //
- // The solution to this is probably to alter SkDebugGlContext's
- // "makeCurrent" method to make a call like "makeCurrent(this)" to
- // the debug GL interface (assuming that the application will create
- // multiple SkGLContext's) to let it switch between the active
- // context. Everything in the GrDebugGL object would then need to be
- // moved to a GrContextObj and the GrDebugGL object would just switch
- // between them. Note that this approach would also require that
- // SkDebugGLContext wrap an arbitrary other context
- // and then pass the wrapped interface to the debug GL interface.
-
-protected:
private:
+ // the OpenGLES 2.0 spec says this must be >= 128
+ static const GrGLint kDefaultMaxVertexUniformVectors = 128;
- SkAutoTUnref<GrGLInterface> fWrapped;
+ // the OpenGLES 2.0 spec says this must be >=16
+ static const GrGLint kDefaultMaxFragmentUniformVectors = 16;
- typedef GrGLInterface INHERITED;
+ // the OpenGLES 2.0 spec says this must be >= 8
+ static const GrGLint kDefaultMaxVertexAttribs = 8;
+
+ // the OpenGLES 2.0 spec says this must be >= 8
+ static const GrGLint kDefaultMaxVaryingVectors = 8;
+
+ // the OpenGLES 2.0 spec says this must be >= 2
+ static const GrGLint kDefaultMaxTextureUnits = 8;
+
+ static const char* kExtensions[];
+
+ GrGLuint fCurrGenericID;
+ GrGLuint fCurrTextureUnit;
+ GrTextureUnitObj* fTextureUnits[kDefaultMaxTextureUnits];
+ GrBufferObj* fArrayBuffer;
+ GrBufferObj* fElementArrayBuffer;
+ GrVertexArrayObj* fVertexArray;
+ GrGLint fPackRowLength;
+ GrGLint fUnpackRowLength;
+ GrGLint fPackAlignment;
+ GrFrameBufferObj* fFrameBuffer;
+ GrRenderBufferObj* fRenderBuffer;
+ GrProgramObj* fProgram;
+ mutable bool fAbandoned;
+ // global store of all objects
+ SkTArray<GrFakeRefObj *> fObjects;
+
+ static const GrGLubyte* CombinedExtensionString() {
+ static SkString gExtString;
+ static SkMutex gMutex;
+ gMutex.acquire();
+ if (0 == gExtString.size()) {
+ int i = 0;
+ while (kExtensions[i]) {
+ if (i > 0) {
+ gExtString.append(" ");
+ }
+ gExtString.append(kExtensions[i]);
+ ++i;
+ }
+ }
+ gMutex.release();
+ return (const GrGLubyte*) gExtString.c_str();
+ }
+
+ GrGLvoid genGenericIds(GrGLsizei n, GrGLuint* ids) {
+ for (int i = 0; i < n; ++i) {
+ ids[i] = ++fCurrGenericID;
+ }
+ }
+
+ GrGLvoid getInfoLog(GrGLuint object, GrGLsizei bufsize, GrGLsizei* length,
+ char* infolog) {
+ if (length) {
+ *length = 0;
+ }
+ if (bufsize > 0) {
+ *infolog = 0;
+ }
+ }
+
+ GrGLvoid getShaderOrProgramiv(GrGLuint object, GrGLenum pname, GrGLint* params) {
+ switch (pname) {
+ case GR_GL_LINK_STATUS: // fallthru
+ case GR_GL_COMPILE_STATUS:
+ *params = GR_GL_TRUE;
+ break;
+ case GR_GL_INFO_LOG_LENGTH:
+ *params = 0;
+ break;
+ // we don't expect any other pnames
+ default:
+ SkFAIL("Unexpected pname to GetProgramiv");
+ break;
+ }
+ }
+
+ template <typename T>
+ void queryResult(GrGLenum GLtarget, GrGLenum pname, T *params) {
+ switch (pname) {
+ case GR_GL_QUERY_RESULT_AVAILABLE:
+ *params = GR_GL_TRUE;
+ break;
+ case GR_GL_QUERY_RESULT:
+ *params = 0;
+ break;
+ default:
+ SkFAIL("Unexpected pname passed to GetQueryObject.");
+ break;
+ }
+ }
+
+ enum ObjTypes {
+ kTexture_ObjTypes = 0,
+ kBuffer_ObjTypes,
+ kRenderBuffer_ObjTypes,
+ kFrameBuffer_ObjTypes,
+ kShader_ObjTypes,
+ kProgram_ObjTypes,
+ kTextureUnit_ObjTypes,
+ kVertexArray_ObjTypes,
+ kObjTypeCount
+ };
+
+ typedef GrFakeRefObj *(*Create)();
+
+ static Create gFactoryFunc[kObjTypeCount];
+
+ GrGLvoid genObjs(ObjTypes type, GrGLsizei n, GrGLuint* ids) {
+ for (int i = 0; i < n; ++i) {
+ GrAlwaysAssert(ids[i] == 0);
+ GrFakeRefObj *obj = this->createObj(type);
+ GrAlwaysAssert(obj);
+ ids[i] = obj->getID();
+ }
+ }
+
+ GrFakeRefObj* createObj(ObjTypes type) {
+ GrFakeRefObj *temp = (*gFactoryFunc[type])();
+
+ fObjects.push_back(temp);
+
+ return temp;
+ }
+
+ GrFakeRefObj* findObject(GrGLuint ID, ObjTypes type) {
+ for (int i = 0; i < fObjects.count(); ++i) {
+ if (fObjects[i]->getID() == ID) { // && fObjects[i]->getType() == type) {
+ // The application shouldn't be accessing objects
+ // that (as far as OpenGL knows) were already deleted
+ GrAlwaysAssert(!fObjects[i]->getDeleted());
+ GrAlwaysAssert(!fObjects[i]->getMarkedForDeletion());
+ return fObjects[i];
+ }
+ }
+ return nullptr;
+ }
+
+ GrTextureUnitObj* getTextureUnit(int unit) {
+ GrAlwaysAssert(0 <= unit && kDefaultMaxTextureUnits > unit);
+
+ return fTextureUnits[unit];
+ }
+
+ void setArrayBuffer(GrBufferObj *arrayBuffer) {
+ if (fArrayBuffer) {
+ // automatically break the binding of the old buffer
+ GrAlwaysAssert(fArrayBuffer->getBound());
+ fArrayBuffer->resetBound();
+
+ GrAlwaysAssert(!fArrayBuffer->getDeleted());
+ fArrayBuffer->unref();
+ }
+
+ fArrayBuffer = arrayBuffer;
+
+ if (fArrayBuffer) {
+ GrAlwaysAssert(!fArrayBuffer->getDeleted());
+ fArrayBuffer->ref();
+
+ GrAlwaysAssert(!fArrayBuffer->getBound());
+ fArrayBuffer->setBound();
+ }
+ }
+
+ GrBufferObj* getArrayBuffer() { return fArrayBuffer; }
+ void setElementArrayBuffer(GrBufferObj *elementArrayBuffer) {
+ if (fElementArrayBuffer) {
+ // automatically break the binding of the old buffer
+ GrAlwaysAssert(fElementArrayBuffer->getBound());
+ fElementArrayBuffer->resetBound();
+
+ GrAlwaysAssert(!fElementArrayBuffer->getDeleted());
+ fElementArrayBuffer->unref();
+ }
+
+ fElementArrayBuffer = elementArrayBuffer;
+
+ if (fElementArrayBuffer) {
+ GrAlwaysAssert(!fElementArrayBuffer->getDeleted());
+ fElementArrayBuffer->ref();
+
+ GrAlwaysAssert(!fElementArrayBuffer->getBound());
+ fElementArrayBuffer->setBound();
+ }
+ }
+
+ GrBufferObj *getElementArrayBuffer() { return fElementArrayBuffer; }
+
+ void setVertexArray(GrVertexArrayObj* vertexArray) {
+ if (vertexArray) {
+ SkASSERT(!vertexArray->getDeleted());
+ }
+ SkRefCnt_SafeAssign(fVertexArray, vertexArray);
+ }
+
+ GrVertexArrayObj* getVertexArray() { return fVertexArray; }
+
+ void setTexture(GrTextureObj *texture) {
+ fTextureUnits[fCurrTextureUnit]->setTexture(texture);
+ }
+
+ void setFrameBuffer(GrFrameBufferObj *frameBuffer) {
+ if (fFrameBuffer) {
+ GrAlwaysAssert(fFrameBuffer->getBound());
+ fFrameBuffer->resetBound();
+
+ GrAlwaysAssert(!fFrameBuffer->getDeleted());
+ fFrameBuffer->unref();
+ }
+
+ fFrameBuffer = frameBuffer;
+
+ if (fFrameBuffer) {
+ GrAlwaysAssert(!fFrameBuffer->getDeleted());
+ fFrameBuffer->ref();
+
+ GrAlwaysAssert(!fFrameBuffer->getBound());
+ fFrameBuffer->setBound();
+ }
+ }
+
+ GrFrameBufferObj *getFrameBuffer() { return fFrameBuffer; }
+
+ void setRenderBuffer(GrRenderBufferObj *renderBuffer) {
+ if (fRenderBuffer) {
+ GrAlwaysAssert(fRenderBuffer->getBound());
+ fRenderBuffer->resetBound();
+
+ GrAlwaysAssert(!fRenderBuffer->getDeleted());
+ fRenderBuffer->unref();
+ }
+
+ fRenderBuffer = renderBuffer;
+
+ if (fRenderBuffer) {
+ GrAlwaysAssert(!fRenderBuffer->getDeleted());
+ fRenderBuffer->ref();
+
+ GrAlwaysAssert(!fRenderBuffer->getBound());
+ fRenderBuffer->setBound();
+ }
+ }
+ GrRenderBufferObj *getRenderBuffer() { return fRenderBuffer; }
+
+ void useProgram(GrProgramObj *program) {
+ if (fProgram) {
+ GrAlwaysAssert(fProgram->getInUse());
+ fProgram->resetInUse();
+
+ GrAlwaysAssert(!fProgram->getDeleted());
+ fProgram->unref();
+ }
+
+ fProgram = program;
+
+ if (fProgram) {
+ GrAlwaysAssert(!fProgram->getDeleted());
+ fProgram->ref();
+
+ GrAlwaysAssert(!fProgram->getInUse());
+ fProgram->setInUse();
+ }
+ }
+
+ void report() const {
+ for (int i = 0; i < fObjects.count(); ++i) {
+ if (!fAbandoned) {
+ GrAlwaysAssert(0 == fObjects[i]->getRefCount());
+ GrAlwaysAssert(fObjects[i]->getDeleted());
+ }
+ }
+ }
+
+ typedef GrGLTestInterface INHERITED;
};
+#undef CREATE
+#undef FIND
+
+DebugInterface::Create DebugInterface::gFactoryFunc[kObjTypeCount] = {
+ GrTextureObj::createGrTextureObj,
+ GrBufferObj::createGrBufferObj,
+ GrRenderBufferObj::createGrRenderBufferObj,
+ GrFrameBufferObj::createGrFrameBufferObj,
+ GrShaderObj::createGrShaderObj,
+ GrProgramObj::createGrProgramObj,
+ GrTextureUnitObj::createGrTextureUnitObj,
+ GrVertexArrayObj::createGrVertexArrayObj,
+};
+
+const char* DebugInterface::kExtensions[] = {
+ "GL_ARB_framebuffer_object",
+ "GL_ARB_blend_func_extended",
+ "GL_ARB_timer_query",
+ "GL_ARB_draw_buffers",
+ "GL_ARB_occlusion_query",
+ "GL_EXT_stencil_wrap",
+ nullptr, // signifies the end of the array.
+};
+
+} // anonymous namespace
+
////////////////////////////////////////////////////////////////////////////////
-const GrGLInterface* GrGLCreateDebugInterface() {
- GrGLInterface *interface = new GrDebugGLInterface;
- interface->fStandard = kGL_GrGLStandard;
-
- GrGLInterface::Functions* functions = &interface->fFunctions;
- functions->fActiveTexture = debugGLActiveTexture;
- functions->fAttachShader = debugGLAttachShader;
- functions->fBeginQuery = debugGLBeginQuery;
- functions->fBindAttribLocation = debugGLBindAttribLocation;
- functions->fBindBuffer = debugGLBindBuffer;
- functions->fBindFragDataLocation = noOpGLBindFragDataLocation;
- functions->fBindTexture = debugGLBindTexture;
- functions->fBindVertexArray = debugGLBindVertexArray;
- functions->fBlendColor = noOpGLBlendColor;
- functions->fBlendEquation = noOpGLBlendEquation;
- functions->fBlendFunc = noOpGLBlendFunc;
- functions->fBufferData = debugGLBufferData;
- functions->fBufferSubData = noOpGLBufferSubData;
- functions->fClear = noOpGLClear;
- functions->fClearColor = noOpGLClearColor;
- functions->fClearStencil = noOpGLClearStencil;
- functions->fColorMask = noOpGLColorMask;
- functions->fCompileShader = noOpGLCompileShader;
- functions->fCompressedTexImage2D = noOpGLCompressedTexImage2D;
- functions->fCompressedTexSubImage2D = noOpGLCompressedTexSubImage2D;
- functions->fCopyTexSubImage2D = noOpGLCopyTexSubImage2D;
- functions->fCreateProgram = debugGLCreateProgram;
- functions->fCreateShader = debugGLCreateShader;
- functions->fCullFace = noOpGLCullFace;
- functions->fDeleteBuffers = debugGLDeleteBuffers;
- functions->fDeleteProgram = debugGLDeleteProgram;
- functions->fDeleteQueries = noOpGLDeleteIds;
- functions->fDeleteShader = debugGLDeleteShader;
- functions->fDeleteTextures = debugGLDeleteTextures;
- functions->fDeleteVertexArrays = debugGLDeleteVertexArrays;
- functions->fDepthMask = noOpGLDepthMask;
- functions->fDisable = noOpGLDisable;
- functions->fDisableVertexAttribArray = noOpGLDisableVertexAttribArray;
- functions->fDrawArrays = noOpGLDrawArrays;
- functions->fDrawArraysInstanced = noOpGLDrawArraysInstanced;
- functions->fDrawBuffer = noOpGLDrawBuffer;
- functions->fDrawBuffers = noOpGLDrawBuffers;
- functions->fDrawElements = noOpGLDrawElements;
- functions->fDrawElementsInstanced = noOpGLDrawElementsInstanced;
- functions->fEnable = noOpGLEnable;
- functions->fEnableVertexAttribArray = noOpGLEnableVertexAttribArray;
- functions->fEndQuery = noOpGLEndQuery;
- functions->fFinish = noOpGLFinish;
- functions->fFlush = noOpGLFlush;
- functions->fFlushMappedBufferRange = debugGLFlushMappedBufferRange;
- functions->fFrontFace = noOpGLFrontFace;
- functions->fGenerateMipmap = debugGLGenerateMipmap;
- functions->fGenBuffers = debugGLGenBuffers;
- functions->fGenQueries = noOpGLGenIds;
- functions->fGenTextures = debugGLGenTextures;
- functions->fGetBufferParameteriv = debugGLGetBufferParameteriv;
- functions->fGetError = noOpGLGetError;
- functions->fGetIntegerv = noOpGLGetIntegerv;
- functions->fGetMultisamplefv = noOpGLGetMultisamplefv;
- functions->fGetQueryObjecti64v = noOpGLGetQueryObjecti64v;
- functions->fGetQueryObjectiv = noOpGLGetQueryObjectiv;
- functions->fGetQueryObjectui64v = noOpGLGetQueryObjectui64v;
- functions->fGetQueryObjectuiv = noOpGLGetQueryObjectuiv;
- functions->fGetQueryiv = noOpGLGetQueryiv;
- functions->fGetProgramInfoLog = noOpGLGetInfoLog;
- functions->fGetProgramiv = noOpGLGetShaderOrProgramiv;
- functions->fGetShaderInfoLog = noOpGLGetInfoLog;
- functions->fGetShaderiv = noOpGLGetShaderOrProgramiv;
- functions->fGetString = noOpGLGetString;
- functions->fGetStringi = noOpGLGetStringi;
- functions->fGetTexLevelParameteriv = noOpGLGetTexLevelParameteriv;
- functions->fGetUniformLocation = noOpGLGetUniformLocation;
- functions->fGenVertexArrays = debugGLGenVertexArrays;
- functions->fLineWidth = noOpGLLineWidth;
- functions->fLinkProgram = noOpGLLinkProgram;
- functions->fMapBuffer = debugGLMapBuffer;
- functions->fMapBufferRange = debugGLMapBufferRange;
- functions->fPixelStorei = debugGLPixelStorei;
- functions->fQueryCounter = noOpGLQueryCounter;
- functions->fReadBuffer = noOpGLReadBuffer;
- functions->fReadPixels = debugGLReadPixels;
- functions->fScissor = noOpGLScissor;
- functions->fShaderSource = noOpGLShaderSource;
- functions->fStencilFunc = noOpGLStencilFunc;
- functions->fStencilFuncSeparate = noOpGLStencilFuncSeparate;
- functions->fStencilMask = noOpGLStencilMask;
- functions->fStencilMaskSeparate = noOpGLStencilMaskSeparate;
- functions->fStencilOp = noOpGLStencilOp;
- functions->fStencilOpSeparate = noOpGLStencilOpSeparate;
- functions->fTexBuffer = noOpGLTexBuffer;
- functions->fTexImage2D = noOpGLTexImage2D;
- functions->fTexParameteri = noOpGLTexParameteri;
- functions->fTexParameteriv = noOpGLTexParameteriv;
- functions->fTexSubImage2D = noOpGLTexSubImage2D;
- functions->fTexStorage2D = noOpGLTexStorage2D;
- functions->fDiscardFramebuffer = noOpGLDiscardFramebuffer;
- functions->fUniform1f = noOpGLUniform1f;
- functions->fUniform1i = noOpGLUniform1i;
- functions->fUniform1fv = noOpGLUniform1fv;
- functions->fUniform1iv = noOpGLUniform1iv;
- functions->fUniform2f = noOpGLUniform2f;
- functions->fUniform2i = noOpGLUniform2i;
- functions->fUniform2fv = noOpGLUniform2fv;
- functions->fUniform2iv = noOpGLUniform2iv;
- functions->fUniform3f = noOpGLUniform3f;
- functions->fUniform3i = noOpGLUniform3i;
- functions->fUniform3fv = noOpGLUniform3fv;
- functions->fUniform3iv = noOpGLUniform3iv;
- functions->fUniform4f = noOpGLUniform4f;
- functions->fUniform4i = noOpGLUniform4i;
- functions->fUniform4fv = noOpGLUniform4fv;
- functions->fUniform4iv = noOpGLUniform4iv;
- functions->fUniformMatrix2fv = noOpGLUniformMatrix2fv;
- functions->fUniformMatrix3fv = noOpGLUniformMatrix3fv;
- functions->fUniformMatrix4fv = noOpGLUniformMatrix4fv;
- functions->fUnmapBuffer = debugGLUnmapBuffer;
- functions->fUseProgram = debugGLUseProgram;
- functions->fVertexAttrib1f = noOpGLVertexAttrib1f;
- functions->fVertexAttrib2fv = noOpGLVertexAttrib2fv;
- functions->fVertexAttrib3fv = noOpGLVertexAttrib3fv;
- functions->fVertexAttrib4fv = noOpGLVertexAttrib4fv;
- functions->fVertexAttribDivisor = noOpGLVertexAttribDivisor;
- functions->fVertexAttribIPointer = noOpGLVertexAttribIPointer;
- functions->fVertexAttribPointer = noOpGLVertexAttribPointer;
- functions->fViewport = noOpGLViewport;
- functions->fBindFramebuffer = debugGLBindFramebuffer;
- functions->fBindRenderbuffer = debugGLBindRenderbuffer;
- functions->fCheckFramebufferStatus = noOpGLCheckFramebufferStatus;
- functions->fDeleteFramebuffers = debugGLDeleteFramebuffers;
- functions->fDeleteRenderbuffers = debugGLDeleteRenderbuffers;
- functions->fFramebufferRenderbuffer = debugGLFramebufferRenderbuffer;
- functions->fFramebufferTexture2D = debugGLFramebufferTexture2D;
- functions->fGenFramebuffers = debugGLGenFramebuffers;
- functions->fGenRenderbuffers = debugGLGenRenderbuffers;
- functions->fGetFramebufferAttachmentParameteriv =
- noOpGLGetFramebufferAttachmentParameteriv;
- functions->fGetRenderbufferParameteriv = noOpGLGetRenderbufferParameteriv;
- functions->fRenderbufferStorage = noOpGLRenderbufferStorage;
- functions->fRenderbufferStorageMultisample =
- noOpGLRenderbufferStorageMultisample;
- functions->fBlitFramebuffer = noOpGLBlitFramebuffer;
- functions->fResolveMultisampleFramebuffer =
- noOpGLResolveMultisampleFramebuffer;
- functions->fMatrixLoadf = noOpGLMatrixLoadf;
- functions->fMatrixLoadIdentity = noOpGLMatrixLoadIdentity;
-
- functions->fBindFragDataLocationIndexed =
- noOpGLBindFragDataLocationIndexed;
-
- interface->fExtensions.init(kGL_GrGLStandard, functions->fGetString, functions->fGetStringi,
- functions->fGetIntegerv, nullptr, GR_EGL_NO_DISPLAY);
-
- return interface;
-}
+const GrGLInterface* GrGLCreateDebugInterface() { return new DebugInterface; }
diff --git a/src/gpu/gl/debug/GrTextureUnitObj.h b/src/gpu/gl/debug/GrTextureUnitObj.h
index b0254a0..5c7a039 100644
--- a/src/gpu/gl/debug/GrTextureUnitObj.h
+++ b/src/gpu/gl/debug/GrTextureUnitObj.h
@@ -14,7 +14,7 @@
////////////////////////////////////////////////////////////////////////////////
// Although texture unit objects are allocated & deallocated like the other
// GL emulation objects they are derived from GrFakeRefObj to provide some
-// uniformity in how the GrDebugGL class manages resources
+// uniformity in how the debug interface class manages resources
class GrTextureUnitObj : public GrFakeRefObj {
GR_DEFINE_CREATOR(GrTextureUnitObj);