| |
| /* |
| * 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 "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 "GrRenderBufferObj.h" |
| #include "SkFloatingPoint.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; |
| |
| namespace { // suppress no previsous prototype warning |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLActiveTexture(GrGLenum texture) { |
| |
| // Ganesh offsets the texture unit indices |
| texture -= GR_GL_TEXTURE0; |
| GrAlwaysAssert(texture < GrDebugGL::getInstance()->getMaxTextureUnits()); |
| |
| GrDebugGL::getInstance()->setCurTextureUnit(texture); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| 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 debugGLBlendColor(GrGLclampf red, |
| GrGLclampf green, |
| GrGLclampf blue, |
| GrGLclampf alpha) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindFragDataLocation(GrGLuint program, |
| GrGLuint colorNumber, |
| const GrGLchar* name) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLBlendFunc(GrGLenum sfactor, |
| GrGLenum dfactor) { |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| 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 = NULL; |
| switch (target) { |
| case GR_GL_ARRAY_BUFFER: |
| buffer = GrDebugGL::getInstance()->getArrayBuffer(); |
| break; |
| case GR_GL_ELEMENT_ARRAY_BUFFER: |
| buffer = GrDebugGL::getInstance()->getElementArrayBuffer(); |
| break; |
| default: |
| GrCrash("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 debugGLBufferSubData(GrGLenum target, |
| GrGLintptr offset, |
| GrGLsizeiptr size, |
| const GrGLvoid* data) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLClear(GrGLbitfield mask) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLClearColor(GrGLclampf red, |
| GrGLclampf green, |
| GrGLclampf blue, |
| GrGLclampf alpha) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLClearStencil(GrGLint s) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLColorMask(GrGLboolean red, |
| GrGLboolean green, |
| GrGLboolean blue, |
| GrGLboolean alpha) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLCompileShader(GrGLuint shader) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLCompressedTexImage2D(GrGLenum target, |
| GrGLint level, |
| GrGLenum internalformat, |
| GrGLsizei width, |
| GrGLsizei height, |
| GrGLint border, |
| GrGLsizei imageSize, |
| const GrGLvoid* data) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLCullFace(GrGLenum mode) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLDepthMask(GrGLboolean flag) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLDisable(GrGLenum cap) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLDisableVertexAttribArray(GrGLuint index) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLDrawArrays(GrGLenum mode, |
| GrGLint first, |
| GrGLsizei count) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLDrawBuffer(GrGLenum mode) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLDrawBuffers(GrGLsizei n, |
| const GrGLenum* bufs) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLDrawElements(GrGLenum mode, |
| GrGLsizei count, |
| GrGLenum type, |
| const GrGLvoid* indices) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLEnable(GrGLenum cap) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLEnableVertexAttribArray(GrGLuint index) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLEndQuery(GrGLenum target) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLFinish() { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLFlush() { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLFrontFace(GrGLenum mode) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLLineWidth(GrGLfloat width) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLLinkProgram(GrGLuint program) { |
| } |
| |
| 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 debugGLQueryCounter(GrGLuint id, |
| GrGLenum target) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLReadBuffer(GrGLenum src) { |
| } |
| |
| 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(); |
| } |
| |
| GrGLint componentsPerPixel = 0; |
| |
| 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; |
| } |
| |
| GrGLint alignment = 4; // the pack alignment (one of 1, 2, 4 or 8) |
| // Ganesh currently doesn't support setting GR_GL_PACK_ALIGNMENT |
| |
| GrGLint componentSize = 0; // size (in bytes) of a single component |
| |
| switch (type) { |
| case GR_GL_UNSIGNED_BYTE: |
| componentSize = 1; |
| break; |
| default: |
| GrAlwaysAssert(false); |
| break; |
| } |
| |
| 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); |
| } |
| |
| GrGLchar *scanline = static_cast<GrGLchar *>(pixels); |
| for (int y = 0; y < height; ++y) { |
| memset(scanline, 0, componentsPerPixel * componentSize * width); |
| scanline += rowStride; |
| } |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLScissor(GrGLint x, |
| GrGLint y, |
| GrGLsizei width, |
| GrGLsizei height) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLShaderSource(GrGLuint shader, |
| GrGLsizei count, |
| #if GR_USE_NEW_GL_SHADER_SOURCE_SIGNATURE |
| const char* const * str, |
| #else |
| const char** str, |
| #endif |
| const GrGLint* length) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLStencilFunc(GrGLenum func, |
| GrGLint ref, |
| GrGLuint mask) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLStencilFuncSeparate(GrGLenum face, |
| GrGLenum func, |
| GrGLint ref, |
| GrGLuint mask) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLStencilMask(GrGLuint mask) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLStencilMaskSeparate(GrGLenum face, |
| GrGLuint mask) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLStencilOp(GrGLenum fail, |
| GrGLenum zfail, |
| GrGLenum zpass) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLStencilOpSeparate(GrGLenum face, |
| GrGLenum fail, |
| GrGLenum zfail, |
| GrGLenum zpass) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLTexImage2D(GrGLenum target, |
| GrGLint level, |
| GrGLint internalformat, |
| GrGLsizei width, |
| GrGLsizei height, |
| GrGLint border, |
| GrGLenum format, |
| GrGLenum type, |
| const GrGLvoid* pixels) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLTexParameteri(GrGLenum target, |
| GrGLenum pname, |
| GrGLint param) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLTexParameteriv(GrGLenum target, |
| GrGLenum pname, |
| const GrGLint* params) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLTexStorage2D(GrGLenum target, |
| GrGLsizei levels, |
| GrGLenum internalformat, |
| GrGLsizei width, |
| GrGLsizei height) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLTexSubImage2D(GrGLenum target, |
| GrGLint level, |
| GrGLint xoffset, |
| GrGLint yoffset, |
| GrGLsizei width, |
| GrGLsizei height, |
| GrGLenum format, |
| GrGLenum type, |
| const GrGLvoid* pixels) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLUniform1f(GrGLint location, |
| GrGLfloat v0) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLUniform1i(GrGLint location, |
| GrGLint v0) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLUniform1fv(GrGLint location, |
| GrGLsizei count, |
| const GrGLfloat* v) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLUniform1iv(GrGLint location, |
| GrGLsizei count, |
| const GrGLint* v) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLUniform2f(GrGLint location, |
| GrGLfloat v0, |
| GrGLfloat v1) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLUniform2i(GrGLint location, |
| GrGLint v0, |
| GrGLint v1) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLUniform2fv(GrGLint location, |
| GrGLsizei count, |
| const GrGLfloat* v) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLUniform2iv(GrGLint location, |
| GrGLsizei count, |
| const GrGLint* v) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLUniform3f(GrGLint location, |
| GrGLfloat v0, |
| GrGLfloat v1, |
| GrGLfloat v2) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLUniform3i(GrGLint location, |
| GrGLint v0, |
| GrGLint v1, |
| GrGLint v2) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLUniform3fv(GrGLint location, |
| GrGLsizei count, |
| const GrGLfloat* v) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLUniform3iv(GrGLint location, |
| GrGLsizei count, |
| const GrGLint* v) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLUniform4f(GrGLint location, |
| GrGLfloat v0, |
| GrGLfloat v1, |
| GrGLfloat v2, |
| GrGLfloat v3) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLUniform4i(GrGLint location, |
| GrGLint v0, |
| GrGLint v1, |
| GrGLint v2, |
| GrGLint v3) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLUniform4fv(GrGLint location, |
| GrGLsizei count, |
| const GrGLfloat* v) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLUniform4iv(GrGLint location, |
| GrGLsizei count, |
| const GrGLint* v) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLUniformMatrix2fv(GrGLint location, |
| GrGLsizei count, |
| GrGLboolean transpose, |
| const GrGLfloat* value) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLUniformMatrix3fv(GrGLint location, |
| GrGLsizei count, |
| GrGLboolean transpose, |
| const GrGLfloat* value) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLUniformMatrix4fv(GrGLint location, |
| GrGLsizei count, |
| GrGLboolean transpose, |
| const GrGLfloat* value) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLUseProgram(GrGLuint programID) { |
| |
| // A programID of 0 is legal |
| GrProgramObj *program = GR_FIND(programID, |
| GrProgramObj, |
| GrDebugGL::kProgram_ObjTypes); |
| |
| GrDebugGL::getInstance()->useProgram(program); |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLVertexAttrib4fv(GrGLuint indx, |
| const GrGLfloat* values) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLVertexAttribPointer(GrGLuint indx, |
| GrGLint size, |
| GrGLenum type, |
| GrGLboolean normalized, |
| GrGLsizei stride, |
| const GrGLvoid* ptr) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLViewport(GrGLint x, |
| GrGLint y, |
| GrGLsizei width, |
| GrGLsizei height) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindFramebuffer(GrGLenum target, |
| GrGLuint frameBufferID) { |
| |
| GrAlwaysAssert(GR_GL_FRAMEBUFFER == target); |
| |
| // a frameBufferID of 0 is acceptable - it binds to the default |
| // frame buffer |
| GrFrameBufferObj *frameBuffer = GR_FIND(frameBufferID, |
| GrFrameBufferObj, |
| GrDebugGL::kFrameBuffer_ObjTypes); |
| |
| GrDebugGL::getInstance()->setFrameBuffer(frameBuffer); |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindRenderbuffer(GrGLenum target, |
| GrGLuint renderBufferID) { |
| |
| GrAlwaysAssert(GR_GL_RENDERBUFFER == target); |
| |
| // a renderBufferID of 0 is acceptable - it unbinds the bound render buffer |
| GrRenderBufferObj *renderBuffer = GR_FIND(renderBufferID, |
| GrRenderBufferObj, |
| GrDebugGL::kRenderBuffer_ObjTypes); |
| |
| GrDebugGL::getInstance()->setRenderBuffer(renderBuffer); |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteTextures(GrGLsizei n, |
| const GrGLuint* textures) { |
| |
| // 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); |
| |
| 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(NULL); |
| } |
| } |
| } |
| } |
| |
| // 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()) { |
| |
| GrFrameBufferObj *frameBuffer = GrDebugGL::getInstance()->getFrameBuffer(); |
| |
| for (int i = 0; i < n; ++i) { |
| |
| if (NULL != frameBuffer->getColor() && |
| textures[i] == frameBuffer->getColor()->getID()) { |
| frameBuffer->setColor(NULL); |
| } |
| if (NULL != frameBuffer->getDepth() && |
| textures[i] == frameBuffer->getDepth()->getID()) { |
| frameBuffer->setDepth(NULL); |
| } |
| if (NULL != frameBuffer->getStencil() && |
| textures[i] == frameBuffer->getStencil()->getID()) { |
| frameBuffer->setStencil(NULL); |
| } |
| } |
| } |
| |
| // then actually "delete" the buffers |
| for (int i = 0; i < n; ++i) { |
| GrTextureObj *buffer = GR_FIND(textures[i], |
| GrTextureObj, |
| GrDebugGL::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(); |
| } |
| |
| } |
| |
| |
| 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(NULL); |
| } |
| } |
| } |
| |
| // then actually "delete" the buffers |
| for (int i = 0; i < n; ++i) { |
| GrFrameBufferObj *buffer = GR_FIND(frameBuffers[i], |
| GrFrameBufferObj, |
| GrDebugGL::kFrameBuffer_ObjTypes); |
| GrAlwaysAssert(buffer); |
| |
| GrAlwaysAssert(!buffer->getDeleted()); |
| buffer->deleteAction(); |
| } |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteRenderbuffers(GrGLsizei n, |
| const GrGLuint *renderBuffers) { |
| |
| // first potentially unbind the buffers |
| if (GrDebugGL::getInstance()->getRenderBuffer()) { |
| for (int i = 0; i < n; ++i) { |
| |
| if (renderBuffers[i] == |
| GrDebugGL::getInstance()->getRenderBuffer()->getID()) { |
| // this ID is the current render buffer - make no |
| // render buffer be bound |
| GrDebugGL::getInstance()->setRenderBuffer(NULL); |
| } |
| } |
| } |
| |
| // 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()) { |
| |
| GrFrameBufferObj *frameBuffer = |
| GrDebugGL::getInstance()->getFrameBuffer(); |
| |
| for (int i = 0; i < n; ++i) { |
| |
| if (NULL != frameBuffer->getColor() && |
| renderBuffers[i] == frameBuffer->getColor()->getID()) { |
| frameBuffer->setColor(NULL); |
| } |
| if (NULL != frameBuffer->getDepth() && |
| renderBuffers[i] == frameBuffer->getDepth()->getID()) { |
| frameBuffer->setDepth(NULL); |
| } |
| if (NULL != frameBuffer->getStencil() && |
| renderBuffers[i] == frameBuffer->getStencil()->getID()) { |
| frameBuffer->setStencil(NULL); |
| } |
| } |
| } |
| |
| // 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()); |
| 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(NULL != 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(NULL != 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; |
| }; |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLGetFramebufferAttachmentParameteriv(GrGLenum target, |
| GrGLenum attachment, |
| GrGLenum pname, |
| GrGLint* params) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLGetRenderbufferParameteriv(GrGLenum target, |
| GrGLenum pname, |
| GrGLint* params) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLRenderbufferStorage(GrGLenum target, |
| GrGLenum internalformat, |
| GrGLsizei width, |
| GrGLsizei height) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLRenderbufferStorageMultisample(GrGLenum target, |
| GrGLsizei samples, |
| GrGLenum internalformat, |
| GrGLsizei width, |
| GrGLsizei height) { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLBlitFramebuffer(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 debugGLResolveMultisampleFramebuffer() { |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindFragDataLocationIndexed(GrGLuint program, |
| GrGLuint colorNumber, |
| GrGLuint index, |
| const GrGLchar * name) { |
| } |
| |
| GrGLenum GR_GL_FUNCTION_TYPE debugGLCheckFramebufferStatus(GrGLenum target) { |
| |
| GrAlwaysAssert(GR_GL_FRAMEBUFFER == target); |
| |
| return GR_GL_FRAMEBUFFER_COMPLETE; |
| } |
| |
| 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(); |
| } |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteShader(GrGLuint shaderID) { |
| |
| GrShaderObj *shader = GR_FIND(shaderID, |
| GrShaderObj, |
| GrDebugGL::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(); |
| } |
| } |
| |
| // same function used for all glGen*(GLsize i, GLuint*) functions |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLGenIds(GrGLsizei n, GrGLuint* ids) { |
| static int gCurrID = 1; |
| for (int i = 0; i < n; ++i) { |
| ids[i] = ++gCurrID; |
| } |
| } |
| |
| GrGLvoid debugGenObjs(GrDebugGL::GrObjTypes type, |
| GrGLsizei n, |
| GrGLuint* ids) { |
| |
| for (int i = 0; i < n; ++i) { |
| GrFakeRefObj *obj = GrDebugGL::getInstance()->createObj(type); |
| GrAlwaysAssert(obj); |
| ids[i] = obj->getID(); |
| } |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLGenBuffers(GrGLsizei n, GrGLuint* ids) { |
| |
| debugGenObjs(GrDebugGL::kBuffer_ObjTypes, n, ids); |
| } |
| |
| 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); |
| } |
| |
| // same delete function for all glDelete*(GLsize i, const GLuint*) except |
| // buffers |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteIds(GrGLsizei n, |
| const GrGLuint* ids) { |
| } |
| |
| 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 permissable 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: |
| GrCrash("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(NULL); |
| } |
| if (GrDebugGL::getInstance()->getElementArrayBuffer() && |
| ids[i] == |
| GrDebugGL::getInstance()->getElementArrayBuffer()->getID()) { |
| // this ID is the current element array buffer |
| GrDebugGL::getInstance()->setElementArrayBuffer(NULL); |
| } |
| } |
| |
| // then actually "delete" the buffers |
| for (int i = 0; i < n; ++i) { |
| GrBufferObj *buffer = GR_FIND(ids[i], |
| GrBufferObj, |
| GrDebugGL::kBuffer_ObjTypes); |
| GrAlwaysAssert(buffer); |
| |
| GrAlwaysAssert(!buffer->getDeleted()); |
| buffer->deleteAction(); |
| } |
| } |
| |
| // map a buffer to the caller's address space |
| GrGLvoid* GR_GL_FUNCTION_TYPE debugGLMapBuffer(GrGLenum target, |
| GrGLenum access) { |
| |
| GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target || |
| GR_GL_ELEMENT_ARRAY_BUFFER == target); |
| // GR_GL_READ_ONLY == access || || GR_GL_READ_WRIT == access); |
| GrAlwaysAssert(GR_GL_WRITE_ONLY == access); |
| |
| GrBufferObj *buffer = NULL; |
| switch (target) { |
| case GR_GL_ARRAY_BUFFER: |
| buffer = GrDebugGL::getInstance()->getArrayBuffer(); |
| break; |
| case GR_GL_ELEMENT_ARRAY_BUFFER: |
| buffer = GrDebugGL::getInstance()->getElementArrayBuffer(); |
| break; |
| default: |
| GrCrash("Unexpected target to glMapBuffer"); |
| break; |
| } |
| |
| if (buffer) { |
| GrAlwaysAssert(!buffer->getMapped()); |
| buffer->setMapped(); |
| return buffer->getDataPtr(); |
| } |
| |
| GrAlwaysAssert(false); |
| return NULL; // no buffer bound to the target |
| } |
| |
| // 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 = NULL; |
| switch (target) { |
| case GR_GL_ARRAY_BUFFER: |
| buffer = GrDebugGL::getInstance()->getArrayBuffer(); |
| break; |
| case GR_GL_ELEMENT_ARRAY_BUFFER: |
| buffer = GrDebugGL::getInstance()->getElementArrayBuffer(); |
| break; |
| default: |
| GrCrash("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 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 = NULL; |
| 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 = buffer->getSize(); |
| break; |
| case GR_GL_BUFFER_USAGE: |
| *params = GR_GL_STATIC_DRAW; |
| if (buffer) |
| *params = buffer->getUsage(); |
| break; |
| default: |
| GrCrash("Unexpected value to glGetBufferParamateriv"); |
| break; |
| } |
| }; |
| |
| GrGLenum GR_GL_FUNCTION_TYPE debugGLGetError() { |
| return GR_GL_NO_ERROR; |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLGetIntegerv(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_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_TEXTURE_IMAGE_UNITS: |
| *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; |
| default: |
| GrCrash("Unexpected pname to GetIntegerv"); |
| } |
| } |
| // used for both the program and shader info logs |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLGetInfoLog(GrGLuint program, |
| GrGLsizei bufsize, |
| GrGLsizei* length, |
| char* infolog) { |
| if (length) { |
| *length = 0; |
| } |
| if (bufsize > 0) { |
| *infolog = 0; |
| } |
| } |
| |
| // used for both the program and shader params |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLGetShaderOrProgramiv(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: |
| GrCrash("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: |
| GrCrash("Unexpected pname passed to GetQueryObject."); |
| break; |
| } |
| } |
| } |
| |
| // Queries on the null GL just don't do anything at all. We could potentially |
| // make the timers work. |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLGetQueryiv(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: |
| GrCrash("Unexpected pname passed GetQueryiv."); |
| } |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLGetQueryObjecti64v(GrGLuint id, |
| GrGLenum pname, |
| GrGLint64 *params) { |
| query_result(id, pname, params); |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLGetQueryObjectiv(GrGLuint id, |
| GrGLenum pname, |
| GrGLint *params) { |
| query_result(id, pname, params); |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLGetQueryObjectui64v(GrGLuint id, |
| GrGLenum pname, |
| GrGLuint64 *params) { |
| query_result(id, pname, params); |
| } |
| |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLGetQueryObjectuiv(GrGLuint id, |
| GrGLenum pname, |
| GrGLuint *params) { |
| query_result(id, pname, params); |
| } |
| |
| const GrGLubyte* GR_GL_FUNCTION_TYPE debugGLGetString(GrGLenum name) { |
| switch (name) { |
| case GR_GL_EXTENSIONS: |
| return (const GrGLubyte*)"GL_ARB_framebuffer_object GL_ARB_blend_func_extended GL_ARB_timer_query GL_ARB_draw_buffers GL_ARB_occlusion_query GL_EXT_blend_color GL_EXT_stencil_wrap"; |
| 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: |
| GrCrash("Unexpected name to GetString"); |
| return NULL; |
| } |
| } |
| |
| // we used to use this to query stuff about externally created textures, |
| // now we just require clients to tell us everything about the texture. |
| GrGLvoid GR_GL_FUNCTION_TYPE debugGLGetTexLevelParameteriv(GrGLenum target, |
| GrGLint level, |
| GrGLenum pname, |
| GrGLint* params) { |
| GrCrash("Should never query texture parameters."); |
| } |
| |
| GrGLint GR_GL_FUNCTION_TYPE debugGLGetUniformLocation(GrGLuint program, |
| const char* name) { |
| static int gUniLocation = 0; |
| return ++gUniLocation; |
| } |
| |
| } // end of namespace |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| struct GrDebugGLInterface : public GrGLInterface { |
| |
| public: |
| SK_DECLARE_INST_COUNT(GrDebugGLInterface) |
| |
| GrDebugGLInterface() |
| : fWrapped(NULL) { |
| GrDebugGL::staticRef(); |
| } |
| |
| virtual ~GrDebugGLInterface() { |
| GrDebugGL::staticUnRef(); |
| } |
| |
| void setWrapped(GrGLInterface *interface) { |
| fWrapped.reset(interface); |
| } |
| |
| // 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: |
| |
| SkAutoTUnref<GrGLInterface> fWrapped; |
| |
| typedef GrGLInterface INHERITED; |
| }; |
| |
| SK_DEFINE_INST_COUNT(GrDebugGLInterface) |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| const GrGLInterface* GrGLCreateDebugInterface() { |
| GrGLInterface* interface = SkNEW(GrDebugGLInterface); |
| |
| interface->fBindingsExported = kDesktop_GrGLBinding; |
| interface->fActiveTexture = debugGLActiveTexture; |
| interface->fAttachShader = debugGLAttachShader; |
| interface->fBeginQuery = debugGLBeginQuery; |
| interface->fBindAttribLocation = debugGLBindAttribLocation; |
| interface->fBindBuffer = debugGLBindBuffer; |
| interface->fBindFragDataLocation = debugGLBindFragDataLocation; |
| interface->fBindTexture = debugGLBindTexture; |
| interface->fBlendColor = debugGLBlendColor; |
| interface->fBlendFunc = debugGLBlendFunc; |
| interface->fBufferData = debugGLBufferData; |
| interface->fBufferSubData = debugGLBufferSubData; |
| interface->fClear = debugGLClear; |
| interface->fClearColor = debugGLClearColor; |
| interface->fClearStencil = debugGLClearStencil; |
| interface->fColorMask = debugGLColorMask; |
| interface->fCompileShader = debugGLCompileShader; |
| interface->fCompressedTexImage2D = debugGLCompressedTexImage2D; |
| interface->fCreateProgram = debugGLCreateProgram; |
| interface->fCreateShader = debugGLCreateShader; |
| interface->fCullFace = debugGLCullFace; |
| interface->fDeleteBuffers = debugGLDeleteBuffers; |
| interface->fDeleteProgram = debugGLDeleteProgram; |
| interface->fDeleteQueries = debugGLDeleteIds; |
| interface->fDeleteShader = debugGLDeleteShader; |
| interface->fDeleteTextures = debugGLDeleteTextures; |
| interface->fDepthMask = debugGLDepthMask; |
| interface->fDisable = debugGLDisable; |
| interface->fDisableVertexAttribArray = debugGLDisableVertexAttribArray; |
| interface->fDrawArrays = debugGLDrawArrays; |
| interface->fDrawBuffer = debugGLDrawBuffer; |
| interface->fDrawBuffers = debugGLDrawBuffers; |
| interface->fDrawElements = debugGLDrawElements; |
| interface->fEnable = debugGLEnable; |
| interface->fEnableVertexAttribArray = debugGLEnableVertexAttribArray; |
| interface->fEndQuery = debugGLEndQuery; |
| interface->fFinish = debugGLFinish; |
| interface->fFlush = debugGLFlush; |
| interface->fFrontFace = debugGLFrontFace; |
| interface->fGenBuffers = debugGLGenBuffers; |
| interface->fGenQueries = debugGLGenIds; |
| interface->fGenTextures = debugGLGenTextures; |
| interface->fGetBufferParameteriv = debugGLGetBufferParameteriv; |
| interface->fGetError = debugGLGetError; |
| interface->fGetIntegerv = debugGLGetIntegerv; |
| interface->fGetQueryObjecti64v = debugGLGetQueryObjecti64v; |
| interface->fGetQueryObjectiv = debugGLGetQueryObjectiv; |
| interface->fGetQueryObjectui64v = debugGLGetQueryObjectui64v; |
| interface->fGetQueryObjectuiv = debugGLGetQueryObjectuiv; |
| interface->fGetQueryiv = debugGLGetQueryiv; |
| interface->fGetProgramInfoLog = debugGLGetInfoLog; |
| interface->fGetProgramiv = debugGLGetShaderOrProgramiv; |
| interface->fGetShaderInfoLog = debugGLGetInfoLog; |
| interface->fGetShaderiv = debugGLGetShaderOrProgramiv; |
| interface->fGetString = debugGLGetString; |
| interface->fGetTexLevelParameteriv = debugGLGetTexLevelParameteriv; |
| interface->fGetUniformLocation = debugGLGetUniformLocation; |
| interface->fLineWidth = debugGLLineWidth; |
| interface->fLinkProgram = debugGLLinkProgram; |
| interface->fPixelStorei = debugGLPixelStorei; |
| interface->fQueryCounter = debugGLQueryCounter; |
| interface->fReadBuffer = debugGLReadBuffer; |
| interface->fReadPixels = debugGLReadPixels; |
| interface->fScissor = debugGLScissor; |
| interface->fShaderSource = debugGLShaderSource; |
| interface->fStencilFunc = debugGLStencilFunc; |
| interface->fStencilFuncSeparate = debugGLStencilFuncSeparate; |
| interface->fStencilMask = debugGLStencilMask; |
| interface->fStencilMaskSeparate = debugGLStencilMaskSeparate; |
| interface->fStencilOp = debugGLStencilOp; |
| interface->fStencilOpSeparate = debugGLStencilOpSeparate; |
| interface->fTexImage2D = debugGLTexImage2D; |
| interface->fTexParameteri = debugGLTexParameteri; |
| interface->fTexParameteriv = debugGLTexParameteriv; |
| interface->fTexSubImage2D = debugGLTexSubImage2D; |
| interface->fTexStorage2D = debugGLTexStorage2D; |
| interface->fUniform1f = debugGLUniform1f; |
| interface->fUniform1i = debugGLUniform1i; |
| interface->fUniform1fv = debugGLUniform1fv; |
| interface->fUniform1iv = debugGLUniform1iv; |
| interface->fUniform2f = debugGLUniform2f; |
| interface->fUniform2i = debugGLUniform2i; |
| interface->fUniform2fv = debugGLUniform2fv; |
| interface->fUniform2iv = debugGLUniform2iv; |
| interface->fUniform3f = debugGLUniform3f; |
| interface->fUniform3i = debugGLUniform3i; |
| interface->fUniform3fv = debugGLUniform3fv; |
| interface->fUniform3iv = debugGLUniform3iv; |
| interface->fUniform4f = debugGLUniform4f; |
| interface->fUniform4i = debugGLUniform4i; |
| interface->fUniform4fv = debugGLUniform4fv; |
| interface->fUniform4iv = debugGLUniform4iv; |
| interface->fUniformMatrix2fv = debugGLUniformMatrix2fv; |
| interface->fUniformMatrix3fv = debugGLUniformMatrix3fv; |
| interface->fUniformMatrix4fv = debugGLUniformMatrix4fv; |
| interface->fUseProgram = debugGLUseProgram; |
| interface->fVertexAttrib4fv = debugGLVertexAttrib4fv; |
| interface->fVertexAttribPointer = debugGLVertexAttribPointer; |
| interface->fViewport = debugGLViewport; |
| interface->fBindFramebuffer = debugGLBindFramebuffer; |
| interface->fBindRenderbuffer = debugGLBindRenderbuffer; |
| interface->fCheckFramebufferStatus = debugGLCheckFramebufferStatus; |
| interface->fDeleteFramebuffers = debugGLDeleteFramebuffers; |
| interface->fDeleteRenderbuffers = debugGLDeleteRenderbuffers; |
| interface->fFramebufferRenderbuffer = debugGLFramebufferRenderbuffer; |
| interface->fFramebufferTexture2D = debugGLFramebufferTexture2D; |
| interface->fGenFramebuffers = debugGLGenFramebuffers; |
| interface->fGenRenderbuffers = debugGLGenRenderbuffers; |
| interface->fGetFramebufferAttachmentParameteriv = |
| debugGLGetFramebufferAttachmentParameteriv; |
| interface->fGetRenderbufferParameteriv = debugGLGetRenderbufferParameteriv; |
| interface->fRenderbufferStorage = debugGLRenderbufferStorage; |
| interface->fRenderbufferStorageMultisample = |
| debugGLRenderbufferStorageMultisample; |
| interface->fBlitFramebuffer = debugGLBlitFramebuffer; |
| interface->fResolveMultisampleFramebuffer = |
| debugGLResolveMultisampleFramebuffer; |
| interface->fMapBuffer = debugGLMapBuffer; |
| interface->fUnmapBuffer = debugGLUnmapBuffer; |
| interface->fBindFragDataLocationIndexed = |
| debugGLBindFragDataLocationIndexed; |
| |
| return interface; |
| } |
