Implement glTexBuffer, multisampled tex functions, glTexImage*

* glTexImage probably makes some assumptions about usage, at the least it
  assumes that it won't be called to re-size/re-allocate textures (that
  will probably break), and it also assumes that level 0 will always be
  glTexImage'd and the other levels are standard mip sizes (I don't know
  what happens in GL if you specify non pow-2 descending mip sizes for
  different levels. Given we're only targetting core 3.2 and above, this is
  probably a safe set of assumptions.

renderdoc/driver/gl/gl_common.h

@@ -95,12 +95,20 @@ enum GLChunkType
 	TEXSTORAGE1D,
 	TEXSTORAGE2D,
 	TEXSTORAGE3D,
+	TEXSTORAGE2DMS,
+	TEXIMAGE1D,
+	TEXIMAGE2D,
+	TEXIMAGE3D,
 	TEXSUBIMAGE1D,
 	TEXSUBIMAGE2D,
 	TEXSUBIMAGE3D,
+	TEXIMAGE1D_COMPRESSED,
+	TEXIMAGE2D_COMPRESSED,
+	TEXIMAGE3D_COMPRESSED,
 	TEXSUBIMAGE1D_COMPRESSED,
 	TEXSUBIMAGE2D_COMPRESSED,
 	TEXSUBIMAGE3D_COMPRESSED,
+	TEXBUFFER,
 	TEXBUFFER_RANGE,
 	PIXELSTORE,
 	TEXPARAMETERF,

renderdoc/driver/gl/gl_driver.cpp

@@ -48,12 +48,20 @@ const char *GLChunkNames[] =
 	"glTexStorage1D",
 	"glTexStorage2D",
 	"glTexStorage3D",
+	"glTexStorage2DMultisample",
+	"glTexImage1D",
+	"glTexImage2D",
+	"glTexImage3D",
 	"glTexSubImage1D",
 	"glTexSubImage2D",
 	"glTexSubImage3D",
+	"glCompressedTexImage1D",
+	"glCompressedTexImage2D",
+	"glCompressedTexImage3D",
 	"glCompressedTexSubImage1D",
 	"glCompressedTexSubImage2D",
 	"glCompressedTexSubImage3D",
+	"glTexBuffer",
 	"glTexBufferRange",
 	"glPixelStore",
 	"glTexParameterf",
@@ -1442,6 +1450,18 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 	case TEXSTORAGE3D:
 		Serialise_glTextureStorage3DEXT(0, eGL_NONE, 0, eGL_NONE, 0, 0, 0);
 		break;
+	case TEXSTORAGE2DMS:
+		Serialise_glTextureStorage2DMultisampleEXT(0, eGL_NONE, 0, eGL_NONE, 0, 0, GL_FALSE);
+		break;
+	case TEXIMAGE1D:
+		Serialise_glTextureImage1DEXT(0, eGL_NONE, 0, 0, 0, 0, eGL_NONE, eGL_NONE, NULL);
+		break;
+	case TEXIMAGE2D:
+		Serialise_glTextureImage2DEXT(0, eGL_NONE, 0, 0, 0, 0, 0, eGL_NONE, eGL_NONE, NULL);
+		break;
+	case TEXIMAGE3D:
+		Serialise_glTextureImage3DEXT(0, eGL_NONE, 0, 0, 0, 0, 0, 0, eGL_NONE, eGL_NONE, NULL);
+		break;
 	case TEXSUBIMAGE1D:
 		Serialise_glTextureSubImage1DEXT(0, eGL_NONE, 0, 0, 0, eGL_NONE, eGL_NONE, NULL);
 		break;
@@ -1451,6 +1471,15 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 	case TEXSUBIMAGE3D:
 		Serialise_glTextureSubImage3DEXT(0, eGL_NONE, 0, 0, 0, 0, 0, 0, 0, eGL_NONE, eGL_NONE, NULL);
 		break;
+	case TEXIMAGE1D_COMPRESSED:
+		Serialise_glCompressedTextureImage1DEXT(0, eGL_NONE, 0, eGL_NONE, 0, 0, 0, NULL);
+		break;
+	case TEXIMAGE2D_COMPRESSED:
+		Serialise_glCompressedTextureImage2DEXT(0, eGL_NONE, 0, eGL_NONE, 0, 0, 0, 0, NULL);
+		break;
+	case TEXIMAGE3D_COMPRESSED:
+		Serialise_glCompressedTextureImage3DEXT(0, eGL_NONE, 0, eGL_NONE, 0, 0, 0, 0, 0, NULL);
+		break;
 	case TEXSUBIMAGE1D_COMPRESSED:
 		Serialise_glCompressedTextureSubImage1DEXT(0, eGL_NONE, 0, 0, 0, eGL_NONE, 0, NULL);
 		break;
@@ -1460,6 +1489,9 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 	case TEXSUBIMAGE3D_COMPRESSED:
 		Serialise_glCompressedTextureSubImage3DEXT(0, eGL_NONE, 0, 0, 0, 0, 0, 0, 0, eGL_NONE, 0, NULL);
 		break;
+	case TEXBUFFER:
+		Serialise_glTextureBufferEXT(0, eGL_NONE, eGL_NONE, 0);
+		break;
 	case TEXBUFFER_RANGE:
 		Serialise_glTextureBufferRangeEXT(0, eGL_NONE, eGL_NONE, 0, 0, 0);
 		break;

renderdoc/driver/gl/gl_driver.h

@@ -380,9 +380,11 @@ class WrappedOpenGL
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glTexImage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *pixels));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * pixels));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * pixels));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTexParameterf(GLenum target, GLenum pname, GLfloat param));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params));
@@ -450,6 +452,7 @@ class WrappedOpenGL
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels));
@@ -962,6 +965,7 @@ class WrappedOpenGL
 		IMPLEMENT_FUNCTION_SERIALISED(void, glNamedFramebufferTexture3DEXT(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glNamedFramebufferRenderbufferEXT(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glNamedFramebufferTextureLayerEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glTextureBufferEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTextureBufferRangeEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels));
@@ -973,6 +977,7 @@ class WrappedOpenGL
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTextureStorage1DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTextureStorage2DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTextureStorage3DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glTextureStorage2DMultisampleEXT(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels));
 		IMPLEMENT_FUNCTION_SERIALISED(void, 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));

