Stan/0ad
1
0
Fork 0
forked from 0ad/0ad
Code Pull Requests Activity

Replaces GL_LINES, GL_QUADS, GL_TRIANGLE_STRIP and GL_TRIANGLE_FAN by GL_TRIANGLES.

Browse Source 
This was SVN commit r26488.
This commit is contained in:
Vladislav Belov 2022-02-26 00:37:27 +00:00
parent 59a0a74951
commit 23a023507a
11 changed files with 77 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

136
source/renderer/DebugRenderer.cpp
View File

@ -157,14 +157,16 @@ void CDebugRenderer::DrawCircle(const CVector3D& origin, const float radius, con
vertices.emplace_back((position).Y); \
vertices.emplace_back((position).Z);
ADD(origin)
constexpr size_t segments = 16;
for (size_t idx = 0; idx <= segments; ++idx)
{
const float angle = M_PI * 2.0f * idx / segments;
const CVector3D offset = cameraUp * sin(angle) - cameraLeft * cos(angle);
const float nextAngle = M_PI * 2.0f * (idx + 1) / segments;
const CVector3D nextOffset = cameraUp * sin(nextAngle) - cameraLeft * cos(nextAngle);
ADD(origin)
ADD(origin + offset * radius)
ADD(origin + nextOffset * radius)
}
#undef ADD
@ -269,18 +271,25 @@ void CDebugRenderer::DrawCameraFrustum(const CCamera& camera, const CColor& colo
#endif
}
void CDebugRenderer::DrawBoundingBox(const CBoundingBoxAligned& boundingBox, const CColor& color)
void CDebugRenderer::DrawBoundingBox(
const CBoundingBoxAligned& boundingBox, const CColor& color,
bool wireframe)
{
DrawBoundingBox(boundingBox, color, g_Renderer.GetSceneRenderer().GetViewCamera().GetViewProjection());
DrawBoundingBox(
boundingBox, color,
g_Renderer.GetSceneRenderer().GetViewCamera().GetViewProjection(), wireframe);
}
void CDebugRenderer::DrawBoundingBox(const CBoundingBoxAligned& boundingBox, const CColor& color, const CMatrix3D& transform)
void CDebugRenderer::DrawBoundingBox(
const CBoundingBoxAligned& boundingBox, const CColor& color,
const CMatrix3D& transform, bool wireframe)
{
CShaderTechniquePtr shaderTech = g_Renderer.GetShaderManager().LoadEffect(str_solid);
shaderTech->BeginPass();
SetGraphicsPipelineStateFromTechAndColor(g_Renderer.GetDeviceCommandContext(), shaderTech, color);
SetGraphicsPipelineStateFromTechAndColor(
g_Renderer.GetDeviceCommandContext(), shaderTech, color, true, wireframe);
CShaderProgramPtr shader = shaderTech->GetShader();
const CShaderProgramPtr& shader = shaderTech->GetShader();
shader->Uniform(str_color, color);
shader->Uniform(str_transform, transform);
@ -291,8 +300,6 @@ void CDebugRenderer::DrawBoundingBox(const CBoundingBoxAligned& boundingBox, con
ADD_PT(1, 1, x, y, z); ADD_PT(0, 1, x, y, z); ADD_PT(0, 0, x, y, z);
#define ADD_PT(u_, v_, x, y, z) \
STMT(int u = u_; int v = v_; \
data.push_back(u); \
data.push_back(v); \
data.push_back(boundingBox[x].X); \
data.push_back(boundingBox[y].Y); \
data.push_back(boundingBox[z].Z); \
@ -307,8 +314,7 @@ void CDebugRenderer::DrawBoundingBox(const CBoundingBoxAligned& boundingBox, con
#undef ADD_FACE
shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, 5*sizeof(float), &data[0]);
shader->VertexPointer(3, GL_FLOAT, 5*sizeof(float), &data[2]);
shader->VertexPointer(3, GL_FLOAT, 3 * sizeof(float), data.data());
shader->AssertPointersBound();
glDrawArrays(GL_TRIANGLES, 0, 6*6);
@ -316,62 +322,14 @@ void CDebugRenderer::DrawBoundingBox(const CBoundingBoxAligned& boundingBox, con
shaderTech->EndPass();
}
void CDebugRenderer::DrawBoundingBoxOutline(const CBoundingBoxAligned& boundingBox, const CColor& color)
{
DrawBoundingBoxOutline(boundingBox, color, g_Renderer.GetSceneRenderer().GetViewCamera().GetViewProjection());
}
void CDebugRenderer::DrawBoundingBoxOutline(const CBoundingBoxAligned& boundingBox, const CColor& color, const CMatrix3D& transform)
void CDebugRenderer::DrawBrush(const CBrush& brush, const CColor& color, bool wireframe)
{
CShaderTechniquePtr shaderTech = g_Renderer.GetShaderManager().LoadEffect(str_solid);
shaderTech->BeginPass();
SetGraphicsPipelineStateFromTechAndColor(g_Renderer.GetDeviceCommandContext(), shaderTech, color, true, true);
SetGraphicsPipelineStateFromTechAndColor(
g_Renderer.GetDeviceCommandContext(), shaderTech, color, true, wireframe);
CShaderProgramPtr shader = shaderTech->GetShader();
shader->Uniform(str_color, color);
shader->Uniform(str_transform, transform);
std::vector<float> data;
#define ADD_FACE(x, y, z) \
ADD_PT(0, 0, x, y, z); ADD_PT(1, 0, x, y, z); \
ADD_PT(1, 0, x, y, z); ADD_PT(1, 1, x, y, z); \
ADD_PT(1, 1, x, y, z); ADD_PT(0, 1, x, y, z); \
ADD_PT(0, 1, x, y, z); ADD_PT(0, 0, x, y, z);
#define ADD_PT(u_, v_, x, y, z) \
STMT(int u = u_; int v = v_; \
data.push_back(u); \
data.push_back(v); \
data.push_back(boundingBox[x].X); \
data.push_back(boundingBox[y].Y); \
data.push_back(boundingBox[z].Z); \
)
ADD_FACE(u, v, 0);
ADD_FACE(0, u, v);
ADD_FACE(u, 0, 1-v);
ADD_FACE(u, 1-v, 1);
ADD_FACE(1, u, 1-v);
ADD_FACE(u, 1, v);
#undef ADD_FACE
shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, 5*sizeof(float), &data[0]);
shader->VertexPointer(3, GL_FLOAT, 5*sizeof(float), &data[2]);
shader->AssertPointersBound();
glDrawArrays(GL_LINES, 0, 6*8);
shaderTech->EndPass();
}
void CDebugRenderer::DrawBrush(const CBrush& brush, const CColor& color)
{
CShaderTechniquePtr shaderTech = g_Renderer.GetShaderManager().LoadEffect(str_solid);
shaderTech->BeginPass();
SetGraphicsPipelineStateFromTechAndColor(g_Renderer.GetDeviceCommandContext(), shaderTech, color);
CShaderProgramPtr shader = shaderTech->GetShader();
const CShaderProgramPtr& shader = shaderTech->GetShader();
shader->Uniform(str_color, color);
shader->Uniform(str_transform, g_Renderer.GetSceneRenderer().GetViewCamera().GetViewProjection());
@ -382,8 +340,6 @@ void CDebugRenderer::DrawBrush(const CBrush& brush, const CColor& color)
#define ADD_VERT(a) \
STMT( \
data.push_back(u); \
data.push_back(v); \
data.push_back(brush.GetVertices()[faces[i][a]].X); \
data.push_back(brush.GetVertices()[faces[i][a]].Y); \
data.push_back(brush.GetVertices()[faces[i][a]].Z); \
@ -394,8 +350,6 @@ void CDebugRenderer::DrawBrush(const CBrush& brush, const CColor& color)
// Triangulate into (0,1,2), (0,2,3), ...
for (size_t j = 1; j < faces[i].size() - 2; ++j)
{
float u = 0;
float v = 0;
ADD_VERT(0);
ADD_VERT(j);
ADD_VERT(j+1);
@ -404,8 +358,7 @@ void CDebugRenderer::DrawBrush(const CBrush& brush, const CColor& color)
#undef ADD_VERT
shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, 5*sizeof(float), &data[0]);
shader->VertexPointer(3, GL_FLOAT, 5*sizeof(float), &data[2]);
shader->VertexPointer(3, GL_FLOAT, 3 * sizeof(float), data.data());
shader->AssertPointersBound();
glDrawArrays(GL_TRIANGLES, 0, data.size() / 5);
@ -413,48 +366,3 @@ void CDebugRenderer::DrawBrush(const CBrush& brush, const CColor& color)
shaderTech->EndPass();
}
void CDebugRenderer::DrawBrushOutline(const CBrush& brush, const CColor& color)
{
CShaderTechniquePtr shaderTech = g_Renderer.GetShaderManager().LoadEffect(str_solid);
shaderTech->BeginPass();
SetGraphicsPipelineStateFromTechAndColor(g_Renderer.GetDeviceCommandContext(), shaderTech, color);
CShaderProgramPtr shader = shaderTech->GetShader();
shader->Uniform(str_color, color);
shader->Uniform(str_transform, g_Renderer.GetSceneRenderer().GetViewCamera().GetViewProjection());
std::vector<float> data;
std::vector<std::vector<size_t>> faces;
brush.GetFaces(faces);
#define ADD_VERT(a) \
STMT( \
data.push_back(u); \
data.push_back(v); \
data.push_back(brush.GetVertices()[faces[i][a]].X); \
data.push_back(brush.GetVertices()[faces[i][a]].Y); \
data.push_back(brush.GetVertices()[faces[i][a]].Z); \
)
for (size_t i = 0; i < faces.size(); ++i)
{
for (size_t j = 0; j < faces[i].size() - 1; ++j)
{
float u = 0;
float v = 0;
ADD_VERT(j);
ADD_VERT(j+1);
}
}
#undef ADD_VERT
shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, 5*sizeof(float), &data[0]);
shader->VertexPointer(3, GL_FLOAT, 5*sizeof(float), &data[2]);
shader->AssertPointersBound();
glDrawArrays(GL_LINES, 0, data.size() / 5);
shaderTech->EndPass();
}

17
source/renderer/DebugRenderer.h
View File

@ -57,24 +57,13 @@ public:
/**
* Render the surfaces of the bound box as triangles.
*/
void DrawBoundingBox(const CBoundingBoxAligned& boundingBox, const CColor& color);
void DrawBoundingBox(const CBoundingBoxAligned& boundingBox, const CColor& color, const CMatrix3D& transform);
/**
* Render the outline of the bound box as lines.
*/
void DrawBoundingBoxOutline(const CBoundingBoxAligned& boundingBox, const CColor& color);
void DrawBoundingBoxOutline(const CBoundingBoxAligned& boundingBox, const CColor& color, const CMatrix3D& transform);
void DrawBoundingBox(const CBoundingBoxAligned& boundingBox, const CColor& color, bool wireframe = false);
void DrawBoundingBox(const CBoundingBoxAligned& boundingBox, const CColor& color, const CMatrix3D& transform, bool wireframe = false);
/**
* Render the surfaces of the brush as triangles.
*/
void DrawBrush(const CBrush& brush, const CColor& color);
/**
* Render the outline of the brush as lines.
*/
void DrawBrushOutline(const CBrush& brush, const CColor& color);
void DrawBrush(const CBrush& brush, const CColor& color, bool wireframe = false);
};
#endif // INCLUDED_DEBUGRENDERER

2
source/renderer/ParticleRenderer.cpp
View File

@ -175,6 +175,6 @@ void ParticleRenderer::RenderBounds(int cullGroup)
{
const CBoundingBoxAligned bounds =
emitter->m_Type->CalculateBounds(emitter->GetPosition(), emitter->GetParticleBounds());
g_Renderer.GetDebugRenderer().DrawBoundingBoxOutline(bounds, CColor(0.0f, 1.0f, 0.0f, 1.0f));
g_Renderer.GetDebugRenderer().DrawBoundingBox(bounds, CColor(0.0f, 1.0f, 0.0f, 1.0f), true);
}
}

8
source/renderer/SceneRenderer.cpp
View File

@ -922,12 +922,12 @@ void CSceneRenderer::RenderSubmissions(
DisplayFrustum();
if (g_RenderingOptions.GetDisplayShadowsFrustum())
{
m->shadow.RenderDebugBounds();
m->shadow.RenderDebugTexture(deviceCommandContext);
}
m->silhouetteRenderer.RenderDebugBounds(deviceCommandContext);
m->silhouetteRenderer.RenderDebugOverlays(deviceCommandContext, m_ViewCamera);
if (g_RenderingOptions.GetDisplayShadowsFrustum())
m->shadow.RenderDebugTexture(deviceCommandContext);
m->silhouetteRenderer.RenderDebugOverlays(deviceCommandContext);
// render overlays that should appear on top of all other objects
m->overlayRenderer.RenderForegroundOverlays(deviceCommandContext, m_ViewCamera);

13
source/renderer/ShadowMap.cpp
View File

@ -544,7 +544,7 @@ void ShadowMapInternals::CreateTexture()
// basic unfiltered depth texture
Renderer::Backend::Sampler::Filter::NEAREST,
#else
// Use GL_LINEAR to trigger automatic PCF on some devices
// Use LINEAR to trigger automatic PCF on some devices.
Renderer::Backend::Sampler::Filter::LINEAR,
#endif
Renderer::Backend::Sampler::AddressMode::CLAMP_TO_EDGE);
@ -685,12 +685,15 @@ void ShadowMap::RenderDebugBounds()
const CMatrix3D transform = g_Renderer.GetSceneRenderer().GetViewCamera().GetViewProjection() * m->InvLightTransform;
g_Renderer.GetDebugRenderer().DrawBoundingBoxOutline(m->ShadowReceiverBound, CColor(1.0f, 1.0f, 0.0f, 1.0f), transform);
g_Renderer.GetDebugRenderer().DrawBoundingBox(
m->ShadowReceiverBound, CColor(1.0f, 1.0f, 0.0f, 1.0f), transform, true);
for (int cascade = 0; cascade < GetCascadeCount(); ++cascade)
{
g_Renderer.GetDebugRenderer().DrawBoundingBox(m->Cascades[cascade].ShadowRenderBound, CColor(0.0f, 0.0f, 1.0f, 0.10f), transform);
g_Renderer.GetDebugRenderer().DrawBoundingBoxOutline(m->Cascades[cascade].ShadowRenderBound, CColor(0.0f, 0.0f, 1.0f, 0.5f), transform);
g_Renderer.GetDebugRenderer().DrawBoundingBox(
m->Cascades[cascade].ShadowRenderBound, CColor(0.0f, 0.0f, 1.0f, 0.10f), transform);
g_Renderer.GetDebugRenderer().DrawBoundingBox(
m->Cascades[cascade].ShadowRenderBound, CColor(0.0f, 0.0f, 1.0f, 0.5f), transform, true);
const CFrustum frustum = GetShadowCasterCullFrustum(cascade);
// We don't have a function to create a brush directly from a frustum, so use
@ -701,7 +704,7 @@ void ShadowMap::RenderDebugBounds()
brush.Intersect(frustum, frustumBrush);
g_Renderer.GetDebugRenderer().DrawBrush(frustumBrush, CColor(1.0f, 0.0f, 0.0f, 0.1f));
g_Renderer.GetDebugRenderer().DrawBrushOutline(frustumBrush, CColor(1.0f, 0.0f, 0.0f, 0.5f));
g_Renderer.GetDebugRenderer().DrawBrush(frustumBrush, CColor(1.0f, 0.0f, 0.0f, 0.1f), true);
}
ogl_WarnIfError();

24
source/renderer/SilhouetteRenderer.cpp
View File

@ -443,16 +443,23 @@ void SilhouetteRenderer::RenderSubmitCasters(SceneCollector& collector)
collector.SubmitNonRecursive(m_VisibleModelCasters[i]);
}
void SilhouetteRenderer::RenderDebugOverlays(
Renderer::Backend::GL::CDeviceCommandContext* deviceCommandContext,
const CCamera& UNUSED(camera))
void SilhouetteRenderer::RenderDebugBounds(
Renderer::Backend::GL::CDeviceCommandContext* deviceCommandContext)
{
if (m_DebugBounds.empty() && m_DebugRects.empty())
if (m_DebugBounds.empty())
return;
for (size_t i = 0; i < m_DebugBounds.size(); ++i)
g_Renderer.GetDebugRenderer().DrawBoundingBoxOutline(m_DebugBounds[i].bounds, m_DebugBounds[i].color);
g_Renderer.GetDebugRenderer().DrawBoundingBox(m_DebugBounds[i].bounds, m_DebugBounds[i].color, true);
}
void SilhouetteRenderer::RenderDebugOverlays(
Renderer::Backend::GL::CDeviceCommandContext* deviceCommandContext)
{
if (m_DebugRects.empty())
return;
// TODO: use CCanvas2D for drawing rects.
CMatrix3D m;
m.SetIdentity();
m.Scale(1.0f, -1.f, 1.0f);
@ -462,11 +469,11 @@ void SilhouetteRenderer::RenderDebugOverlays(
proj.SetOrtho(0.f, g_MaxCoord, 0.f, g_MaxCoord, -1.f, 1000.f);
m = proj * m;
CShaderTechniquePtr shaderTech = g_Renderer.GetShaderManager().LoadEffect(str_solid);
shaderTech->BeginPass();
Renderer::Backend::GraphicsPipelineStateDesc pipelineStateDesc =
shaderTech->GetGraphicsPipelineStateDesc();
pipelineStateDesc.rasterizationState.polygonMode = Renderer::Backend::PolygonMode::LINE;
pipelineStateDesc.rasterizationState.cullMode = Renderer::Backend::CullMode::NONE;
deviceCommandContext->SetGraphicsPipelineState(pipelineStateDesc);
@ -482,11 +489,12 @@ void SilhouetteRenderer::RenderDebugOverlays(
r.x0, r.y0,
r.x1, r.y0,
r.x1, r.y1,
r.x0, r.y1,
r.x0, r.y0,
r.x1, r.y1,
r.x0, r.y1,
};
shader->VertexPointer(2, GL_SHORT, 0, verts);
glDrawArrays(GL_LINE_STRIP, 0, 5);
glDrawArrays(GL_TRIANGLES, 0, 6);
}
shaderTech->EndPass();

5
source/renderer/SilhouetteRenderer.h
View File

@ -41,9 +41,10 @@ public:
void RenderSubmitOccluders(SceneCollector& collector);
void RenderSubmitCasters(SceneCollector& collector);
void RenderDebugBounds(
Renderer::Backend::GL::CDeviceCommandContext* deviceCommandContext);
void RenderDebugOverlays(
Renderer::Backend::GL::CDeviceCommandContext* deviceCommandContext,
const CCamera& camera);
Renderer::Backend::GL::CDeviceCommandContext* deviceCommandContext);
void EndFrame();

