From 33deeb8618da07017f86681ab0a8327bf08d722e Mon Sep 17 00:00:00 2001 From: baldurk Date: Sun, 22 Feb 2015 21:22:56 +0000 Subject: [PATCH] ARB_dsa part 2 - Implement Texture* family of functions * Since this would be another duplicated set of code, move the variants into common functions - each of the variants (ARB_dsa, EXT_dsa, non-DSA and possibly MultiTex) calls into a common function just with a different resource record. * Handling the ARB/EXT dsa differences on the texture calls, the target parameter is set to GL_NONE for the ARB dsa calls (which lack a target parameter). Then in the serialise replay part, if the target is GL_NONE we use the ARB variant and otherwise use the EXT variant. See the comments at the top of gl_texture_funcs.cpp * For functions with common code that needs to happen on replay, we pass the resource's ID instead of its record, to be compatible with replay where there are no records. To save time & unnecessary queries, also force all internal texture creates on replay to happen through the DSA interfaces so we don't have to go looking up the texture via selectors. --- renderdoc/driver/gl/gl_common.h | 1 + renderdoc/driver/gl/gl_debug.cpp | 14 +- renderdoc/driver/gl/gl_driver.cpp | 12 +- renderdoc/driver/gl/gl_driver.h | 46 + renderdoc/driver/gl/gl_replay.cpp | 30 +- renderdoc/driver/gl/gl_resources.h | 1 + renderdoc/driver/gl/wrappers/gl_emulated.cpp | 1 + .../driver/gl/wrappers/gl_texture_funcs.cpp | 3852 +++++------------ 8 files changed, 1266 insertions(+), 2691 deletions(-) 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