renderdoc/driver/gl/gl_hookset.h

@@ -91,7 +91,10 @@ struct GLHookSet
 	PFNGLTEXSTORAGE1DPROC glTexStorage1D;
 	PFNGLTEXSTORAGE2DPROC glTexStorage2D;
 	PFNGLTEXSTORAGE3DPROC glTexStorage3D;
+	PFNGLTEXSTORAGE2DMULTISAMPLEPROC glTexStorage2DMultisample;
 	PFNGLTEXSUBIMAGE3DPROC glTexSubImage3D;
+	PFNGLTEXBUFFERPROC glTexBuffer;
+	PFNGLTEXIMAGE2DMULTISAMPLEPROC glTexImage2DMultisample;
 	PFNGLCOMPRESSEDTEXIMAGE1DPROC glCompressedTexImage1D;
 	PFNGLCOMPRESSEDTEXIMAGE2DPROC glCompressedTexImage2D;
 	PFNGLCOMPRESSEDTEXIMAGE3DPROC glCompressedTexImage3D;
@@ -569,6 +572,7 @@ struct GLHookSet
 	PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC glNamedFramebufferTexture3DEXT;
 	PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC glNamedFramebufferRenderbufferEXT;
 	PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC glNamedFramebufferTextureLayerEXT;
+	PFNGLTEXTUREBUFFEREXTPROC glTextureBufferEXT;
 	PFNGLTEXTUREBUFFERRANGEEXTPROC glTextureBufferRangeEXT;
 	PFNGLTEXTUREIMAGE1DEXTPROC glTextureImage1DEXT;
 	PFNGLTEXTUREIMAGE2DEXTPROC glTextureImage2DEXT;
@@ -580,6 +584,7 @@ struct GLHookSet
 	PFNGLTEXTURESTORAGE1DEXTPROC glTextureStorage1DEXT;
 	PFNGLTEXTURESTORAGE2DEXTPROC glTextureStorage2DEXT;
 	PFNGLTEXTURESTORAGE3DEXTPROC glTextureStorage3DEXT;
+	PFNGLTEXTURESTORAGE2DMULTISAMPLEEXTPROC glTextureStorage2DMultisampleEXT;
 	PFNGLTEXTURESUBIMAGE1DEXTPROC glTextureSubImage1DEXT;
 	PFNGLTEXTURESUBIMAGE2DEXTPROC glTextureSubImage2DEXT;
 	PFNGLTEXTURESUBIMAGE3DEXTPROC glTextureSubImage3DEXT;

renderdoc/driver/gl/gl_hookset_defs.h

@@ -94,7 +94,10 @@
     HookExtension(PFNGLTEXSTORAGE1DPROC, glTexStorage1D); \
     HookExtension(PFNGLTEXSTORAGE2DPROC, glTexStorage2D); \
     HookExtension(PFNGLTEXSTORAGE3DPROC, glTexStorage3D); \
+    HookExtension(PFNGLTEXSTORAGE2DMULTISAMPLEPROC, glTexStorage2DMultisample); \
     HookExtension(PFNGLTEXSUBIMAGE3DPROC, glTexSubImage3D); \
+    HookExtension(PFNGLTEXBUFFERPROC, glTexBuffer); \
+    HookExtension(PFNGLTEXIMAGE2DMULTISAMPLEPROC, glTexImage2DMultisample); \
     HookExtension(PFNGLCOMPRESSEDTEXIMAGE1DPROC, glCompressedTexImage1D); \
     HookExtension(PFNGLCOMPRESSEDTEXIMAGE2DPROC, glCompressedTexImage2D); \
     HookExtension(PFNGLCOMPRESSEDTEXIMAGE3DPROC, glCompressedTexImage3D); \
@@ -588,6 +591,7 @@
     HookExtension(PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC, glNamedFramebufferTexture3DEXT); \
     HookExtension(PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC, glNamedFramebufferRenderbufferEXT); \
     HookExtension(PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC, glNamedFramebufferTextureLayerEXT); \
+    HookExtension(PFNGLTEXTUREBUFFEREXTPROC, glTextureBufferEXT); \
     HookExtension(PFNGLTEXTUREBUFFERRANGEEXTPROC, glTextureBufferRangeEXT); \
     HookExtension(PFNGLTEXTUREIMAGE1DEXTPROC, glTextureImage1DEXT); \
     HookExtension(PFNGLTEXTUREIMAGE2DEXTPROC, glTextureImage2DEXT); \
@@ -599,6 +603,7 @@
     HookExtension(PFNGLTEXTURESTORAGE1DEXTPROC, glTextureStorage1DEXT); \
     HookExtension(PFNGLTEXTURESTORAGE2DEXTPROC, glTextureStorage2DEXT); \
     HookExtension(PFNGLTEXTURESTORAGE3DEXTPROC, glTextureStorage3DEXT); \
+    HookExtension(PFNGLTEXTURESTORAGE2DMULTISAMPLEEXTPROC, glTextureStorage2DMultisampleEXT); \
     HookExtension(PFNGLTEXTURESUBIMAGE1DEXTPROC, glTextureSubImage1DEXT); \
     HookExtension(PFNGLTEXTURESUBIMAGE2DEXTPROC, glTextureSubImage2DEXT); \
     HookExtension(PFNGLTEXTURESUBIMAGE3DEXTPROC, glTextureSubImage3DEXT); \
@@ -725,7 +730,10 @@
     HookWrapper4(void, glTexStorage1D, GLenum, target, GLsizei, levels, GLenum, internalformat, GLsizei, width); \
     HookWrapper5(void, glTexStorage2D, GLenum, target, GLsizei, levels, GLenum, internalformat, GLsizei, width, GLsizei, height); \
     HookWrapper6(void, glTexStorage3D, GLenum, target, GLsizei, levels, GLenum, internalformat, GLsizei, width, GLsizei, height, GLsizei, depth); \
