real_tabasco_sauce/0ad
1
0
Fork 0
forked from 0ad/0ad
Code Pull Requests Actions Activity

Replaces native GL types by backend format in vertex attributes in CShaderProgram.

Browse Source 
This was SVN commit r26594.
This commit is contained in:
Vladislav Belov 2022-03-07 02:21:05 +00:00
parent 36faf3bb4f
commit 647fccd410
24 changed files with 289 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
source/graphics/Canvas2D.cpp
View File

@ -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());

4
source/graphics/LOSTexture.cpp
View File

@ -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);

12
source/graphics/MiniMapTexture.cpp
View File

@ -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());

12
source/graphics/ParticleEmitter.cpp
View File

@ -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();

96
source/graphics/ShaderProgram.cpp
View File

@ -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);

11
source/graphics/ShaderProgram.h
View File

@ -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.

6
source/graphics/TextRenderer.cpp
View File

@ -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);

6
source/gui/ObjectTypes/CMiniMap.cpp
View File

@ -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);

18
source/renderer/DebugRenderer.cpp
View File

@ -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);

9
source/renderer/DecalRData.cpp
View File

@ -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();

24
source/renderer/HWLightingModelRenderer.cpp
View File

@ -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();

32
source/renderer/InstancingModelRenderer.cpp
View File

@ -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();

17
source/renderer/OverlayRenderer.cpp
View File

@ -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)
{

49
source/renderer/PatchRData.cpp
View File

@ -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();

24
source/renderer/PostprocManager.cpp
View File

@ -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);

6
source/renderer/ShadowMap.cpp
View File

@ -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);

3
source/renderer/SilhouetteRenderer.cpp
View File

@ -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);
}

4
source/renderer/SkyManager.cpp
View File

@ -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());

6
source/renderer/TerrainOverlay.cpp
View File

@ -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);

6
source/renderer/TerrainRenderer.cpp
View File

@ -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);

6
source/renderer/TexturedLineRData.cpp
View File

@ -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();

19
source/renderer/WaterManager.cpp
View File

@ -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();

6
source/renderer/backend/Format.h
View File

@ -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,

3
source/renderer/backend/gl/Device.cpp
View File

@ -872,6 +872,9 @@ bool CDevice::IsTextureFormatSupported(const Format format) const
case Format::BC3_UNORM:
supported = m_Capabilities.S3TC;
break;
default:
break;
}
return supported;
}