diff --git a/source/graphics/Canvas2D.cpp b/source/graphics/Canvas2D.cpp
index 1968c90666..859f3ae5c8 100644
--- a/source/graphics/Canvas2D.cpp
+++ b/source/graphics/Canvas2D.cpp
@@ -56,8 +56,10 @@ inline void DrawTextureImpl(
 	shader->Uniform(str_colorAdd, add);
 	shader->Uniform(str_colorMul, multiply);
 	shader->Uniform(str_grayscaleFactor, grayscaleFactor);
-	shader->VertexPointer(2, GL_FLOAT, 0, vertices.data());
-	shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, 0, uvs.data());
+	shader->VertexPointer(
+		Renderer::Backend::Format::R32G32_SFLOAT, 0, vertices.data());
+	shader->TexCoordPointer(
+		GL_TEXTURE0, Renderer::Backend::Format::R32G32_SFLOAT, 0, uvs.data());
 	shader->AssertPointersBound();
 
 	deviceCommandContext->Draw(0, vertices.size() / 2);
@@ -249,8 +251,10 @@ void CCanvas2D::DrawLine(const std::vector<CVector2D>& points, const float width
 	shader->Uniform(str_colorAdd, CColor(0.0f, 0.0f, 0.0f, 0.0f));
 	shader->Uniform(str_colorMul, color);
 	shader->Uniform(str_grayscaleFactor, 0.0f);
-	shader->VertexPointer(2, GL_FLOAT, 0, vertices.data());
-	shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, 0, uvs.data());
+	shader->VertexPointer(
+		Renderer::Backend::Format::R32G32_SFLOAT, 0, vertices.data());
+	shader->TexCoordPointer(
+		GL_TEXTURE0, Renderer::Backend::Format::R32G32_SFLOAT, 0, uvs.data());
 	shader->AssertPointersBound();
 
 	m->DeviceCommandContext->SetIndexBufferData(indices.data());
diff --git a/source/graphics/LOSTexture.cpp b/source/graphics/LOSTexture.cpp
index 925ef32e8c..851f3fda2c 100644
--- a/source/graphics/LOSTexture.cpp
+++ b/source/graphics/LOSTexture.cpp
@@ -181,8 +181,8 @@ void CLOSTexture::InterpolateLOS(Renderer::Backend::GL::CDeviceCommandContext* d
 		1.0f, 0.0f,
 		1.0f, 1.0f
 	};
-	shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, 0, quadTex);
-	shader->VertexPointer(2, GL_FLOAT, 0, quadVerts);
+	shader->TexCoordPointer(GL_TEXTURE0, Renderer::Backend::Format::R32G32_SFLOAT, 0, quadTex);
+	shader->VertexPointer(Renderer::Backend::Format::R32G32_SFLOAT, 0, quadVerts);
 	shader->AssertPointersBound();
 	deviceCommandContext->Draw(0, 6);
 
diff --git a/source/graphics/MiniMapTexture.cpp b/source/graphics/MiniMapTexture.cpp
index 46f35cfc59..5a98bb7d16 100644
--- a/source/graphics/MiniMapTexture.cpp
+++ b/source/graphics/MiniMapTexture.cpp
@@ -95,8 +95,10 @@ void DrawTexture(
 		-1.0f, -1.0f, 0.0f
 	};
 
-	shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, 0, quadUVs);
-	shader->VertexPointer(3, GL_FLOAT, 0, quadVertices);
+	shader->TexCoordPointer(
+		GL_TEXTURE0, Renderer::Backend::Format::R32G32_SFLOAT, 0, quadUVs);
+	shader->VertexPointer(
+		Renderer::Backend::Format::R32G32B32_SFLOAT, 0, quadVertices);
 	shader->AssertPointersBound();
 
 	deviceCommandContext->Draw(0, 6);