+    HookWrapper6(void, glTexStorage2DMultisample, GLenum, target, GLsizei, samples, GLenum, internalformat, GLsizei, width, GLsizei, height, GLboolean, fixedsamplelocations); \
     HookWrapper11(void, glTexSubImage3D, GLenum, target, GLint, level, GLint, xoffset, GLint, yoffset, GLint, zoffset, GLsizei, width, GLsizei, height, GLsizei, depth, GLenum, format, GLenum, type, const void *, pixels); \
+    HookWrapper3(void, glTexBuffer, GLenum, target, GLenum, internalformat, GLuint, buffer); \
+    HookWrapper6(void, glTexImage2DMultisample, GLenum, target, GLsizei, samples, GLenum, internalformat, GLsizei, width, GLsizei, height, GLboolean, fixedsamplelocations); \
     HookWrapper7(void, glCompressedTexImage1D, GLenum, target, GLint, level, GLenum, internalformat, GLsizei, width, GLint, border, GLsizei, imageSize, const void *, data); \
     HookWrapper8(void, glCompressedTexImage2D, GLenum, target, GLint, level, GLenum, internalformat, GLsizei, width, GLsizei, height, GLint, border, GLsizei, imageSize, const void *, data); \
     HookWrapper9(void, glCompressedTexImage3D, GLenum, target, GLint, level, GLenum, internalformat, GLsizei, width, GLsizei, height, GLsizei, depth, GLint, border, GLsizei, imageSize, const void *, data); \
@@ -1203,6 +1211,7 @@
     HookWrapper6(void, glNamedFramebufferTexture3DEXT, GLuint, framebuffer, GLenum, attachment, GLenum, textarget, GLuint, texture, GLint, level, GLint, zoffset); \
     HookWrapper4(void, glNamedFramebufferRenderbufferEXT, GLuint, framebuffer, GLenum, attachment, GLenum, renderbuffertarget, GLuint, renderbuffer); \
     HookWrapper5(void, glNamedFramebufferTextureLayerEXT, GLuint, framebuffer, GLenum, attachment, GLuint, texture, GLint, level, GLint, layer); \
+    HookWrapper4(void, glTextureBufferEXT, GLuint, texture, GLenum, target, GLenum, internalformat, GLuint, buffer); \
     HookWrapper6(void, glTextureBufferRangeEXT, GLuint, texture, GLenum, target, GLenum, internalformat, GLuint, buffer, GLintptr, offset, GLsizeiptr, size); \
     HookWrapper9(void, glTextureImage1DEXT, GLuint, texture, GLenum, target, GLint, level, GLint, internalformat, GLsizei, width, GLint, border, GLenum, format, GLenum, type, const void *, pixels); \
     HookWrapper10(void, glTextureImage2DEXT, GLuint, texture, GLenum, target, GLint, level, GLint, internalformat, GLsizei, width, GLsizei, height, GLint, border, GLenum, format, GLenum, type, const void *, pixels); \
@@ -1214,6 +1223,7 @@
     HookWrapper5(void, glTextureStorage1DEXT, GLuint, texture, GLenum, target, GLsizei, levels, GLenum, internalformat, GLsizei, width); \
     HookWrapper6(void, glTextureStorage2DEXT, GLuint, texture, GLenum, target, GLsizei, levels, GLenum, internalformat, GLsizei, width, GLsizei, height); \
     HookWrapper7(void, glTextureStorage3DEXT, GLuint, texture, GLenum, target, GLsizei, levels, GLenum, internalformat, GLsizei, width, GLsizei, height, GLsizei, depth); \
+    HookWrapper7(void, glTextureStorage2DMultisampleEXT, GLuint, texture, GLenum, target, GLsizei, samples, GLenum, internalformat, GLsizei, width, GLsizei, height, GLboolean, fixedsamplelocations); \
     HookWrapper8(void, glTextureSubImage1DEXT, GLuint, texture, GLenum, target, GLint, level, GLint, xoffset, GLsizei, width, GLenum, format, GLenum, type, const void *, pixels); \
     HookWrapper10(void, glTextureSubImage2DEXT, GLuint, texture, GLenum, target, GLint, level, GLint, xoffset, GLint, yoffset, GLsizei, width, GLsizei, height, GLenum, format, GLenum, type, const void *, pixels); \
     HookWrapper12(void, 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); \

renderdoc/driver/gl/gl_replay.cpp

