| /* | |
| * 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 "GrVertexArrayObj.h" | |
| #include "SkFloatingPoint.h" | |
| #include "../GrGLNoOpInterface.h" | |
| namespace { // suppress no previous 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 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; | |
| } | |
| GrAlwaysAssert(buffer); | |
| GrAlwaysAssert(buffer->getBound()); | |
| buffer->allocate(size, reinterpret_cast<const GrGLchar *>(data)); | |
| buffer->setUsage(usage); | |
| } | |
| 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(); | |
| } | |
| 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 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 debugGLBindFramebuffer(GrGLenum target, | |
| GrGLuint frameBufferID) { | |
| 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 = 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(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 (GrDebugGL::getInstance()->getFrameBuffer()) { | |
| GrFrameBufferObj *frameBuffer = GrDebugGL::getInstance()->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 = 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(nullptr); | |
| } | |
| } | |
| } | |
| // 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(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 (GrDebugGL::getInstance()->getFrameBuffer()) { | |
| GrFrameBufferObj *frameBuffer = | |
| GrDebugGL::getInstance()->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 = 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(); | |
| } | |
| } | |
| 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(); | |
| } | |
| } | |
| GrGLvoid debugGenObjs(GrDebugGL::GrObjTypes type, | |
| GrGLsizei n, | |
| GrGLuint* ids) { | |
| for (int i = 0; i < n; ++i) { | |
| GrAlwaysAssert(ids[i] == 0); | |
| 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 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(); | |
| } 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); | |
| } | |
| } | |
| // 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 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; | |
| } | |
| 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: | |
| SkAutoTUnref<GrGLInterface> fWrapped; | |
| typedef GrGLInterface INHERITED; | |
| }; | |
| //////////////////////////////////////////////////////////////////////////////// | |
| 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->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->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; | |
| } |