diff --git a/renderdoc/driver/gl/gl_context_driver.cpp b/renderdoc/driver/gl/gl_context_driver.cpp
index 6517a7a9b..b7f75ea60 100644
--- a/renderdoc/driver/gl/gl_context_driver.cpp
+++ b/renderdoc/driver/gl/gl_context_driver.cpp
@@ -57,10 +57,10 @@ void WrappedOpenGL::glBlendFunc(GLenum sfactor, GLenum dfactor)
 
 bool WrappedOpenGL::Serialise_glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-	SERIALISE_ELEMENT(GLfloat, r, red);
-	SERIALISE_ELEMENT(GLfloat, g, green);
-	SERIALISE_ELEMENT(GLfloat, b, blue);
-	SERIALISE_ELEMENT(GLfloat, a, alpha);
+	SERIALISE_ELEMENT(float, r, red);
+	SERIALISE_ELEMENT(float, g, green);
+	SERIALISE_ELEMENT(float, b, blue);
+	SERIALISE_ELEMENT(float, a, alpha);
 
 	if(m_State <= EXECUTING)
 	{
@@ -452,10 +452,10 @@ void WrappedOpenGL::glColorMaski(GLuint buf, GLboolean red, GLboolean green, GLb
 
 bool WrappedOpenGL::Serialise_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-	SERIALISE_ELEMENT(GLint, X, x);
-	SERIALISE_ELEMENT(GLint, Y, y);
-	SERIALISE_ELEMENT(GLint, W, width);
-	SERIALISE_ELEMENT(GLint, H, height);
+	SERIALISE_ELEMENT(int32_t, X, x);
+	SERIALISE_ELEMENT(int32_t, Y, y);
+	SERIALISE_ELEMENT(int32_t, W, width);
+	SERIALISE_ELEMENT(int32_t, H, height);
 
 	if(m_State <= EXECUTING)
 	{
@@ -480,8 +480,8 @@ void WrappedOpenGL::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 
 bool WrappedOpenGL::Serialise_glViewportArrayv(GLuint index, GLuint count, const GLfloat *v)
 {
-	SERIALISE_ELEMENT(GLuint, idx, index);
-	SERIALISE_ELEMENT(GLuint, cnt, count);
+	SERIALISE_ELEMENT(uint32_t, idx, index);
+	SERIALISE_ELEMENT(uint32_t, cnt, count);
 	SERIALISE_ELEMENT_ARR(GLfloat, views, v, cnt*4);
 
 	if(m_State <= EXECUTING)
@@ -630,7 +630,7 @@ bool WrappedOpenGL::Serialise_glObjectLabel(GLenum identifier, GLuint name, GLsi
 
 	SERIALISE_ELEMENT(GLenum, Identifier, identifier);
 	SERIALISE_ELEMENT(ResourceId, id, liveid);
-	SERIALISE_ELEMENT(GLsizei, Length, length);
+	SERIALISE_ELEMENT(uint32_t, Length, length);
 	SERIALISE_ELEMENT(bool, HasLabel, label != NULL);
 
 	m_pSerialiser->SerialiseString("label", Label);
@@ -664,10 +664,10 @@ void WrappedOpenGL::glObjectLabel(GLenum identifier, GLuint name, GLsizei length
 bool WrappedOpenGL::Serialise_glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
 {
 	SERIALISE_ELEMENT(GLenum, Mode, mode);
-	SERIALISE_ELEMENT(GLint, First, first);
-	SERIALISE_ELEMENT(GLsizei, Count, count);
-	SERIALISE_ELEMENT(GLsizei, InstanceCount, instancecount);
-	SERIALISE_ELEMENT(GLuint, BaseInstance, baseinstance);
+	SERIALISE_ELEMENT(int32_t, First, first);
+	SERIALISE_ELEMENT(uint32_t, Count, count);
+	SERIALISE_ELEMENT(uint32_t, InstanceCount, instancecount);
+	SERIALISE_ELEMENT(uint32_t, BaseInstance, baseinstance);
 
 	if(m_State <= EXECUTING)
 	{
@@ -720,8 +720,8 @@ void WrappedOpenGL::glDrawArraysInstancedBaseInstance(GLenum mode, GLint first,
 bool WrappedOpenGL::Serialise_glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
 	SERIALISE_ELEMENT(GLenum, Mode, mode);
-	SERIALISE_ELEMENT(GLint, First, first);
-	SERIALISE_ELEMENT(GLsizei, Count, count);
+	SERIALISE_ELEMENT(int32_t, First, first);
+	SERIALISE_ELEMENT(uint32_t, Count, count);
 
 	if(m_State <= EXECUTING)
 	{
@@ -772,7 +772,7 @@ void WrappedOpenGL::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 bool WrappedOpenGL::Serialise_glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
 	SERIALISE_ELEMENT(GLenum, buf, buffer);
-	SERIALISE_ELEMENT(GLint, draw, drawbuffer);
+	SERIALISE_ELEMENT(int32_t, draw, drawbuffer);
 	
 	if(buf != eGL_DEPTH)
 	{
@@ -786,7 +786,7 @@ bool WrappedOpenGL::Serialise_glClearBufferfv(GLenum buffer, GLint drawbuffer, c
 	}
 	else
 	{
-		SERIALISE_ELEMENT(GLfloat, val, *value);
+		SERIALISE_ELEMENT(float, val, *value);
 
 		if(m_State <= EXECUTING)
 			m_Real.glClearBufferfv(buf, draw, &val);
@@ -828,7 +828,7 @@ void WrappedOpenGL::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLflo
 bool WrappedOpenGL::Serialise_glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
 {
 	SERIALISE_ELEMENT(GLenum, buf, buffer);
-	SERIALISE_ELEMENT(GLint, draw, drawbuffer);
+	SERIALISE_ELEMENT(int32_t, draw, drawbuffer);
 	
 	if(buf != eGL_STENCIL)
 	{
@@ -842,7 +842,7 @@ bool WrappedOpenGL::Serialise_glClearBufferiv(GLenum buffer, GLint drawbuffer, c
 	}
 	else
 	{
-		SERIALISE_ELEMENT(GLint, val, *value);
+		SERIALISE_ELEMENT(int32_t, val, *value);
 
 		if(m_State <= EXECUTING)
 			m_Real.glClearBufferiv(buf, draw, &val);
@@ -884,7 +884,7 @@ void WrappedOpenGL::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint
 bool WrappedOpenGL::Serialise_glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
 	SERIALISE_ELEMENT(GLenum, buf, buffer);
-	SERIALISE_ELEMENT(GLint, draw, drawbuffer);
+	SERIALISE_ELEMENT(int32_t, draw, drawbuffer);
 	
 	{
 		uint32_t v[4];
@@ -931,9 +931,9 @@ void WrappedOpenGL::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLui
 bool WrappedOpenGL::Serialise_glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
 	SERIALISE_ELEMENT(GLenum, buf, buffer);
-	SERIALISE_ELEMENT(GLint, draw, drawbuffer);
-	SERIALISE_ELEMENT(GLfloat, d, depth);
-	SERIALISE_ELEMENT(GLint, s, stencil);
+	SERIALISE_ELEMENT(int32_t, draw, drawbuffer);
+	SERIALISE_ELEMENT(float, d, depth);
+	SERIALISE_ELEMENT(int32_t, s, stencil);
 	
 	if(m_State <= EXECUTING)
 		m_Real.glClearBufferfi(buf, draw, d, s);
@@ -972,7 +972,7 @@ void WrappedOpenGL::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat dep
 
 bool WrappedOpenGL::Serialise_glClear(GLbitfield mask)
 {
-	SERIALISE_ELEMENT(GLbitfield, Mask, mask);
+	SERIALISE_ELEMENT(uint32_t, Mask, mask);
 
 	if(m_State <= EXECUTING)
 		m_Real.glClear(Mask);
@@ -1315,9 +1315,9 @@ void WrappedOpenGL::glEnd()
 
 bool WrappedOpenGL::Serialise_glVertex3f(GLfloat x, GLfloat y, GLfloat z)
 {
-	SERIALISE_ELEMENT(GLfloat, X, x);
-	SERIALISE_ELEMENT(GLfloat, Y, y);
-	SERIALISE_ELEMENT(GLfloat, Z, z);
+	SERIALISE_ELEMENT(float, X, x);
+	SERIALISE_ELEMENT(float, Y, y);
+	SERIALISE_ELEMENT(float, Z, z);
 
 	if(m_State <= EXECUTING)
 		m_Real.glVertex3f(X, Y, Z);
@@ -1343,9 +1343,9 @@ void WrappedOpenGL::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
 
 bool WrappedOpenGL::Serialise_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-	SERIALISE_ELEMENT(GLfloat, NX, nx);
-	SERIALISE_ELEMENT(GLfloat, NY, ny);
-	SERIALISE_ELEMENT(GLfloat, NZ, nz);
+	SERIALISE_ELEMENT(float, NX, nx);
+	SERIALISE_ELEMENT(float, NY, ny);
+	SERIALISE_ELEMENT(float, NZ, nz);
 
 	if(m_State <= EXECUTING)
 		m_Real.glNormal3f(NX, NY, NZ);
@@ -1468,12 +1468,12 @@ void WrappedOpenGL::glLoadIdentity()
 
 bool WrappedOpenGL::Serialise_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-	SERIALISE_ELEMENT(GLdouble, L, left);
-	SERIALISE_ELEMENT(GLdouble, R, right);
-	SERIALISE_ELEMENT(GLdouble, B, bottom);
-	SERIALISE_ELEMENT(GLdouble, T, top);
-	SERIALISE_ELEMENT(GLdouble, N, zNear);
-	SERIALISE_ELEMENT(GLdouble, F, zFar);
+	SERIALISE_ELEMENT(double, L, left);
+	SERIALISE_ELEMENT(double, R, right);
+	SERIALISE_ELEMENT(double, B, bottom);
+	SERIALISE_ELEMENT(double, T, top);
+	SERIALISE_ELEMENT(double, N, zNear);
+	SERIALISE_ELEMENT(double, F, zFar);
 
 	if(m_State <= EXECUTING)
 		m_Real.glFrustum(L, R, B, T, N, F);
@@ -1495,9 +1495,9 @@ void WrappedOpenGL::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GL
 
 bool WrappedOpenGL::Serialise_glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-	SERIALISE_ELEMENT(GLfloat, X, x);
-	SERIALISE_ELEMENT(GLfloat, Y, y);
-	SERIALISE_ELEMENT(GLfloat, Z, z);
+	SERIALISE_ELEMENT(float, X, x);
+	SERIALISE_ELEMENT(float, Y, y);
+	SERIALISE_ELEMENT(float, Z, z);
 
 	if(m_State <= EXECUTING)
 		m_Real.glTranslatef(X, Y, Z);
@@ -1524,10 +1524,10 @@ void WrappedOpenGL::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 
 bool WrappedOpenGL::Serialise_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-	SERIALISE_ELEMENT(GLfloat, ang, angle);
-	SERIALISE_ELEMENT(GLfloat, X, x);
-	SERIALISE_ELEMENT(GLfloat, Y, y);
-	SERIALISE_ELEMENT(GLfloat, Z, z);
+	SERIALISE_ELEMENT(float, ang, angle);
+	SERIALISE_ELEMENT(float, X, x);
+	SERIALISE_ELEMENT(float, Y, y);
+	SERIALISE_ELEMENT(float, Z, z);
 
 	if(m_State <= EXECUTING)
 		m_Real.glRotatef(ang, X, Y, Z);
diff --git a/renderdoc/driver/gl/gl_device_driver.cpp b/renderdoc/driver/gl/gl_device_driver.cpp
index 92e943604..2380b4aea 100644
--- a/renderdoc/driver/gl/gl_device_driver.cpp
+++ b/renderdoc/driver/gl/gl_device_driver.cpp
@@ -167,10 +167,10 @@ void WrappedOpenGL::glBindTexture(GLenum target, GLuint texture)
 bool WrappedOpenGL::Serialise_glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
 {
 	SERIALISE_ELEMENT(GLenum, Target, target);
-	SERIALISE_ELEMENT(GLsizei, Levels, levels);
+	SERIALISE_ELEMENT(uint32_t, Levels, levels);
 	SERIALISE_ELEMENT(GLenum, Format, internalformat);
-	SERIALISE_ELEMENT(GLsizei, Width, width);
-	SERIALISE_ELEMENT(GLsizei, Height, height);
+	SERIALISE_ELEMENT(uint32_t, Width, width);
+	SERIALISE_ELEMENT(uint32_t, Height, height);
 	SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID());
 
 	if(m_State == READING)
@@ -205,11 +205,11 @@ void WrappedOpenGL::glTexStorage2D(GLenum target, GLsizei levels, GLenum interna
 bool WrappedOpenGL::Serialise_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
 {
 	SERIALISE_ELEMENT(GLenum, Target, target);
-	SERIALISE_ELEMENT(GLint, Level, level);
-	SERIALISE_ELEMENT(GLint, xoff, xoffset);
-	SERIALISE_ELEMENT(GLint, yoff, yoffset);
-	SERIALISE_ELEMENT(GLsizei, Width, width);
-	SERIALISE_ELEMENT(GLsizei, Height, height);
+	SERIALISE_ELEMENT(int32_t, Level, level);
+	SERIALISE_ELEMENT(int32_t, xoff, xoffset);
+	SERIALISE_ELEMENT(int32_t, yoff, yoffset);
+	SERIALISE_ELEMENT(uint32_t, Width, width);
+	SERIALISE_ELEMENT(uint32_t, Height, height);
 	SERIALISE_ELEMENT(GLenum, Format, format);
 	SERIALISE_ELEMENT(GLenum, Type, type);
 	SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID());
@@ -361,7 +361,7 @@ void WrappedOpenGL::glSamplerParameteri(GLuint sampler, GLenum pname, GLint para
 bool WrappedOpenGL::Serialise_glPixelStorei(GLenum pname, GLint param)
 {
 	SERIALISE_ELEMENT(GLenum, PName, pname);
-	SERIALISE_ELEMENT(GLint, Param, param);
+	SERIALISE_ELEMENT(int32_t, Param, param);
 
 	if(m_State == READING)
 		m_Real.glPixelStorei(PName, Param);
@@ -549,11 +549,11 @@ GLuint WrappedOpenGL::glCreateShader(GLenum type)
 bool WrappedOpenGL::Serialise_glShaderSource(GLuint shader, GLsizei count, const GLchar* const *source, const GLint *length)
 {
 	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ShaderRes(shader)));
-	SERIALISE_ELEMENT(GLsizei, Count, count);
+	SERIALISE_ELEMENT(uint32_t, Count, count);
 
 	vector<string> srcs;
 
-	for(GLsizei i=0; i < Count; i++)
+	for(uint32_t i=0; i < Count; i++)
 	{
 		string s;
 		if(source)
@@ -573,7 +573,7 @@ bool WrappedOpenGL::Serialise_glShaderSource(GLuint shader, GLsizei count, const
 
 		ResourceId liveId = GetResourceManager()->GetLiveID(id);
 
-		for(GLsizei i=0; i < Count; i++)
+		for(uint32_t i=0; i < Count; i++)
 			m_Shaders[liveId].sources.push_back(strings[i]);
 
 		m_Real.glShaderSource(GetResourceManager()->GetLiveResource(id).name, Count, strings, NULL);
@@ -787,9 +787,9 @@ void WrappedOpenGL::glUseProgram(GLuint program)
 bool WrappedOpenGL::Serialise_glUniformMatrix(GLint location, GLsizei count, GLboolean transpose, const void *value, UniformType type)
 {
 	SERIALISE_ELEMENT(UniformType, Type, type);
-	SERIALISE_ELEMENT(GLint, Loc, location);
-	SERIALISE_ELEMENT(GLsizei, Count, count);
-	SERIALISE_ELEMENT(GLboolean, Transpose, transpose);
+	SERIALISE_ELEMENT(int32_t, Loc, location);
+	SERIALISE_ELEMENT(uint32_t, Count, count);
+	SERIALISE_ELEMENT(uint8_t, Transpose, transpose);
 
 	size_t elemsPerMat = 0;
 
@@ -863,8 +863,8 @@ void WrappedOpenGL::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean
 bool WrappedOpenGL::Serialise_glUniformVector(GLint location, GLsizei count, const void *value, UniformType type)
 {
 	SERIALISE_ELEMENT(UniformType, Type, type);
-	SERIALISE_ELEMENT(GLint, Loc, location);
-	SERIALISE_ELEMENT(GLsizei, Count, count);
+	SERIALISE_ELEMENT(int32_t, Loc, location);
+	SERIALISE_ELEMENT(uint32_t, Count, count);
 	
 	size_t elemsPerVec = 0;
 
@@ -1215,11 +1215,11 @@ GLboolean WrappedOpenGL::glUnmapBuffer(GLenum target)
 
 bool WrappedOpenGL::Serialise_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer)
 {
-	SERIALISE_ELEMENT(GLuint, Index, index);
-	SERIALISE_ELEMENT(GLint, Size, size);
+	SERIALISE_ELEMENT(uint32_t, Index, index);
+	SERIALISE_ELEMENT(int32_t, Size, size);
 	SERIALISE_ELEMENT(GLenum, Type, type);
-	SERIALISE_ELEMENT(GLboolean, Norm, normalized);
-	SERIALISE_ELEMENT(GLsizei, Stride, stride);
+	SERIALISE_ELEMENT(uint8_t, Norm, normalized);
+	SERIALISE_ELEMENT(uint32_t, Stride, stride);
 	SERIALISE_ELEMENT(uint64_t, Offset, (uint64_t)pointer);
 	SERIALISE_ELEMENT(ResourceId, id, m_VertexArrayRecord ? m_VertexArrayRecord->GetResourceID() : ResourceId());
 	
@@ -1258,7 +1258,7 @@ void WrappedOpenGL::glVertexAttribPointer(GLuint index, GLint size, GLenum type,
 
 bool WrappedOpenGL::Serialise_glEnableVertexAttribArray(GLuint index)
 {
-	SERIALISE_ELEMENT(GLuint, Index, index);
+	SERIALISE_ELEMENT(uint32_t, Index, index);
 	
 	if(m_State < WRITING)
 	{