@@ -996,49 +996,43 @@ void GLReplay::SavePipelineState()
 
 					switch(refls[s]->Resources[r].resType)
 					{
-					case eResType_None:
-						t = eGL_NONE;
-						break;
-					case eResType_Buffer:
-						t = eGL_TEXTURE_BINDING_BUFFER;
-						break;
-					case eResType_Texture1D:
-						t = eGL_TEXTURE_BINDING_1D;
-						target = eGL_TEXTURE_1D;
-						break;
-					case eResType_Texture1DArray:
-						t = eGL_TEXTURE_BINDING_1D_ARRAY;
-						target = eGL_TEXTURE_1D_ARRAY;
-						break;
-					case eResType_Texture2D:
-						t = eGL_TEXTURE_BINDING_2D;
-						target = eGL_TEXTURE_2D;
-						break;
-					case eResType_Texture2DArray:
-						t = eGL_TEXTURE_BINDING_2D_ARRAY;
-						target = eGL_TEXTURE_2D_ARRAY;
-						break;
-					case eResType_Texture2DMS:
-						t = eGL_TEXTURE_BINDING_2D_MULTISAMPLE;
-						target = eGL_TEXTURE_2D_MULTISAMPLE;
-						break;
-					case eResType_Texture2DMSArray:
-						t = eGL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY;
-						target = eGL_TEXTURE_2D_MULTISAMPLE_ARRAY;
-						break;
-					case eResType_Texture3D:
-						t = eGL_TEXTURE_BINDING_3D;
-						target = eGL_TEXTURE_3D;
-						break;
-					case eResType_TextureCube:
-						t = eGL_TEXTURE_BINDING_CUBE_MAP;
-						target = eGL_TEXTURE_CUBE_MAP;
-						break;
-					case eResType_TextureCubeArray:
-						t = eGL_TEXTURE_BINDING_CUBE_MAP_ARRAY;
-						target = eGL_TEXTURE_CUBE_MAP_ARRAY;
-						break;
+						case eResType_None:
+							target = eGL_NONE;
+							break;
+						case eResType_Buffer:
+							target = eGL_TEXTURE_BUFFER;
+							break;
+						case eResType_Texture1D:
+							target = eGL_TEXTURE_1D;
+							break;
+						case eResType_Texture1DArray:
+							target = eGL_TEXTURE_1D_ARRAY;
+							break;
+						case eResType_Texture2D:
+							target = eGL_TEXTURE_2D;
+							break;
+						case eResType_Texture2DArray:
+							target = eGL_TEXTURE_2D_ARRAY;
+							break;
+						case eResType_Texture2DMS:
+							target = eGL_TEXTURE_2D_MULTISAMPLE;
+							break;
+						case eResType_Texture2DMSArray:
+							target = eGL_TEXTURE_2D_MULTISAMPLE_ARRAY;
+							break;
+						case eResType_Texture3D:
+							target = eGL_TEXTURE_3D;
+							break;
+						case eResType_TextureCube:
+							target = eGL_TEXTURE_CUBE_MAP;
+							break;
+						case eResType_TextureCubeArray:
+							target = eGL_TEXTURE_CUBE_MAP_ARRAY;
+							break;
 					}
+					
+					if(target != eGL_NONE)
+						t = TextureBinding(target);
 
 					if(binding == eGL_NONE)
 					{

renderdoc/driver/gl/gl_resources.cpp

@@ -380,3 +380,35 @@ bool IsSIntFormat(GLenum internalFormat)
 
 	return false;
 }
+
+GLenum TextureBinding(GLenum target)
+{
+	switch(target)
+	{
+		case eGL_TEXTURE_1D:
+			return eGL_TEXTURE_BINDING_1D;
+		case eGL_TEXTURE_1D_ARRAY:
+			return eGL_TEXTURE_BINDING_1D_ARRAY;
+		case eGL_TEXTURE_2D:
+			return eGL_TEXTURE_BINDING_2D;
+		case eGL_TEXTURE_2D_ARRAY:
+			return eGL_TEXTURE_BINDING_2D_ARRAY;
+		case eGL_TEXTURE_2D_MULTISAMPLE:
+			return eGL_TEXTURE_BINDING_2D_MULTISAMPLE;
+		case eGL_TEXTURE_2D_MULTISAMPLE_ARRAY:
+			return eGL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY;
+		case eGL_TEXTURE_RECTANGLE:
+			return eGL_TEXTURE_BINDING_RECTANGLE;
+		case eGL_TEXTURE_3D:
+			return eGL_TEXTURE_BINDING_3D;
+		case eGL_TEXTURE_CUBE_MAP:
+			return eGL_TEXTURE_BINDING_CUBE_MAP;
+		case eGL_TEXTURE_CUBE_MAP_ARRAY:
+			return eGL_TEXTURE_BINDING_CUBE_MAP_ARRAY;
+		case eGL_TEXTURE_BUFFER:
+			return eGL_TEXTURE_BINDING_BUFFER;
+	}
+
+	RDCERR("Unexpected target %x", target);
+	return eGL_NONE;
+}

renderdoc/driver/gl/gl_resources.h

@@ -37,6 +37,8 @@ bool IsDepthStencilFormat(GLenum internalFormat);
 bool IsUIntFormat(GLenum internalFormat);
 bool IsSIntFormat(GLenum internalFormat);
 
+GLenum TextureBinding(GLenum target);
+
 enum GLNamespace
 {
 	eResUnknown = 0,

renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp

@@ -865,92 +865,615 @@ void WrappedOpenGL::glActiveTexture(GLenum texture)
 	}
 }
 
-#pragma region Texture Storage/Upload
+#pragma region Texture Creation (old glTexImage)
 
-void WrappedOpenGL::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
+bool WrappedOpenGL::Serialise_glTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
 {
-	m_Real.glTexImage1D(target, level, internalformat, width, border, format, type, pixels);
+	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(GetCtx(), texture)));
+	SERIALISE_ELEMENT(GLenum, Target, target);
+	SERIALISE_ELEMENT(int32_t, Level, level);
+	SERIALISE_ELEMENT(GLenum, IntFormat, (GLenum)internalformat);
+	SERIALISE_ELEMENT(uint32_t, Width, width);
+	SERIALISE_ELEMENT(int32_t, Border, border);
+	SERIALISE_ELEMENT(GLenum, Format, format);
+	SERIALISE_ELEMENT(GLenum, Type, type);
+	
+	GLint align = 1;
+	m_Real.glGetIntegerv(eGL_UNPACK_ALIGNMENT, &align);
+	
+	GLint rowlen = 0;
+	m_Real.glGetIntegerv(eGL_UNPACK_ROW_LENGTH, &rowlen);
 
-	RDCUNIMPLEMENTED("Old glTexImage1D API not implemented");
-}
+	size_t subimageSize = GetByteSize(rowlen > 0 ? rowlen : Width, 1, 1, Format, Type, align);
 