24
source/renderer/TerrainOverlay.cpp
View File

@ -245,14 +245,14 @@ void TerrainOverlay::RenderTile(
void TerrainOverlay::RenderTileOutline(
Renderer::Backend::GL::CDeviceCommandContext* deviceCommandContext,
const CColor& color, int lineWidth, bool drawHidden)
const CColor& color, bool drawHidden)
{
RenderTileOutline(deviceCommandContext, color, lineWidth, drawHidden, m_i, m_j);
RenderTileOutline(deviceCommandContext, color, drawHidden, m_i, m_j);
}
void TerrainOverlay::RenderTileOutline(
Renderer::Backend::GL::CDeviceCommandContext* deviceCommandContext,
const CColor& color, int lineWidth, bool drawHidden, ssize_t i, ssize_t j)
const CColor& color, bool drawHidden, ssize_t i, ssize_t j)
{
#if CONFIG2_GLES
UNUSED2(deviceCommandContext);
@ -272,10 +272,12 @@ void TerrainOverlay::RenderTileOutline(
vertices.emplace_back(position.Z);
CVector3D position;
ADD(i, j);
ADD(i+1, j);
ADD(i+1, j+1);
ADD(i, j+1);
ADD(i, j);
ADD(i + 1, j);
ADD(i + 1, j + 1);
ADD(i, j);
ADD(i + 1, j + 1);
ADD(i, j + 1);
#undef ADD
CShaderTechniquePtr overlayTech =
@ -296,9 +298,6 @@ void TerrainOverlay::RenderTileOutline(
overlayTech->BeginPass();
deviceCommandContext->SetGraphicsPipelineState(pipelineStateDesc);
if (lineWidth != 1)
glLineWidth(static_cast<float>(lineWidth));
const CShaderProgramPtr& overlayShader = overlayTech->GetShader();
overlayShader->Uniform(str_transform, g_Renderer.GetSceneRenderer().GetViewCamera().GetViewProjection());
@ -307,12 +306,9 @@ void TerrainOverlay::RenderTileOutline(
overlayShader->VertexPointer(3, GL_FLOAT, 0, vertices.data());
overlayShader->AssertPointersBound();
glDrawArrays(GL_QUADS, 0, vertices.size() / 3);
glDrawArrays(GL_TRIANGLES, 0, vertices.size() / 3);
overlayTech->EndPass();
if (lineWidth != 1)
glLineWidth(1.0f);
#endif
}

4
source/renderer/TerrainOverlay.h
View File

@ -160,14 +160,14 @@ protected:
*/
void RenderTileOutline(
Renderer::Backend::GL::CDeviceCommandContext* deviceCommandContext,
const CColor& color, int lineWidth, bool drawHidden);
const CColor& color, bool drawHidden);
/**
* Draw an outlined quad on top of the given tile.
*/
void RenderTileOutline(
Renderer::Backend::GL::CDeviceCommandContext* deviceCommandContext,
const CColor& color, int lineWidth, bool drawHidden, ssize_t i, ssize_t j);
const CColor& color, bool drawHidden, ssize_t i, ssize_t j);
private:
// Process all tiles

11
source/renderer/TerrainRenderer.cpp
View File

@ -197,11 +197,14 @@ void TerrainRenderer::RenderTerrainOverlayTexture(
{
// Add a delta to avoid z-fighting.
const float height = g_Renderer.GetSceneRenderer().GetWaterManager().m_WaterHeight + 0.05f;
const float waterPos[] = {
const float waterPos[] =
{
waterBounds[0].X, height, waterBounds[0].Z,
waterBounds[1].X, height, waterBounds[0].Z,
waterBounds[0].X, height, waterBounds[1].Z,
waterBounds[1].X, height, waterBounds[1].Z
waterBounds[1].X, height, waterBounds[1].Z,
waterBounds[0].X, height, waterBounds[0].Z,
waterBounds[1].X, height, waterBounds[1].Z,
waterBounds[0].X, height, waterBounds[1].Z
};
const GLsizei stride = sizeof(float) * 3;
@ -209,7 +212,7 @@ void TerrainRenderer::RenderTerrainOverlayTexture(
debugOverlayShader->TexCoordPointer(GL_TEXTURE0, 3, GL_FLOAT, stride, waterPos);
debugOverlayShader->AssertPointersBound();
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glDrawArrays(GL_TRIANGLES, 0, 6);
}
debugOverlayTech->EndPass();

2
source/tools/atlas/GameInterface/Brushes.cpp
View File

@ -66,7 +66,7 @@ public:
) / 4.f;
RenderTile(deviceCommandContext, CColor(0, 1, 0, avg*0.8f), false);
if (avg > 0.1f)
RenderTileOutline(deviceCommandContext, CColor(1, 1, 1, std::min(0.4f, avg-0.1f)), 1, true);
RenderTileOutline(deviceCommandContext, CColor(1, 1, 1, std::min(0.4f, avg-0.1f)), true);
}
const AtlasMessage::Brush* m_Brush;