diff --git a/renderdoc/driver/gl/gl_common.h b/renderdoc/driver/gl/gl_common.h index 8092cb4a9..f35298b48 100644 --- a/renderdoc/driver/gl/gl_common.h +++ b/renderdoc/driver/gl/gl_common.h @@ -163,6 +163,7 @@ enum GLChunkType BIND_TEXTURE, BIND_TEXTURES, BIND_MULTI_TEX, + BIND_TEXTURE_UNIT, BIND_IMAGE_TEXTURE, BIND_IMAGE_TEXTURES, ACTIVE_TEXTURE, diff --git a/renderdoc/driver/gl/gl_debug.cpp b/renderdoc/driver/gl/gl_debug.cpp index 4becab66f..8f9e1ab90 100644 --- a/renderdoc/driver/gl/gl_debug.cpp +++ b/renderdoc/driver/gl/gl_debug.cpp @@ -336,7 +336,7 @@ void GLReplay::InitDebugData() gl.glGenTextures(1, &DebugData.pickPixelTex); gl.glBindTexture(eGL_TEXTURE_2D, DebugData.pickPixelTex); - gl.glTexStorage2D(eGL_TEXTURE_2D, 1, eGL_RGBA32F, 1, 1); + gl.glTextureStorage2DEXT(DebugData.pickPixelTex, eGL_TEXTURE_2D, 1, eGL_RGBA32F, 1, 1); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MIN_FILTER, eGL_NEAREST); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MAG_FILTER, eGL_NEAREST); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_WRAP_S, eGL_CLAMP_TO_EDGE); @@ -1511,7 +1511,7 @@ ResourceId GLReplay::RenderOverlay(ResourceId texid, TextureDisplayOverlay overl DebugData.overlayTexWidth = texDetails.width; DebugData.overlayTexHeight = texDetails.height; - gl.glTexStorage2D(eGL_TEXTURE_2D, 1, eGL_RGBA16, texDetails.width, texDetails.height); + gl.glTextureStorage2DEXT(DebugData.overlayTex, eGL_TEXTURE_2D, 1, eGL_RGBA16, texDetails.width, texDetails.height); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MIN_FILTER, eGL_NEAREST); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MAG_FILTER, eGL_NEAREST); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_WRAP_S, eGL_CLAMP_TO_EDGE); @@ -1622,7 +1622,7 @@ ResourceId GLReplay::RenderOverlay(ResourceId texid, TextureDisplayOverlay overl gl.glGenTextures(1, &depthCopy); gl.glBindTexture(eGL_TEXTURE_2D, depthCopy); - gl.glTexStorage2D(eGL_TEXTURE_2D, 1, fmt, DebugData.overlayTexWidth, DebugData.overlayTexHeight); + gl.glTextureStorage2DEXT(depthCopy, eGL_TEXTURE_2D, 1, fmt, DebugData.overlayTexWidth, DebugData.overlayTexHeight); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MIN_FILTER, eGL_NEAREST); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MAG_FILTER, eGL_NEAREST); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_WRAP_S, eGL_CLAMP_TO_EDGE); @@ -1642,7 +1642,7 @@ ResourceId GLReplay::RenderOverlay(ResourceId texid, TextureDisplayOverlay overl gl.glGenTextures(1, &stencilCopy); gl.glBindTexture(eGL_TEXTURE_2D, stencilCopy); - gl.glTexStorage2D(eGL_TEXTURE_2D, 1, fmt, DebugData.overlayTexWidth, DebugData.overlayTexHeight); + gl.glTextureStorage2DEXT(stencilCopy, eGL_TEXTURE_2D, 1, fmt, DebugData.overlayTexWidth, DebugData.overlayTexHeight); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MIN_FILTER, eGL_NEAREST); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MAG_FILTER, eGL_NEAREST); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_WRAP_S, eGL_CLAMP_TO_EDGE); @@ -1763,7 +1763,7 @@ ResourceId GLReplay::RenderOverlay(ResourceId texid, TextureDisplayOverlay overl // image for quad usage gl.glBindTexture(eGL_TEXTURE_2D_ARRAY, quadtexs[2]); - gl.glTexStorage3D(eGL_TEXTURE_2D_ARRAY, 1, eGL_R32UI, texDetails.width>>1, texDetails.height>>1, 4); + gl.glTextureStorage3DEXT(quadtexs[2], eGL_TEXTURE_2D_ARRAY, 1, eGL_R32UI, texDetails.width>>1, texDetails.height>>1, 4); // temporarily attach to FBO to clear it GLint zero = 0; @@ -1777,7 +1777,7 @@ ResourceId GLReplay::RenderOverlay(ResourceId texid, TextureDisplayOverlay overl gl.glClearBufferiv(eGL_COLOR, 0, &zero); gl.glBindTexture(eGL_TEXTURE_2D, quadtexs[0]); - gl.glTexStorage2D(eGL_TEXTURE_2D, 1, eGL_RGBA8, texDetails.width, texDetails.height); + gl.glTextureStorage2DEXT(quadtexs[0], eGL_TEXTURE_2D, 1, eGL_RGBA8, texDetails.width, texDetails.height); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MIN_FILTER, eGL_NEAREST); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MAG_FILTER, eGL_NEAREST); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_WRAP_S, eGL_CLAMP_TO_EDGE); @@ -1785,7 +1785,7 @@ ResourceId GLReplay::RenderOverlay(ResourceId texid, TextureDisplayOverlay overl gl.glFramebufferTexture(eGL_FRAMEBUFFER, eGL_COLOR_ATTACHMENT0, quadtexs[0], 0); gl.glBindTexture(eGL_TEXTURE_2D, quadtexs[1]); - gl.glTexStorage2D(eGL_TEXTURE_2D, 1, eGL_DEPTH32F_STENCIL8, texDetails.width, texDetails.height); + gl.glTextureStorage2DEXT(quadtexs[1], eGL_TEXTURE_2D, 1, eGL_DEPTH32F_STENCIL8, texDetails.width, texDetails.height); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MIN_FILTER, eGL_NEAREST); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MAG_FILTER, eGL_NEAREST); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_WRAP_S, eGL_CLAMP_TO_EDGE); diff --git a/renderdoc/driver/gl/gl_driver.cpp b/renderdoc/driver/gl/gl_driver.cpp index 771906b5e..456616dc4 100644 --- a/renderdoc/driver/gl/gl_driver.cpp +++ b/renderdoc/driver/gl/gl_driver.cpp @@ -47,6 +47,7 @@ const char *GLChunkNames[] = "glBindTexture", "glBindTextures", "glBindMultiTexture", + "glBindTextureUnit", "glBindImageTexture", "glBindImageTextures", "glActiveTexture", @@ -794,11 +795,11 @@ void WrappedOpenGL::Initialise(GLInitParams ¶ms) if(params.multiSamples > 1) { - gl.glTexStorage2DMultisample(target, params.multiSamples, colfmt, params.width, params.height, true); + gl.glTextureStorage2DMultisampleEXT(m_FakeBB_Color, target, params.multiSamples, colfmt, params.width, params.height, true); } else { - gl.glTexStorage2D(target, 1, colfmt, params.width, params.height); + gl.glTextureStorage2DEXT(m_FakeBB_Color, target, 1, colfmt, params.width, params.height); gl.glTexParameteri(target, eGL_TEXTURE_MIN_FILTER, eGL_NEAREST); gl.glTexParameteri(target, eGL_TEXTURE_MAG_FILTER, eGL_NEAREST); gl.glTexParameteri(target, eGL_TEXTURE_WRAP_S, eGL_CLAMP_TO_EDGE); @@ -847,9 +848,9 @@ void WrappedOpenGL::Initialise(GLInitParams ¶ms) gl.glObjectLabel(eGL_TEXTURE, m_FakeBB_DepthStencil, -1, "Backbuffer Depth"); if(params.multiSamples > 1) - gl.glTexStorage2DMultisample(target, params.multiSamples, depthfmt, params.width, params.height, true); + gl.glTextureStorage2DMultisampleEXT(m_FakeBB_DepthStencil, target, params.multiSamples, depthfmt, params.width, params.height, true); else - gl.glTexStorage2D(target, 1, depthfmt, params.width, params.height); + gl.glTextureStorage2DEXT(m_FakeBB_DepthStencil, target, 1, depthfmt, params.width, params.height); if(stencil) gl.glFramebufferTexture(eGL_FRAMEBUFFER, eGL_DEPTH_STENCIL_ATTACHMENT, m_FakeBB_DepthStencil, 0); @@ -2323,6 +2324,9 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) case BIND_MULTI_TEX: Serialise_glBindMultiTextureEXT(eGL_NONE, eGL_NONE, 0); break; + case BIND_TEXTURE_UNIT: + Serialise_glBindTextureUnit(0, 0); + break; case BIND_IMAGE_TEXTURE: Serialise_glBindImageTexture(0, 0, 0, 0, 0, eGL_NONE, eGL_NONE); break; diff --git a/renderdoc/driver/gl/gl_driver.h b/renderdoc/driver/gl/gl_driver.h index 8400d2d5f..a8054d44f 100644 --- a/renderdoc/driver/gl/gl_driver.h +++ b/renderdoc/driver/gl/gl_driver.h @@ -1094,6 +1094,52 @@ class WrappedOpenGL IMPLEMENT_FUNCTION_SERIALISED(void, glDeleteVertexArrays(GLsizei n, const GLuint *arrays)); // EXT_direct_state_access + + // there's a lot of duplicated code in some of these variants, between + // EXT_dsa, ARB_dsa, non-dsa and for textures the MultiTex variants etc. + // So we make a Common_ function similar to the Serialise_ function based + // on the EXT_dsa interface, which takes the function parameters and a + // GLResourceRecord* which does all the common tasks between all of these + // functions. + + void Common_glGenerateTextureMipmapEXT(GLResourceRecord *record, GLenum target); + + void Common_glCopyTextureImage1DEXT(GLResourceRecord *record, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); + void Common_glCopyTextureImage2DEXT(GLResourceRecord *record, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); + void Common_glCopyTextureSubImage1DEXT(GLResourceRecord *record, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); + void Common_glCopyTextureSubImage2DEXT(GLResourceRecord *record, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); + void Common_glCopyTextureSubImage3DEXT(GLResourceRecord *record, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); + + void Common_glTextureBufferEXT(ResourceId id, GLenum target, GLenum internalformat, GLuint buffer); + void Common_glTextureBufferRangeEXT(ResourceId id, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size); + + void Common_glTextureImage1DEXT(ResourceId id, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); + void Common_glTextureImage2DEXT(ResourceId id, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); + void Common_glTextureImage3DEXT(ResourceId id, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); + void Common_glCompressedTextureImage1DEXT(ResourceId id, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits); + void Common_glCompressedTextureImage2DEXT(ResourceId id, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits); + void Common_glCompressedTextureImage3DEXT(ResourceId id, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits); + + void Common_glTextureStorage1DEXT(ResourceId id, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width); + void Common_glTextureStorage2DEXT(ResourceId id, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); + void Common_glTextureStorage3DEXT(ResourceId id, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth); + void Common_glTextureStorage2DMultisampleEXT(ResourceId id, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); + void Common_glTextureStorage3DMultisampleEXT(ResourceId id, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); + + void Common_glTextureSubImage1DEXT(GLResourceRecord *record, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); + void Common_glTextureSubImage2DEXT(GLResourceRecord *record, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); + void Common_glTextureSubImage3DEXT(GLResourceRecord *record, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); + void Common_glCompressedTextureSubImage1DEXT(GLResourceRecord *record, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits); + void Common_glCompressedTextureSubImage2DEXT(GLResourceRecord *record, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits); + void Common_glCompressedTextureSubImage3DEXT(GLResourceRecord *record, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *bits); + + void Common_glTextureParameterfEXT(GLResourceRecord *record, GLenum target, GLenum pname, GLfloat param); + void Common_glTextureParameterfvEXT(GLResourceRecord *record, GLenum target, GLenum pname, const GLfloat *params); + void Common_glTextureParameteriEXT(GLResourceRecord *record, GLenum target, GLenum pname, GLint param); + void Common_glTextureParameterivEXT(GLResourceRecord *record, GLenum target, GLenum pname, const GLint *params); + void Common_glTextureParameterIivEXT(GLResourceRecord *record, GLenum target, GLenum pname, const GLint *params); + void Common_glTextureParameterIuivEXT(GLResourceRecord *record, GLenum target, GLenum pname, const GLuint *params); + IMPLEMENT_FUNCTION_SERIALISED(GLenum, glCheckNamedFramebufferStatusEXT(GLuint framebuffer, GLenum target)); IMPLEMENT_FUNCTION_SERIALISED(void, glCompressedTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits)); IMPLEMENT_FUNCTION_SERIALISED(void, glCompressedTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits)); diff --git a/renderdoc/driver/gl/gl_replay.cpp b/renderdoc/driver/gl/gl_replay.cpp index 066e316e2..15bb808e4 100644 --- a/renderdoc/driver/gl/gl_replay.cpp +++ b/renderdoc/driver/gl/gl_replay.cpp @@ -164,7 +164,7 @@ void GLReplay::CreateOutputWindowBackbuffer(OutputWindow &outwin, bool depth) gl.glGenTextures(1, &outwin.BlitData.backbuffer); gl.glBindTexture(eGL_TEXTURE_2D, outwin.BlitData.backbuffer); - gl.glTexStorage2D(eGL_TEXTURE_2D, 1, eGL_SRGB8, outwin.width, outwin.height); + gl.glTextureStorage2DEXT(outwin.BlitData.backbuffer, eGL_TEXTURE_2D, 1, eGL_SRGB8, outwin.width, outwin.height); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MIN_FILTER, eGL_NEAREST); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MAG_FILTER, eGL_NEAREST); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_WRAP_S, eGL_CLAMP_TO_EDGE); @@ -176,7 +176,7 @@ void GLReplay::CreateOutputWindowBackbuffer(OutputWindow &outwin, bool depth) gl.glGenTextures(1, &outwin.BlitData.depthstencil); gl.glBindTexture(eGL_TEXTURE_2D, outwin.BlitData.depthstencil); - gl.glTexStorage2D(eGL_TEXTURE_2D, 1, eGL_DEPTH_COMPONENT24, outwin.width, outwin.height); + gl.glTextureStorage2DEXT(outwin.BlitData.depthstencil, eGL_TEXTURE_2D, 1, eGL_DEPTH_COMPONENT24, outwin.width, outwin.height); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MIN_FILTER, eGL_NEAREST); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MAG_FILTER, eGL_NEAREST); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_WRAP_S, eGL_CLAMP_TO_EDGE); @@ -2228,9 +2228,9 @@ byte *GLReplay::GetTextureData(ResourceId tex, uint32_t arrayIdx, uint32_t mip, gl.glGenTextures(1, &tempTex); gl.glBindTexture(newtarget, tempTex); if(newtarget == eGL_TEXTURE_3D) - gl.glTexStorage3D(newtarget, 1, finalFormat, width, height, depth); + gl.glTextureStorage3DEXT(tempTex, newtarget, 1, finalFormat, width, height, depth); else - gl.glTexStorage2D(newtarget, 1, finalFormat, width, height); + gl.glTextureStorage2DEXT(tempTex, newtarget, 1, finalFormat, width, height); // create temp framebuffer GLuint fbo = 0; @@ -2310,7 +2310,7 @@ byte *GLReplay::GetTextureData(ResourceId tex, uint32_t arrayIdx, uint32_t mip, // create temporary texture of width/height in same format to render to gl.glGenTextures(1, &tempTex); gl.glBindTexture(eGL_TEXTURE_2D, tempTex); - gl.glTexStorage2D(eGL_TEXTURE_2D, 1, intFormat, width, height); + gl.glTextureStorage2DEXT(tempTex, eGL_TEXTURE_2D, 1, intFormat, width, height); // create temp framebuffers GLuint fbos[2] = { 0 }; @@ -2354,7 +2354,7 @@ byte *GLReplay::GetTextureData(ResourceId tex, uint32_t arrayIdx, uint32_t mip, // with the same number of array slices as multi samples. gl.glGenTextures(1, &tempTex); gl.glBindTexture(eGL_TEXTURE_2D_ARRAY, tempTex); - gl.glTexStorage3D(eGL_TEXTURE_2D_ARRAY, 1, intFormat, width, height, arraysize*samples); + gl.glTextureStorage3DEXT(tempTex, eGL_TEXTURE_2D_ARRAY, 1, intFormat, width, height, arraysize*samples); // copy multisampled texture to an array CopyTex2DMSToArray(tempTex, texname, width, height, arraysize, samples, intFormat); @@ -2702,56 +2702,56 @@ ResourceId GLReplay::CreateProxyTexture(FetchTexture templateTex) case eResType_Texture1D: { gl.glBindTexture(eGL_TEXTURE_1D, tex); - gl.glTexStorage1D(eGL_TEXTURE_1D, templateTex.mips, intFormat, templateTex.width); + gl.glTextureStorage1DEXT(tex, eGL_TEXTURE_1D, templateTex.mips, intFormat, templateTex.width); break; } case eResType_Texture1DArray: { gl.glBindTexture(eGL_TEXTURE_1D_ARRAY, tex); - gl.glTexStorage2D(eGL_TEXTURE_1D_ARRAY, templateTex.mips, intFormat, templateTex.width, templateTex.arraysize); + gl.glTextureStorage2DEXT(tex, eGL_TEXTURE_1D_ARRAY, templateTex.mips, intFormat, templateTex.width, templateTex.arraysize); break; } case eResType_TextureRect: case eResType_Texture2D: { gl.glBindTexture(eGL_TEXTURE_2D, tex); - gl.glTexStorage2D(eGL_TEXTURE_2D, templateTex.mips, intFormat, templateTex.width, templateTex.height); + gl.glTextureStorage2DEXT(tex, eGL_TEXTURE_2D, templateTex.mips, intFormat, templateTex.width, templateTex.height); break; } case eResType_Texture2DArray: { gl.glBindTexture(eGL_TEXTURE_2D_ARRAY, tex); - gl.glTexStorage3D(eGL_TEXTURE_2D_ARRAY, templateTex.mips, intFormat, templateTex.width, templateTex.height, templateTex.arraysize); + gl.glTextureStorage3DEXT(tex, eGL_TEXTURE_2D_ARRAY, templateTex.mips, intFormat, templateTex.width, templateTex.height, templateTex.arraysize); break; } case eResType_Texture2DMS: { gl.glBindTexture(eGL_TEXTURE_2D_MULTISAMPLE, tex); - gl.glTexStorage2DMultisample(eGL_TEXTURE_2D_MULTISAMPLE, templateTex.msSamp, intFormat, templateTex.width, templateTex.height, GL_TRUE); + gl.glTextureStorage2DMultisampleEXT(tex, eGL_TEXTURE_2D_MULTISAMPLE, templateTex.msSamp, intFormat, templateTex.width, templateTex.height, GL_TRUE); break; } case eResType_Texture2DMSArray: { gl.glBindTexture(eGL_TEXTURE_2D_MULTISAMPLE_ARRAY, tex); - gl.glTexStorage3DMultisample(eGL_TEXTURE_2D_MULTISAMPLE_ARRAY, templateTex.msSamp, intFormat, templateTex.width, templateTex.height, templateTex.arraysize, GL_TRUE); + gl.glTextureStorage3DMultisampleEXT(tex, eGL_TEXTURE_2D_MULTISAMPLE_ARRAY, templateTex.msSamp, intFormat, templateTex.width, templateTex.height, templateTex.arraysize, GL_TRUE); break; } case eResType_Texture3D: { gl.glBindTexture(eGL_TEXTURE_3D, tex); - gl.glTexStorage3D(eGL_TEXTURE_3D, templateTex.mips, intFormat, templateTex.width, templateTex.height, templateTex.depth); + gl.glTextureStorage3DEXT(tex, eGL_TEXTURE_3D, templateTex.mips, intFormat, templateTex.width, templateTex.height, templateTex.depth); break; } case eResType_TextureCube: { gl.glBindTexture(eGL_TEXTURE_CUBE_MAP, tex); - gl.glTexStorage2D(eGL_TEXTURE_CUBE_MAP, templateTex.mips, intFormat, templateTex.width, templateTex.height); + gl.glTextureStorage2DEXT(tex, eGL_TEXTURE_CUBE_MAP, templateTex.mips, intFormat, templateTex.width, templateTex.height); break; } case eResType_TextureCubeArray: { gl.glBindTexture(eGL_TEXTURE_CUBE_MAP_ARRAY, tex); - gl.glTexStorage3D(eGL_TEXTURE_CUBE_MAP_ARRAY, templateTex.mips, intFormat, templateTex.width, templateTex.height, templateTex.arraysize); + gl.glTextureStorage3DEXT(tex, eGL_TEXTURE_CUBE_MAP_ARRAY, templateTex.mips, intFormat, templateTex.width, templateTex.height, templateTex.arraysize); break; } } diff --git a/renderdoc/driver/gl/gl_resources.h b/renderdoc/driver/gl/gl_resources.h index ba1ab2a67..7d379a004 100644 --- a/renderdoc/driver/gl/gl_resources.h +++ b/renderdoc/driver/gl/gl_resources.h @@ -168,6 +168,7 @@ struct GLResourceRecord : public ResourceRecord void VerifyDataType(GLenum target) { #if !defined(RELEASE) + if(target == eGL_NONE) return; // target == GL_NONE means ARB_dsa, target was omitted if(datatype == eGL_NONE) datatype = TextureBinding(target); else diff --git a/renderdoc/driver/gl/wrappers/gl_emulated.cpp b/renderdoc/driver/gl/wrappers/gl_emulated.cpp index 002852e2c..43ab8291d 100644 --- a/renderdoc/driver/gl/wrappers/gl_emulated.cpp +++ b/renderdoc/driver/gl/wrappers/gl_emulated.cpp @@ -136,6 +136,7 @@ void EmulateUnsupportedFunctions(GLHookSet *hooks) EMULATE_UNSUPPORTED(glClearNamedFramebufferfv) EMULATE_UNSUPPORTED(glClearNamedFramebufferfi) EMULATE_UNSUPPORTED(glBlitNamedFramebuffer) + EMULATE_UNSUPPORTED(glVertexArrayElementBuffer); EMULATE_UNSUPPORTED(glVertexArrayVertexBuffers) } diff --git a/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp index 9083dff7c..f36fbf330 100644 --- a/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp @@ -26,6 +26,29 @@ #include "serialise/string_utils.h" #include "../gl_driver.h" +// NOTE: Handling of ARB_dsa vs. EXT_dsa +// +// To avoid lots of redundancy between the ARB_dsa/EXT_dsa variants, we handle it +// by passing along GL_NONE as the target parameter where the EXT function expects +// a target but there isn't a target parameter for the ARB function. +// +// As with everywhere else, non-DSA variants are always "promoted" to DSA functions +// and serialised as such. Since we require EXT_dsa functionality on replay this +// means we only need to differentiate between ARB and EXT. +// +// On replay, we check the target and if it's GL_NONE assume that it was an ARB +// call and replay as such. If the target is valid (or at least != GL_NONE) then +// we call the EXT variant. Since GL_NONE is never a valid target, there's no risk +// of overlap. That way we don't have to worry about emulating ARB_dsa when it's +// not present, as we only ever serialise an ARB version when the original call was +// ARB, unlike the promotion to DSA from non-DSA where there's ambiguity on what +// the original call was. + +// This of course means that if a log is captured using ARB_dsa functions then the +// replay context must have ARB_dsa support, but this is to be expected and it +// would be a nightmare to support replaying without extensions that were present & +// used when capturing. + bool WrappedOpenGL::Serialise_glGenTextures(GLsizei n, GLuint* textures) { SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(GetCtx(), *textures))); @@ -341,6 +364,53 @@ void WrappedOpenGL::glBindMultiTextureEXT(GLenum texunit, GLenum target, GLuint } } +bool WrappedOpenGL::Serialise_glBindTextureUnit(GLuint texunit, GLuint texture) +{ + SERIALISE_ELEMENT(uint32_t, Unit, texunit); + SERIALISE_ELEMENT(ResourceId, Id, (texture ? GetResourceManager()->GetID(TextureRes(GetCtx(), texture)) : ResourceId())); + + if(m_State < WRITING) + { + if(Id == ResourceId()) + { + m_Real.glBindTextureUnit(Unit, 0); + } + else + { + GLResource res = GetResourceManager()->GetLiveResource(Id); + m_Real.glBindTextureUnit(Unit, res.name); + } + } + + return true; +} + +void WrappedOpenGL::glBindTextureUnit(GLuint unit, GLuint texture) +{ + m_Real.glBindTextureUnit(unit, texture); + + if(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)) == ResourceId()) + return; + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(BIND_TEXTURE_UNIT); + Serialise_glBindTextureUnit(unit, texture); + + m_ContextRecord->AddChunk(scope.Get()); + } + + if(m_State >= WRITING) + { + ContextData &cd = GetCtxData(); + + if(texture == 0) + cd.m_TextureRecord[unit] = NULL; + else + cd.m_TextureRecord[unit] = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); + } +} + bool WrappedOpenGL::Serialise_glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format) { SERIALISE_ELEMENT(uint32_t, Unit, unit); @@ -503,91 +573,65 @@ bool WrappedOpenGL::Serialise_glGenerateTextureMipmapEXT(GLuint texture, GLenum if(m_State == READING) { - m_Real.glGenerateTextureMipmapEXT(GetResourceManager()->GetLiveResource(id).name, Target); + if(Target != eGL_NONE) + m_Real.glGenerateTextureMipmapEXT(GetResourceManager()->GetLiveResource(id).name, Target); + else + m_Real.glGenerateTextureMipmap(GetResourceManager()->GetLiveResource(id).name); } return true; } +void WrappedOpenGL::Common_glGenerateTextureMipmapEXT(GLResourceRecord *record, GLenum target) +{ + if(!record) return; + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(GENERATE_MIPMAP); + Serialise_glGenerateTextureMipmapEXT(record->Resource.name, target); + + m_ContextRecord->AddChunk(scope.Get()); + } + else if(m_State == WRITING_IDLE) + { + SCOPED_SERIALISE_CONTEXT(GENERATE_MIPMAP); + Serialise_glGenerateTextureMipmapEXT(record->Resource.name, target); + + record->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glGenerateTextureMipmapEXT(GLuint texture, GLenum target) { m_Real.glGenerateTextureMipmapEXT(texture, target); - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(GENERATE_MIPMAP); - Serialise_glGenerateTextureMipmapEXT(texture, target); - - m_ContextRecord->AddChunk(scope.Get()); - } - else if(m_State == WRITING_IDLE) - { - SCOPED_SERIALISE_CONTEXT(GENERATE_MIPMAP); - Serialise_glGenerateTextureMipmapEXT(texture, target); + if(m_State >= WRITING) + Common_glGenerateTextureMipmapEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), target); +} - ResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); - RDCASSERT(record); - if(record) - record->AddChunk(scope.Get()); - } +void WrappedOpenGL::glGenerateTextureMipmap(GLuint texture) +{ + m_Real.glGenerateTextureMipmap(texture); + + if(m_State >= WRITING) + Common_glGenerateTextureMipmapEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), eGL_NONE); } void WrappedOpenGL::glGenerateMipmap(GLenum target) { m_Real.glGenerateMipmap(target); - - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - if(!record) return; - - GLuint texture = record->Resource.name; - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(GENERATE_MIPMAP); - Serialise_glGenerateTextureMipmapEXT(texture, target); - - m_ContextRecord->AddChunk(scope.Get()); - } - else if(m_State == WRITING_IDLE) - { - SCOPED_SERIALISE_CONTEXT(GENERATE_MIPMAP); - Serialise_glGenerateTextureMipmapEXT(texture, target); - - RDCASSERT(record); - if(record) - record->AddChunk(scope.Get()); - } + if(m_State >= WRITING) + Common_glGenerateTextureMipmapEXT(GetCtxData().GetActiveTexRecord(), target); } void WrappedOpenGL::glGenerateMultiTexMipmapEXT(GLenum texunit, GLenum target) { m_Real.glGenerateMultiTexMipmapEXT(texunit, target); - - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - if(!record) return; - - GLuint texture = record->Resource.name; - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(GENERATE_MIPMAP); - Serialise_glGenerateTextureMipmapEXT(texture, target); - - m_ContextRecord->AddChunk(scope.Get()); - } - else if(m_State == WRITING_IDLE) - { - SCOPED_SERIALISE_CONTEXT(GENERATE_MIPMAP); - Serialise_glGenerateTextureMipmapEXT(texture, target); - - RDCASSERT(record); - if(record) - record->AddChunk(scope.Get()); - } + if(m_State >= WRITING) + Common_glGenerateTextureMipmapEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0], target); } void WrappedOpenGL::glInvalidateTexImage(GLuint texture, GLint level) @@ -675,62 +719,63 @@ bool WrappedOpenGL::Serialise_glCopyTextureSubImage1DEXT(GLuint texture, GLenum SERIALISE_ELEMENT(int32_t, Width, width); if(m_State < WRITING) - m_Real.glCopyTextureSubImage1DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, Xoffset, X, Y, Width); + { + if(Target != eGL_NONE) + m_Real.glCopyTextureSubImage1DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, Xoffset, X, Y, Width); + else + m_Real.glCopyTextureSubImage1D(GetResourceManager()->GetLiveResource(id).name, Level, Xoffset, X, Y, Width); + } + return true; } +void WrappedOpenGL::Common_glCopyTextureSubImage1DEXT(GLResourceRecord *record, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + if(!record) return; + + if(m_State == WRITING_IDLE) + { + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); + } + else if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(COPY_SUBIMAGE1D); + Serialise_glCopyTextureSubImage1DEXT(record->Resource.name, target, level, xoffset, x, y, width); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glCopyTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) { m_Real.glCopyTextureSubImage1DEXT(texture, target, level, xoffset, x, y, width); - if(m_State == WRITING_IDLE) - { - if(GetCtxData().GetActiveTexRecord()) - GetResourceManager()->MarkDirtyResource(GetResourceManager()->GetID(TextureRes(GetCtx(), texture))); - } - else if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(COPY_SUBIMAGE1D); - Serialise_glCopyTextureSubImage1DEXT(texture, target, level, xoffset, x, y, width); + if(m_State >= WRITING) + Common_glCopyTextureSubImage1DEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), target, level, xoffset, x, y, width); +} - m_ContextRecord->AddChunk(scope.Get()); - } +void WrappedOpenGL::glCopyTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + m_Real.glCopyTextureSubImage1D(texture, level, xoffset, x, y, width); + + if(m_State >= WRITING) + Common_glCopyTextureSubImage1DEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), eGL_NONE, level, xoffset, x, y, width); } void WrappedOpenGL::glCopyMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) { m_Real.glCopyMultiTexSubImage1DEXT(texunit, target, level, xoffset, x, y, width); - if(m_State == WRITING_IDLE) - { - if(GetCtxData().GetActiveTexRecord()) - GetResourceManager()->MarkDirtyResource(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->GetResourceID()); - } - else if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(COPY_SUBIMAGE1D); - Serialise_glCopyTextureSubImage1DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->Resource.name, target, level, xoffset, x, y, width); - - m_ContextRecord->AddChunk(scope.Get()); - } + if(m_State >= WRITING) + Common_glCopyTextureSubImage1DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0], target, level, xoffset, x, y, width); } void WrappedOpenGL::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) { m_Real.glCopyTexSubImage1D(target, level, xoffset, x, y, width); - if(m_State == WRITING_IDLE) - { - if(GetCtxData().GetActiveTexRecord()) - GetResourceManager()->MarkDirtyResource(GetCtxData().GetActiveTexRecord()->GetResourceID()); - } - else if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(COPY_SUBIMAGE1D); - Serialise_glCopyTextureSubImage1DEXT(GetCtxData().GetActiveTexRecord()->Resource.name, target, level, xoffset, x, y, width); - - m_ContextRecord->AddChunk(scope.Get()); - } + if(m_State >= WRITING) + Common_glCopyTextureSubImage1DEXT(GetCtxData().GetActiveTexRecord(), eGL_NONE, level, xoffset, x, y, width); } bool WrappedOpenGL::Serialise_glCopyTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) @@ -746,62 +791,63 @@ bool WrappedOpenGL::Serialise_glCopyTextureSubImage2DEXT(GLuint texture, GLenum SERIALISE_ELEMENT(int32_t, Height, height); if(m_State < WRITING) - m_Real.glCopyTextureSubImage2DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, Xoffset, Yoffset, X, Y, Width, Height); + { + if(Target != eGL_NONE) + m_Real.glCopyTextureSubImage2DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, Xoffset, Yoffset, X, Y, Width, Height); + else + m_Real.glCopyTextureSubImage2D(GetResourceManager()->GetLiveResource(id).name, Level, Xoffset, Yoffset, X, Y, Width, Height); + } + return true; } +void WrappedOpenGL::Common_glCopyTextureSubImage2DEXT(GLResourceRecord *record, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + if(!record) return; + + if(m_State == WRITING_IDLE) + { + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); + } + else if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(COPY_SUBIMAGE2D); + Serialise_glCopyTextureSubImage2DEXT(record->Resource.name, target, level, xoffset, yoffset, x, y, width, height); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glCopyTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { m_Real.glCopyTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, x, y, width, height); - if(m_State == WRITING_IDLE) - { - if(GetCtxData().GetActiveTexRecord()) - GetResourceManager()->MarkDirtyResource(GetResourceManager()->GetID(TextureRes(GetCtx(), texture))); - } - else if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(COPY_SUBIMAGE2D); - Serialise_glCopyTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, x, y, width, height); + if(m_State >= WRITING) + Common_glCopyTextureSubImage2DEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), target, level, xoffset, yoffset, x, y, width, height); +} - m_ContextRecord->AddChunk(scope.Get()); - } +void WrappedOpenGL::glCopyTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + m_Real.glCopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height); + + if(m_State >= WRITING) + Common_glCopyTextureSubImage2DEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), eGL_NONE, level, xoffset, yoffset, x, y, width, height); } void WrappedOpenGL::glCopyMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { m_Real.glCopyMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, x, y, width, height); - if(m_State == WRITING_IDLE) - { - if(GetCtxData().GetActiveTexRecord()) - GetResourceManager()->MarkDirtyResource(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->GetResourceID()); - } - else if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(COPY_SUBIMAGE2D); - Serialise_glCopyTextureSubImage2DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->Resource.name, target, level, xoffset, yoffset, x, y, width, height); - - m_ContextRecord->AddChunk(scope.Get()); - } + if(m_State >= WRITING) + Common_glCopyTextureSubImage2DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0], target, level, xoffset, yoffset, x, y, width, height); } void WrappedOpenGL::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { m_Real.glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); - if(m_State == WRITING_IDLE) - { - if(GetCtxData().GetActiveTexRecord()) - GetResourceManager()->MarkDirtyResource(GetCtxData().GetActiveTexRecord()->GetResourceID()); - } - else if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(COPY_SUBIMAGE2D); - Serialise_glCopyTextureSubImage2DEXT(GetCtxData().GetActiveTexRecord()->Resource.name, target, level, xoffset, yoffset, x, y, width, height); - - m_ContextRecord->AddChunk(scope.Get()); - } + if(m_State >= WRITING) + Common_glCopyTextureSubImage2DEXT(GetCtxData().GetActiveTexRecord(), target, level, xoffset, yoffset, x, y, width, height); } bool WrappedOpenGL::Serialise_glCopyTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) @@ -818,62 +864,63 @@ bool WrappedOpenGL::Serialise_glCopyTextureSubImage3DEXT(GLuint texture, GLenum SERIALISE_ELEMENT(int32_t, Height, height); if(m_State < WRITING) - m_Real.glCopyTextureSubImage3DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, Xoffset, Yoffset, Zoffset, X, Y, Width, Height); + { + if(Target != eGL_NONE) + m_Real.glCopyTextureSubImage3DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, Xoffset, Yoffset, Zoffset, X, Y, Width, Height); + else + m_Real.glCopyTextureSubImage3D(GetResourceManager()->GetLiveResource(id).name, Level, Xoffset, Yoffset, Zoffset, X, Y, Width, Height); + } + return true; } +void WrappedOpenGL::Common_glCopyTextureSubImage3DEXT(GLResourceRecord *record, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + if(!record) return; + + if(m_State == WRITING_IDLE) + { + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); + } + else if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(COPY_SUBIMAGE3D); + Serialise_glCopyTextureSubImage3DEXT(record->Resource.name, target, level, xoffset, yoffset, zoffset, x, y, width, height); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glCopyTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { m_Real.glCopyTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, x, y, width, height); - if(m_State == WRITING_IDLE) - { - if(GetCtxData().GetActiveTexRecord()) - GetResourceManager()->MarkDirtyResource(GetResourceManager()->GetID(TextureRes(GetCtx(), texture))); - } - else if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(COPY_SUBIMAGE3D); - Serialise_glCopyTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, x, y, width, height); + if(m_State >= WRITING) + Common_glCopyTextureSubImage3DEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), target, level, xoffset, yoffset, zoffset, x, y, width, height); +} - m_ContextRecord->AddChunk(scope.Get()); - } +void WrappedOpenGL::glCopyTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + m_Real.glCopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height); + + if(m_State >= WRITING) + Common_glCopyTextureSubImage3DEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), eGL_NONE, level, xoffset, yoffset, zoffset, x, y, width, height); } void WrappedOpenGL::glCopyMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { m_Real.glCopyMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height); - if(m_State == WRITING_IDLE) - { - if(GetCtxData().GetActiveTexRecord()) - GetResourceManager()->MarkDirtyResource(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->GetResourceID()); - } - else if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(COPY_SUBIMAGE3D); - Serialise_glCopyTextureSubImage3DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->Resource.name, target, level, xoffset, yoffset, zoffset, x, y, width, height); - - m_ContextRecord->AddChunk(scope.Get()); - } + if(m_State >= WRITING) + Common_glCopyTextureSubImage3DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0], target, level, xoffset, yoffset, zoffset, x, y, width, height); } void WrappedOpenGL::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { m_Real.glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); - if(m_State == WRITING_IDLE) - { - if(GetCtxData().GetActiveTexRecord()) - GetResourceManager()->MarkDirtyResource(GetCtxData().GetActiveTexRecord()->GetResourceID()); - } - else if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(COPY_SUBIMAGE3D); - Serialise_glCopyTextureSubImage3DEXT(GetCtxData().GetActiveTexRecord()->Resource.name, target, level, xoffset, yoffset, zoffset, x, y, width, height); - - m_ContextRecord->AddChunk(scope.Get()); - } + if(m_State >= WRITING) + Common_glCopyTextureSubImage3DEXT(GetCtxData().GetActiveTexRecord(), target, level, xoffset, yoffset, zoffset, x, y, width, height); } bool WrappedOpenGL::Serialise_glTextureParameteriEXT(GLuint texture, GLenum target, GLenum pname, GLint param) @@ -885,43 +932,56 @@ bool WrappedOpenGL::Serialise_glTextureParameteriEXT(GLuint texture, GLenum targ if(m_State < WRITING) { - m_Real.glTextureParameteriEXT(GetResourceManager()->GetLiveResource(id).name, Target, PName, Param); + if(Target != eGL_NONE) + m_Real.glTextureParameteriEXT(GetResourceManager()->GetLiveResource(id).name, Target, PName, Param); + else + m_Real.glTextureParameteri(GetResourceManager()->GetLiveResource(id).name, PName, Param); } return true; } +void WrappedOpenGL::Common_glTextureParameteriEXT(GLResourceRecord *record, GLenum target, GLenum pname, GLint param) +{ + if(!record) return; + + if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) + return; + + SCOPED_SERIALISE_CONTEXT(TEXPARAMETERI); + Serialise_glTextureParameteriEXT(record->Resource.name, target, pname, param); + + if(m_State == WRITING_CAPFRAME) + { + m_ContextRecord->AddChunk(scope.Get()); + } + else + { + record->AddChunk(scope.Get()); + record->UpdateCount++; + + if(record->UpdateCount > 12) + { + m_HighTrafficResources.insert(record->GetResourceID()); + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); + } + } +} + +void WrappedOpenGL::glTextureParameteri(GLuint texture, GLenum pname, GLint param) +{ + m_Real.glTextureParameteri(texture, pname, param); + + if(m_State >= WRITING) + Common_glTextureParameteriEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), eGL_NONE, pname, param); +} + void WrappedOpenGL::glTextureParameteriEXT(GLuint texture, GLenum target, GLenum pname, GLint param) { m_Real.glTextureParameteriEXT(texture, target, pname, param); if(m_State >= WRITING) - { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) - return; - - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERI); - Serialise_glTextureParameteriEXT(texture, target, pname, param); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 12) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } + Common_glTextureParameteriEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), target, pname, param); } void WrappedOpenGL::glTexParameteri(GLenum target, GLenum pname, GLint param) @@ -929,34 +989,7 @@ void WrappedOpenGL::glTexParameteri(GLenum target, GLenum pname, GLint param) m_Real.glTexParameteri(target, pname, param); if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - GLResource res = record->Resource; - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) - return; - - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERI); - Serialise_glTextureParameteriEXT(res.name, target, pname, param); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 12) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } + Common_glTextureParameteriEXT(GetCtxData().GetActiveTexRecord(), target, pname, param); } void WrappedOpenGL::glMultiTexParameteriEXT(GLenum texunit, GLenum target, GLenum pname, GLint param) @@ -964,34 +997,7 @@ void WrappedOpenGL::glMultiTexParameteriEXT(GLenum texunit, GLenum target, GLenu m_Real.glMultiTexParameteriEXT(texunit, target, pname, param); if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - GLResource res = record->Resource; - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) - return; - - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERI); - Serialise_glTextureParameteriEXT(res.name, target, pname, param); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 12) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } + Common_glTextureParameteriEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0], target, pname, param); } bool WrappedOpenGL::Serialise_glTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, const GLint *params) @@ -1004,7 +1010,10 @@ bool WrappedOpenGL::Serialise_glTextureParameterivEXT(GLuint texture, GLenum tar if(m_State < WRITING) { - m_Real.glTextureParameterivEXT(GetResourceManager()->GetLiveResource(id).name, Target, PName, Params); + if(Target != eGL_NONE) + m_Real.glTextureParameterivEXT(GetResourceManager()->GetLiveResource(id).name, Target, PName, Params); + else + m_Real.glTextureParameteriv(GetResourceManager()->GetLiveResource(id).name, PName, Params); } delete[] Params; @@ -1012,107 +1021,63 @@ bool WrappedOpenGL::Serialise_glTextureParameterivEXT(GLuint texture, GLenum tar return true; } +void WrappedOpenGL::Common_glTextureParameterivEXT(GLResourceRecord *record, GLenum target, GLenum pname, const GLint *params) +{ + if(!record) return; + + if(m_State != WRITING_CAPFRAME && m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end()) + return; + + SCOPED_SERIALISE_CONTEXT(TEXPARAMETERIV); + Serialise_glTextureParameterivEXT(record->Resource.name, eGL_NONE, pname, params); + + if(m_State == WRITING_CAPFRAME) + { + m_ContextRecord->AddChunk(scope.Get()); + } + else + { + record->AddChunk(scope.Get()); + record->UpdateCount++; + + if(record->UpdateCount > 12) + { + m_HighTrafficResources.insert(record->GetResourceID()); + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); + } + } +} + void WrappedOpenGL::glTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, const GLint *params) { m_Real.glTextureParameterivEXT(texture, target, pname, params); - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) - return; - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERIV); - Serialise_glTextureParameterivEXT(texture, target, pname, params); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 12) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } + if(m_State >= WRITING) + Common_glTextureParameterivEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), target, pname, params); +} + +void WrappedOpenGL::glTextureParameteriv(GLuint texture, GLenum pname, const GLint *params) +{ + m_Real.glTextureParameteriv(texture, pname, params); + + if(m_State >= WRITING) + Common_glTextureParameterivEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), eGL_NONE, pname, params); } void WrappedOpenGL::glTexParameteriv(GLenum target, GLenum pname, const GLint *params) { m_Real.glTexParameteriv(target, pname, params); - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - GLResource res = record->Resource; - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) - return; - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERIV); - Serialise_glTextureParameterivEXT(res.name, target, pname, params); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 12) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } + if(m_State >= WRITING) + Common_glTextureParameterivEXT(GetCtxData().GetActiveTexRecord(), target, pname, params); } void WrappedOpenGL::glMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint *params) { m_Real.glMultiTexParameterivEXT(texunit, target, pname, params); - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - GLResource res = record->Resource; - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) - return; - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERIV); - Serialise_glTextureParameterivEXT(res.name, target, pname, params); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 12) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } + if(m_State >= WRITING) + Common_glTextureParameterivEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0], target, pname, params); } bool WrappedOpenGL::Serialise_glTextureParameterIivEXT(GLuint texture, GLenum target, GLenum pname, const GLint *params) @@ -1125,7 +1090,10 @@ bool WrappedOpenGL::Serialise_glTextureParameterIivEXT(GLuint texture, GLenum ta if(m_State < WRITING) { - m_Real.glTextureParameterIivEXT(GetResourceManager()->GetLiveResource(id).name, Target, PName, Params); + if(Target != eGL_NONE) + m_Real.glTextureParameterIivEXT(GetResourceManager()->GetLiveResource(id).name, Target, PName, Params); + else + m_Real.glTextureParameterIiv(GetResourceManager()->GetLiveResource(id).name, PName, Params); } delete[] Params; @@ -1133,37 +1101,47 @@ bool WrappedOpenGL::Serialise_glTextureParameterIivEXT(GLuint texture, GLenum ta return true; } +void WrappedOpenGL::Common_glTextureParameterIivEXT(GLResourceRecord *record, GLenum target, GLenum pname, const GLint *params) +{ + if(!record) return; + + if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) + return; + + SCOPED_SERIALISE_CONTEXT(TEXPARAMETERIIV); + Serialise_glTextureParameterIivEXT(record->Resource.name, target, pname, params); + + if(m_State == WRITING_CAPFRAME) + { + m_ContextRecord->AddChunk(scope.Get()); + } + else + { + record->AddChunk(scope.Get()); + record->UpdateCount++; + + if(record->UpdateCount > 12) + { + m_HighTrafficResources.insert(record->GetResourceID()); + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); + } + } +} + void WrappedOpenGL::glTextureParameterIivEXT(GLuint texture, GLenum target, GLenum pname, const GLint *params) { m_Real.glTextureParameterIivEXT(texture, target, pname, params); if(m_State >= WRITING) - { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) - return; + Common_glTextureParameterIivEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), target, pname, params); +} - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERIIV); - Serialise_glTextureParameterIivEXT(texture, target, pname, params); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 12) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } +void WrappedOpenGL::glTextureParameterIiv(GLuint texture, GLenum pname, const GLint *params) +{ + m_Real.glTextureParameterIiv(texture, pname, params); + + if(m_State >= WRITING) + Common_glTextureParameterIivEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), eGL_NONE, pname, params); } void WrappedOpenGL::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params) @@ -1171,34 +1149,7 @@ void WrappedOpenGL::glTexParameterIiv(GLenum target, GLenum pname, const GLint * m_Real.glTexParameterIiv(target, pname, params); if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - GLResource res = record->Resource; - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) - return; - - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERIIV); - Serialise_glTextureParameterIivEXT(res.name, target, pname, params); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 12) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } + Common_glTextureParameterIivEXT(GetCtxData().GetActiveTexRecord(), target, pname, params); } void WrappedOpenGL::glMultiTexParameterIivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint *params) @@ -1206,34 +1157,7 @@ void WrappedOpenGL::glMultiTexParameterIivEXT(GLenum texunit, GLenum target, GLe m_Real.glMultiTexParameterIivEXT(texunit, target, pname, params); if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - GLResource res = record->Resource; - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) - return; - - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERIIV); - Serialise_glTextureParameterIivEXT(res.name, target, pname, params); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 12) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } + Common_glTextureParameterIivEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0], target, pname, params); } bool WrappedOpenGL::Serialise_glTextureParameterIuivEXT(GLuint texture, GLenum target, GLenum pname, const GLuint *params) @@ -1246,7 +1170,10 @@ bool WrappedOpenGL::Serialise_glTextureParameterIuivEXT(GLuint texture, GLenum t if(m_State < WRITING) { - m_Real.glTextureParameterIuivEXT(GetResourceManager()->GetLiveResource(id).name, Target, PName, Params); + if(Target != eGL_NONE) + m_Real.glTextureParameterIuivEXT(GetResourceManager()->GetLiveResource(id).name, Target, PName, Params); + else + m_Real.glTextureParameterIuiv(GetResourceManager()->GetLiveResource(id).name, PName, Params); } delete[] Params; @@ -1254,37 +1181,47 @@ bool WrappedOpenGL::Serialise_glTextureParameterIuivEXT(GLuint texture, GLenum t return true; } +void WrappedOpenGL::Common_glTextureParameterIuivEXT(GLResourceRecord *record, GLenum target, GLenum pname, const GLuint *params) +{ + if(!record) return; + + if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) + return; + + SCOPED_SERIALISE_CONTEXT(TEXPARAMETERIUIV); + Serialise_glTextureParameterIuivEXT(record->Resource.name, target, pname, params); + + if(m_State == WRITING_CAPFRAME) + { + m_ContextRecord->AddChunk(scope.Get()); + } + else + { + record->AddChunk(scope.Get()); + record->UpdateCount++; + + if(record->UpdateCount > 12) + { + m_HighTrafficResources.insert(record->GetResourceID()); + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); + } + } +} + void WrappedOpenGL::glTextureParameterIuivEXT(GLuint texture, GLenum target, GLenum pname, const GLuint *params) { m_Real.glTextureParameterIuivEXT(texture, target, pname, params); if(m_State >= WRITING) - { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) - return; + Common_glTextureParameterIuivEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), target, pname, params); +} - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERIUIV); - Serialise_glTextureParameterIuivEXT(texture, target, pname, params); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 12) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } +void WrappedOpenGL::glTextureParameterIuiv(GLuint texture, GLenum pname, const GLuint *params) +{ + m_Real.glTextureParameterIuiv(texture, pname, params); + + if(m_State >= WRITING) + Common_glTextureParameterIuivEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), eGL_NONE, pname, params); } void WrappedOpenGL::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params) @@ -1292,34 +1229,7 @@ void WrappedOpenGL::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint m_Real.glTexParameterIuiv(target, pname, params); if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - GLResource res = record->Resource; - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) - return; - - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERIUIV); - Serialise_glTextureParameterIuivEXT(res.name, target, pname, params); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 12) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } + Common_glTextureParameterIuivEXT(GetCtxData().GetActiveTexRecord(), target, pname, params); } void WrappedOpenGL::glMultiTexParameterIuivEXT(GLenum texunit, GLenum target, GLenum pname, const GLuint *params) @@ -1327,34 +1237,7 @@ void WrappedOpenGL::glMultiTexParameterIuivEXT(GLenum texunit, GLenum target, GL m_Real.glMultiTexParameterIuivEXT(texunit, target, pname, params); if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - GLResource res = record->Resource; - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) - return; - - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERIUIV); - Serialise_glTextureParameterIuivEXT(res.name, target, pname, params); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 12) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } + Common_glTextureParameterIuivEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0], target, pname, params); } bool WrappedOpenGL::Serialise_glTextureParameterfEXT(GLuint texture, GLenum target, GLenum pname, GLfloat param) @@ -1366,43 +1249,56 @@ bool WrappedOpenGL::Serialise_glTextureParameterfEXT(GLuint texture, GLenum targ if(m_State < WRITING) { - m_Real.glTextureParameterfEXT(GetResourceManager()->GetLiveResource(id).name, Target, PName, Param); + if(Target != eGL_NONE) + m_Real.glTextureParameterfEXT(GetResourceManager()->GetLiveResource(id).name, Target, PName, Param); + else + m_Real.glTextureParameterf(GetResourceManager()->GetLiveResource(id).name, PName, Param); } return true; } +void WrappedOpenGL::Common_glTextureParameterfEXT(GLResourceRecord *record, GLenum target, GLenum pname, GLfloat param) +{ + if(!record) return; + + if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) + return; + + SCOPED_SERIALISE_CONTEXT(TEXPARAMETERF); + Serialise_glTextureParameterfEXT(record->Resource.name, target, pname, param); + + if(m_State == WRITING_CAPFRAME) + { + m_ContextRecord->AddChunk(scope.Get()); + } + else + { + record->AddChunk(scope.Get()); + record->UpdateCount++; + + if(record->UpdateCount > 12) + { + m_HighTrafficResources.insert(record->GetResourceID()); + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); + } + } +} + void WrappedOpenGL::glTextureParameterfEXT(GLuint texture, GLenum target, GLenum pname, GLfloat param) { m_Real.glTextureParameterfEXT(texture, target, pname, param); if(m_State >= WRITING) - { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) - return; + Common_glTextureParameterfEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), target, pname, param); +} - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERF); - Serialise_glTextureParameterfEXT(texture, target, pname, param); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 12) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } +void WrappedOpenGL::glTextureParameterf(GLuint texture, GLenum pname, GLfloat param) +{ + m_Real.glTextureParameterf(texture, pname, param); + + if(m_State >= WRITING) + Common_glTextureParameterfEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), eGL_NONE, pname, param); } void WrappedOpenGL::glTexParameterf(GLenum target, GLenum pname, GLfloat param) @@ -1410,34 +1306,7 @@ void WrappedOpenGL::glTexParameterf(GLenum target, GLenum pname, GLfloat param) m_Real.glTexParameterf(target, pname, param); if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - GLResource res = record->Resource; - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) - return; - - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERF); - Serialise_glTextureParameterfEXT(res.name, target, pname, param); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 12) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } + Common_glTextureParameterfEXT(GetCtxData().GetActiveTexRecord(), target, pname, param); } void WrappedOpenGL::glMultiTexParameterfEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat param) @@ -1445,34 +1314,7 @@ void WrappedOpenGL::glMultiTexParameterfEXT(GLenum texunit, GLenum target, GLenu m_Real.glMultiTexParameterfEXT(texunit, target, pname, param); if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - GLResource res = record->Resource; - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) - return; - - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERF); - Serialise_glTextureParameterfEXT(res.name, target, pname, param); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 12) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } + Common_glTextureParameterfEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0], target, pname, param); } bool WrappedOpenGL::Serialise_glTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, const GLfloat *params) @@ -1485,7 +1327,10 @@ bool WrappedOpenGL::Serialise_glTextureParameterfvEXT(GLuint texture, GLenum tar if(m_State < WRITING) { - m_Real.glTextureParameterfvEXT(GetResourceManager()->GetLiveResource(id).name, Target, PName, Params); + if(Target != eGL_NONE) + m_Real.glTextureParameterfvEXT(GetResourceManager()->GetLiveResource(id).name, Target, PName, Params); + else + m_Real.glTextureParameterfv(GetResourceManager()->GetLiveResource(id).name, PName, Params); } delete[] Params; @@ -1493,37 +1338,47 @@ bool WrappedOpenGL::Serialise_glTextureParameterfvEXT(GLuint texture, GLenum tar return true; } +void WrappedOpenGL::Common_glTextureParameterfvEXT(GLResourceRecord *record, GLenum target, GLenum pname, const GLfloat *params) +{ + if(!record) return; + + if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) + return; + + SCOPED_SERIALISE_CONTEXT(TEXPARAMETERFV); + Serialise_glTextureParameterfvEXT(record->Resource.name, target, pname, params); + + if(m_State == WRITING_CAPFRAME) + { + m_ContextRecord->AddChunk(scope.Get()); + } + else + { + record->AddChunk(scope.Get()); + record->UpdateCount++; + + if(record->UpdateCount > 12) + { + m_HighTrafficResources.insert(record->GetResourceID()); + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); + } + } +} + void WrappedOpenGL::glTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, const GLfloat *params) { m_Real.glTextureParameterfvEXT(texture, target, pname, params); if(m_State >= WRITING) - { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) - return; + Common_glTextureParameterfvEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), target, pname, params); +} - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERFV); - Serialise_glTextureParameterfvEXT(texture, target, pname, params); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 12) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } +void WrappedOpenGL::glTextureParameterfv(GLuint texture, GLenum pname, const GLfloat *params) +{ + m_Real.glTextureParameterfv(texture, pname, params); + + if(m_State >= WRITING) + Common_glTextureParameterfvEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), eGL_NONE, pname, params); } void WrappedOpenGL::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) @@ -1531,34 +1386,7 @@ void WrappedOpenGL::glTexParameterfv(GLenum target, GLenum pname, const GLfloat m_Real.glTexParameterfv(target, pname, params); if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - GLResource res = record->Resource; - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) - return; - - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERFV); - Serialise_glTextureParameterfvEXT(res.name, target, pname, params); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 12) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } + Common_glTextureParameterfvEXT(GetCtxData().GetActiveTexRecord(), target, pname, params); } void WrappedOpenGL::glMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, const GLfloat *params) @@ -1566,34 +1394,7 @@ void WrappedOpenGL::glMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLen m_Real.glMultiTexParameterfvEXT(texunit, target, pname, params); if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - GLResource res = record->Resource; - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State != WRITING_CAPFRAME) - return; - - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERFV); - Serialise_glTextureParameterfvEXT(res.name, target, pname, params); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 12) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } + Common_glTextureParameterfvEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0], target, pname, params); } bool WrappedOpenGL::Serialise_glPixelStorei(GLenum pname, GLint param) @@ -1710,7 +1511,7 @@ bool WrappedOpenGL::Serialise_glTextureImage1DEXT(GLuint texture, GLenum target, m_Textures[liveId].width = Width; m_Textures[liveId].height = 1; m_Textures[liveId].depth = 1; - m_Textures[liveId].curType = TextureTarget(Target); + if(Target != eGL_NONE) m_Textures[liveId].curType = TextureTarget(Target); m_Textures[liveId].dimension = 1; m_Textures[liveId].internalFormat = IntFormat; } @@ -1732,10 +1533,10 @@ bool WrappedOpenGL::Serialise_glTextureImage1DEXT(GLuint texture, GLenum target, return true; } -void WrappedOpenGL::glTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels) +void WrappedOpenGL::Common_glTextureImage1DEXT(ResourceId texId, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels) { - m_Real.glTextureImage1DEXT(texture, target, level, internalformat, width, border, format, type, pixels); - + if(texId == ResourceId()) return; + // proxy formats are used for querying texture capabilities, don't serialise these if(IsProxyTarget(target) || internalformat == 0) return; @@ -1747,12 +1548,12 @@ void WrappedOpenGL::glTextureImage1DEXT(GLuint texture, GLenum target, GLint lev m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); fromunpackbuf = (unpackbuf != 0); } - + if(m_State >= WRITING) { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(texId); RDCASSERT(record); - + // This is kind of an arbitary heuristic, but in the past a game has re-specified a texture with glTexImage over and over // so we need to attempt to catch the case where glTexImage is called to re-upload data, not actually re-create it. // Ideally we'd check for non-zero levels, but that would complicate the condition @@ -1778,138 +1579,42 @@ void WrappedOpenGL::glTextureImage1DEXT(GLuint texture, GLenum target, GLint lev if(level == 0) { - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - m_Textures[texId].width = width; m_Textures[texId].height = 1; m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); + if(target != eGL_NONE) m_Textures[texId].curType = TextureTarget(target); m_Textures[texId].dimension = 1; m_Textures[texId].internalFormat = (GLenum)internalformat; } } +void WrappedOpenGL::glTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels) +{ + m_Real.glTextureImage1DEXT(texture, target, level, internalformat, width, border, format, type, pixels); + + Common_glTextureImage1DEXT(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)), target, level, internalformat, width, border, format, type, pixels); +} + void WrappedOpenGL::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels) { m_Real.glTexImage1D(target, level, internalformat, width, border, format, type, pixels); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(target) || internalformat == 0) return; - - internalformat = GetSizedFormat(m_Real, target, (GLenum)internalformat); + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - bool fromunpackbuf = false; - { - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - fromunpackbuf = (unpackbuf != 0); - } - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - // This is kind of an arbitary heuristic, but in the past a game has re-specified a texture with glTexImage over and over - // so we need to attempt to catch the case where glTexImage is called to re-upload data, not actually re-create it. - // Ideally we'd check for non-zero levels, but that would complicate the condition - // if we're uploading new data but otherwise everything is identical, ignore this chunk and simply mark the texture dirty - if(record->AlreadyDataType(target) && level == 0 && - m_Textures[record->GetResourceID()].width == width && - m_Textures[record->GetResourceID()].internalFormat == (GLenum)internalformat) - { - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - else - { - SCOPED_SERIALISE_CONTEXT(TEXIMAGE1D); - Serialise_glTextureImage1DEXT(record->Resource.name, - target, level, internalformat, width, border, format, type, fromunpackbuf ? NULL : pixels); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - - if(fromunpackbuf) - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - - if(level == 0) - { - ResourceId texId = GetResourceManager()->GetID(GetCtxData().GetActiveTexRecord()->Resource); - - m_Textures[texId].width = width; - m_Textures[texId].height = 1; - m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 1; - m_Textures[texId].internalFormat = (GLenum)internalformat; - } + Common_glTextureImage1DEXT(GetCtxData().GetActiveTexRecord()->GetResourceID(), target, level, internalformat, width, border, format, type, pixels); } void WrappedOpenGL::glMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels) { m_Real.glMultiTexImage1DEXT(texunit, target, level, internalformat, width, border, format, type, pixels); - - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(target) || internalformat == 0) return; - internalformat = GetSizedFormat(m_Real, target, (GLenum)internalformat); + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - bool fromunpackbuf = false; - { - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - fromunpackbuf = (unpackbuf != 0); - } - - GLuint texture = 0; - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - texture = record->Resource.name; - - // This is kind of an arbitary heuristic, but in the past a game has re-specified a texture with glTexImage over and over - // so we need to attempt to catch the case where glTexImage is called to re-upload data, not actually re-create it. - // Ideally we'd check for non-zero levels, but that would complicate the condition - // if we're uploading new data but otherwise everything is identical, ignore this chunk and simply mark the texture dirty - if(record->AlreadyDataType(target) && level == 0 && - m_Textures[record->GetResourceID()].width == width && - m_Textures[record->GetResourceID()].internalFormat == (GLenum)internalformat) - { - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - else - { - SCOPED_SERIALISE_CONTEXT(TEXIMAGE1D); - Serialise_glTextureImage1DEXT(texture, target, level, internalformat, width, border, format, type, fromunpackbuf ? NULL : pixels); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - - if(fromunpackbuf) - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - - if(level == 0) - { - ResourceId texId = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->GetResourceID(); - - m_Textures[texId].width = width; - m_Textures[texId].height = 1; - m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 1; - m_Textures[texId].internalFormat = (GLenum)internalformat; - } + Common_glTextureImage1DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->GetResourceID(), target, level, internalformat, width, border, format, type, pixels); } bool WrappedOpenGL::Serialise_glTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) @@ -1954,7 +1659,7 @@ bool WrappedOpenGL::Serialise_glTextureImage2DEXT(GLuint texture, GLenum target, m_Textures[liveId].width = Width; m_Textures[liveId].height = Height; m_Textures[liveId].depth = 1; - m_Textures[liveId].curType = TextureTarget(Target); + if(Target != eGL_NONE) m_Textures[liveId].curType = TextureTarget(Target); m_Textures[liveId].dimension = 2; m_Textures[liveId].internalFormat = IntFormat; } @@ -1998,9 +1703,9 @@ bool WrappedOpenGL::Serialise_glTextureImage2DEXT(GLuint texture, GLenum target, return true; } -void WrappedOpenGL::glTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) +void WrappedOpenGL::Common_glTextureImage2DEXT(ResourceId texId, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) { - m_Real.glTextureImage2DEXT(texture, target, level, internalformat, width, height, border, format, type, pixels); + if(texId == ResourceId()) return; // proxy formats are used for querying texture capabilities, don't serialise these if(IsProxyTarget(target) || internalformat == 0) return; @@ -2013,10 +1718,10 @@ void WrappedOpenGL::glTextureImage2DEXT(GLuint texture, GLenum target, GLint lev m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); fromunpackbuf = (unpackbuf != 0); } - + if(m_State >= WRITING) { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(texId); RDCASSERT(record); // This is kind of an arbitary heuristic, but in the past a game has re-specified a texture with glTexImage over and over @@ -2048,140 +1753,42 @@ void WrappedOpenGL::glTextureImage2DEXT(GLuint texture, GLenum target, GLint lev if(level == 0) { - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - m_Textures[texId].width = width; m_Textures[texId].height = height; m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); + if(target != eGL_NONE) m_Textures[texId].curType = TextureTarget(target); m_Textures[texId].dimension = 2; m_Textures[texId].internalFormat = (GLenum)internalformat; } } +void WrappedOpenGL::glTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) +{ + m_Real.glTextureImage2DEXT(texture, target, level, internalformat, width, height, border, format, type, pixels); + + Common_glTextureImage2DEXT(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)), target, level, internalformat, width, height, border, format, type, pixels); +} + void WrappedOpenGL::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels) { m_Real.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(target) || internalformat == 0) return; + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - internalformat = GetSizedFormat(m_Real, target, (GLenum)internalformat); - - bool fromunpackbuf = false; - { - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - fromunpackbuf = (unpackbuf != 0); - } - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - // This is kind of an arbitary heuristic, but in the past a game has re-specified a texture with glTexImage over and over - // so we need to attempt to catch the case where glTexImage is called to re-upload data, not actually re-create it. - // Ideally we'd check for non-zero levels, but that would complicate the condition - // if we're uploading new data but otherwise everything is identical, ignore this chunk and simply mark the texture dirty - if(record->AlreadyDataType(target) && level == 0 && - m_Textures[record->GetResourceID()].width == width && - m_Textures[record->GetResourceID()].height == height && - m_Textures[record->GetResourceID()].internalFormat == (GLenum)internalformat) - { - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - else - { - SCOPED_SERIALISE_CONTEXT(TEXIMAGE2D); - Serialise_glTextureImage2DEXT(record->Resource.name, - target, level, internalformat, width, height, border, format, type, fromunpackbuf ? NULL : pixels); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - - if(fromunpackbuf) - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - - if(level == 0) - { - ResourceId texId = GetResourceManager()->GetID(GetCtxData().GetActiveTexRecord()->Resource); - - m_Textures[texId].width = width; - m_Textures[texId].height = height; - m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 2; - m_Textures[texId].internalFormat = (GLenum)internalformat; - } + Common_glTextureImage2DEXT(GetCtxData().GetActiveTexRecord()->GetResourceID(), target, level, internalformat, width, height, border, format, type, pixels); } void WrappedOpenGL::glMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels) { m_Real.glMultiTexImage2DEXT(texunit, target, level, internalformat, width, height, border, format, type, pixels); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(target) || internalformat == 0) return; + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - internalformat = GetSizedFormat(m_Real, target, (GLenum)internalformat); - - bool fromunpackbuf = false; - { - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - fromunpackbuf = (unpackbuf != 0); - } - - GLuint texture = 0; - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - texture = record->Resource.name; - - // This is kind of an arbitary heuristic, but in the past a game has re-specified a texture with glTexImage over and over - // so we need to attempt to catch the case where glTexImage is called to re-upload data, not actually re-create it. - // Ideally we'd check for non-zero levels, but that would complicate the condition - // if we're uploading new data but otherwise everything is identical, ignore this chunk and simply mark the texture dirty - if(record->AlreadyDataType(target) && level == 0 && - m_Textures[record->GetResourceID()].width == width && - m_Textures[record->GetResourceID()].height == height && - m_Textures[record->GetResourceID()].internalFormat == (GLenum)internalformat) - { - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - else - { - SCOPED_SERIALISE_CONTEXT(TEXIMAGE2D); - Serialise_glTextureImage2DEXT(texture, target, level, internalformat, width, height, border, format, type, fromunpackbuf ? NULL : pixels); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - - if(fromunpackbuf) - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - - if(level == 0) - { - ResourceId texId = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->GetResourceID(); - - m_Textures[texId].width = width; - m_Textures[texId].height = height; - m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 2; - m_Textures[texId].internalFormat = (GLenum)internalformat; - } + Common_glTextureImage2DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->GetResourceID(), target, level, internalformat, width, height, border, format, type, pixels); } bool WrappedOpenGL::Serialise_glTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels) @@ -2227,7 +1834,7 @@ bool WrappedOpenGL::Serialise_glTextureImage3DEXT(GLuint texture, GLenum target, m_Textures[liveId].width = Width; m_Textures[liveId].height = Height; m_Textures[liveId].depth = Depth; - m_Textures[liveId].curType = TextureTarget(Target); + if(Target != eGL_NONE) m_Textures[liveId].curType = TextureTarget(Target); m_Textures[liveId].dimension = 3; m_Textures[liveId].internalFormat = IntFormat; } @@ -2249,9 +1856,9 @@ bool WrappedOpenGL::Serialise_glTextureImage3DEXT(GLuint texture, GLenum target, return true; } -void WrappedOpenGL::glTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels) +void WrappedOpenGL::Common_glTextureImage3DEXT(ResourceId texId, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels) { - m_Real.glTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, format, type, pixels); + if(texId == ResourceId()) return; // proxy formats are used for querying texture capabilities, don't serialise these if(IsProxyTarget(target) || internalformat == 0) return; @@ -2264,10 +1871,10 @@ void WrappedOpenGL::glTextureImage3DEXT(GLuint texture, GLenum target, GLint lev m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); fromunpackbuf = (unpackbuf != 0); } - + if(m_State >= WRITING) { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(texId); RDCASSERT(record); // This is kind of an arbitary heuristic, but in the past a game has re-specified a texture with glTexImage over and over @@ -2300,142 +1907,42 @@ void WrappedOpenGL::glTextureImage3DEXT(GLuint texture, GLenum target, GLint lev if(level == 0) { - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - m_Textures[texId].width = width; m_Textures[texId].height = height; m_Textures[texId].depth = depth; - m_Textures[texId].curType = TextureTarget(target); + if(target != eGL_NONE) m_Textures[texId].curType = TextureTarget(target); m_Textures[texId].dimension = 3; m_Textures[texId].internalFormat = (GLenum)internalformat; } } +void WrappedOpenGL::glTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels) +{ + m_Real.glTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, format, type, pixels); + + Common_glTextureImage3DEXT(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)), target, level, internalformat, width, height, depth, border, format, type, pixels); +} + void WrappedOpenGL::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels) { m_Real.glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(target) || internalformat == 0) return; - - internalformat = GetSizedFormat(m_Real, target, (GLenum)internalformat); + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - bool fromunpackbuf = false; - { - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - fromunpackbuf = (unpackbuf != 0); - } - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - // This is kind of an arbitary heuristic, but in the past a game has re-specified a texture with glTexImage over and over - // so we need to attempt to catch the case where glTexImage is called to re-upload data, not actually re-create it. - // Ideally we'd check for non-zero levels, but that would complicate the condition - // if we're uploading new data but otherwise everything is identical, ignore this chunk and simply mark the texture dirty - if(record->AlreadyDataType(target) && level == 0 && - m_Textures[record->GetResourceID()].width == width && - m_Textures[record->GetResourceID()].height == height && - m_Textures[record->GetResourceID()].depth == depth && - m_Textures[record->GetResourceID()].internalFormat == (GLenum)internalformat) - { - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - else - { - SCOPED_SERIALISE_CONTEXT(TEXIMAGE3D); - Serialise_glTextureImage3DEXT(record->Resource.name, - target, level, internalformat, width, height, depth, border, format, type, fromunpackbuf ? NULL : pixels); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - - if(fromunpackbuf) - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - - if(level == 0) - { - ResourceId texId = GetResourceManager()->GetID(GetCtxData().GetActiveTexRecord()->Resource); - - m_Textures[texId].width = width; - m_Textures[texId].height = height; - m_Textures[texId].depth = depth; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 3; - m_Textures[texId].internalFormat = (GLenum)internalformat; - } + Common_glTextureImage3DEXT(GetCtxData().GetActiveTexRecord()->GetResourceID(), target, level, internalformat, width, height, depth, border, format, type, pixels); } void WrappedOpenGL::glMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels) { m_Real.glMultiTexImage3DEXT(texunit, target, level, internalformat, width, height, depth, border, format, type, pixels); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(target) || internalformat == 0) return; - - internalformat = GetSizedFormat(m_Real, target, (GLenum)internalformat); + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - bool fromunpackbuf = false; - { - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - fromunpackbuf = (unpackbuf != 0); - } - - GLuint texture = 0; - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - texture = record->Resource.name; - - // This is kind of an arbitary heuristic, but in the past a game has re-specified a texture with glTexImage over and over - // so we need to attempt to catch the case where glTexImage is called to re-upload data, not actually re-create it. - // Ideally we'd check for non-zero levels, but that would complicate the condition - // if we're uploading new data but otherwise everything is identical, ignore this chunk and simply mark the texture dirty - if(record->AlreadyDataType(target) && level == 0 && - m_Textures[record->GetResourceID()].width == width && - m_Textures[record->GetResourceID()].height == height && - m_Textures[record->GetResourceID()].depth == depth && - m_Textures[record->GetResourceID()].internalFormat == (GLenum)internalformat) - { - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - else - { - SCOPED_SERIALISE_CONTEXT(TEXIMAGE3D); - Serialise_glTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, format, type, fromunpackbuf ? NULL : pixels); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - - if(fromunpackbuf) - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - - if(level == 0) - { - ResourceId texId = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->GetResourceID(); - - m_Textures[texId].width = width; - m_Textures[texId].height = height; - m_Textures[texId].depth = depth; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 3; - m_Textures[texId].internalFormat = (GLenum)internalformat; - } + Common_glTextureImage3DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->GetResourceID(), target, level, internalformat, width, height, depth, border, format, type, pixels); } bool WrappedOpenGL::Serialise_glCompressedTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *pixels) @@ -2486,7 +1993,7 @@ bool WrappedOpenGL::Serialise_glCompressedTextureImage1DEXT(GLuint texture, GLen m_Textures[liveId].width = Width; m_Textures[liveId].height = 1; m_Textures[liveId].depth = 1; - m_Textures[liveId].curType = TextureTarget(Target); + if(Target != eGL_NONE) m_Textures[liveId].curType = TextureTarget(Target); m_Textures[liveId].dimension = 1; m_Textures[liveId].internalFormat = fmt; } @@ -2508,9 +2015,9 @@ bool WrappedOpenGL::Serialise_glCompressedTextureImage1DEXT(GLuint texture, GLen return true; } -void WrappedOpenGL::glCompressedTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *pixels) +void WrappedOpenGL::Common_glCompressedTextureImage1DEXT(ResourceId texId, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *pixels) { - m_Real.glCompressedTextureImage1DEXT(texture, target, level, internalformat, width, border, imageSize, pixels); + if(texId == ResourceId()) return; // proxy formats are used for querying texture capabilities, don't serialise these if(IsProxyTarget(target) || internalformat == 0) return; @@ -2523,10 +2030,10 @@ void WrappedOpenGL::glCompressedTextureImage1DEXT(GLuint texture, GLenum target, m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); fromunpackbuf = (unpackbuf != 0); } - + if(m_State >= WRITING) { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(texId); RDCASSERT(record); // This is kind of an arbitary heuristic, but in the past a game has re-specified a texture with glTexImage over and over @@ -2557,138 +2064,42 @@ void WrappedOpenGL::glCompressedTextureImage1DEXT(GLuint texture, GLenum target, if(level == 0) { - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - m_Textures[texId].width = width; m_Textures[texId].height = 1; m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); + if(target != eGL_NONE) m_Textures[texId].curType = TextureTarget(target); m_Textures[texId].dimension = 1; m_Textures[texId].internalFormat = internalformat; } } +void WrappedOpenGL::glCompressedTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *pixels) +{ + m_Real.glCompressedTextureImage1DEXT(texture, target, level, internalformat, width, border, imageSize, pixels); + + Common_glCompressedTextureImage1DEXT(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)), target, level, internalformat, width, border, imageSize, pixels); +} + void WrappedOpenGL::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *pixels) { m_Real.glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, pixels); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(target) || internalformat == 0) return; - - internalformat = GetSizedFormat(m_Real, target, internalformat); + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - bool fromunpackbuf = false; - { - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - fromunpackbuf = (unpackbuf != 0); - } - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - // This is kind of an arbitary heuristic, but in the past a game has re-specified a texture with glTexImage over and over - // so we need to attempt to catch the case where glTexImage is called to re-upload data, not actually re-create it. - // Ideally we'd check for non-zero levels, but that would complicate the condition - // if we're uploading new data but otherwise everything is identical, ignore this chunk and simply mark the texture dirty - if(record->AlreadyDataType(target) && level == 0 && - m_Textures[record->GetResourceID()].width == width && - m_Textures[record->GetResourceID()].internalFormat == (GLenum)internalformat) - { - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - else - { - SCOPED_SERIALISE_CONTEXT(TEXIMAGE1D_COMPRESSED); - Serialise_glCompressedTextureImage1DEXT(record->Resource.name, - target, level, internalformat, width, border, imageSize, fromunpackbuf ? NULL : pixels); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - - if(fromunpackbuf) - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - - if(level == 0) - { - ResourceId texId = GetResourceManager()->GetID(GetCtxData().GetActiveTexRecord()->Resource); - - m_Textures[texId].width = width; - m_Textures[texId].height = 1; - m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 1; - m_Textures[texId].internalFormat = internalformat; - } + Common_glCompressedTextureImage1DEXT(GetCtxData().GetActiveTexRecord()->GetResourceID(), target, level, internalformat, width, border, imageSize, pixels); } void WrappedOpenGL::glCompressedMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *pixels) { m_Real.glCompressedMultiTexImage1DEXT(texunit, target, level, internalformat, width, border, imageSize, pixels); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(target) || internalformat == 0) return; - - internalformat = GetSizedFormat(m_Real, target, internalformat); + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - bool fromunpackbuf = false; - { - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - fromunpackbuf = (unpackbuf != 0); - } - - GLuint texture = 0; - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - texture = record->Resource.name; - - // This is kind of an arbitary heuristic, but in the past a game has re-specified a texture with glTexImage over and over - // so we need to attempt to catch the case where glTexImage is called to re-upload data, not actually re-create it. - // Ideally we'd check for non-zero levels, but that would complicate the condition - // if we're uploading new data but otherwise everything is identical, ignore this chunk and simply mark the texture dirty - if(record->AlreadyDataType(target) && level == 0 && - m_Textures[record->GetResourceID()].width == width && - m_Textures[record->GetResourceID()].internalFormat == (GLenum)internalformat) - { - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - else - { - SCOPED_SERIALISE_CONTEXT(TEXIMAGE1D_COMPRESSED); - Serialise_glCompressedTextureImage1DEXT(texture, target, level, internalformat, width, border, imageSize, fromunpackbuf ? NULL : pixels); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - - if(fromunpackbuf) - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - - if(level == 0) - { - ResourceId texId = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->GetResourceID(); - - m_Textures[texId].width = width; - m_Textures[texId].height = 1; - m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 1; - m_Textures[texId].internalFormat = internalformat; - } + Common_glCompressedTextureImage1DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->GetResourceID(), target, level, internalformat, width, border, imageSize, pixels); } bool WrappedOpenGL::Serialise_glCompressedTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * pixels) @@ -2740,7 +2151,7 @@ bool WrappedOpenGL::Serialise_glCompressedTextureImage2DEXT(GLuint texture, GLen m_Textures[liveId].width = Width; m_Textures[liveId].height = Height; m_Textures[liveId].depth = 1; - m_Textures[liveId].curType = TextureTarget(Target); + if(Target != eGL_NONE) m_Textures[liveId].curType = TextureTarget(Target); m_Textures[liveId].dimension = 2; m_Textures[liveId].internalFormat = fmt; } @@ -2784,9 +2195,9 @@ bool WrappedOpenGL::Serialise_glCompressedTextureImage2DEXT(GLuint texture, GLen return true; } -void WrappedOpenGL::glCompressedTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * pixels) +void WrappedOpenGL::Common_glCompressedTextureImage2DEXT(ResourceId texId, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *pixels) { - m_Real.glCompressedTextureImage2DEXT(texture, target, level, internalformat, width, height, border, imageSize, pixels); + if(texId == ResourceId()) return; // proxy formats are used for querying texture capabilities, don't serialise these if(IsProxyTarget(target) || internalformat == 0) return; @@ -2799,10 +2210,10 @@ void WrappedOpenGL::glCompressedTextureImage2DEXT(GLuint texture, GLenum target, m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); fromunpackbuf = (unpackbuf != 0); } - + if(m_State >= WRITING) { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(texId); RDCASSERT(record); // This is kind of an arbitary heuristic, but in the past a game has re-specified a texture with glTexImage over and over @@ -2834,140 +2245,42 @@ void WrappedOpenGL::glCompressedTextureImage2DEXT(GLuint texture, GLenum target, if(level == 0) { - GLuint texture = 0; - m_Real.glGetIntegerv(TextureBinding(target), (GLint *)&texture); - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - m_Textures[texId].width = width; m_Textures[texId].height = height; m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); + if(target != eGL_NONE) m_Textures[texId].curType = TextureTarget(target); m_Textures[texId].dimension = 2; m_Textures[texId].internalFormat = internalformat; } } +void WrappedOpenGL::glCompressedTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * pixels) +{ + m_Real.glCompressedTextureImage2DEXT(texture, target, level, internalformat, width, height, border, imageSize, pixels); + + Common_glCompressedTextureImage2DEXT(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)), target, level, internalformat, width, height, border, imageSize, pixels); +} + void WrappedOpenGL::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * pixels) { m_Real.glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, pixels); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(target) || internalformat == 0) return; - - internalformat = GetSizedFormat(m_Real, target, internalformat); + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - bool fromunpackbuf = false; - { - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - fromunpackbuf = (unpackbuf != 0); - } - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - // This is kind of an arbitary heuristic, but in the past a game has re-specified a texture with glTexImage over and over - // so we need to attempt to catch the case where glTexImage is called to re-upload data, not actually re-create it. - // Ideally we'd check for non-zero levels, but that would complicate the condition - // if we're uploading new data but otherwise everything is identical, ignore this chunk and simply mark the texture dirty - if(record->AlreadyDataType(target) && level == 0 && - m_Textures[record->GetResourceID()].width == width && - m_Textures[record->GetResourceID()].height == height && - m_Textures[record->GetResourceID()].internalFormat == (GLenum)internalformat) - { - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - else - { - SCOPED_SERIALISE_CONTEXT(TEXIMAGE2D_COMPRESSED); - Serialise_glCompressedTextureImage2DEXT(record->Resource.name, - target, level, internalformat, width, height, border, imageSize, fromunpackbuf ? NULL : pixels); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - - if(fromunpackbuf) - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - - if(level == 0) - { - ResourceId texId = GetResourceManager()->GetID(GetCtxData().GetActiveTexRecord()->Resource); - - m_Textures[texId].width = width; - m_Textures[texId].height = height; - m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 2; - m_Textures[texId].internalFormat = internalformat; - } + Common_glCompressedTextureImage2DEXT(GetCtxData().GetActiveTexRecord()->GetResourceID(), target, level, internalformat, width, height, border, imageSize, pixels); } void WrappedOpenGL::glCompressedMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * pixels) { m_Real.glCompressedMultiTexImage2DEXT(texunit, target, level, internalformat, width, height, border, imageSize, pixels); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(target) || internalformat == 0) return; - - internalformat = GetSizedFormat(m_Real, target, internalformat); + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - bool fromunpackbuf = false; - { - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - fromunpackbuf = (unpackbuf != 0); - } - - GLuint texture = 0; - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - // This is kind of an arbitary heuristic, but in the past a game has re-specified a texture with glTexImage over and over - // so we need to attempt to catch the case where glTexImage is called to re-upload data, not actually re-create it. - // Ideally we'd check for non-zero levels, but that would complicate the condition - // if we're uploading new data but otherwise everything is identical, ignore this chunk and simply mark the texture dirty - if(record->AlreadyDataType(target) && level == 0 && - m_Textures[record->GetResourceID()].width == width && - m_Textures[record->GetResourceID()].height == height && - m_Textures[record->GetResourceID()].internalFormat == (GLenum)internalformat) - { - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - else - { - SCOPED_SERIALISE_CONTEXT(TEXIMAGE2D_COMPRESSED); - Serialise_glCompressedTextureImage2DEXT(texture, target, level, internalformat, width, height, border, imageSize, fromunpackbuf ? NULL : pixels); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - - if(fromunpackbuf) - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - - if(level == 0) - { - ResourceId texId = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->GetResourceID(); - - m_Textures[texId].width = width; - m_Textures[texId].height = height; - m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 2; - m_Textures[texId].internalFormat = internalformat; - } + Common_glCompressedTextureImage2DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->GetResourceID(), target, level, internalformat, width, height, border, imageSize, pixels); } bool WrappedOpenGL::Serialise_glCompressedTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * pixels) @@ -3020,7 +2333,7 @@ bool WrappedOpenGL::Serialise_glCompressedTextureImage3DEXT(GLuint texture, GLen m_Textures[liveId].width = Width; m_Textures[liveId].height = Height; m_Textures[liveId].depth = Depth; - m_Textures[liveId].curType = TextureTarget(Target); + if(Target != eGL_NONE) m_Textures[liveId].curType = TextureTarget(Target); m_Textures[liveId].dimension = 3; m_Textures[liveId].internalFormat = fmt; } @@ -3042,9 +2355,9 @@ bool WrappedOpenGL::Serialise_glCompressedTextureImage3DEXT(GLuint texture, GLen return true; } -void WrappedOpenGL::glCompressedTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *pixels) +void WrappedOpenGL::Common_glCompressedTextureImage3DEXT(ResourceId texId, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *pixels) { - m_Real.glCompressedTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, imageSize, pixels); + if(texId == ResourceId()) return; // proxy formats are used for querying texture capabilities, don't serialise these if(IsProxyTarget(target) || internalformat == 0) return; @@ -3060,7 +2373,7 @@ void WrappedOpenGL::glCompressedTextureImage3DEXT(GLuint texture, GLenum target, if(m_State >= WRITING) { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(texId); RDCASSERT(record); // This is kind of an arbitary heuristic, but in the past a game has re-specified a texture with glTexImage over and over @@ -3093,142 +2406,42 @@ void WrappedOpenGL::glCompressedTextureImage3DEXT(GLuint texture, GLenum target, if(level == 0) { - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - m_Textures[texId].width = width; m_Textures[texId].height = height; m_Textures[texId].depth = depth; - m_Textures[texId].curType = TextureTarget(target); + if(target != eGL_NONE) m_Textures[texId].curType = TextureTarget(target); m_Textures[texId].dimension = 3; m_Textures[texId].internalFormat = internalformat; } } +void WrappedOpenGL::glCompressedTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *pixels) +{ + m_Real.glCompressedTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, imageSize, pixels); + + Common_glCompressedTextureImage3DEXT(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)), target, level, internalformat, width, height, depth, border, imageSize, pixels); +} + void WrappedOpenGL::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * pixels) { m_Real.glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, pixels); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(target) || internalformat == 0) return; - - internalformat = GetSizedFormat(m_Real, target, internalformat); + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - bool fromunpackbuf = false; - { - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - fromunpackbuf = (unpackbuf != 0); - } - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - // This is kind of an arbitary heuristic, but in the past a game has re-specified a texture with glTexImage over and over - // so we need to attempt to catch the case where glTexImage is called to re-upload data, not actually re-create it. - // Ideally we'd check for non-zero levels, but that would complicate the condition - // if we're uploading new data but otherwise everything is identical, ignore this chunk and simply mark the texture dirty - if(record->AlreadyDataType(target) && level == 0 && - m_Textures[record->GetResourceID()].width == width && - m_Textures[record->GetResourceID()].height == height && - m_Textures[record->GetResourceID()].depth == depth && - m_Textures[record->GetResourceID()].internalFormat == (GLenum)internalformat) - { - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - else - { - SCOPED_SERIALISE_CONTEXT(TEXIMAGE3D_COMPRESSED); - Serialise_glCompressedTextureImage3DEXT(record->Resource.name, - target, level, internalformat, width, height, depth, border, imageSize, fromunpackbuf ? NULL : pixels); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - - if(fromunpackbuf) - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - - if(level == 0) - { - ResourceId texId = GetResourceManager()->GetID(GetCtxData().GetActiveTexRecord()->Resource); - - m_Textures[texId].width = width; - m_Textures[texId].height = height; - m_Textures[texId].depth = depth; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 3; - m_Textures[texId].internalFormat = internalformat; - } + Common_glCompressedTextureImage3DEXT(GetCtxData().GetActiveTexRecord()->GetResourceID(), target, level, internalformat, width, height, depth, border, imageSize, pixels); } void WrappedOpenGL::glCompressedMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * pixels) { m_Real.glCompressedMultiTexImage3DEXT(texunit, target, level, internalformat, width, height, depth, border, imageSize, pixels); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(target) || internalformat == 0) return; - - internalformat = GetSizedFormat(m_Real, target, internalformat); + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - bool fromunpackbuf = false; - { - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - fromunpackbuf = (unpackbuf != 0); - } - - GLuint texture = 0; - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - texture = record->Resource.name; - - // This is kind of an arbitary heuristic, but in the past a game has re-specified a texture with glTexImage over and over - // so we need to attempt to catch the case where glTexImage is called to re-upload data, not actually re-create it. - // Ideally we'd check for non-zero levels, but that would complicate the condition - // if we're uploading new data but otherwise everything is identical, ignore this chunk and simply mark the texture dirty - if(record->AlreadyDataType(target) && level == 0 && - m_Textures[record->GetResourceID()].width == width && - m_Textures[record->GetResourceID()].height == height && - m_Textures[record->GetResourceID()].depth == depth && - m_Textures[record->GetResourceID()].internalFormat == (GLenum)internalformat) - { - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - else - { - SCOPED_SERIALISE_CONTEXT(TEXIMAGE3D_COMPRESSED); - Serialise_glCompressedTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, imageSize, fromunpackbuf ? NULL : pixels); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - - if(fromunpackbuf) - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - - if(level == 0) - { - ResourceId texId = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->GetResourceID(); - - m_Textures[texId].width = width; - m_Textures[texId].height = height; - m_Textures[texId].depth = depth; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 3; - m_Textures[texId].internalFormat = internalformat; - } + Common_glCompressedTextureImage3DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->GetResourceID(), target, level, internalformat, width, height, depth, border, imageSize, pixels); } #pragma endregion @@ -3254,7 +2467,7 @@ bool WrappedOpenGL::Serialise_glCopyTextureImage1DEXT(GLuint texture, GLenum tar m_Textures[liveId].width = Width; m_Textures[liveId].height = 1; m_Textures[liveId].depth = 1; - m_Textures[liveId].curType = TextureTarget(Target); + if(Target != eGL_NONE) m_Textures[liveId].curType = TextureTarget(Target); m_Textures[liveId].dimension = 1; m_Textures[liveId].internalFormat = Format; } @@ -3264,9 +2477,9 @@ bool WrappedOpenGL::Serialise_glCopyTextureImage1DEXT(GLuint texture, GLenum tar return true; } -void WrappedOpenGL::glCopyTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) +void WrappedOpenGL::Common_glCopyTextureImage1DEXT(GLResourceRecord *record, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) { - m_Real.glCopyTextureImage1DEXT(texture, target, level, internalformat, x, y, width, border); + if(!record) return; // not sure if proxy formats are valid, but ignore these anyway if(IsProxyTarget(target) || internalformat == 0) return; @@ -3275,104 +2488,6 @@ void WrappedOpenGL::glCopyTextureImage1DEXT(GLuint texture, GLenum target, GLint if(m_State == WRITING_IDLE) { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); - - // add a fake teximage1D chunk to create the texture properly on live (as we won't replay this copy chunk). - if(record) - { - SCOPED_SERIALISE_CONTEXT(TEXIMAGE1D); - Serialise_glTextureImage1DEXT(record->Resource.name, target, level, internalformat, width, border, - GetBaseFormat(internalformat), GetDataType(internalformat), NULL); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - - GetResourceManager()->MarkDirtyResource(GetResourceManager()->GetID(TextureRes(GetCtx(), texture))); - } - } - else if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(COPY_IMAGE1D); - Serialise_glCopyTextureImage1DEXT(texture, target, level, internalformat, x, y, width, border); - - m_ContextRecord->AddChunk(scope.Get()); - } - - if(level == 0) - { - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - - m_Textures[texId].width = width; - m_Textures[texId].height = 1; - m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 1; - m_Textures[texId].internalFormat = internalformat; - } -} - -void WrappedOpenGL::glCopyMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) -{ - m_Real.glCopyMultiTexImage1DEXT(texunit, target, level, internalformat, x, y, width, border); - - // not sure if proxy formats are valid, but ignore these anyway - if(IsProxyTarget(target) || internalformat == 0) return; - - internalformat = GetSizedFormat(m_Real, target, (GLenum)internalformat); - - if(m_State == WRITING_IDLE) - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - // add a fake teximage1D chunk to create the texture properly on live (as we won't replay this copy chunk). - SCOPED_SERIALISE_CONTEXT(TEXIMAGE1D); - Serialise_glTextureImage1DEXT(record->Resource.name, target, level, internalformat, width, border, - GetBaseFormat(internalformat), GetDataType(internalformat), NULL); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - else if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(COPY_IMAGE1D); - Serialise_glCopyTextureImage1DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->Resource.name, target, level, internalformat, x, y, width, border); - - m_ContextRecord->AddChunk(scope.Get()); - } - - if(level == 0) - { - ResourceId texId = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->GetResourceID(); - - m_Textures[texId].width = width; - m_Textures[texId].height = 1; - m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 1; - m_Textures[texId].internalFormat = internalformat; - } -} - -void WrappedOpenGL::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) -{ - m_Real.glCopyTexImage1D(target, level, internalformat, x, y, width, border); - - // not sure if proxy formats are valid, but ignore these anyway - if(IsProxyTarget(target) || internalformat == 0) return; - - internalformat = GetSizedFormat(m_Real, target, (GLenum)internalformat); - - if(m_State == WRITING_IDLE) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - // add a fake teximage1D chunk to create the texture properly on live (as we won't replay this copy chunk). if(record) { @@ -3391,24 +2506,53 @@ void WrappedOpenGL::glCopyTexImage1D(GLenum target, GLint level, GLenum internal else if(m_State == WRITING_CAPFRAME) { SCOPED_SERIALISE_CONTEXT(COPY_IMAGE1D); - Serialise_glCopyTextureImage1DEXT(GetCtxData().GetActiveTexRecord()->Resource.name, target, level, internalformat, x, y, width, border); + Serialise_glCopyTextureImage1DEXT(record->Resource.name, target, level, internalformat, x, y, width, border); m_ContextRecord->AddChunk(scope.Get()); } if(level == 0) { - ResourceId texId = GetResourceManager()->GetID(GetCtxData().GetActiveTexRecord()->Resource); + ResourceId texId = record->GetResourceID(); m_Textures[texId].width = width; m_Textures[texId].height = 1; m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); + if(target != eGL_NONE) m_Textures[texId].curType = TextureTarget(target); m_Textures[texId].dimension = 1; m_Textures[texId].internalFormat = internalformat; } } +void WrappedOpenGL::glCopyTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) +{ + m_Real.glCopyTextureImage1DEXT(texture, target, level, internalformat, x, y, width, border); + + Common_glCopyTextureImage1DEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), target, level, internalformat, x, y, width, border); +} + +void WrappedOpenGL::glCopyMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) +{ + m_Real.glCopyMultiTexImage1DEXT(texunit, target, level, internalformat, x, y, width, border); + + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); + + Common_glCopyTextureImage1DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0], target, level, internalformat, x, y, width, border); +} + +void WrappedOpenGL::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) +{ + m_Real.glCopyTexImage1D(target, level, internalformat, x, y, width, border); + + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); + + Common_glCopyTextureImage1DEXT(GetCtxData().GetActiveTexRecord(), target, level, internalformat, x, y, width, border); +} + bool WrappedOpenGL::Serialise_glCopyTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(GetCtx(), texture))); @@ -3429,7 +2573,7 @@ bool WrappedOpenGL::Serialise_glCopyTextureImage2DEXT(GLuint texture, GLenum tar m_Textures[liveId].width = Width; m_Textures[liveId].height = Height; m_Textures[liveId].depth = 1; - m_Textures[liveId].curType = TextureTarget(Target); + if(Target != eGL_NONE) m_Textures[liveId].curType = TextureTarget(Target); m_Textures[liveId].dimension = 2; m_Textures[liveId].internalFormat = Format; } @@ -3439,9 +2583,9 @@ bool WrappedOpenGL::Serialise_glCopyTextureImage2DEXT(GLuint texture, GLenum tar return true; } -void WrappedOpenGL::glCopyTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +void WrappedOpenGL::Common_glCopyTextureImage2DEXT(GLResourceRecord *record, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { - m_Real.glCopyTextureImage2DEXT(texture, target, level, internalformat, x, y, width, height, border); + if(!record) return; // not sure if proxy formats are valid, but ignore these anyway if(IsProxyTarget(target) || internalformat == 0) return; @@ -3450,104 +2594,6 @@ void WrappedOpenGL::glCopyTextureImage2DEXT(GLuint texture, GLenum target, GLint if(m_State == WRITING_IDLE) { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); - - // add a fake teximage1D chunk to create the texture properly on live (as we won't replay this copy chunk). - if(record) - { - SCOPED_SERIALISE_CONTEXT(TEXIMAGE2D); - Serialise_glTextureImage2DEXT(record->Resource.name, target, level, internalformat, width, height, border, - GetBaseFormat(internalformat), GetDataType(internalformat), NULL); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - - GetResourceManager()->MarkDirtyResource(GetResourceManager()->GetID(TextureRes(GetCtx(), texture))); - } - } - else if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(COPY_IMAGE2D); - Serialise_glCopyTextureImage2DEXT(texture, target, level, internalformat, x, y, width, height, border); - - m_ContextRecord->AddChunk(scope.Get()); - } - - if(level == 0) - { - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - - m_Textures[texId].width = width; - m_Textures[texId].height = height; - m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 2; - m_Textures[texId].internalFormat = internalformat; - } -} - -void WrappedOpenGL::glCopyMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) -{ - m_Real.glCopyMultiTexImage2DEXT(texunit, target, level, internalformat, x, y, width, height, border); - - // not sure if proxy formats are valid, but ignore these anyway - if(IsProxyTarget(target) || internalformat == 0) return; - - internalformat = GetSizedFormat(m_Real, target, (GLenum)internalformat); - - if(m_State == WRITING_IDLE) - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - // add a fake teximage1D chunk to create the texture properly on live (as we won't replay this copy chunk). - SCOPED_SERIALISE_CONTEXT(TEXIMAGE2D); - Serialise_glTextureImage2DEXT(record->Resource.name, target, level, internalformat, width, height, border, - GetBaseFormat(internalformat), GetDataType(internalformat), NULL); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - else if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(COPY_IMAGE2D); - Serialise_glCopyTextureImage2DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->Resource.name, target, level, internalformat, x, y, width, height, border); - - m_ContextRecord->AddChunk(scope.Get()); - } - - if(level == 0) - { - ResourceId texId = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->GetResourceID(); - - m_Textures[texId].width = width; - m_Textures[texId].height = height; - m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 2; - m_Textures[texId].internalFormat = internalformat; - } -} - -void WrappedOpenGL::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) -{ - m_Real.glCopyTexImage2D(target, level, internalformat, x, y, width, height, border); - - // not sure if proxy formats are valid, but ignore these anyway - if(IsProxyTarget(target) || internalformat == 0) return; - - internalformat = GetSizedFormat(m_Real, target, (GLenum)internalformat); - - if(m_State == WRITING_IDLE) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - // add a fake teximage1D chunk to create the texture properly on live (as we won't replay this copy chunk). if(record) { @@ -3566,24 +2612,53 @@ void WrappedOpenGL::glCopyTexImage2D(GLenum target, GLint level, GLenum internal else if(m_State == WRITING_CAPFRAME) { SCOPED_SERIALISE_CONTEXT(COPY_IMAGE2D); - Serialise_glCopyTextureImage2DEXT(GetCtxData().GetActiveTexRecord()->Resource.name, target, level, internalformat, x, y, width, height, border); + Serialise_glCopyTextureImage2DEXT(record->Resource.name, target, level, internalformat, x, y, width, height, border); m_ContextRecord->AddChunk(scope.Get()); } if(level == 0) { - ResourceId texId = GetResourceManager()->GetID(GetCtxData().GetActiveTexRecord()->Resource); + ResourceId texId = record->GetResourceID(); m_Textures[texId].width = width; m_Textures[texId].height = height; m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); + if(target != eGL_NONE) m_Textures[texId].curType = TextureTarget(target); m_Textures[texId].dimension = 2; m_Textures[texId].internalFormat = internalformat; } } +void WrappedOpenGL::glCopyTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + m_Real.glCopyTextureImage2DEXT(texture, target, level, internalformat, x, y, width, height, border); + + Common_glCopyTextureImage2DEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), target, level, internalformat, x, y, width, height, border); +} + +void WrappedOpenGL::glCopyMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + m_Real.glCopyMultiTexImage2DEXT(texunit, target, level, internalformat, x, y, width, height, border); + + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); + + Common_glCopyTextureImage2DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0], target, level, internalformat, x, y, width, height, border); +} + +void WrappedOpenGL::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + m_Real.glCopyTexImage2D(target, level, internalformat, x, y, width, height, border); + + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); + + Common_glCopyTextureImage2DEXT(GetCtxData().GetActiveTexRecord(), target, level, internalformat, x, y, width, height, border); +} + #pragma endregion #pragma region Texture Creation (glTexStorage*) @@ -3602,19 +2677,22 @@ bool WrappedOpenGL::Serialise_glTextureStorage1DEXT(GLuint texture, GLenum targe m_Textures[liveId].width = Width; m_Textures[liveId].height = 1; m_Textures[liveId].depth = 1; - m_Textures[liveId].curType = TextureTarget(Target); + if(Target != eGL_NONE) m_Textures[liveId].curType = TextureTarget(Target); m_Textures[liveId].dimension = 1; m_Textures[liveId].internalFormat = Format; - m_Real.glTextureStorage1DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Levels, Format, Width); + if(Target != eGL_NONE) + m_Real.glTextureStorage1DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Levels, Format, Width); + else + m_Real.glTextureStorage1D(GetResourceManager()->GetLiveResource(id).name, Levels, Format, Width); } return true; } -void WrappedOpenGL::glTextureStorage1DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) +void WrappedOpenGL::Common_glTextureStorage1DEXT(ResourceId texId, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) { - m_Real.glTextureStorage1DEXT(texture, target, levels, internalformat, width); + if(texId == ResourceId()) return; // proxy formats are used for querying texture capabilities, don't serialise these if(IsProxyTarget(target) || internalformat == 0) return; @@ -3623,11 +2701,11 @@ void WrappedOpenGL::glTextureStorage1DEXT(GLuint texture, GLenum target, GLsizei if(m_State >= WRITING) { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(texId); RDCASSERT(record); - + SCOPED_SERIALISE_CONTEXT(TEXSTORAGE1D); - Serialise_glTextureStorage1DEXT(texture, target, levels, internalformat, width); + Serialise_glTextureStorage1DEXT(record->Resource.name, target, levels, internalformat, width); record->AddChunk(scope.Get()); @@ -3636,51 +2714,42 @@ void WrappedOpenGL::glTextureStorage1DEXT(GLuint texture, GLenum target, GLsizei } { - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - m_Textures[texId].width = width; m_Textures[texId].height = 1; m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); + if(target != eGL_NONE) m_Textures[texId].curType = TextureTarget(target); m_Textures[texId].dimension = 1; m_Textures[texId].internalFormat = internalformat; } } +void WrappedOpenGL::glTextureStorage1DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) +{ + m_Real.glTextureStorage1DEXT(texture, target, levels, internalformat, width); + + Common_glTextureStorage1DEXT(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)), target, levels, internalformat, width); +} + +void WrappedOpenGL::glTextureStorage1D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width) +{ + m_Real.glTextureStorage1D(texture, levels, internalformat, width); + + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); + + Common_glTextureStorage1DEXT(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)), eGL_NONE, levels, internalformat, width); +} + void WrappedOpenGL::glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) { m_Real.glTexStorage1D(target, levels, internalformat, width); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(target) || internalformat == 0) return; - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - SCOPED_SERIALISE_CONTEXT(TEXSTORAGE1D); - Serialise_glTextureStorage1DEXT(record->Resource.name, - target, levels, internalformat, width); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - } - - { - GLuint texture = 0; - m_Real.glGetIntegerv(TextureBinding(target), (GLint *)&texture); - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - - m_Textures[texId].width = width; - m_Textures[texId].height = 1; - m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 1; - m_Textures[texId].internalFormat = internalformat; - } + Common_glTextureStorage1DEXT(GetCtxData().GetActiveTexRecord()->GetResourceID(), target, levels, internalformat, width); } bool WrappedOpenGL::Serialise_glTextureStorage2DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) @@ -3698,30 +2767,33 @@ bool WrappedOpenGL::Serialise_glTextureStorage2DEXT(GLuint texture, GLenum targe m_Textures[liveId].width = Width; m_Textures[liveId].height = Height; m_Textures[liveId].depth = 1; - m_Textures[liveId].curType = TextureTarget(Target); + if(Target != eGL_NONE) m_Textures[liveId].curType = TextureTarget(Target); m_Textures[liveId].dimension = 2; m_Textures[liveId].internalFormat = Format; - m_Real.glTextureStorage2DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Levels, Format, Width, Height); + if(Target != eGL_NONE) + m_Real.glTextureStorage2DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Levels, Format, Width, Height); + else + m_Real.glTextureStorage2D(GetResourceManager()->GetLiveResource(id).name, Levels, Format, Width, Height); } return true; } -void WrappedOpenGL::glTextureStorage2DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) +void WrappedOpenGL::Common_glTextureStorage2DEXT(ResourceId texId, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) { - m_Real.glTextureStorage2DEXT(texture, target, levels, internalformat, width, height); + if(texId == ResourceId()) return; // proxy formats are used for querying texture capabilities, don't serialise these if(IsProxyTarget(target) || internalformat == 0) return; if(m_State >= WRITING) { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(texId); RDCASSERT(record); SCOPED_SERIALISE_CONTEXT(TEXSTORAGE2D); - Serialise_glTextureStorage2DEXT(texture, target, levels, internalformat, width, height); + Serialise_glTextureStorage2DEXT(record->Resource.name, target, levels, internalformat, width, height); record->AddChunk(scope.Get()); @@ -3730,51 +2802,42 @@ void WrappedOpenGL::glTextureStorage2DEXT(GLuint texture, GLenum target, GLsizei } { - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - m_Textures[texId].width = width; m_Textures[texId].height = height; m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); + if(target != eGL_NONE) m_Textures[texId].curType = TextureTarget(target); m_Textures[texId].dimension = 2; m_Textures[texId].internalFormat = internalformat; } } +void WrappedOpenGL::glTextureStorage2DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) +{ + m_Real.glTextureStorage2DEXT(texture, target, levels, internalformat, width, height); + + Common_glTextureStorage2DEXT(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)), target, levels, internalformat, width, height); +} + +void WrappedOpenGL::glTextureStorage2D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) +{ + m_Real.glTextureStorage2D(texture, levels, internalformat, width, height); + + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); + + Common_glTextureStorage2DEXT(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)), eGL_NONE, levels, internalformat, width, height); +} + void WrappedOpenGL::glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) { m_Real.glTexStorage2D(target, levels, internalformat, width, height); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(target) || internalformat == 0) return; - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - SCOPED_SERIALISE_CONTEXT(TEXSTORAGE2D); - Serialise_glTextureStorage2DEXT(record->Resource.name, - target, levels, internalformat, width, height); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - } - - { - GLuint texture = 0; - m_Real.glGetIntegerv(TextureBinding(target), (GLint *)&texture); - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - - m_Textures[texId].width = width; - m_Textures[texId].height = height; - m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 2; - m_Textures[texId].internalFormat = internalformat; - } + Common_glTextureStorage2DEXT(GetCtxData().GetActiveTexRecord()->GetResourceID(), target, levels, internalformat, width, height); } bool WrappedOpenGL::Serialise_glTextureStorage3DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) @@ -3793,30 +2856,33 @@ bool WrappedOpenGL::Serialise_glTextureStorage3DEXT(GLuint texture, GLenum targe m_Textures[liveId].width = Width; m_Textures[liveId].height = Height; m_Textures[liveId].depth = Depth; - m_Textures[liveId].curType = TextureTarget(Target); + if(Target != eGL_NONE) m_Textures[liveId].curType = TextureTarget(Target); m_Textures[liveId].dimension = 3; m_Textures[liveId].internalFormat = Format; - m_Real.glTextureStorage3DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Levels, Format, Width, Height, Depth); + if(Target != eGL_NONE) + m_Real.glTextureStorage3DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Levels, Format, Width, Height, Depth); + else + m_Real.glTextureStorage3D(GetResourceManager()->GetLiveResource(id).name, Levels, Format, Width, Height, Depth); } return true; } -void WrappedOpenGL::glTextureStorage3DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) +void WrappedOpenGL::Common_glTextureStorage3DEXT(ResourceId texId, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) { - m_Real.glTextureStorage3DEXT(texture, target, levels, internalformat, width, height, depth); + if(texId == ResourceId()) return; // proxy formats are used for querying texture capabilities, don't serialise these if(IsProxyTarget(target) || internalformat == 0) return; if(m_State >= WRITING) { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(texId); RDCASSERT(record); SCOPED_SERIALISE_CONTEXT(TEXSTORAGE3D); - Serialise_glTextureStorage3DEXT(texture, target, levels, internalformat, width, height, depth); + Serialise_glTextureStorage3DEXT(record->Resource.name, target, levels, internalformat, width, height, depth); record->AddChunk(scope.Get()); @@ -3825,51 +2891,42 @@ void WrappedOpenGL::glTextureStorage3DEXT(GLuint texture, GLenum target, GLsizei } { - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - m_Textures[texId].width = width; m_Textures[texId].height = height; m_Textures[texId].depth = depth; - m_Textures[texId].curType = TextureTarget(target); + if(target != eGL_NONE) m_Textures[texId].curType = TextureTarget(target); m_Textures[texId].dimension = 3; m_Textures[texId].internalFormat = internalformat; } } +void WrappedOpenGL::glTextureStorage3DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) +{ + m_Real.glTextureStorage3DEXT(texture, target, levels, internalformat, width, height, depth); + + Common_glTextureStorage3DEXT(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)), target, levels, internalformat, width, height, depth); +} + +void WrappedOpenGL::glTextureStorage3D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) +{ + m_Real.glTextureStorage3D(texture, levels, internalformat, width, height, depth); + + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); + + Common_glTextureStorage3DEXT(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)), eGL_NONE, levels, internalformat, width, height, depth); +} + void WrappedOpenGL::glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) { m_Real.glTexStorage3D(target, levels, internalformat, width, height, depth); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(target) || internalformat == 0) return; - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - SCOPED_SERIALISE_CONTEXT(TEXSTORAGE3D); - Serialise_glTextureStorage3DEXT(record->Resource.name, - target, levels, internalformat, width, height, depth); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - } - - { - GLuint texture = 0; - m_Real.glGetIntegerv(TextureBinding(target), (GLint *)&texture); - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - - m_Textures[texId].width = width; - m_Textures[texId].height = height; - m_Textures[texId].depth = depth; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 3; - m_Textures[texId].internalFormat = internalformat; - } + Common_glTextureStorage3DEXT(GetCtxData().GetActiveTexRecord()->GetResourceID(), target, levels, internalformat, width, height, depth); } bool WrappedOpenGL::Serialise_glTextureStorage2DMultisampleEXT(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) @@ -3889,30 +2946,33 @@ bool WrappedOpenGL::Serialise_glTextureStorage2DMultisampleEXT(GLuint texture, G m_Textures[liveId].height = Height; m_Textures[liveId].depth = 1; m_Textures[liveId].samples = Samples; - m_Textures[liveId].curType = TextureTarget(Target); + if(Target != eGL_NONE) m_Textures[liveId].curType = TextureTarget(Target); m_Textures[liveId].dimension = 2; m_Textures[liveId].internalFormat = Format; - - m_Real.glTextureStorage2DMultisampleEXT(GetResourceManager()->GetLiveResource(id).name, Target, Samples, Format, Width, Height, Fixedlocs ? GL_TRUE : GL_FALSE); + + if(Target != eGL_NONE) + m_Real.glTextureStorage2DMultisampleEXT(GetResourceManager()->GetLiveResource(id).name, Target, Samples, Format, Width, Height, Fixedlocs ? GL_TRUE : GL_FALSE); + else + m_Real.glTextureStorage2DMultisample(GetResourceManager()->GetLiveResource(id).name, Samples, Format, Width, Height, Fixedlocs ? GL_TRUE : GL_FALSE); } return true; } -void WrappedOpenGL::glTextureStorage2DMultisampleEXT(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) +void WrappedOpenGL::Common_glTextureStorage2DMultisampleEXT(ResourceId texId, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) { - m_Real.glTextureStorage2DMultisampleEXT(texture, target, samples, internalformat, width, height, fixedsamplelocations); + if(texId == ResourceId()) return; // proxy formats are used for querying texture capabilities, don't serialise these if(IsProxyTarget(target) || internalformat == 0) return; if(m_State >= WRITING) { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(texId); RDCASSERT(record); SCOPED_SERIALISE_CONTEXT(TEXSTORAGE2DMS); - Serialise_glTextureStorage2DMultisampleEXT(texture, target, samples, internalformat, width, height, fixedsamplelocations); + Serialise_glTextureStorage2DMultisampleEXT(record->Resource.name, target, samples, internalformat, width, height, fixedsamplelocations); record->AddChunk(scope.Get()); @@ -3921,94 +2981,56 @@ void WrappedOpenGL::glTextureStorage2DMultisampleEXT(GLuint texture, GLenum targ } { - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - m_Textures[texId].width = width; m_Textures[texId].height = height; m_Textures[texId].depth = 1; m_Textures[texId].samples = samples; - m_Textures[texId].curType = TextureTarget(target); + if(target != eGL_NONE) m_Textures[texId].curType = TextureTarget(target); m_Textures[texId].dimension = 2; m_Textures[texId].internalFormat = internalformat; } } +void WrappedOpenGL::glTextureStorage2DMultisampleEXT(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) +{ + m_Real.glTextureStorage2DMultisampleEXT(texture, target, samples, internalformat, width, height, fixedsamplelocations); + + Common_glTextureStorage2DMultisampleEXT(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)), target, samples, internalformat, width, height, fixedsamplelocations); +} + +void WrappedOpenGL::glTextureStorage2DMultisample(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) +{ + m_Real.glTextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations); + + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); + + Common_glTextureStorage2DMultisampleEXT(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)), eGL_NONE, samples, internalformat, width, height, fixedsamplelocations); +} + void WrappedOpenGL::glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) { m_Real.glTexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(target) || internalformat == 0) return; - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - SCOPED_SERIALISE_CONTEXT(TEXSTORAGE2DMS); - Serialise_glTextureStorage2DMultisampleEXT(record->Resource.name, - target, samples, internalformat, width, height, fixedsamplelocations); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - } - - { - GLuint texture = 0; - m_Real.glGetIntegerv(TextureBinding(target), (GLint *)&texture); - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - - m_Textures[texId].width = width; - m_Textures[texId].height = height; - m_Textures[texId].depth = 1; - m_Textures[texId].samples = samples; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 2; - m_Textures[texId].internalFormat = internalformat; - } + Common_glTextureStorage2DMultisampleEXT(GetCtxData().GetActiveTexRecord()->GetResourceID(), target, samples, internalformat, width, height, fixedsamplelocations); } void WrappedOpenGL::glTexImage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) { m_Real.glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(target) || internalformat == 0) return; - - internalformat = GetSizedFormat(m_Real, target, internalformat); + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - // assuming texstorage is equivalent to teximage (this is not true in the case where someone - // tries to re-size an image by re-calling teximage). - SCOPED_SERIALISE_CONTEXT(TEXSTORAGE2DMS); - Serialise_glTextureStorage2DMultisampleEXT(record->Resource.name, - target, samples, internalformat, width, height, fixedsamplelocations); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - } - - { - GLuint texture = 0; - m_Real.glGetIntegerv(TextureBinding(target), (GLint *)&texture); - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - - m_Textures[texId].width = width; - m_Textures[texId].height = height; - m_Textures[texId].depth = 1; - m_Textures[texId].samples = samples; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 2; - m_Textures[texId].internalFormat = internalformat; - } + // assuming texstorage is equivalent to teximage (this is not true in the case where someone + // tries to re-size an image by re-calling teximage). + Common_glTextureStorage2DMultisampleEXT(GetCtxData().GetActiveTexRecord()->GetResourceID(), target, samples, internalformat, width, height, fixedsamplelocations); } bool WrappedOpenGL::Serialise_glTextureStorage3DMultisampleEXT(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) @@ -4029,30 +3051,33 @@ bool WrappedOpenGL::Serialise_glTextureStorage3DMultisampleEXT(GLuint texture, G m_Textures[liveId].height = Height; m_Textures[liveId].depth = Depth; m_Textures[liveId].samples = Samples; - m_Textures[liveId].curType = TextureTarget(Target); + if(Target != eGL_NONE) m_Textures[liveId].curType = TextureTarget(Target); m_Textures[liveId].dimension = 2; m_Textures[liveId].internalFormat = Format; - - m_Real.glTextureStorage3DMultisampleEXT(GetResourceManager()->GetLiveResource(id).name, Target, Samples, Format, Width, Height, Depth, Fixedlocs ? GL_TRUE : GL_FALSE); + + if(Target != eGL_NONE) + m_Real.glTextureStorage3DMultisampleEXT(GetResourceManager()->GetLiveResource(id).name, Target, Samples, Format, Width, Height, Depth, Fixedlocs ? GL_TRUE : GL_FALSE); + else + m_Real.glTextureStorage3DMultisample(GetResourceManager()->GetLiveResource(id).name, Samples, Format, Width, Height, Depth, Fixedlocs ? GL_TRUE : GL_FALSE); } return true; } -void WrappedOpenGL::glTextureStorage3DMultisampleEXT(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) +void WrappedOpenGL::Common_glTextureStorage3DMultisampleEXT(ResourceId texId, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) { - m_Real.glTextureStorage3DMultisampleEXT(texture, target, samples, internalformat, width, height, depth, fixedsamplelocations); + if(texId == ResourceId()) return; // proxy formats are used for querying texture capabilities, don't serialise these if(IsProxyTarget(target) || internalformat == 0) return; if(m_State >= WRITING) { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(texId); RDCASSERT(record); SCOPED_SERIALISE_CONTEXT(TEXSTORAGE3DMS); - Serialise_glTextureStorage3DMultisampleEXT(texture, target, samples, internalformat, width, height, depth, fixedsamplelocations); + Serialise_glTextureStorage3DMultisampleEXT(record->Resource.name, target, samples, internalformat, width, height, depth, fixedsamplelocations); record->AddChunk(scope.Get()); @@ -4061,94 +3086,56 @@ void WrappedOpenGL::glTextureStorage3DMultisampleEXT(GLuint texture, GLenum targ } { - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - m_Textures[texId].width = width; m_Textures[texId].height = height; m_Textures[texId].depth = depth; m_Textures[texId].samples = samples; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 2; + if(target != eGL_NONE) m_Textures[texId].curType = TextureTarget(target); + m_Textures[texId].dimension = 3; m_Textures[texId].internalFormat = internalformat; } } +void WrappedOpenGL::glTextureStorage3DMultisampleEXT(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) +{ + m_Real.glTextureStorage3DMultisampleEXT(texture, target, samples, internalformat, width, height, depth, fixedsamplelocations); + + Common_glTextureStorage3DMultisampleEXT(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)), target, samples, internalformat, width, height, depth, fixedsamplelocations); +} + +void WrappedOpenGL::glTextureStorage3DMultisample(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) +{ + m_Real.glTextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations); + + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); + + Common_glTextureStorage3DMultisampleEXT(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)), eGL_NONE, samples, internalformat, width, height, depth, fixedsamplelocations); +} + void WrappedOpenGL::glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) { m_Real.glTexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(target) || internalformat == 0) return; - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - SCOPED_SERIALISE_CONTEXT(TEXSTORAGE3DMS); - Serialise_glTextureStorage3DMultisampleEXT(record->Resource.name, - target, samples, internalformat, width, height, depth, fixedsamplelocations); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - } - - { - GLuint texture = 0; - m_Real.glGetIntegerv(TextureBinding(target), (GLint *)&texture); - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - - m_Textures[texId].width = width; - m_Textures[texId].height = height; - m_Textures[texId].depth = depth; - m_Textures[texId].samples = samples; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 2; - m_Textures[texId].internalFormat = internalformat; - } + Common_glTextureStorage3DMultisampleEXT(GetCtxData().GetActiveTexRecord()->GetResourceID(), target, samples, internalformat, width, height, depth, fixedsamplelocations); } void WrappedOpenGL::glTexImage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) { - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(target) || internalformat == 0) return; - - internalformat = GetSizedFormat(m_Real, target, internalformat); - m_Real.glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations); - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - // assuming texstorage is equivalent to teximage (this is not true in the case where someone - // tries to re-size an image by re-calling teximage). - SCOPED_SERIALISE_CONTEXT(TEXSTORAGE3DMS); - Serialise_glTextureStorage3DMultisampleEXT(record->Resource.name, - target, samples, internalformat, width, height, depth, fixedsamplelocations); - - record->AddChunk(scope.Get()); - - // illegal to re-type textures - record->VerifyDataType(target); - } - - { - GLuint texture = 0; - m_Real.glGetIntegerv(TextureBinding(target), (GLint *)&texture); - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - - m_Textures[texId].width = width; - m_Textures[texId].height = height; - m_Textures[texId].depth = depth; - m_Textures[texId].samples = samples; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 2; - m_Textures[texId].internalFormat = internalformat; - } + // assuming texstorage is equivalent to teximage (this is not true in the case where someone + // tries to re-size an image by re-calling teximage). + Common_glTextureStorage3DMultisampleEXT(GetCtxData().GetActiveTexRecord()->GetResourceID(), target, samples, internalformat, width, height, depth, fixedsamplelocations); } #pragma endregion @@ -4210,8 +3197,11 @@ bool WrappedOpenGL::Serialise_glTextureSubImage1DEXT(GLuint texture, GLenum targ if(m_Textures[liveId].internalFormat == eGL_R8) Format = eGL_RED; } - - m_Real.glTextureSubImage1DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, xoff, Width, Format, Type, buf ? buf : (const void *)bufoffs); + + if(Target != eGL_NONE) + m_Real.glTextureSubImage1DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, xoff, Width, Format, Type, buf ? buf : (const void *)bufoffs); + else + m_Real.glTextureSubImage1D(GetResourceManager()->GetLiveResource(id).name, Level, xoff, Width, Format, Type, buf ? buf : (const void *)bufoffs); if(!UnpackBufBound && m_State == READING && m_CurEventID == 0) m_Real.glBindBuffer(eGL_PIXEL_UNPACK_BUFFER, unpackbuf); @@ -4221,10 +3211,10 @@ bool WrappedOpenGL::Serialise_glTextureSubImage1DEXT(GLuint texture, GLenum targ return true; } - -void WrappedOpenGL::glTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) + +void WrappedOpenGL::Common_glTextureSubImage1DEXT(GLResourceRecord *record, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) { - m_Real.glTextureSubImage1DEXT(texture, target, level, xoffset, width, format, type, pixels); + if(!record) return; // proxy formats are used for querying texture capabilities, don't serialise these if(IsProxyTarget(format)) return; @@ -4232,134 +3222,66 @@ void WrappedOpenGL::glTextureSubImage1DEXT(GLuint texture, GLenum target, GLint GLint unpackbuf = 0; m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - if(m_State >= WRITING) + if(m_State == WRITING_IDLE && unpackbuf != 0) { - if(m_State == WRITING_IDLE && unpackbuf != 0) + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); + } + else + { + if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) + return; + + SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE1D); + Serialise_glTextureSubImage1DEXT(record->Resource.name, target, level, xoffset, width, format, type, pixels); + + if(m_State == WRITING_CAPFRAME) { - GetResourceManager()->MarkDirtyResource(TextureRes(GetCtx(), texture)); + m_ContextRecord->AddChunk(scope.Get()); } else { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) - return; + record->AddChunk(scope.Get()); + record->UpdateCount++; - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE1D); - Serialise_glTextureSubImage1DEXT(texture, target, level, xoffset, width, format, type, pixels); - - if(m_State == WRITING_CAPFRAME) + if(record->UpdateCount > 60) { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 60) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } + m_HighTrafficResources.insert(record->GetResourceID()); + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); } } } } +void WrappedOpenGL::glTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) +{ + m_Real.glTextureSubImage1DEXT(texture, target, level, xoffset, width, format, type, pixels); + + if(m_State >= WRITING) + Common_glTextureSubImage1DEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), target, level, xoffset, width, format, type, pixels); +} + +void WrappedOpenGL::glTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) +{ + m_Real.glTextureSubImage1D(texture, level, xoffset, width, format, type, pixels); + + if(m_State >= WRITING) + Common_glTextureSubImage1DEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), eGL_NONE, level, xoffset, width, format, type, pixels); +} + void WrappedOpenGL::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) { m_Real.glTexSubImage1D(target, level, xoffset, width, format, type, pixels); - - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(format)) return; - - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); if(m_State >= WRITING) - { - if(m_State == WRITING_IDLE && unpackbuf != 0) - { - GetResourceManager()->MarkDirtyResource(GetCtxData().GetActiveTexRecord()->GetResourceID()); - } - else - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) - return; - - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE1D); - Serialise_glTextureSubImage1DEXT(record->Resource.name, - target, level, xoffset, width, format, type, pixels); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 60) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } - } + Common_glTextureSubImage1DEXT(GetCtxData().GetActiveTexRecord(), target, level, xoffset, width, format, type, pixels); } void WrappedOpenGL::glMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) { m_Real.glMultiTexSubImage1DEXT(texunit, target, level, xoffset, width, format, type, pixels); - - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(format)) return; - - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); if(m_State >= WRITING) - { - if(m_State == WRITING_IDLE && unpackbuf != 0) - { - GetResourceManager()->MarkDirtyResource(GetCtxData().GetActiveTexRecord()->GetResourceID()); - } - else - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) - return; - - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE1D); - Serialise_glTextureSubImage1DEXT(record->Resource.name, - target, level, xoffset, width, format, type, pixels); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 60) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } - } + Common_glTextureSubImage1DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0], target, level, xoffset, width, format, type, pixels); } bool WrappedOpenGL::Serialise_glTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) @@ -4419,8 +3341,11 @@ bool WrappedOpenGL::Serialise_glTextureSubImage2DEXT(GLuint texture, GLenum targ if(m_Textures[liveId].internalFormat == eGL_R8) Format = eGL_RED; } - - m_Real.glTextureSubImage2DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, xoff, yoff, Width, Height, Format, Type, buf ? buf : (const void *)bufoffs); + + if(Target != eGL_NONE) + m_Real.glTextureSubImage2DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, xoff, yoff, Width, Height, Format, Type, buf ? buf : (const void *)bufoffs); + else + m_Real.glTextureSubImage2D(GetResourceManager()->GetLiveResource(id).name, Level, xoff, yoff, Width, Height, Format, Type, buf ? buf : (const void *)bufoffs); if(!UnpackBufBound && m_State == READING && m_CurEventID == 0) m_Real.glBindBuffer(eGL_PIXEL_UNPACK_BUFFER, unpackbuf); @@ -4431,9 +3356,9 @@ bool WrappedOpenGL::Serialise_glTextureSubImage2DEXT(GLuint texture, GLenum targ return true; } -void WrappedOpenGL::glTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) +void WrappedOpenGL::Common_glTextureSubImage2DEXT(GLResourceRecord *record, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) { - m_Real.glTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, type, pixels); + if(!record) return; // proxy formats are used for querying texture capabilities, don't serialise these if(IsProxyTarget(format)) return; @@ -4441,134 +3366,66 @@ void WrappedOpenGL::glTextureSubImage2DEXT(GLuint texture, GLenum target, GLint GLint unpackbuf = 0; m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - if(m_State >= WRITING) + if(m_State == WRITING_IDLE && unpackbuf != 0) { - if(m_State == WRITING_IDLE && unpackbuf != 0) + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); + } + else + { + if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) + return; + + SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE2D); + Serialise_glTextureSubImage2DEXT(record->Resource.name, target, level, xoffset, yoffset, width, height, format, type, pixels); + + if(m_State == WRITING_CAPFRAME) { - GetResourceManager()->MarkDirtyResource(TextureRes(GetCtx(), texture)); + m_ContextRecord->AddChunk(scope.Get()); } else { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) - return; + record->AddChunk(scope.Get()); + record->UpdateCount++; - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE2D); - Serialise_glTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, type, pixels); - - if(m_State == WRITING_CAPFRAME) + if(record->UpdateCount > 60) { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 60) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } + m_HighTrafficResources.insert(record->GetResourceID()); + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); } } } } +void WrappedOpenGL::glTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) +{ + m_Real.glTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, type, pixels); + + if(m_State >= WRITING) + Common_glTextureSubImage2DEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), target, level, xoffset, yoffset, width, height, format, type, pixels); +} + +void WrappedOpenGL::glTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) +{ + m_Real.glTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels); + + if(m_State >= WRITING) + Common_glTextureSubImage2DEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), eGL_NONE, level, xoffset, yoffset, width, height, format, type, pixels); +} + void WrappedOpenGL::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) { m_Real.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); - - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(format)) return; - - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); if(m_State >= WRITING) - { - if(m_State == WRITING_IDLE && unpackbuf != 0) - { - GetResourceManager()->MarkDirtyResource(GetCtxData().GetActiveTexRecord()->GetResourceID()); - } - else - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) - return; - - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE2D); - Serialise_glTextureSubImage2DEXT(record->Resource.name, - target, level, xoffset, yoffset, width, height, format, type, pixels); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 60) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } - } + Common_glTextureSubImage2DEXT(GetCtxData().GetActiveTexRecord(), target, level, xoffset, yoffset, width, height, format, type, pixels); } void WrappedOpenGL::glMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) { m_Real.glMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, type, pixels); - - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(format)) return; - - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); if(m_State >= WRITING) - { - if(m_State == WRITING_IDLE && unpackbuf != 0) - { - GetResourceManager()->MarkDirtyResource(GetCtxData().GetActiveTexRecord()->GetResourceID()); - } - else - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) - return; - - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE2D); - Serialise_glTextureSubImage2DEXT(record->Resource.name, - target, level, xoffset, yoffset, width, height, format, type, pixels); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 60) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } - } + Common_glTextureSubImage2DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0], target, level, xoffset, yoffset, width, height, format, type, pixels); } bool WrappedOpenGL::Serialise_glTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) @@ -4630,8 +3487,11 @@ bool WrappedOpenGL::Serialise_glTextureSubImage3DEXT(GLuint texture, GLenum targ if(m_Textures[liveId].internalFormat == eGL_R8) Format = eGL_RED; } - - m_Real.glTextureSubImage3DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, xoff, yoff, zoff, Width, Height, Depth, Format, Type, buf ? buf : (const void *)bufoffs); + + if(Target != eGL_NONE) + m_Real.glTextureSubImage3DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, xoff, yoff, zoff, Width, Height, Depth, Format, Type, buf ? buf : (const void *)bufoffs); + else + m_Real.glTextureSubImage3D(GetResourceManager()->GetLiveResource(id).name, Level, xoff, yoff, zoff, Width, Height, Depth, Format, Type, buf ? buf : (const void *)bufoffs); if(!UnpackBufBound && m_State == READING && m_CurEventID == 0) m_Real.glBindBuffer(eGL_PIXEL_UNPACK_BUFFER, unpackbuf); @@ -4642,9 +3502,9 @@ bool WrappedOpenGL::Serialise_glTextureSubImage3DEXT(GLuint texture, GLenum targ return true; } -void WrappedOpenGL::glTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) +void WrappedOpenGL::Common_glTextureSubImage3DEXT(GLResourceRecord *record, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) { - m_Real.glTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); + if(!record) return; // proxy formats are used for querying texture capabilities, don't serialise these if(IsProxyTarget(format)) return; @@ -4652,134 +3512,66 @@ void WrappedOpenGL::glTextureSubImage3DEXT(GLuint texture, GLenum target, GLint GLint unpackbuf = 0; m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - if(m_State >= WRITING) + if(m_State == WRITING_IDLE && unpackbuf != 0) { - if(m_State == WRITING_IDLE && unpackbuf != 0) + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); + } + else + { + if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) + return; + + SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE3D); + Serialise_glTextureSubImage3DEXT(record->Resource.name, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); + + if(m_State == WRITING_CAPFRAME) { - GetResourceManager()->MarkDirtyResource(TextureRes(GetCtx(), texture)); + m_ContextRecord->AddChunk(scope.Get()); } else { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) - return; + record->AddChunk(scope.Get()); + record->UpdateCount++; - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE3D); - Serialise_glTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); - - if(m_State == WRITING_CAPFRAME) + if(record->UpdateCount > 60) { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 60) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } + m_HighTrafficResources.insert(record->GetResourceID()); + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); } } } } +void WrappedOpenGL::glTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) +{ + m_Real.glTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); + + if(m_State >= WRITING) + Common_glTextureSubImage3DEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); +} + +void WrappedOpenGL::glTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) +{ + m_Real.glTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); + + if(m_State >= WRITING) + Common_glTextureSubImage3DEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), eGL_NONE, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); +} + void WrappedOpenGL::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) { m_Real.glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); - - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(format)) return; - - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); if(m_State >= WRITING) - { - if(m_State == WRITING_IDLE && unpackbuf != 0) - { - GetResourceManager()->MarkDirtyResource(GetCtxData().GetActiveTexRecord()->GetResourceID()); - } - else - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) - return; - - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE3D); - Serialise_glTextureSubImage3DEXT(record->Resource.name, - target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 60) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } - } + Common_glTextureSubImage3DEXT(GetCtxData().GetActiveTexRecord(), target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); } void WrappedOpenGL::glMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) { m_Real.glMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); - - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(format)) return; - - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); if(m_State >= WRITING) - { - if(m_State == WRITING_IDLE && unpackbuf != 0) - { - GetResourceManager()->MarkDirtyResource(GetCtxData().GetActiveTexRecord()->GetResourceID()); - } - else - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) - return; - - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE3D); - Serialise_glTextureSubImage3DEXT(record->Resource.name, - target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 60) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } - } + Common_glTextureSubImage3DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0], target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); } bool WrappedOpenGL::Serialise_glCompressedTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *pixels) @@ -4820,7 +3612,10 @@ bool WrappedOpenGL::Serialise_glCompressedTextureSubImage1DEXT(GLuint texture, G if(!UnpackBufBound && m_State == READING && m_CurEventID == 0) m_Real.glBindBuffer(eGL_PIXEL_UNPACK_BUFFER, 0); - m_Real.glCompressedTextureSubImage1DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, xoff, Width, fmt, byteSize, buf ? buf : (const void *)bufoffs); + if(Target != eGL_NONE) + m_Real.glCompressedTextureSubImage1DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, xoff, Width, fmt, byteSize, buf ? buf : (const void *)bufoffs); + else + m_Real.glCompressedTextureSubImage1D(GetResourceManager()->GetLiveResource(id).name, Level, xoff, Width, fmt, byteSize, buf ? buf : (const void *)bufoffs); if(!UnpackBufBound && m_State == READING && m_CurEventID == 0) m_Real.glBindBuffer(eGL_PIXEL_UNPACK_BUFFER, unpackbuf); @@ -4831,144 +3626,76 @@ bool WrappedOpenGL::Serialise_glCompressedTextureSubImage1DEXT(GLuint texture, G return true; } -void WrappedOpenGL::glCompressedTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *pixels) +void WrappedOpenGL::Common_glCompressedTextureSubImage1DEXT(GLResourceRecord *record, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *pixels) { - m_Real.glCompressedTextureSubImage1DEXT(texture, target, level, xoffset, width, format, imageSize, pixels); - + if(!record) return; + // proxy formats are used for querying texture capabilities, don't serialise these if(IsProxyTarget(format)) return; GLint unpackbuf = 0; m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - if(m_State >= WRITING) + if(m_State == WRITING_IDLE && unpackbuf != 0) { - if(m_State == WRITING_IDLE && unpackbuf != 0) + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); + } + else + { + if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) + return; + + SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE1D_COMPRESSED); + Serialise_glCompressedTextureSubImage1DEXT(record->Resource.name, target, level, xoffset, width, format, imageSize, pixels); + + if(m_State == WRITING_CAPFRAME) { - GetResourceManager()->MarkDirtyResource(TextureRes(GetCtx(), texture)); + m_ContextRecord->AddChunk(scope.Get()); } else { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) - return; + record->AddChunk(scope.Get()); + record->UpdateCount++; - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE1D_COMPRESSED); - Serialise_glCompressedTextureSubImage1DEXT(texture, target, level, xoffset, width, format, imageSize, pixels); - - if(m_State == WRITING_CAPFRAME) + if(record->UpdateCount > 60) { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 60) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } + m_HighTrafficResources.insert(record->GetResourceID()); + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); } } } } +void WrappedOpenGL::glCompressedTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *pixels) +{ + m_Real.glCompressedTextureSubImage1DEXT(texture, target, level, xoffset, width, format, imageSize, pixels); + + if(m_State >= WRITING) + Common_glCompressedTextureSubImage1DEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), target, level, xoffset, width, format, imageSize, pixels); +} + +void WrappedOpenGL::glCompressedTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *pixels) +{ + m_Real.glCompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, pixels); + + if(m_State >= WRITING) + Common_glCompressedTextureSubImage1DEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), eGL_NONE, level, xoffset, width, format, imageSize, pixels); +} + void WrappedOpenGL::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *pixels) { m_Real.glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, pixels); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(format)) return; - - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - if(m_State >= WRITING) - { - if(m_State == WRITING_IDLE && unpackbuf != 0) - { - GetResourceManager()->MarkDirtyResource(GetCtxData().GetActiveTexRecord()->GetResourceID()); - } - else - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) - return; - - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE1D_COMPRESSED); - Serialise_glCompressedTextureSubImage1DEXT(record->Resource.name, - target, level, xoffset, width, format, imageSize, pixels); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 60) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } - } + Common_glCompressedTextureSubImage1DEXT(GetCtxData().GetActiveTexRecord(), target, level, xoffset, width, format, imageSize, pixels); } void WrappedOpenGL::glCompressedMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *pixels) { m_Real.glCompressedMultiTexSubImage1DEXT(texunit, target, level, xoffset, width, format, imageSize, pixels); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(format)) return; - - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - if(m_State >= WRITING) - { - if(m_State == WRITING_IDLE && unpackbuf != 0) - { - GetResourceManager()->MarkDirtyResource(GetCtxData().GetActiveTexRecord()->GetResourceID()); - } - else - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) - return; - - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE1D_COMPRESSED); - Serialise_glCompressedTextureSubImage1DEXT(record->Resource.name, - target, level, xoffset, width, format, imageSize, pixels); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 60) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } - } + Common_glCompressedTextureSubImage1DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0], target, level, xoffset, width, format, imageSize, pixels); } bool WrappedOpenGL::Serialise_glCompressedTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) @@ -5010,8 +3737,11 @@ bool WrappedOpenGL::Serialise_glCompressedTextureSubImage2DEXT(GLuint texture, G { if(!UnpackBufBound && m_State == READING && m_CurEventID == 0) m_Real.glBindBuffer(eGL_PIXEL_UNPACK_BUFFER, 0); - - m_Real.glCompressedTextureSubImage2DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, xoff, yoff, Width, Height, fmt, byteSize, buf ? buf : (const void *)bufoffs); + + if(Target != eGL_NONE) + m_Real.glCompressedTextureSubImage2DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, xoff, yoff, Width, Height, fmt, byteSize, buf ? buf : (const void *)bufoffs); + else + m_Real.glCompressedTextureSubImage2D(GetResourceManager()->GetLiveResource(id).name, Level, xoff, yoff, Width, Height, fmt, byteSize, buf ? buf : (const void *)bufoffs); if(!UnpackBufBound && m_State == READING && m_CurEventID == 0) m_Real.glBindBuffer(eGL_PIXEL_UNPACK_BUFFER, unpackbuf); @@ -5022,144 +3752,76 @@ bool WrappedOpenGL::Serialise_glCompressedTextureSubImage2DEXT(GLuint texture, G return true; } -void WrappedOpenGL::glCompressedTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) +void WrappedOpenGL::Common_glCompressedTextureSubImage2DEXT(GLResourceRecord *record, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) { - m_Real.glCompressedTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, imageSize, pixels); - + if(!record) return; + // proxy formats are used for querying texture capabilities, don't serialise these if(IsProxyTarget(format)) return; GLint unpackbuf = 0; m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - if(m_State >= WRITING) + if(m_State == WRITING_IDLE && unpackbuf != 0) { - if(m_State == WRITING_IDLE && unpackbuf != 0) + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); + } + else + { + if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) + return; + + SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE2D_COMPRESSED); + Serialise_glCompressedTextureSubImage2DEXT(record->Resource.name, target, level, xoffset, yoffset, width, height, format, imageSize, pixels); + + if(m_State == WRITING_CAPFRAME) { - GetResourceManager()->MarkDirtyResource(TextureRes(GetCtx(), texture)); + m_ContextRecord->AddChunk(scope.Get()); } else { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) - return; + record->AddChunk(scope.Get()); + record->UpdateCount++; - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE2D_COMPRESSED); - Serialise_glCompressedTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, imageSize, pixels); - - if(m_State == WRITING_CAPFRAME) + if(record->UpdateCount > 60) { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 60) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } + m_HighTrafficResources.insert(record->GetResourceID()); + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); } } } } +void WrappedOpenGL::glCompressedTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) +{ + m_Real.glCompressedTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, imageSize, pixels); + + if(m_State >= WRITING) + Common_glCompressedTextureSubImage2DEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), target, level, xoffset, yoffset, width, height, format, imageSize, pixels); +} + +void WrappedOpenGL::glCompressedTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) +{ + m_Real.glCompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, pixels); + + if(m_State >= WRITING) + Common_glCompressedTextureSubImage2DEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), eGL_NONE, level, xoffset, yoffset, width, height, format, imageSize, pixels); +} + void WrappedOpenGL::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) { m_Real.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, pixels); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(format)) return; - - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - if(m_State >= WRITING) - { - if(m_State == WRITING_IDLE && unpackbuf != 0) - { - GetResourceManager()->MarkDirtyResource(GetCtxData().GetActiveTexRecord()->GetResourceID()); - } - else - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) - return; - - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE2D_COMPRESSED); - Serialise_glCompressedTextureSubImage2DEXT(record->Resource.name, - target, level, xoffset, yoffset, width, height, format, imageSize, pixels); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 60) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } - } + Common_glCompressedTextureSubImage2DEXT(GetCtxData().GetActiveTexRecord(), target, level, xoffset, yoffset, width, height, format, imageSize, pixels); } void WrappedOpenGL::glCompressedMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) { m_Real.glCompressedMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, imageSize, pixels); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(format)) return; - - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - if(m_State >= WRITING) - { - if(m_State == WRITING_IDLE && unpackbuf != 0) - { - GetResourceManager()->MarkDirtyResource(GetCtxData().GetActiveTexRecord()->GetResourceID()); - } - else - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) - return; - - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE2D_COMPRESSED); - Serialise_glCompressedTextureSubImage2DEXT(record->Resource.name, - target, level, xoffset, yoffset, width, height, format, imageSize, pixels); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 60) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } - } + Common_glCompressedTextureSubImage2DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0], target, level, xoffset, yoffset, width, height, format, imageSize, pixels); } bool WrappedOpenGL::Serialise_glCompressedTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) @@ -5203,8 +3865,11 @@ bool WrappedOpenGL::Serialise_glCompressedTextureSubImage3DEXT(GLuint texture, G { if(!UnpackBufBound && m_State == READING && m_CurEventID == 0) m_Real.glBindBuffer(eGL_PIXEL_UNPACK_BUFFER, 0); - - m_Real.glCompressedTextureSubImage3DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, xoff, yoff, zoff, Width, Height, Depth, fmt, byteSize, buf ? buf : (const void *)bufoffs); + + if(Target != eGL_NONE) + m_Real.glCompressedTextureSubImage3DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, xoff, yoff, zoff, Width, Height, Depth, fmt, byteSize, buf ? buf : (const void *)bufoffs); + else + m_Real.glCompressedTextureSubImage3D(GetResourceManager()->GetLiveResource(id).name, Level, xoff, yoff, zoff, Width, Height, Depth, fmt, byteSize, buf ? buf : (const void *)bufoffs); if(!UnpackBufBound && m_State == READING && m_CurEventID == 0) m_Real.glBindBuffer(eGL_PIXEL_UNPACK_BUFFER, unpackbuf); @@ -5215,144 +3880,76 @@ bool WrappedOpenGL::Serialise_glCompressedTextureSubImage3DEXT(GLuint texture, G return true; } -void WrappedOpenGL::glCompressedTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) +void WrappedOpenGL::Common_glCompressedTextureSubImage3DEXT(GLResourceRecord *record, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) { - m_Real.glCompressedTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); - + if(!record) return; + // proxy formats are used for querying texture capabilities, don't serialise these if(IsProxyTarget(format)) return; GLint unpackbuf = 0; m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - if(m_State >= WRITING) + if(m_State == WRITING_IDLE && unpackbuf != 0) { - if(m_State == WRITING_IDLE && unpackbuf != 0) + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); + } + else + { + if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) + return; + + SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE3D_COMPRESSED); + Serialise_glCompressedTextureSubImage3DEXT(record->Resource.name, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); + + if(m_State == WRITING_CAPFRAME) { - GetResourceManager()->MarkDirtyResource(TextureRes(GetCtx(), texture)); + m_ContextRecord->AddChunk(scope.Get()); } else { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) - return; + record->AddChunk(scope.Get()); + record->UpdateCount++; - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE3D_COMPRESSED); - Serialise_glCompressedTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); - - if(m_State == WRITING_CAPFRAME) + if(record->UpdateCount > 60) { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 60) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } + m_HighTrafficResources.insert(record->GetResourceID()); + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); } } } } +void WrappedOpenGL::glCompressedTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) +{ + m_Real.glCompressedTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); + + if(m_State >= WRITING) + Common_glCompressedTextureSubImage3DEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); +} + +void WrappedOpenGL::glCompressedTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) +{ + m_Real.glCompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); + + if(m_State >= WRITING) + Common_glCompressedTextureSubImage3DEXT(GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)), eGL_NONE, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); +} + void WrappedOpenGL::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) { m_Real.glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(format)) return; - - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - if(m_State >= WRITING) - { - if(m_State == WRITING_IDLE && unpackbuf != 0) - { - GetResourceManager()->MarkDirtyResource(GetCtxData().GetActiveTexRecord()->GetResourceID()); - } - else - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) - return; - - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE3D_COMPRESSED); - Serialise_glCompressedTextureSubImage3DEXT(record->Resource.name, - target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 60) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } - } + Common_glCompressedTextureSubImage3DEXT(GetCtxData().GetActiveTexRecord(), target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); } void WrappedOpenGL::glCompressedMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) { m_Real.glCompressedMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); - // proxy formats are used for querying texture capabilities, don't serialise these - if(IsProxyTarget(format)) return; - - GLint unpackbuf = 0; - m_Real.glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, &unpackbuf); - if(m_State >= WRITING) - { - if(m_State == WRITING_IDLE && unpackbuf != 0) - { - GetResourceManager()->MarkDirtyResource(GetCtxData().GetActiveTexRecord()->GetResourceID()); - } - else - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - if(m_HighTrafficResources.find(record->GetResourceID()) != m_HighTrafficResources.end() && m_State == WRITING_IDLE) - return; - - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE3D_COMPRESSED); - Serialise_glCompressedTextureSubImage3DEXT(record->Resource.name, - target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->UpdateCount++; - - if(record->UpdateCount > 60) - { - m_HighTrafficResources.insert(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - } - } - } - } + Common_glCompressedTextureSubImage3DEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0], target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); } #pragma endregion @@ -5376,37 +3973,43 @@ bool WrappedOpenGL::Serialise_glTextureBufferRangeEXT(GLuint texture, GLenum tar m_Textures[liveId].width = uint32_t(Size)/uint32_t(GetByteSize(1, 1, 1, GetBaseFormat(fmt), GetDataType(fmt))); m_Textures[liveId].height = 1; m_Textures[liveId].depth = 1; - m_Textures[liveId].curType = TextureTarget(Target); + if(Target != eGL_NONE) m_Textures[liveId].curType = TextureTarget(Target); m_Textures[liveId].internalFormat = fmt; } - m_Real.glTextureBufferRangeEXT(GetResourceManager()->GetLiveResource(texid).name, - Target, fmt, - GetResourceManager()->GetLiveResource(bufid).name, - (GLintptr)offs, (GLsizeiptr)Size); + if(Target != eGL_NONE) + m_Real.glTextureBufferRangeEXT(GetResourceManager()->GetLiveResource(texid).name, + Target, fmt, + GetResourceManager()->GetLiveResource(bufid).name, + (GLintptr)offs, (GLsizeiptr)Size); + else + m_Real.glTextureBufferRange(GetResourceManager()->GetLiveResource(texid).name, + fmt, + GetResourceManager()->GetLiveResource(bufid).name, + (GLintptr)offs, (GLsizei)Size); } return true; } -void WrappedOpenGL::glTextureBufferRangeEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) +void WrappedOpenGL::Common_glTextureBufferRangeEXT(ResourceId texId, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) { - m_Real.glTextureBufferRangeEXT(texture, target, internalformat, buffer, offset, size); - + if(texId == ResourceId()) return; + if(m_State >= WRITING) { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(texId); RDCASSERT(record); - if(record->datatype == TextureBinding(target) && m_Textures[record->GetResourceID()].internalFormat == internalformat && m_State == WRITING_IDLE) + if(record->datatype == TextureBinding(target) && m_Textures[texId].internalFormat == internalformat && m_State == WRITING_IDLE) { - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); + GetResourceManager()->MarkDirtyResource(texId); GetResourceManager()->MarkDirtyResource(BufferRes(GetCtx(), buffer)); return; } SCOPED_SERIALISE_CONTEXT(TEXBUFFER_RANGE); - Serialise_glTextureBufferRangeEXT(texture, target, internalformat, buffer, offset, size); + Serialise_glTextureBufferRangeEXT(record->Resource.name, target, internalformat, buffer, offset, size); if(m_State == WRITING_CAPFRAME) { @@ -5420,62 +4023,42 @@ void WrappedOpenGL::glTextureBufferRangeEXT(GLuint texture, GLenum target, GLenu } { - GLuint texture = 0; - m_Real.glGetIntegerv(TextureBinding(target), (GLint *)&texture); - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - m_Textures[texId].width = uint32_t(size)/uint32_t(GetByteSize(1, 1, 1, GetBaseFormat(internalformat), GetDataType(internalformat))); m_Textures[texId].height = 1; m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); + if(target != eGL_NONE) m_Textures[texId].curType = TextureTarget(target); m_Textures[texId].dimension = 1; m_Textures[texId].internalFormat = internalformat; } } +void WrappedOpenGL::glTextureBufferRangeEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + m_Real.glTextureBufferRangeEXT(texture, target, internalformat, buffer, offset, size); + + Common_glTextureBufferRangeEXT(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)), target, internalformat, buffer, offset, size); +} + +void WrappedOpenGL::glTextureBufferRange(GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizei size) +{ + m_Real.glTextureBufferRange(texture, internalformat, buffer, offset, size); + + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); + + Common_glTextureBufferRangeEXT(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)), eGL_NONE, internalformat, buffer, offset, (GLsizeiptr)size); +} + void WrappedOpenGL::glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) { m_Real.glTexBufferRange(target, internalformat, buffer, offset, size); - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - if(record->datatype == TextureBinding(target) && m_Textures[record->GetResourceID()].internalFormat == internalformat && m_State == WRITING_IDLE) - { - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(BufferRes(GetCtx(), buffer)); - return; - } + + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - SCOPED_SERIALISE_CONTEXT(TEXBUFFER_RANGE); - Serialise_glTextureBufferRangeEXT(record->Resource.name, - target, internalformat, buffer, offset, size); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(scope.Get()); - } - else - { - record->AddChunk(scope.Get()); - record->AddParent(GetResourceManager()->GetResourceRecord(BufferRes(GetCtx(), buffer))); - } - } - - { - GLuint texture = 0; - m_Real.glGetIntegerv(TextureBinding(target), (GLint *)&texture); - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - - m_Textures[texId].width = uint32_t(size)/uint32_t(GetByteSize(1, 1, 1, GetBaseFormat(internalformat), GetDataType(internalformat))); - m_Textures[texId].height = 1; - m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 1; - m_Textures[texId].internalFormat = internalformat; - } + Common_glTextureBufferRangeEXT(GetCtxData().GetActiveTexRecord()->GetResourceID(), target, internalformat, buffer, offset, size); } bool WrappedOpenGL::Serialise_glTextureBufferEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer) @@ -5497,36 +4080,37 @@ bool WrappedOpenGL::Serialise_glTextureBufferEXT(GLuint texture, GLenum target, m_Textures[liveId].width = Size/uint32_t(GetByteSize(1, 1, 1, GetBaseFormat(fmt), GetDataType(fmt))); m_Textures[liveId].height = 1; m_Textures[liveId].depth = 1; - m_Textures[liveId].curType = TextureTarget(Target); + if(Target != eGL_NONE) m_Textures[liveId].curType = TextureTarget(Target); m_Textures[liveId].internalFormat = fmt; } - - m_Real.glTextureBufferEXT(GetResourceManager()->GetLiveResource(texid).name, - Target, fmt, - buffer); + + if(Target != eGL_NONE) + m_Real.glTextureBufferEXT(GetResourceManager()->GetLiveResource(texid).name, Target, fmt, buffer); + else + m_Real.glTextureBuffer(GetResourceManager()->GetLiveResource(texid).name, fmt, buffer); } return true; } -void WrappedOpenGL::glTextureBufferEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer) +void WrappedOpenGL::Common_glTextureBufferEXT(ResourceId texId, GLenum target, GLenum internalformat, GLuint buffer) { - m_Real.glTextureBufferEXT(texture, target, internalformat, buffer); + if(texId == ResourceId()) return; if(m_State >= WRITING) { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture)); + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(texId); RDCASSERT(record); - - if(record->datatype == TextureBinding(target) && m_Textures[record->GetResourceID()].internalFormat == internalformat && m_State == WRITING_IDLE) + + if(record->datatype == TextureBinding(target) && m_Textures[texId].internalFormat == internalformat && m_State == WRITING_IDLE) { - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); + GetResourceManager()->MarkDirtyResource(texId); GetResourceManager()->MarkDirtyResource(BufferRes(GetCtx(), buffer)); return; } SCOPED_SERIALISE_CONTEXT(TEXBUFFER); - Serialise_glTextureBufferEXT(texture, target, internalformat, buffer); + Serialise_glTextureBufferEXT(record->Resource.name, target, internalformat, buffer); Chunk *chunk = scope.Get(); @@ -5542,117 +4126,55 @@ void WrappedOpenGL::glTextureBufferEXT(GLuint texture, GLenum target, GLenum int } { - GLuint texture = 0; - m_Real.glGetIntegerv(TextureBinding(target), (GLint *)&texture); - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - uint32_t size = 1; m_Real.glGetNamedBufferParameterivEXT(buffer, eGL_BUFFER_SIZE, (GLint *)&size); m_Textures[texId].width = uint32_t(size)/uint32_t(GetByteSize(1, 1, 1, GetBaseFormat(internalformat), GetDataType(internalformat))); m_Textures[texId].height = 1; m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); + if(target != eGL_NONE) m_Textures[texId].curType = TextureTarget(target); m_Textures[texId].dimension = 1; m_Textures[texId].internalFormat = internalformat; } } +void WrappedOpenGL::glTextureBufferEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer) +{ + m_Real.glTextureBufferEXT(texture, target, internalformat, buffer); + + Common_glTextureBufferEXT(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)), target, internalformat, buffer); +} + +void WrappedOpenGL::glTextureBuffer(GLuint texture, GLenum internalformat, GLuint buffer) +{ + m_Real.glTextureBuffer(texture, internalformat, buffer); + + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); + + Common_glTextureBufferEXT(GetResourceManager()->GetID(TextureRes(GetCtx(), texture)), eGL_NONE, internalformat, buffer); +} + void WrappedOpenGL::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer) { m_Real.glTexBuffer(target, internalformat, buffer); - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().GetActiveTexRecord(); - RDCASSERT(record); - - if(record->datatype == TextureBinding(target) && m_Textures[record->GetResourceID()].internalFormat == internalformat && m_State == WRITING_IDLE) - { - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(BufferRes(GetCtx(), buffer)); - return; - } + + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - SCOPED_SERIALISE_CONTEXT(TEXBUFFER); - Serialise_glTextureBufferEXT(record->Resource.name, - target, internalformat, buffer); - - Chunk *chunk = scope.Get(); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(chunk); - } - else - { - record->AddChunk(chunk); - record->AddParent(GetResourceManager()->GetResourceRecord(BufferRes(GetCtx(), buffer))); - } - } - - { - GLuint texture = 0; - m_Real.glGetIntegerv(TextureBinding(target), (GLint *)&texture); - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - - uint32_t size = 1; - m_Real.glGetNamedBufferParameterivEXT(buffer, eGL_BUFFER_SIZE, (GLint *)&size); - m_Textures[texId].width = uint32_t(size)/uint32_t(GetByteSize(1, 1, 1, GetBaseFormat(internalformat), GetDataType(internalformat))); - m_Textures[texId].height = 1; - m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 1; - m_Textures[texId].internalFormat = internalformat; - } + Common_glTextureBufferEXT(GetCtxData().GetActiveTexRecord()->GetResourceID(), target, internalformat, buffer); } void WrappedOpenGL::glMultiTexBufferEXT(GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer) { m_Real.glMultiTexBufferEXT(texunit, target, internalformat, buffer); - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]; - RDCASSERT(record); - - if(record->datatype == TextureBinding(target) && m_Textures[record->GetResourceID()].internalFormat == internalformat && m_State == WRITING_IDLE) - { - GetResourceManager()->MarkDirtyResource(record->GetResourceID()); - GetResourceManager()->MarkDirtyResource(BufferRes(GetCtx(), buffer)); - return; - } + + // saves on queries of the currently bound texture to this target, as we don't have records on replay + if(m_State < WRITING) + RDCERR("Internal textures should be allocated via dsa interfaces"); - SCOPED_SERIALISE_CONTEXT(TEXBUFFER); - Serialise_glTextureBufferEXT(record->Resource.name, - target, internalformat, buffer); - - Chunk *chunk = scope.Get(); - - if(m_State == WRITING_CAPFRAME) - { - m_ContextRecord->AddChunk(chunk); - } - else - { - record->AddChunk(chunk); - record->AddParent(GetResourceManager()->GetResourceRecord(BufferRes(GetCtx(), buffer))); - } - } - - { - GLuint texture = 0; - m_Real.glGetIntegerv(TextureBinding(target), (GLint *)&texture); - ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture)); - - uint32_t size = 1; - m_Real.glGetNamedBufferParameterivEXT(buffer, eGL_BUFFER_SIZE, (GLint *)&size); - m_Textures[texId].width = uint32_t(size)/uint32_t(GetByteSize(1, 1, 1, GetBaseFormat(internalformat), GetDataType(internalformat))); - m_Textures[texId].height = 1; - m_Textures[texId].depth = 1; - m_Textures[texId].curType = TextureTarget(target); - m_Textures[texId].dimension = 1; - m_Textures[texId].internalFormat = internalformat; - } + Common_glTextureBufferEXT(GetCtxData().m_TextureRecord[texunit-eGL_TEXTURE0]->GetResourceID(), target, internalformat, buffer); } #pragma endregion