-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);
+	SERIALISE_ELEMENT_BUF_OPT(byte *, buf, pixels, subimageSize, pixels != NULL);
+	
+	if(m_State == READING)
+	{
+		if(Level == 0) // assume level 0 will always get a glTexImage call
+		{
+			ResourceId liveId = GetResourceManager()->GetLiveID(id);
+			m_Textures[liveId].width = Width;
+			m_Textures[liveId].height = 1;
+			m_Textures[liveId].depth = 1;
+			m_Textures[liveId].curType = Target;
+			m_Textures[liveId].internalFormat = IntFormat;
+		}
 
-	RDCUNIMPLEMENTED("Old glTexImage2D API not implemented");
-}
+		m_Real.glTextureImage1DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, IntFormat, Width, Border, Format, Type, buf);
 
-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);
+		SAFE_DELETE_ARRAY(buf);
+	}
 
-	RDCUNIMPLEMENTED("Old glTexImage3D API not implemented");
+	return true;
 }
 
 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);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture));
+		RDCASSERT(record);
 
-	RDCUNIMPLEMENTED("Old glTexImage1D API not implemented");
+		SCOPED_SERIALISE_CONTEXT(TEXIMAGE1D);
+		Serialise_glTextureImage1DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name,
+																		target, level, internalformat, width, border, format, type, pixels);
+
+		record->AddChunk(scope.Get());
+
+		// illegal to re-type textures
+		if(record->datatype == eGL_NONE)
+			record->datatype = target;
+		else
+			RDCASSERT(record->datatype == target);
+	}
+	else 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 = 1;
+		m_Textures[texId].depth = 1;
+		m_Textures[texId].internalFormat = (GLenum)internalformat;
+	}
+}
+
+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);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = m_TextureRecord[m_TextureUnit];
+		RDCASSERT(record);
+
+		SCOPED_SERIALISE_CONTEXT(TEXIMAGE1D);
+		Serialise_glTextureImage1DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name,
+																		target, level, internalformat, width, border, format, type, pixels);
+
+		record->AddChunk(scope.Get());
+
+		// illegal to re-type textures
+		if(record->datatype == eGL_NONE)
+			record->datatype = target;
+		else
+			RDCASSERT(record->datatype == target);
+	}
+	else 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 = 1;
+		m_Textures[texId].depth = 1;
+		m_Textures[texId].internalFormat = (GLenum)internalformat;
+	}
+}
+
+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)
+{
+	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(GetCtx(), texture)));
+	SERIALISE_ELEMENT(GLenum, Target, target);
+	SERIALISE_ELEMENT(int32_t, Level, level);
+	SERIALISE_ELEMENT(GLenum, IntFormat, (GLenum)internalformat);
+	SERIALISE_ELEMENT(uint32_t, Width, width);
+	SERIALISE_ELEMENT(uint32_t, Height, height);
+	SERIALISE_ELEMENT(int32_t, Border, border);
+	SERIALISE_ELEMENT(GLenum, Format, format);
+	SERIALISE_ELEMENT(GLenum, Type, type);
+	
+	GLint align = 1;
+	m_Real.glGetIntegerv(eGL_UNPACK_ALIGNMENT, &align);
+	
+	GLint rowlen = 0;
+	m_Real.glGetIntegerv(eGL_UNPACK_ROW_LENGTH, &rowlen);
+
+	size_t subimageSize = GetByteSize(rowlen > 0 ? rowlen : Width, Height, 1, Format, Type, align);
+
+	SERIALISE_ELEMENT_BUF_OPT(byte *, buf, pixels, subimageSize, pixels != NULL);
+	
+	if(m_State == READING)
+	{
+		if(Level == 0) // assume level 0 will always get a glTexImage call
+		{
+			ResourceId liveId = GetResourceManager()->GetLiveID(id);
+			m_Textures[liveId].width = Width;
+			m_Textures[liveId].height = Height;
+			m_Textures[liveId].depth = 1;
+			m_Textures[liveId].curType = Target;
+			m_Textures[liveId].internalFormat = IntFormat;
+		}
+
+		m_Real.glTextureImage2DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, IntFormat, Width, Height, Border, Format, Type, buf);
+
+		SAFE_DELETE_ARRAY(buf);
+	}
+
+	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)
 {
 	m_Real.glTextureImage2DEXT(texture, target, level, internalformat, width, height, border, format, type, pixels);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture));
+		RDCASSERT(record);
 
-	RDCUNIMPLEMENTED("Old glTexImage2D API not implemented");
+		SCOPED_SERIALISE_CONTEXT(TEXIMAGE2D);
+		Serialise_glTextureImage2DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name,
+																		target, level, internalformat, width, height, border, format, type, pixels);
+
+		record->AddChunk(scope.Get());
+
+		// illegal to re-type textures
+		if(record->datatype == eGL_NONE)
+			record->datatype = target;
+		else
+			RDCASSERT(record->datatype == target);
+	}
+	else 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].internalFormat = (GLenum)internalformat;
+	}
+}
+
+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);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = m_TextureRecord[m_TextureUnit];
+		RDCASSERT(record);
+
+		SCOPED_SERIALISE_CONTEXT(TEXIMAGE2D);
+		Serialise_glTextureImage2DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name,
+																		target, level, internalformat, width, height, border, format, type, pixels);
+
+		record->AddChunk(scope.Get());
+
+		// illegal to re-type textures
+		if(record->datatype == eGL_NONE)
+			record->datatype = target;
+		else
+			RDCASSERT(record->datatype == target);
+	}
+	else 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].internalFormat = (GLenum)internalformat;
+	}
+}
+
+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)
+{
+	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(GetCtx(), texture)));
+	SERIALISE_ELEMENT(GLenum, Target, target);
+	SERIALISE_ELEMENT(int32_t, Level, level);
+	SERIALISE_ELEMENT(GLenum, IntFormat, (GLenum)internalformat);
+	SERIALISE_ELEMENT(uint32_t, Width, width);
+	SERIALISE_ELEMENT(uint32_t, Height, height);
+	SERIALISE_ELEMENT(uint32_t, Depth, depth);
+	SERIALISE_ELEMENT(int32_t, Border, border);
+	SERIALISE_ELEMENT(GLenum, Format, format);
+	SERIALISE_ELEMENT(GLenum, Type, type);
+	
+	GLint align = 1;
+	m_Real.glGetIntegerv(eGL_UNPACK_ALIGNMENT, &align);
+	
+	GLint rowlen = 0;
+	m_Real.glGetIntegerv(eGL_UNPACK_ROW_LENGTH, &rowlen);
+
+	size_t subimageSize = GetByteSize(rowlen > 0 ? rowlen : Width, Height, Depth, Format, Type, align);
+
+	SERIALISE_ELEMENT_BUF_OPT(byte *, buf, pixels, subimageSize, pixels != NULL);
+	
+	if(m_State == READING)
+	{
+		if(Level == 0) // assume level 0 will always get a glTexImage call
+		{
+			ResourceId liveId = GetResourceManager()->GetLiveID(id);
+			m_Textures[liveId].width = Width;
+			m_Textures[liveId].height = Height;
+			m_Textures[liveId].depth = Depth;
+			m_Textures[liveId].curType = Target;
+			m_Textures[liveId].internalFormat = IntFormat;
+		}
+
+		m_Real.glTextureImage3DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, IntFormat, Width, Height, Depth, Border, Format, Type, buf);
+
+		SAFE_DELETE_ARRAY(buf);
+	}
+
+	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)
 {
 	m_Real.glTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, format, type, pixels);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture));