@@ -566,8 +568,10 @@ void CMiniMapTexture::RenderFinalTexture(
 		u8* base = m_VertexArray.Bind(deviceCommandContext);
 		const GLsizei stride = (GLsizei)m_VertexArray.GetStride();
 
-		shader->VertexPointer(2, GL_FLOAT, stride, base + m_AttributePos.offset);
-		shader->ColorPointer(4, GL_UNSIGNED_BYTE, stride, base + m_AttributeColor.offset);
+		shader->VertexPointer(
+			Renderer::Backend::Format::R32G32_SFLOAT, stride, base + m_AttributePos.offset);
+		shader->ColorPointer(
+			Renderer::Backend::Format::R8G8B8A8_UNORM, stride, base + m_AttributeColor.offset);
 		shader->AssertPointersBound();
 
 		deviceCommandContext->SetIndexBuffer(m_IndexArray.GetBuffer());
diff --git a/source/graphics/ParticleEmitter.cpp b/source/graphics/ParticleEmitter.cpp
index 576bf60272..ddf5a64ad8 100644
--- a/source/graphics/ParticleEmitter.cpp
+++ b/source/graphics/ParticleEmitter.cpp
@@ -208,14 +208,18 @@ void CParticleEmitter::RenderArray(
 
 	GLsizei stride = (GLsizei)m_VertexArray.GetStride();
 
-	shader->VertexPointer(3, GL_FLOAT, stride, base + m_AttributePos.offset);
+	shader->VertexPointer(
+		Renderer::Backend::Format::R32G32B32_SFLOAT, stride, base + m_AttributePos.offset);
 
 	// Pass the sin/cos axis components as texcoords for no particular reason
 	// other than that they fit. (Maybe this should be glVertexAttrib* instead?)
-	shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, stride, base + m_AttributeUV.offset);
-	shader->TexCoordPointer(GL_TEXTURE1, 2, GL_FLOAT, stride, base + m_AttributeAxis.offset);
+	shader->TexCoordPointer(
+		GL_TEXTURE0, Renderer::Backend::Format::R32G32_SFLOAT, stride, base + m_AttributeUV.offset);
+	shader->TexCoordPointer(
+		GL_TEXTURE1, Renderer::Backend::Format::R32G32_SFLOAT, stride, base + m_AttributeAxis.offset);
 
-	shader->ColorPointer(4, GL_UNSIGNED_BYTE, stride, base + m_AttributeColor.offset);
+	shader->ColorPointer(
+		Renderer::Backend::Format::R8G8B8A8_UNORM, stride, base + m_AttributeColor.offset);
 
 	shader->AssertPointersBound();
 
diff --git a/source/graphics/ShaderProgram.cpp b/source/graphics/ShaderProgram.cpp
index b2bb57b621..f76d41702e 100644
--- a/source/graphics/ShaderProgram.cpp
+++ b/source/graphics/ShaderProgram.cpp
@@ -33,6 +33,58 @@
 
 #include <algorithm>
 
+namespace
+{
+
+GLint GLSizeFromFormat(const Renderer::Backend::Format format)
+{
+	GLint size = 1;
+	if (format == Renderer::Backend::Format::R32_SFLOAT ||
+		format == Renderer::Backend::Format::R16_SINT)
+		size = 1;
+	else if (
+		format == Renderer::Backend::Format::R8G8_UNORM ||
+		format == Renderer::Backend::Format::R8G8_UINT ||
+		format == Renderer::Backend::Format::R16G16_SINT ||
+		format == Renderer::Backend::Format::R32G32_SFLOAT)
+		size = 2;
+	else if (format == Renderer::Backend::Format::R32G32B32_SFLOAT)
+		size = 3;
+	else if (
+		format == Renderer::Backend::Format::R32G32B32A32_SFLOAT ||
+		format == Renderer::Backend::Format::R8G8B8A8_UNORM ||
+		format == Renderer::Backend::Format::R8G8B8A8_UINT)
+		size = 4;
+	else
+		debug_warn("Unsupported format.");
+	return size;
+}
+
+GLenum GLTypeFromFormat(const Renderer::Backend::Format format)
+{
+	GLenum type = GL_FLOAT;
+	if (format == Renderer::Backend::Format::R32_SFLOAT ||
+		format == Renderer::Backend::Format::R32G32_SFLOAT ||
+		format == Renderer::Backend::Format::R32G32B32_SFLOAT ||
+		format == Renderer::Backend::Format::R32G32B32A32_SFLOAT)
+		type = GL_FLOAT;
+	else if (
+		format == Renderer::Backend::Format::R16_SINT ||
+		format == Renderer::Backend::Format::R16G16_SINT)
+		type = GL_SHORT;
+	else if (
+		format == Renderer::Backend::Format::R8G8_UNORM ||
+		format == Renderer::Backend::Format::R8G8_UINT ||
+		format == Renderer::Backend::Format::R8G8B8A8_UNORM ||
+		format == Renderer::Backend::Format::R8G8B8A8_UINT)
+		type = GL_UNSIGNED_BYTE;
+	else
+		debug_warn("Unsupported format.");
+	return type;
+}
+
+} // anonymous namespace
+
 #if !CONFIG2_GLES
 
 class CShaderProgramARB : public CShaderProgram
@@ -598,35 +650,45 @@ public:
 	// Map the various fixed-function Pointer functions onto generic vertex attributes
 	// (matching the attribute indexes from ShaderManager's ParseAttribSemantics):
 
-	void VertexPointer(GLint size, GLenum type, GLsizei stride, const void* pointer) override
+	void VertexPointer(const Renderer::Backend::Format format, GLsizei stride, const void* pointer) override
 	{
+		const GLint size = GLSizeFromFormat(format);
+		const GLenum type = GLTypeFromFormat(format);
 		glVertexAttribPointer(0, size, type, GL_FALSE, stride, pointer);
 		m_ValidStreams |= STREAM_POS;
 	}
 
-	void NormalPointer(GLenum type, GLsizei stride, const void* pointer) override
+	void NormalPointer(const Renderer::Backend::Format format, GLsizei stride, const void* pointer) override
 	{
-		glVertexAttribPointer(2, 3, type, (type == GL_FLOAT ? GL_FALSE : GL_TRUE), stride, pointer);
+		const GLint size = GLSizeFromFormat(format);
+		const GLenum type = GLTypeFromFormat(format);
+		glVertexAttribPointer(2, size, type, (type == GL_FLOAT ? GL_FALSE : GL_TRUE), stride, pointer);
 		m_ValidStreams |= STREAM_NORMAL;
 	}
 
-	void ColorPointer(GLint size, GLenum type, GLsizei stride, const void* pointer) override
+	void ColorPointer(const Renderer::Backend::Format format, GLsizei stride, const void* pointer) override
 	{
+		const GLint size = GLSizeFromFormat(format);
+		const GLenum type = GLTypeFromFormat(format);
 		glVertexAttribPointer(3, size, type, (type == GL_FLOAT ? GL_FALSE : GL_TRUE), stride, pointer);
 		m_ValidStreams |= STREAM_COLOR;
 	}
 
-	void TexCoordPointer(GLenum texture, GLint size, GLenum type, GLsizei stride, const void* pointer) override
+	void TexCoordPointer(GLenum texture, const Renderer::Backend::Format format, GLsizei stride, const void* pointer) override
 	{
+		const GLint size = GLSizeFromFormat(format);
+		const GLenum type = GLTypeFromFormat(format);
 		glVertexAttribPointer(8 + texture - GL_TEXTURE0, size, type, GL_FALSE, stride, pointer);
 		m_ValidStreams |= STREAM_UV0 << (texture - GL_TEXTURE0);
 	}
 
-	void VertexAttribPointer(attrib_id_t id, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* pointer) override
+	void VertexAttribPointer(attrib_id_t id, const Renderer::Backend::Format format, GLboolean normalized, GLsizei stride, const void* pointer) override
 	{
 		std::map<CStrIntern, int>::iterator it = m_VertexAttribs.find(id);
 		if (it != m_VertexAttribs.end())
 		{
+			const GLint size = GLSizeFromFormat(format);
+			const GLenum type = GLTypeFromFormat(format);
 			glVertexAttribPointer(it->second, size, type, normalized, stride, pointer);
 		}
 	}
@@ -775,7 +837,7 @@ void CShaderProgram::Uniform(uniform_id_t id, size_t count, const float* v)
 // These should all be overridden by CShaderProgramGLSL, and not used
 // if a non-GLSL shader was loaded instead:
 
-void CShaderProgram::VertexAttribPointer(attrib_id_t UNUSED(id), GLint UNUSED(size), GLenum UNUSED(type),
+void CShaderProgram::VertexAttribPointer(attrib_id_t UNUSED(id), const Renderer::Backend::Format UNUSED(format),
 	GLboolean UNUSED(normalized), GLsizei UNUSED(stride), const void* UNUSED(pointer))
 {
 	debug_warn("Shader type doesn't support VertexAttribPointer");
@@ -809,27 +871,37 @@ void CShaderProgram::TexCoordPointer(GLenum UNUSED(texture), GLint UNUSED(size),
 // both use the fixed-function vertex attribute pointers so we'll share their
 // definitions here:
 
-void CShaderProgram::VertexPointer(GLint size, GLenum type, GLsizei stride, const void* pointer)
+void CShaderProgram::VertexPointer(const Renderer::Backend::Format format, GLsizei stride, const void* pointer)
 {
+	const GLint size = GLSizeFromFormat(format);
+	ENSURE(2 <= size && size <= 4);
+	const GLenum type = GLTypeFromFormat(format);
 	glVertexPointer(size, type, stride, pointer);
 	m_ValidStreams |= STREAM_POS;
 }
 
-void CShaderProgram::NormalPointer(GLenum type, GLsizei stride, const void* pointer)
+void CShaderProgram::NormalPointer(const Renderer::Backend::Format format, GLsizei stride, const void* pointer)
 {
-	glNormalPointer(type, stride, pointer);
+	ENSURE(format == Renderer::Backend::Format::R32G32B32_SFLOAT);
+	glNormalPointer(GL_FLOAT, stride, pointer);
 	m_ValidStreams |= STREAM_NORMAL;
 }
 
-void CShaderProgram::ColorPointer(GLint size, GLenum type, GLsizei stride, const void* pointer)
+void CShaderProgram::ColorPointer(const Renderer::Backend::Format format, GLsizei stride, const void* pointer)
 {
+	const GLint size = GLSizeFromFormat(format);
+	ENSURE(3 <= size && size <= 4);
+	const GLenum type = GLTypeFromFormat(format);
 	glColorPointer(size, type, stride, pointer);
 	m_ValidStreams |= STREAM_COLOR;
 }
 
-void CShaderProgram::TexCoordPointer(GLenum texture, GLint size, GLenum type, GLsizei stride, const void* pointer)
+void CShaderProgram::TexCoordPointer(GLenum texture, const Renderer::Backend::Format format, GLsizei stride, const void* pointer)
 {
 	glClientActiveTextureARB(texture);
+	const GLint size = GLSizeFromFormat(format);
+	ENSURE(1 <= size && size <= 4);
+	const GLenum type = GLTypeFromFormat(format);
 	glTexCoordPointer(size, type, stride, pointer);
 	glClientActiveTextureARB(GL_TEXTURE0);
 	m_ValidStreams |= STREAM_UV0 << (texture - GL_TEXTURE0);
diff --git a/source/graphics/ShaderProgram.h b/source/graphics/ShaderProgram.h
index 2ad4bf5c67..508744f67e 100644
--- a/source/graphics/ShaderProgram.h
+++ b/source/graphics/ShaderProgram.h
@@ -21,6 +21,7 @@
 #include "graphics/ShaderProgramPtr.h"
 #include "lib/ogl.h"
 #include "lib/file/vfs/vfs_path.h"
+#include "renderer/backend/Format.h"
 #include "renderer/backend/gl/Texture.h"
 
 #include <map>
@@ -164,11 +165,11 @@ public:
 
 	// Vertex attribute pointers (equivalent to glVertexPointer etc):
 
-	virtual void VertexPointer(GLint size, GLenum type, GLsizei stride, const void* pointer);
-	virtual void NormalPointer(GLenum type, GLsizei stride, const void* pointer);
-	virtual void ColorPointer(GLint size, GLenum type, GLsizei stride, const void* pointer);
-	virtual void TexCoordPointer(GLenum texture, GLint size, GLenum type, GLsizei stride, const void* pointer);
-	virtual void VertexAttribPointer(attrib_id_t id, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* pointer);
+	virtual void VertexPointer(const Renderer::Backend::Format format, GLsizei stride, const void* pointer);
+	virtual void NormalPointer(const Renderer::Backend::Format format, GLsizei stride, const void* pointer);
+	virtual void ColorPointer(const Renderer::Backend::Format format, GLsizei stride, const void* pointer);
+	virtual void TexCoordPointer(GLenum texture, const Renderer::Backend::Format format, GLsizei stride, const void* pointer);
+	virtual void VertexAttribPointer(attrib_id_t id, const Renderer::Backend::Format format, GLboolean normalized, GLsizei stride, const void* pointer);
 
 	/**
 	 * Checks that all the required vertex attributes have been set.
diff --git a/source/graphics/TextRenderer.cpp b/source/graphics/TextRenderer.cpp
index 429d3043f5..dfe27d794d 100644
--- a/source/graphics/TextRenderer.cpp
+++ b/source/graphics/TextRenderer.cpp
@@ -266,8 +266,10 @@ void CTextRenderer::Render(
 		auto flush = [deviceCommandContext, &idx, &vertexes, &indexes, &shader]() -> void {
 			if (idx == 0)
 				return;
-			shader->VertexPointer(2, GL_SHORT, sizeof(t2f_v2i), &vertexes[0].x);
-			shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, sizeof(t2f_v2i), &vertexes[0].u);
+			shader->VertexPointer(
+				Renderer::Backend::Format::R16G16_SINT, sizeof(t2f_v2i), &vertexes[0].x);
+			shader->TexCoordPointer(
+				GL_TEXTURE0, Renderer::Backend::Format::R32G32_SFLOAT, sizeof(t2f_v2i), &vertexes[0].u);
 
 			deviceCommandContext->SetIndexBufferData(indexes.data());
 			deviceCommandContext->DrawIndexed(0, idx * 6, 0);
diff --git a/source/gui/ObjectTypes/CMiniMap.cpp b/source/gui/ObjectTypes/CMiniMap.cpp
index 648fa9eeea..91b583bb77 100644
--- a/source/gui/ObjectTypes/CMiniMap.cpp
+++ b/source/gui/ObjectTypes/CMiniMap.cpp
@@ -124,8 +124,10 @@ void DrawTexture(
 		x, y, 0.0f
 	};
 
-	shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, 0, quadTex);
-	shader->VertexPointer(3, GL_FLOAT, 0, quadVerts);
+	shader->TexCoordPointer(
+		GL_TEXTURE0, Renderer::Backend::Format::R32G32_SFLOAT, 0, quadTex);
+	shader->VertexPointer(
+		Renderer::Backend::Format::R32G32B32_SFLOAT, 0, quadVerts);
 	shader->AssertPointersBound();
 
 	deviceCommandContext->Draw(0, 6);
diff --git a/source/renderer/DebugRenderer.cpp b/source/renderer/DebugRenderer.cpp
index e9d2a8f038..558d88bcd2 100644
--- a/source/renderer/DebugRenderer.cpp
+++ b/source/renderer/DebugRenderer.cpp
@@ -126,7 +126,8 @@ void CDebugRenderer::DrawLine(
 
 #undef ADD
 
-	debugLineShader->VertexPointer(3, GL_FLOAT, 0, vertices.data());
+	debugLineShader->VertexPointer(
+		Renderer::Backend::Format::R32G32B32_SFLOAT, 0, vertices.data());
 	debugLineShader->AssertPointersBound();
 	deviceCommandContext->Draw(0, vertices.size() / 3);
 
@@ -177,7 +178,8 @@ void CDebugRenderer::DrawCircle(const CVector3D& origin, const float radius, con
 
 #undef ADD
 
-	debugCircleShader->VertexPointer(3, GL_FLOAT, 0, vertices.data());
+	debugCircleShader->VertexPointer(
+		Renderer::Backend::Format::R32G32B32_SFLOAT, 0, vertices.data());
 	debugCircleShader->AssertPointersBound();
 	deviceCommandContext->Draw(0, vertices.size() / 3);
 
@@ -253,7 +255,8 @@ void CDebugRenderer::DrawCameraFrustum(const CCamera& camera, const CColor& colo
 		ADD(intermediatePoints[3]);
 	}
 
-	overlayShader->VertexPointer(3, GL_FLOAT, 0, vertices.data());
+	overlayShader->VertexPointer(
+		Renderer::Backend::Format::R32G32B32_SFLOAT, 0, vertices.data());
 	overlayShader->AssertPointersBound();
 	deviceCommandContext->Draw(0, vertices.size() / 3);
 
@@ -271,7 +274,8 @@ void CDebugRenderer::DrawCameraFrustum(const CCamera& camera, const CColor& colo
 		ADD(farPoints[nextI]);
 	}
 
-	overlayShader->VertexPointer(3, GL_FLOAT, 0, vertices.data());
+	overlayShader->VertexPointer(
+		Renderer::Backend::Format::R32G32B32_SFLOAT, 0, vertices.data());
 	overlayShader->AssertPointersBound();
 	deviceCommandContext->Draw(0, vertices.size() / 3);
 #undef ADD
@@ -325,7 +329,8 @@ void CDebugRenderer::DrawBoundingBox(
 
 #undef ADD_FACE
 
-	shader->VertexPointer(3, GL_FLOAT, 3 * sizeof(float), data.data());
+	shader->VertexPointer(
+		Renderer::Backend::Format::R32G32B32_SFLOAT, 3 * sizeof(float), data.data());
 
 	shader->AssertPointersBound();
 	deviceCommandContext->Draw(0, 6*6);
@@ -371,7 +376,8 @@ void CDebugRenderer::DrawBrush(const CBrush& brush, const CColor& color, bool wi
 
 #undef ADD_VERT
 
-	shader->VertexPointer(3, GL_FLOAT, 3 * sizeof(float), data.data());
+	shader->VertexPointer(
+		Renderer::Backend::Format::R32G32B32_SFLOAT, 3 * sizeof(float), data.data());
 
 	shader->AssertPointersBound();
 	deviceCommandContext->Draw(0, data.size() / 5);
diff --git a/source/renderer/DecalRData.cpp b/source/renderer/DecalRData.cpp
index 3ecb8d73aa..516ed30b26 100644
--- a/source/renderer/DecalRData.cpp
+++ b/source/renderer/DecalRData.cpp
@@ -201,9 +201,12 @@ void CDecalRData::RenderDecals(
 					const GLsizei stride = sizeof(SDecalVertex);
 					SDecalVertex* base = (SDecalVertex*)batch.vertices->m_Owner->Bind(deviceCommandContext);
 
-					shader->VertexPointer(3, GL_FLOAT, stride, &base->m_Position[0]);
-					shader->NormalPointer(GL_FLOAT, stride, &base->m_Normal[0]);
-					shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, stride, &base->m_UV[0]);
+					shader->VertexPointer(
+						Renderer::Backend::Format::R32G32B32_SFLOAT, stride, &base->m_Position[0]);
+					shader->NormalPointer(
+						Renderer::Backend::Format::R32G32B32_SFLOAT, stride, &base->m_Normal[0]);
+					shader->TexCoordPointer(
+						GL_TEXTURE0, Renderer::Backend::Format::R32G32_SFLOAT, stride, &base->m_UV[0]);
 				}
 
 				shader->AssertPointersBound();
diff --git a/source/renderer/HWLightingModelRenderer.cpp b/source/renderer/HWLightingModelRenderer.cpp
index 3942d1cefd..4ed45bbc1b 100644
--- a/source/renderer/HWLightingModelRenderer.cpp
+++ b/source/renderer/HWLightingModelRenderer.cpp
@@ -203,10 +203,18 @@ void ShaderModelVertexRenderer::PrepareModelDef(
 	GLsizei stride = (GLsizei)m->shadermodeldef->m_Array.GetStride();
 
 	if (streamflags & STREAM_UV0)
-		shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, stride, base + m->shadermodeldef->m_UVs[0].offset);
+	{
+		shader->TexCoordPointer(
+			GL_TEXTURE0, Renderer::Backend::Format::R32G32_SFLOAT, stride,
+			base + m->shadermodeldef->m_UVs[0].offset);
+	}
 
 	if ((streamflags & STREAM_UV1) && def.GetNumUVsPerVertex() >= 2)
-		shader->TexCoordPointer(GL_TEXTURE1, 2, GL_FLOAT, stride, base + m->shadermodeldef->m_UVs[1].offset);
+	{
+		shader->TexCoordPointer(
+			GL_TEXTURE1, Renderer::Backend::Format::R32G32_SFLOAT, stride,
+			base + m->shadermodeldef->m_UVs[1].offset);
+	}
 }
 
 
@@ -225,10 +233,18 @@ void ShaderModelVertexRenderer::RenderModel(
 	deviceCommandContext->SetIndexBuffer(m->shadermodeldef->m_IndexArray.GetBuffer());
 
 	if (streamflags & STREAM_POS)
-		shader->VertexPointer(3, GL_FLOAT, stride, base + shadermodel->m_Position.offset);
+	{
+		shader->VertexPointer(
+			Renderer::Backend::Format::R32G32B32_SFLOAT, stride,
+			base + shadermodel->m_Position.offset);
+	}
 
 	if (streamflags & STREAM_NORMAL)
-		shader->NormalPointer(GL_FLOAT, stride, base + shadermodel->m_Normal.offset);
+	{
+		shader->NormalPointer(
+			Renderer::Backend::Format::R32G32B32_SFLOAT, stride,
+			base + shadermodel->m_Normal.offset);
+	}
 
 	shader->AssertPointersBound();
 
diff --git a/source/renderer/InstancingModelRenderer.cpp b/source/renderer/InstancingModelRenderer.cpp
index dc4a6c89cb..bbac74964c 100644
--- a/source/renderer/InstancingModelRenderer.cpp
+++ b/source/renderer/InstancingModelRenderer.cpp
@@ -331,20 +331,36 @@ void InstancingModelRenderer::PrepareModelDef(
 	deviceCommandContext->SetIndexBuffer(m->imodeldef->m_IndexArray.GetBuffer());
 
 	if (streamflags & STREAM_POS)
-		shader->VertexPointer(3, GL_FLOAT, stride, base + m->imodeldef->m_Position.offset);
+	{
+		shader->VertexPointer(
+			Renderer::Backend::Format::R32G32B32_SFLOAT, stride,
+			base + m->imodeldef->m_Position.offset);
+	}
 
 	if (streamflags & STREAM_NORMAL)
-		shader->NormalPointer(GL_FLOAT, stride, base + m->imodeldef->m_Normal.offset);
+	{
+		shader->NormalPointer(
+			Renderer::Backend::Format::R32G32B32_SFLOAT, stride,
+			base + m->imodeldef->m_Normal.offset);
+	}
 
 	if (m->calculateTangents)
-		shader->VertexAttribPointer(str_a_tangent, 4, GL_FLOAT, GL_FALSE, stride, base + m->imodeldef->m_Tangent.offset);
+	{
+		shader->VertexAttribPointer(
+			str_a_tangent, Renderer::Backend::Format::R32G32B32A32_SFLOAT,
+			GL_FALSE, stride, base + m->imodeldef->m_Tangent.offset);
+	}
 
 	// The last UV set is STREAM_UV3
 	for (size_t uv = 0; uv < 4; ++uv)
 		if (streamflags & (STREAM_UV0 << uv))
 		{
 			if (def.GetNumUVsPerVertex() >= uv + 1)
-				shader->TexCoordPointer(GL_TEXTURE0 + uv, 2, GL_FLOAT, stride, base + m->imodeldef->m_UVs[uv].offset);
+			{
+				shader->TexCoordPointer(
+					GL_TEXTURE0 + uv, Renderer::Backend::Format::R32G32_SFLOAT, stride,
+					base + m->imodeldef->m_UVs[uv].offset);
+			}
 			else
 				ONCE(LOGERROR("Model '%s' has no UV%d set.", def.GetName().string8().c_str(), uv));
 		}
@@ -352,8 +368,12 @@ void InstancingModelRenderer::PrepareModelDef(
 	// GPU skinning requires extra attributes to compute positions/normals
 	if (m->gpuSkinning)
 	{
-		shader->VertexAttribPointer(str_a_skinJoints, 4, GL_UNSIGNED_BYTE, GL_FALSE, stride, base + m->imodeldef->m_BlendJoints.offset);
-		shader->VertexAttribPointer(str_a_skinWeights, 4, GL_UNSIGNED_BYTE, GL_TRUE, stride, base + m->imodeldef->m_BlendWeights.offset);
+		shader->VertexAttribPointer(
+			str_a_skinJoints, Renderer::Backend::Format::R8G8B8A8_UINT, GL_FALSE,
+			stride, base + m->imodeldef->m_BlendJoints.offset);
+		shader->VertexAttribPointer(
+			str_a_skinWeights, Renderer::Backend::Format::R8G8B8A8_UNORM, GL_TRUE,
+			stride, base + m->imodeldef->m_BlendWeights.offset);
 	}
 
 	shader->AssertPointersBound();
diff --git a/source/renderer/OverlayRenderer.cpp b/source/renderer/OverlayRenderer.cpp
index e77933b76c..ca3769d5e0 100644
--- a/source/renderer/OverlayRenderer.cpp
+++ b/source/renderer/OverlayRenderer.cpp
@@ -573,16 +573,16 @@ void OverlayRenderer::RenderQuadOverlays(
 		int streamflags = shader->GetStreamFlags();
 
 		if (streamflags & STREAM_POS)
-			shader->VertexPointer(m->quadAttributePos.elems, m->quadAttributePos.type, vertexStride, vertexBase + m->quadAttributePos.offset);
+			shader->VertexPointer(Renderer::Backend::Format::R32G32B32_SFLOAT, vertexStride, vertexBase + m->quadAttributePos.offset);
 
 		if (streamflags & STREAM_UV0)
-			shader->TexCoordPointer(GL_TEXTURE0, m->quadAttributeUV.elems, m->quadAttributeUV.type, vertexStride, vertexBase + m->quadAttributeUV.offset);
+			shader->TexCoordPointer(GL_TEXTURE0, Renderer::Backend::Format::R16G16_SINT, vertexStride, vertexBase + m->quadAttributeUV.offset);
 
 		if (streamflags & STREAM_UV1)
-			shader->TexCoordPointer(GL_TEXTURE1, m->quadAttributeUV.elems, m->quadAttributeUV.type, vertexStride, vertexBase + m->quadAttributeUV.offset);
+			shader->TexCoordPointer(GL_TEXTURE1, Renderer::Backend::Format::R16G16_SINT, vertexStride, vertexBase + m->quadAttributeUV.offset);
 
 		if (streamflags & STREAM_COLOR)
-			shader->ColorPointer(m->quadAttributeColor.elems, m->quadAttributeColor.type, vertexStride, vertexBase + m->quadAttributeColor.offset);
+			shader->ColorPointer(Renderer::Backend::Format::R32G32B32A32_SFLOAT, vertexStride, vertexBase + m->quadAttributeColor.offset);
 
 		shader->AssertPointersBound();
 		deviceCommandContext->DrawIndexed(m->quadIndices.GetOffset() + batchRenderData.m_IndicesBase, batchNumQuads * 6, 0);
@@ -644,7 +644,8 @@ void OverlayRenderer::RenderForegroundOverlays(
 		{0.0f, 0.0f},
 	};
 
-	shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, sizeof(CVector2D), &uvs[0]);
+	shader->TexCoordPointer(
+		GL_TEXTURE0, Renderer::Backend::Format::R32G32_SFLOAT, sizeof(CVector2D), &uvs[0]);
 
 	for (size_t i = 0; i < m->sprites.size(); ++i)
 	{
@@ -667,7 +668,8 @@ void OverlayRenderer::RenderForegroundOverlays(
 			sprite->m_Position + right*sprite->m_X0 + up*sprite->m_Y1
 		};
 
-		shader->VertexPointer(3, GL_FLOAT, sizeof(CVector3D), &position[0].X);
+		shader->VertexPointer(
+			Renderer::Backend::Format::R32G32B32_SFLOAT, sizeof(CVector3D), &position[0].X);
 
 		deviceCommandContext->Draw(0, 6);
 
@@ -773,7 +775,8 @@ void OverlayRenderer::RenderSphereOverlays(
 
 	m->GenerateSphere();
 
-	shader->VertexPointer(3, GL_FLOAT, 0, &m->sphereVertexes[0]);
+	shader->VertexPointer(
+		Renderer::Backend::Format::R32G32B32_SFLOAT, 0, &m->sphereVertexes[0]);
 
 	for (size_t i = 0; i < m->spheres.size(); ++i)
 	{
diff --git a/source/renderer/PatchRData.cpp b/source/renderer/PatchRData.cpp
index 3e41760250..17ab75bc52 100644
--- a/source/renderer/PatchRData.cpp
+++ b/source/renderer/PatchRData.cpp
@@ -803,9 +803,12 @@ void CPatchRData::RenderBases(
 				{
 					GLsizei stride = sizeof(SBaseVertex);
 					SBaseVertex *base = (SBaseVertex *)itv->first->Bind(deviceCommandContext);
-					shader->VertexPointer(3, GL_FLOAT, stride, &base->m_Position[0]);
-					shader->NormalPointer(GL_FLOAT, stride, &base->m_Normal[0]);
-					shader->TexCoordPointer(GL_TEXTURE0, 3, GL_FLOAT, stride, &base->m_Position[0]);
+					shader->VertexPointer(
+						Renderer::Backend::Format::R32G32B32_SFLOAT, stride, &base->m_Position[0]);
+					shader->NormalPointer(
+						Renderer::Backend::Format::R32G32B32_SFLOAT, stride, &base->m_Normal[0]);
+					shader->TexCoordPointer(
+						GL_TEXTURE0, Renderer::Backend::Format::R32G32B32_SFLOAT, stride, &base->m_Position[0]);
 
 					shader->AssertPointersBound();
 
@@ -1029,10 +1032,14 @@ void CPatchRData::RenderBlends(
 						GLsizei stride = sizeof(SBlendVertex);
 						SBlendVertex *base = (SBlendVertex *)itv->first->Bind(deviceCommandContext);
 
-						shader->VertexPointer(3, GL_FLOAT, stride, &base->m_Position[0]);
-						shader->NormalPointer(GL_FLOAT, stride, &base->m_Normal[0]);
-						shader->TexCoordPointer(GL_TEXTURE0, 3, GL_FLOAT, stride, &base->m_Position[0]);
-						shader->TexCoordPointer(GL_TEXTURE1, 2, GL_FLOAT, stride, &base->m_AlphaUVs[0]);
+						shader->VertexPointer(
+							Renderer::Backend::Format::R32G32B32_SFLOAT, stride, &base->m_Position[0]);
+						shader->NormalPointer(
+							Renderer::Backend::Format::R32G32B32_SFLOAT, stride, &base->m_Normal[0]);
+						shader->TexCoordPointer(
+							GL_TEXTURE0, Renderer::Backend::Format::R32G32B32_SFLOAT, stride, &base->m_Position[0]);
+						shader->TexCoordPointer(
+							GL_TEXTURE1, Renderer::Backend::Format::R32G32_SFLOAT, stride, &base->m_AlphaUVs[0]);
 					}
 
 					shader->AssertPointersBound();
@@ -1098,9 +1105,13 @@ void CPatchRData::RenderStreams(
 		GLsizei stride = sizeof(SBaseVertex);
 		SBaseVertex *base = (SBaseVertex *)streamBatch.first->Bind(deviceCommandContext);
 
-		shader->VertexPointer(3, GL_FLOAT, stride, &base->m_Position);
+		shader->VertexPointer(
+			Renderer::Backend::Format::R32G32B32_SFLOAT, stride, &base->m_Position);
 		if (bindPositionAsTexCoord)
-			shader->TexCoordPointer(GL_TEXTURE0, 3, GL_FLOAT, stride, &base->m_Position);
+		{
+			shader->TexCoordPointer(
+				GL_TEXTURE0, Renderer::Backend::Format::R32G32B32_SFLOAT, stride, &base->m_Position);
+		}
 
 		shader->AssertPointersBound();
 
@@ -1174,7 +1185,8 @@ void CPatchRData::RenderSides(
 
 			// setup data pointers
 			GLsizei stride = sizeof(SSideVertex);
-			shader->VertexPointer(3, GL_FLOAT, stride, &base->m_Position);
+			shader->VertexPointer(
+				Renderer::Backend::Format::R32G32B32_SFLOAT, stride, &base->m_Position);
 		}
 
 		shader->AssertPointersBound();
@@ -1431,9 +1443,14 @@ void CPatchRData::RenderWaterSurface(
 
 	// Setup data pointers.
 	const GLsizei stride = sizeof(SWaterVertex);
-	shader->VertexPointer(3, GL_FLOAT, stride, &base[m_VBWater->m_Index].m_Position);
+	shader->VertexPointer(
+		Renderer::Backend::Format::R32G32B32_SFLOAT, stride, &base[m_VBWater->m_Index].m_Position);
 	if (bindWaterData)
-		shader->VertexAttribPointer(str_a_waterInfo, 2, GL_FLOAT, false, stride, &base[m_VBWater->m_Index].m_WaterData);
+	{
+		shader->VertexAttribPointer(
+			str_a_waterInfo, Renderer::Backend::Format::R32G32_SFLOAT, false, stride,
+			&base[m_VBWater->m_Index].m_WaterData);
+	}
 
 	shader->AssertPointersBound();
 
@@ -1460,8 +1477,12 @@ void CPatchRData::RenderWaterShore(
 	SWaterVertex* base = reinterpret_cast<SWaterVertex*>(m_VBWaterShore->m_Owner->Bind(deviceCommandContext));
 
 	const GLsizei stride = sizeof(SWaterVertex);
-	shader->VertexPointer(3, GL_FLOAT, stride, &base[m_VBWaterShore->m_Index].m_Position);
-	shader->VertexAttribPointer(str_a_waterInfo, 2, GL_FLOAT, false, stride, &base[m_VBWaterShore->m_Index].m_WaterData);
+	shader->VertexPointer(
+		Renderer::Backend::Format::R32G32B32_SFLOAT, stride,
+		&base[m_VBWaterShore->m_Index].m_Position);
+	shader->VertexAttribPointer(
+		str_a_waterInfo, Renderer::Backend::Format::R32G32_SFLOAT, false, stride,
+		&base[m_VBWaterShore->m_Index].m_WaterData);
 
 	shader->AssertPointersBound();
 
diff --git a/source/renderer/PostprocManager.cpp b/source/renderer/PostprocManager.cpp
index 0d9e08e220..62ba4723d2 100644
--- a/source/renderer/PostprocManager.cpp
+++ b/source/renderer/PostprocManager.cpp
@@ -228,8 +228,10 @@ void CPostprocManager::ApplyBlurDownscale2x(
 		1.0f, 0.0f,
 		1.0f, 1.0f
 	};
-	shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, 0, quadTex);
-	shader->VertexPointer(2, GL_FLOAT, 0, quadVerts);
+	shader->TexCoordPointer(
+		GL_TEXTURE0, Renderer::Backend::Format::R32G32_SFLOAT, 0, quadTex);
+	shader->VertexPointer(
+		Renderer::Backend::Format::R32G32_SFLOAT, 0, quadVerts);
 	shader->AssertPointersBound();
 	deviceCommandContext->Draw(0, 6);
 
@@ -284,8 +286,10 @@ void CPostprocManager::ApplyBlurGauss(
 		1.0f, 0.0f,
 		1.0f, 1.0f
 	};
-	shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, 0, quadTex);
-	shader->VertexPointer(2, GL_FLOAT, 0, quadVerts);
+	shader->TexCoordPointer(
+		GL_TEXTURE0, Renderer::Backend::Format::R32G32_SFLOAT, 0, quadTex);
+	shader->VertexPointer(
+		Renderer::Backend::Format::R32G32_SFLOAT, 0, quadVerts);
 	shader->AssertPointersBound();
 	deviceCommandContext->Draw(0, 6);
 
@@ -309,8 +313,10 @@ void CPostprocManager::ApplyBlurGauss(
 
 	g_Renderer.SetViewport(vp);
 
-	shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, 0, quadTex);
-	shader->VertexPointer(2, GL_FLOAT, 0, quadVerts);
+	shader->TexCoordPointer(
+		GL_TEXTURE0, Renderer::Backend::Format::R32G32_SFLOAT, 0, quadTex);
+	shader->VertexPointer(
+		Renderer::Backend::Format::R32G32_SFLOAT, 0, quadVerts);
 	shader->AssertPointersBound();
 	deviceCommandContext->Draw(0, 6);
 
@@ -429,8 +435,10 @@ void CPostprocManager::ApplyEffect(
 		1.0f, 0.0f,
 		1.0f, 1.0f
 	};
-	shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, 0, quadTex);
-	shader->VertexPointer(2, GL_FLOAT, 0, quadVerts);
+	shader->TexCoordPointer(
+		GL_TEXTURE0, Renderer::Backend::Format::R32G32_SFLOAT, 0, quadTex);
+	shader->VertexPointer(
+		Renderer::Backend::Format::R32G32_SFLOAT, 0, quadVerts);
 	shader->AssertPointersBound();
 	deviceCommandContext->Draw(0, 6);
 
diff --git a/source/renderer/ShadowMap.cpp b/source/renderer/ShadowMap.cpp
index aa444cfec0..b0df337cd1 100644
--- a/source/renderer/ShadowMap.cpp
+++ b/source/renderer/ShadowMap.cpp
@@ -747,8 +747,10 @@ void ShadowMap::RenderDebugTexture(
 		1,0, 0,1, 1,1
 	};
 
-	texShader->VertexPointer(2, GL_FLOAT, 0, boxVerts);
-	texShader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, 0, boxUV);
+	texShader->VertexPointer(
+		Renderer::Backend::Format::R32G32_SFLOAT, 0, boxVerts);
+	texShader->TexCoordPointer(
+		GL_TEXTURE0, Renderer::Backend::Format::R32G32_SFLOAT, 0, boxUV);
 	texShader->AssertPointersBound();
 	deviceCommandContext->Draw(0, 6);
 
diff --git a/source/renderer/SilhouetteRenderer.cpp b/source/renderer/SilhouetteRenderer.cpp
index e49ec8578b..6e1450c375 100644
--- a/source/renderer/SilhouetteRenderer.cpp
+++ b/source/renderer/SilhouetteRenderer.cpp
@@ -493,7 +493,8 @@ void SilhouetteRenderer::RenderDebugOverlays(
 			r.x1, r.y1,
 			r.x0, r.y1,
 		};
-		shader->VertexPointer(2, GL_SHORT, 0, verts);
+		shader->VertexPointer(
+			Renderer::Backend::Format::R16G16_SINT, 0, verts);
 		deviceCommandContext->Draw(0, 6);
 	}
 
diff --git a/source/renderer/SkyManager.cpp b/source/renderer/SkyManager.cpp
index 66c8a058f1..2957bf441f 100644
--- a/source/renderer/SkyManager.cpp
+++ b/source/renderer/SkyManager.cpp
@@ -243,9 +243,9 @@ void SkyManager::RenderSky(
 	const GLsizei stride = static_cast<GLsizei>(m_VertexArray.GetStride());
 
 	shader->VertexPointer(
-		3, GL_FLOAT, stride, base + m_AttributePosition.offset);
+		Renderer::Backend::Format::R32G32B32_SFLOAT, stride, base + m_AttributePosition.offset);
 	shader->TexCoordPointer(
-		GL_TEXTURE0, 3, GL_FLOAT, stride, base + m_AttributeUV.offset);
+		GL_TEXTURE0, Renderer::Backend::Format::R32G32B32_SFLOAT, stride, base + m_AttributeUV.offset);
 	shader->AssertPointersBound();
 
 	deviceCommandContext->Draw(0, m_VertexArray.GetNumberOfVertices());
diff --git a/source/renderer/TerrainOverlay.cpp b/source/renderer/TerrainOverlay.cpp
index 70e12a778c..0576f7c5c8 100644
--- a/source/renderer/TerrainOverlay.cpp
+++ b/source/renderer/TerrainOverlay.cpp
@@ -229,7 +229,8 @@ void TerrainOverlay::RenderTile(
 	overlayShader->Uniform(str_transform, g_Renderer.GetSceneRenderer().GetViewCamera().GetViewProjection());
 	overlayShader->Uniform(str_color, color);
 
-	overlayShader->VertexPointer(3, GL_FLOAT, 0, vertices.data());
+	overlayShader->VertexPointer(
+		Renderer::Backend::Format::R32G32B32_SFLOAT, 0, vertices.data());
 	overlayShader->AssertPointersBound();
 
 	deviceCommandContext->Draw(0, vertices.size() / 3);
@@ -297,7 +298,8 @@ void TerrainOverlay::RenderTileOutline(
 	overlayShader->Uniform(str_transform, g_Renderer.GetSceneRenderer().GetViewCamera().GetViewProjection());
 	overlayShader->Uniform(str_color, color);
 
-	overlayShader->VertexPointer(3, GL_FLOAT, 0, vertices.data());
+	overlayShader->VertexPointer(
+		Renderer::Backend::Format::R32G32B32_SFLOAT, 0, vertices.data());
 	overlayShader->AssertPointersBound();
 
 	deviceCommandContext->Draw(0, vertices.size() / 3);
diff --git a/source/renderer/TerrainRenderer.cpp b/source/renderer/TerrainRenderer.cpp
index 9f825217f8..eb1f9eb5c6 100644
--- a/source/renderer/TerrainRenderer.cpp
+++ b/source/renderer/TerrainRenderer.cpp
@@ -208,8 +208,10 @@ void TerrainRenderer::RenderTerrainOverlayTexture(
 		};
 
 		const GLsizei stride = sizeof(float) * 3;
-		debugOverlayShader->VertexPointer(3, GL_FLOAT, stride, waterPos);
-		debugOverlayShader->TexCoordPointer(GL_TEXTURE0, 3, GL_FLOAT, stride, waterPos);
+		debugOverlayShader->VertexPointer(
+			Renderer::Backend::Format::R32G32B32_SFLOAT, stride, waterPos);
+		debugOverlayShader->TexCoordPointer(
+			GL_TEXTURE0, Renderer::Backend::Format::R32G32B32_SFLOAT, stride, waterPos);
 		debugOverlayShader->AssertPointersBound();
 
 		deviceCommandContext->Draw(0, 6);
diff --git a/source/renderer/TexturedLineRData.cpp b/source/renderer/TexturedLineRData.cpp
index dac09f35b7..c1c3676431 100644
--- a/source/renderer/TexturedLineRData.cpp
+++ b/source/renderer/TexturedLineRData.cpp
@@ -60,13 +60,13 @@ void CTexturedLineRData::Render(
 		reinterpret_cast<CTexturedLineRData::SVertex*>(m_VB->m_Owner->Bind(deviceCommandContext));
 
 	if (streamFlags & STREAM_POS)
-		shader->VertexPointer(3, GL_FLOAT, stride, &vertexBase->m_Position[0]);
+		shader->VertexPointer(Renderer::Backend::Format::R32G32B32_SFLOAT, stride, &vertexBase->m_Position[0]);
 
 	if (streamFlags & STREAM_UV0)
-		shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, stride, &vertexBase->m_UVs[0]);
+		shader->TexCoordPointer(GL_TEXTURE0, Renderer::Backend::Format::R32G32_SFLOAT, stride, &vertexBase->m_UVs[0]);
 
 	if (streamFlags & STREAM_UV1)
-		shader->TexCoordPointer(GL_TEXTURE1, 2, GL_FLOAT, stride, &vertexBase->m_UVs[0]);
+		shader->TexCoordPointer(GL_TEXTURE1, Renderer::Backend::Format::R32G32_SFLOAT, stride, &vertexBase->m_UVs[0]);
 
 	shader->AssertPointersBound();
 
diff --git a/source/renderer/WaterManager.cpp b/source/renderer/WaterManager.cpp
index 41db04a380..ee3d29e91c 100644
--- a/source/renderer/WaterManager.cpp
+++ b/source/renderer/WaterManager.cpp
@@ -799,13 +799,18 @@ void WaterManager::RenderWaves(
 
 		// setup data pointers
 		GLsizei stride = sizeof(SWavesVertex);
-		shader->VertexPointer(3, GL_FLOAT, stride, &base[VBchunk->m_Index].m_BasePosition);
-		shader->TexCoordPointer(GL_TEXTURE0, 2, GL_UNSIGNED_BYTE, stride, &base[VBchunk->m_Index].m_UV);
-		//	NormalPointer(gl_FLOAT, stride, &base[m_VBWater->m_Index].m_UV)
-		glVertexAttribPointerARB(2, 2, GL_FLOAT, GL_FALSE, stride, &base[VBchunk->m_Index].m_PerpVect);	// replaces commented above because my normal is vec2
-		shader->VertexAttribPointer(str_a_apexPosition, 3, GL_FLOAT, false, stride, &base[VBchunk->m_Index].m_ApexPosition);
-		shader->VertexAttribPointer(str_a_splashPosition, 3, GL_FLOAT, false, stride, &base[VBchunk->m_Index].m_SplashPosition);
-		shader->VertexAttribPointer(str_a_retreatPosition, 3, GL_FLOAT, false, stride, &base[VBchunk->m_Index].m_RetreatPosition);
+		shader->VertexPointer(
+			Renderer::Backend::Format::R32G32B32_SFLOAT, stride, &base[VBchunk->m_Index].m_BasePosition);
+		shader->TexCoordPointer(
+			GL_TEXTURE0, Renderer::Backend::Format::R8G8_UINT, stride, &base[VBchunk->m_Index].m_UV);
+		shader->NormalPointer(
+			Renderer::Backend::Format::R32G32_SFLOAT, stride, &base[VBchunk->m_Index].m_PerpVect);
+		shader->VertexAttribPointer(
+			str_a_apexPosition, Renderer::Backend::Format::R32G32B32_SFLOAT, false, stride, &base[VBchunk->m_Index].m_ApexPosition);
+		shader->VertexAttribPointer(
+			str_a_splashPosition, Renderer::Backend::Format::R32G32B32_SFLOAT, false, stride, &base[VBchunk->m_Index].m_SplashPosition);
+		shader->VertexAttribPointer(
+			str_a_retreatPosition, Renderer::Backend::Format::R32G32B32_SFLOAT, false, stride, &base[VBchunk->m_Index].m_RetreatPosition);
 
 		shader->AssertPointersBound();
 
diff --git a/source/renderer/backend/Format.h b/source/renderer/backend/Format.h
index 3d0cb47803..8b0aa018c8 100644
--- a/source/renderer/backend/Format.h
+++ b/source/renderer/backend/Format.h
@@ -27,12 +27,18 @@ namespace Backend
 enum class Format
 {
 	UNDEFINED,
+	R8G8_UNORM,
+	R8G8_UINT,
 	R8G8B8_UNORM,
 	R8G8B8A8_UNORM,
+	R8G8B8A8_UINT,
 
 	A8_UNORM,
 	L8_UNORM,
 
+	R16_SINT,
+	R16G16_SINT,
+
 	R32_SFLOAT,
 	R32G32_SFLOAT,
 	R32G32B32_SFLOAT,
diff --git a/source/renderer/backend/gl/Device.cpp b/source/renderer/backend/gl/Device.cpp
index 21535c850a..f395dce746 100644
--- a/source/renderer/backend/gl/Device.cpp
+++ b/source/renderer/backend/gl/Device.cpp
@@ -872,6 +872,9 @@ bool CDevice::IsTextureFormatSupported(const Format format) const
 	case Format::BC3_UNORM:
 		supported = m_Capabilities.S3TC;
 		break;
+
+	default:
+		break;
 	}
 	return supported;
 }