+		RDCASSERT(record);
 
-	RDCUNIMPLEMENTED("Old glTexImage3D API not implemented");
+		SCOPED_SERIALISE_CONTEXT(TEXIMAGE3D);
+		Serialise_glTextureImage3DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name,
+																		target, level, internalformat, width, height, depth, border, format, type, pixels);
+
+		record->AddChunk(scope.Get());
+
+		// illegal to re-type textures
+		if(record->datatype == eGL_NONE)
+			record->datatype = target;
+		else
+			RDCASSERT(record->datatype == target);
+	}
+	else 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 = depth;
+		m_Textures[texId].internalFormat = (GLenum)internalformat;
+	}
 }
 
-void WrappedOpenGL::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *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.glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, pixels);
+	m_Real.glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = m_TextureRecord[m_TextureUnit];
+		RDCASSERT(record);
 
-	RDCUNIMPLEMENTED("Old glCompressedTexImage1D API not implemented");
+		SCOPED_SERIALISE_CONTEXT(TEXIMAGE3D);
+		Serialise_glTextureImage3DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name,
+																		target, level, internalformat, width, height, depth, border, format, type, pixels);
+
+		record->AddChunk(scope.Get());
+
+		// illegal to re-type textures
+		if(record->datatype == eGL_NONE)
+			record->datatype = target;
+		else
+			RDCASSERT(record->datatype == target);
+	}
+	else 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 = depth;
+		m_Textures[texId].internalFormat = (GLenum)internalformat;
+	}
 }
 
-void WrappedOpenGL::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * pixels)
+bool WrappedOpenGL::Serialise_glCompressedTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *pixels)
 {
-	m_Real.glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, pixels);
+	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(GetCtx(), texture)));
+	SERIALISE_ELEMENT(GLenum, Target, target);
+	SERIALISE_ELEMENT(int32_t, Level, level);
+	SERIALISE_ELEMENT(uint32_t, Width, width);
+	SERIALISE_ELEMENT(GLenum, fmt, internalformat);
+	SERIALISE_ELEMENT(int32_t, Border, border);
+	SERIALISE_ELEMENT(uint32_t, byteSize, imageSize);
 
-	RDCUNIMPLEMENTED("Old glCompressedTexImage2D API not implemented");
-}
+	SERIALISE_ELEMENT_BUF_OPT(byte *, buf, pixels, byteSize, pixels != NULL);
+	
+	if(m_State == READING)
+	{
+		m_Real.glCompressedTextureImage1DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, fmt, Width, Border, byteSize, buf);
 
-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);
+		SAFE_DELETE_ARRAY(buf);
+	}
 
-	RDCUNIMPLEMENTED("Old glCompressedTexImage3D API not implemented");
+	return true;
 }
 
 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);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture));
+		RDCASSERT(record);
 
-	RDCUNIMPLEMENTED("Old glCompressedTexImage1D API not implemented");
+		SCOPED_SERIALISE_CONTEXT(TEXIMAGE1D_COMPRESSED);
+		Serialise_glCompressedTextureImage1DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name,
+																		target, level, internalformat, width, border, imageSize, pixels);
+
+		record->AddChunk(scope.Get());
+
+		// illegal to re-type textures
+		if(record->datatype == eGL_NONE)
+			record->datatype = target;
+		else
+			RDCASSERT(record->datatype == target);
+	}
+	else 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 = 1;
+		m_Textures[texId].depth = 1;
+		m_Textures[texId].internalFormat = internalformat;
+	}
+}
+
+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);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = m_TextureRecord[m_TextureUnit];
+		RDCASSERT(record);
+
+		SCOPED_SERIALISE_CONTEXT(TEXIMAGE1D_COMPRESSED);
+		Serialise_glCompressedTextureImage1DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name,
+																		target, level, internalformat, width, border, imageSize, pixels);
+
+		record->AddChunk(scope.Get());
+
+		// illegal to re-type textures
+		if(record->datatype == eGL_NONE)
+			record->datatype = target;
+		else
+			RDCASSERT(record->datatype == target);
+	}
+	else 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 = 1;
+		m_Textures[texId].depth = 1;
+		m_Textures[texId].internalFormat = internalformat;
+	}
+}
+
+bool WrappedOpenGL::Serialise_glCompressedTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * pixels)
+{
+	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(GetCtx(), texture)));
+	SERIALISE_ELEMENT(GLenum, Target, target);
+	SERIALISE_ELEMENT(int32_t, Level, level);
+	SERIALISE_ELEMENT(uint32_t, Width, width);
+	SERIALISE_ELEMENT(uint32_t, Height, height);
+	SERIALISE_ELEMENT(GLenum, fmt, internalformat);
+	SERIALISE_ELEMENT(int32_t, Border, border);
+	SERIALISE_ELEMENT(uint32_t, byteSize, imageSize);
+
+	SERIALISE_ELEMENT_BUF_OPT(byte *, buf, pixels, byteSize, pixels != NULL);
+	
+	if(m_State == READING)
+	{
+		m_Real.glCompressedTextureImage2DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, fmt, Width, Height, Border, byteSize, buf);
+
+		SAFE_DELETE_ARRAY(buf);
+	}
+
+	return true;
 }
 
 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);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture));
+		RDCASSERT(record);
 
-	RDCUNIMPLEMENTED("Old glCompressedTexImage2D API not implemented");
+		SCOPED_SERIALISE_CONTEXT(TEXIMAGE2D_COMPRESSED);
+		Serialise_glCompressedTextureImage2DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name,
+																		target, level, internalformat, width, height, border, imageSize, pixels);
+
+		record->AddChunk(scope.Get());
+
+		// illegal to re-type textures
+		if(record->datatype == eGL_NONE)
+			record->datatype = target;
+		else
+			RDCASSERT(record->datatype == target);
+	}
+	else 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].internalFormat = internalformat;
+	}
 }
 
-void WrappedOpenGL::glCompressedTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * 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);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = m_TextureRecord[m_TextureUnit];
+		RDCASSERT(record);
+
+		SCOPED_SERIALISE_CONTEXT(TEXIMAGE2D_COMPRESSED);
+		Serialise_glCompressedTextureImage2DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name,
+																		target, level, internalformat, width, height, border, imageSize, pixels);
+
+		record->AddChunk(scope.Get());
+
+		// illegal to re-type textures
+		if(record->datatype == eGL_NONE)
+			record->datatype = target;
+		else
+			RDCASSERT(record->datatype == target);
+	}
+	else 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].internalFormat = internalformat;
+	}
+}
+
+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)
+{
+	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(GetCtx(), texture)));
+	SERIALISE_ELEMENT(GLenum, Target, target);
+	SERIALISE_ELEMENT(int32_t, Level, level);
+	SERIALISE_ELEMENT(uint32_t, Width, width);
+	SERIALISE_ELEMENT(uint32_t, Height, height);
+	SERIALISE_ELEMENT(uint32_t, Depth, depth);
+	SERIALISE_ELEMENT(GLenum, fmt, internalformat);
+	SERIALISE_ELEMENT(int32_t, Border, border);
+	SERIALISE_ELEMENT(uint32_t, byteSize, imageSize);
+
+	SERIALISE_ELEMENT_BUF_OPT(byte *, buf, pixels, byteSize, pixels != NULL);
+	
+	if(m_State == READING)
+	{
+		m_Real.glCompressedTextureImage3DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, fmt, Width, Height, Depth, Border, byteSize, buf);
+
+		SAFE_DELETE_ARRAY(buf);
+	}
+
+	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)
 {
 	m_Real.glCompressedTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, imageSize, pixels);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture));
+		RDCASSERT(record);
 
-	RDCUNIMPLEMENTED("Old glCompressedTexImage3D API not implemented");
+		SCOPED_SERIALISE_CONTEXT(TEXIMAGE3D);
+		Serialise_glCompressedTextureImage3DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name,
+																		target, level, internalformat, width, height, depth, border, imageSize, pixels);
+
+		record->AddChunk(scope.Get());
+
+		// illegal to re-type textures
+		if(record->datatype == eGL_NONE)
+			record->datatype = target;
+		else
+			RDCASSERT(record->datatype == target);
+	}
+	else 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 = depth;
+		m_Textures[texId].internalFormat = internalformat;
+	}
 }
 
+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);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = m_TextureRecord[m_TextureUnit];
+		RDCASSERT(record);
+
+		SCOPED_SERIALISE_CONTEXT(TEXIMAGE3D_COMPRESSED);
+		Serialise_glCompressedTextureImage3DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name,
+																		target, level, internalformat, width, height, depth, border, imageSize, pixels);
+
+		record->AddChunk(scope.Get());
+
+		// illegal to re-type textures
+		if(record->datatype == eGL_NONE)
+			record->datatype = target;
+		else
+			RDCASSERT(record->datatype == target);
+	}
+	else 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 = depth;
+		m_Textures[texId].internalFormat = internalformat;
+	}
+}
+
+#pragma endregion
+
+#pragma region Texture Creation (glTexStorage*)
+
 bool WrappedOpenGL::Serialise_glTextureStorage1DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
 {
 	SERIALISE_ELEMENT(GLenum, Target, target);
@@ -1019,11 +1542,17 @@ void WrappedOpenGL::glTexStorage1D(GLenum target, GLsizei levels, GLenum interna
 																		target, levels, internalformat, width);
 
 		record->AddChunk(scope.Get());
+
+		// illegal to re-type textures
+		if(record->datatype == eGL_NONE)
+			record->datatype = target;
+		else
+			RDCASSERT(record->datatype == target);
 	}
 	else
 	{
 		GLuint texture = 0;
-		m_Real.glGetIntegerv(eGL_TEXTURE_BINDING_1D, (GLint *)&texture);
+		m_Real.glGetIntegerv(TextureBinding(target), (GLint *)&texture);
 		ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture));
 
 		m_Textures[texId].width = width;
@@ -1112,7 +1641,7 @@ void WrappedOpenGL::glTexStorage2D(GLenum target, GLsizei levels, GLenum interna
 	else
 	{
 		GLuint texture = 0;
-		m_Real.glGetIntegerv(eGL_TEXTURE_BINDING_2D, (GLint *)&texture);
+		m_Real.glGetIntegerv(TextureBinding(target), (GLint *)&texture);
 		ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture));
 
 		m_Textures[texId].width = width;
@@ -1202,7 +1731,7 @@ void WrappedOpenGL::glTexStorage3D(GLenum target, GLsizei levels, GLenum interna
 	else
 	{
 		GLuint texture = 0;
-		m_Real.glGetIntegerv(eGL_TEXTURE_BINDING_3D, (GLint *)&texture);
+		m_Real.glGetIntegerv(TextureBinding(target), (GLint *)&texture);
 		ResourceId texId = GetResourceManager()->GetID(TextureRes(GetCtx(), texture));
 
 		m_Textures[texId].width = width;
@@ -1212,6 +1741,136 @@ void WrappedOpenGL::glTexStorage3D(GLenum target, GLsizei levels, GLenum interna
 	}
 }
 
+bool WrappedOpenGL::Serialise_glTextureStorage2DMultisampleEXT(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
+{
+	SERIALISE_ELEMENT(GLenum, Target, target);
+	SERIALISE_ELEMENT(uint32_t, Samples, samples);
+	SERIALISE_ELEMENT(GLenum, Format, internalformat);
+	SERIALISE_ELEMENT(uint32_t, Width, width);
+	SERIALISE_ELEMENT(uint32_t, Height, height);
+	SERIALISE_ELEMENT(bool, Fixedlocs, fixedsamplelocations != 0);
+	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(GetCtx(), texture)));
+
+	if(m_State == READING)
+	{
+		ResourceId liveId = GetResourceManager()->GetLiveID(id);
+		m_Textures[liveId].width = Width;
+		m_Textures[liveId].height = Height;
+		m_Textures[liveId].depth = 1;
+		m_Textures[liveId].curType = Target;
+		m_Textures[liveId].internalFormat = Format;
+
+		m_Real.glTextureStorage2DMultisampleEXT(GetResourceManager()->GetLiveResource(id).name, Target, 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)
+{
+	m_Real.glTextureStorage2DMultisampleEXT(texture, target, samples, internalformat, width, height, fixedsamplelocations);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture));
+		RDCASSERT(record);
+
+		SCOPED_SERIALISE_CONTEXT(TEXSTORAGE2DMS);
+		Serialise_glTextureStorage2DMultisampleEXT(texture, target, samples, internalformat, width, height, fixedsamplelocations);
+
+		record->AddChunk(scope.Get());
+
+		// illegal to re-type textures
+		if(record->datatype == eGL_NONE)
+			record->datatype = target;
+		else
+			RDCASSERT(record->datatype == target);
+	}
+	else
+	{
+		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].internalFormat = internalformat;
+	}
+}
+
+void WrappedOpenGL::glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
+{
+	m_Real.glTexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = m_TextureRecord[m_TextureUnit];
+		RDCASSERT(record);
+
+		SCOPED_SERIALISE_CONTEXT(TEXSTORAGE2DMS);
+		Serialise_glTextureStorage2DMultisampleEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name,
+																		target, samples, internalformat, width, height, fixedsamplelocations);
+
+		record->AddChunk(scope.Get());
+
+		// illegal to re-type textures
+		if(record->datatype == eGL_NONE)
+			record->datatype = target;
+		else
+			RDCASSERT(record->datatype == target);
+	}
+	else
+	{
+		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].internalFormat = internalformat;
+	}
+}
+
+void WrappedOpenGL::glTexImage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
+{
+	m_Real.glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = m_TextureRecord[m_TextureUnit];
+		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(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name,
+		                                           target, samples, internalformat, width, height, fixedsamplelocations);
+
+		record->AddChunk(scope.Get());
+
+		// illegal to re-type textures
+		if(record->datatype == eGL_NONE)
+			record->datatype = target;
+		else
+			RDCASSERT(record->datatype == target);
+	}
+	else
+	{
+		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].internalFormat = internalformat;
+	}
+}
+
+#pragma endregion
+
+#pragma region Texture upload (glTexSubImage*)
+
 bool WrappedOpenGL::Serialise_glTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
 {
 	SERIALISE_ELEMENT(GLenum, Target, target);
@@ -1620,6 +2279,10 @@ void WrappedOpenGL::glCompressedTexSubImage3D(GLenum target, GLint level, GLint
 	}
 }
 
+#pragma endregion
+
+#pragma region Tex Buffer
+
 bool WrappedOpenGL::Serialise_glTextureBufferRangeEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
 	SERIALISE_ELEMENT(GLenum, Target, target);
@@ -1673,4 +2336,54 @@ void WrappedOpenGL::glTexBufferRange(GLenum target, GLenum internalformat, GLuin
 	}
 }
 
+bool WrappedOpenGL::Serialise_glTextureBufferEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer)
+{
+	SERIALISE_ELEMENT(GLenum, Target, target);
+	SERIALISE_ELEMENT(GLenum, fmt, internalformat);
+	SERIALISE_ELEMENT(ResourceId, texid, GetResourceManager()->GetID(TextureRes(GetCtx(), texture)));
+	SERIALISE_ELEMENT(ResourceId, bufid, GetResourceManager()->GetID(TextureRes(GetCtx(), buffer)));
+	
+	if(m_State == READING)
+	{
+		m_Real.glTextureBufferEXT(GetResourceManager()->GetLiveResource(texid).name,
+																	 Target, fmt,
+																	 GetResourceManager()->GetLiveResource(bufid).name);
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glTextureBufferEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer)
+{
+	m_Real.glTextureBufferEXT(texture, target, internalformat, buffer);
+		
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), texture));
+		RDCASSERT(record);
+
+		SCOPED_SERIALISE_CONTEXT(TEXBUFFER);
+		Serialise_glTextureBufferEXT(texture, target, internalformat, buffer);
+
+		record->AddChunk(scope.Get());
+	}
+}
+
+void WrappedOpenGL::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
+{
+	m_Real.glTexBuffer(target, internalformat, buffer);
+		
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = m_TextureRecord[m_TextureUnit];
+		RDCASSERT(record);
+
+		SCOPED_SERIALISE_CONTEXT(TEXBUFFER);
+		Serialise_glTextureBufferEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name,
+																		  target, internalformat, buffer);
+
+		record->AddChunk(scope.Get());
+	}
+}
+
 #pragma endregion