sid/NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add new Renderer architecture (far from complete)

Browse Source 
Former-commit-id: 52226793d7a087dfe0523315d3303934daffee49 [formerly 9de1c04df6b371f861a2eee8bba38902ee5041cd] [formerly ecd3099df5498722f6390447f40bd3907b8e40c4 [formerly 3076df585565fc9759ab3e718270f2e5ef620840]]
Former-commit-id: 92d52f967d0b088d1271afef26069e08cacd6b0f [formerly 5fe27e2ead104278951c772c2121a7b677f88d4d]
Former-commit-id: fb6c2456d8edd3ec022d5d953f79fecdd4f2b8f4
This commit is contained in:
Lynix
2016-08-23 12:52:34 +02:00
parent d7a10031d7
commit bdedd05032
132 changed files with 6300 additions and 12587 deletions
Download Patch File Download Diff File Expand all files Collapse all files

741
src/Nazara/Renderer/DebugDrawer.cpp
View File

@@ -1,741 +0,0 @@
// Copyright (C) 2015 Jérôme Leclercq
// This file is part of the "Nazara Engine - Renderer module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Renderer/DebugDrawer.hpp>
#include <Nazara/Core/ErrorFlags.hpp>
#include <Nazara/Renderer/OpenGL.hpp>
#include <Nazara/Renderer/Renderer.hpp>
#include <Nazara/Renderer/RenderStates.hpp>
#include <Nazara/Renderer/Shader.hpp>
#include <Nazara/Utility/BufferMapper.hpp>
#include <Nazara/Utility/Mesh.hpp>
#include <Nazara/Utility/Skeleton.hpp>
#include <Nazara/Utility/VertexBuffer.hpp>
#include <Nazara/Utility/VertexDeclaration.hpp>
#include <Nazara/Utility/VertexStruct.hpp>
#include <memory>
#include <Nazara/Renderer/Debug.hpp>
///TODO: Améliorer
namespace Nz
{
namespace
{
static Shader* s_shader = nullptr;
static Color s_primaryColor;
static Color s_secondaryColor;
static RenderStates s_renderStates;
static VertexBuffer s_vertexBuffer;
static bool s_initialized = false;
static int s_colorLocation = -1;
}
void DebugDrawer::Draw(const BoundingVolumef& volume)
{
if (!Initialize())
{
NazaraError("Failed to initialize Debug Drawer");
return;
}
if (!volume.IsFinite())
return;
Color oldPrimaryColor = s_primaryColor;
Draw(volume.aabb);
s_primaryColor = s_secondaryColor;
Draw(volume.obb);
s_primaryColor = oldPrimaryColor;
}
void DebugDrawer::Draw(const Boxi& box)
{
Draw(Boxf(box));
}
void DebugDrawer::Draw(const Boxf& box)
{
if (!Initialize())
{
NazaraError("Failed to initialize Debug Drawer");
return;
}
BufferMapper<VertexBuffer> mapper(s_vertexBuffer, BufferAccess_DiscardAndWrite, 0, 24);
VertexStruct_XYZ* vertex = static_cast<VertexStruct_XYZ*>(mapper.GetPointer());
Vector3f max, min;
max = box.GetMaximum();
min = box.GetMinimum();
vertex->position.Set(min.x, min.y, min.z);
vertex++;
vertex->position.Set(max.x, min.y, min.z);
vertex++;
vertex->position.Set(min.x, min.y, min.z);
vertex++;
vertex->position.Set(min.x, max.y, min.z);
vertex++;
vertex->position.Set(min.x, min.y, min.z);
vertex++;
vertex->position.Set(min.x, min.y, max.z);
vertex++;
vertex->position.Set(max.x, max.y, max.z);
vertex++;
vertex->position.Set(min.x, max.y, max.z);
vertex++;
vertex->position.Set(max.x, max.y, max.z);
vertex++;
vertex->position.Set(max.x, min.y, max.z);
vertex++;
vertex->position.Set(max.x, max.y, max.z);
vertex++;
vertex->position.Set(max.x, max.y, min.z);
vertex++;
vertex->position.Set(min.x, min.y, max.z);
vertex++;
vertex->position.Set(max.x, min.y, max.z);
vertex++;
vertex->position.Set(min.x, min.y, max.z);
vertex++;
vertex->position.Set(min.x, max.y, max.z);
vertex++;
vertex->position.Set(min.x, max.y, min.z);
vertex++;
vertex->position.Set(max.x, max.y, min.z);
vertex++;
vertex->position.Set(min.x, max.y, min.z);
vertex++;
vertex->position.Set(min.x, max.y, max.z);
vertex++;
vertex->position.Set(max.x, min.y, min.z);
vertex++;
vertex->position.Set(max.x, max.y, min.z);
vertex++;
vertex->position.Set(max.x, min.y, min.z);
vertex++;
vertex->position.Set(max.x, min.y, max.z);
vertex++;
mapper.Unmap();
Renderer::SetRenderStates(s_renderStates);
Renderer::SetShader(s_shader);
Renderer::SetVertexBuffer(&s_vertexBuffer);
s_shader->SendColor(s_colorLocation, s_primaryColor);
Renderer::DrawPrimitives(PrimitiveMode_LineList, 0, 24);
}
void DebugDrawer::Draw(const Boxui& box)
{
Draw(Boxf(box));
}
void DebugDrawer::Draw(const Frustumf& frustum)
{
if (!Initialize())
{
NazaraError("Failed to initialize Debug Drawer");
return;
}
BufferMapper<VertexBuffer> mapper(s_vertexBuffer, BufferAccess_DiscardAndWrite, 0, 24);
VertexStruct_XYZ* vertex = static_cast<VertexStruct_XYZ*>(mapper.GetPointer());
vertex->position.Set(frustum.GetCorner(BoxCorner_NearLeftBottom));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_NearRightBottom));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_NearLeftBottom));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_NearLeftTop));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_NearLeftBottom));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_FarLeftBottom));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_FarRightTop));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_FarLeftTop));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_FarRightTop));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_FarRightBottom));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_FarRightTop));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_NearRightTop));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_FarLeftBottom));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_FarRightBottom));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_FarLeftBottom));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_FarLeftTop));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_NearLeftTop));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_NearRightTop));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_NearLeftTop));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_FarLeftTop));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_NearRightBottom));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_NearRightTop));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_NearRightBottom));
vertex++;
vertex->position.Set(frustum.GetCorner(BoxCorner_FarRightBottom));
vertex++;
mapper.Unmap();
Renderer::SetRenderStates(s_renderStates);
Renderer::SetShader(s_shader);
Renderer::SetVertexBuffer(&s_vertexBuffer);
s_shader->SendColor(s_colorLocation, s_primaryColor);
Renderer::DrawPrimitives(PrimitiveMode_LineList, 0, 24);
}
void DebugDrawer::Draw(const OrientedBoxf& orientedBox)
{
if (!Initialize())
{
NazaraError("Failed to initialize Debug Drawer");
return;
}
BufferMapper<VertexBuffer> mapper(s_vertexBuffer, BufferAccess_DiscardAndWrite, 0, 24);
VertexStruct_XYZ* vertex = static_cast<VertexStruct_XYZ*>(mapper.GetPointer());
vertex->position.Set(orientedBox.GetCorner(BoxCorner_NearLeftBottom));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_NearRightBottom));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_NearLeftBottom));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_NearLeftTop));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_NearLeftBottom));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_FarLeftBottom));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_FarRightTop));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_FarLeftTop));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_FarRightTop));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_FarRightBottom));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_FarRightTop));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_NearRightTop));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_FarLeftBottom));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_FarRightBottom));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_FarLeftBottom));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_FarLeftTop));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_NearLeftTop));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_NearRightTop));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_NearLeftTop));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_FarLeftTop));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_NearRightBottom));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_NearRightTop));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_NearRightBottom));
vertex++;
vertex->position.Set(orientedBox.GetCorner(BoxCorner_FarRightBottom));
vertex++;
mapper.Unmap();
Renderer::SetRenderStates(s_renderStates);
Renderer::SetShader(s_shader);
Renderer::SetVertexBuffer(&s_vertexBuffer);
s_shader->SendColor(s_colorLocation, s_primaryColor);
Renderer::DrawPrimitives(PrimitiveMode_LineList, 0, 24);
}
void DebugDrawer::Draw(const Skeleton* skeleton)
{
if (!Initialize())
{
NazaraError("Failed to initialize Debug Drawer");
return;
}
unsigned int jointCount = skeleton->GetJointCount();
if (s_vertexBuffer.GetVertexCount() < jointCount*2)
{
NazaraError("Debug buffer not large enougth to draw object");
return;
}
BufferMapper<VertexBuffer> mapper(s_vertexBuffer, BufferAccess_DiscardAndWrite, 0, jointCount*2);
VertexStruct_XYZ* vertex = static_cast<VertexStruct_XYZ*>(mapper.GetPointer());
unsigned int vertexCount = 0;
for (unsigned int i = 0; i < jointCount; ++i)
{
const Node* joint = skeleton->GetJoint(i);
const Node* parent = joint->GetParent();
if (parent)
{
vertex->position = joint->GetPosition();
vertex++;
vertex->position = parent->GetPosition();
vertex++;
vertexCount += 2;
}
}
mapper.Unmap();
if (vertexCount > 0)
{
Renderer::SetRenderStates(s_renderStates);
Renderer::SetShader(s_shader);
Renderer::SetVertexBuffer(&s_vertexBuffer);
s_shader->SendColor(s_colorLocation, s_primaryColor);
Renderer::DrawPrimitives(PrimitiveMode_LineList, 0, vertexCount);
s_shader->SendColor(s_colorLocation, s_secondaryColor);
Renderer::DrawPrimitives(PrimitiveMode_PointList, 0, vertexCount);
}
}
void DebugDrawer::Draw(const Vector3f& position, float size)
{
Draw(Boxf(position.x - size*0.5f, position.y - size*0.5f, position.z - size*0.5f, size, size, size));
}
void DebugDrawer::DrawAxes(const Vector3f& position, float size)
{
Color oldPrimaryColor = s_primaryColor;
s_primaryColor = Color::Red;
DrawLine(position, position + Vector3f::UnitX() * 3.f * size / 4.f);
s_primaryColor = Color::Green;
DrawLine(position, position + Vector3f::UnitY() * 3.f * size / 4.f);
s_primaryColor = Color::Blue;
DrawLine(position, position + Vector3f::UnitZ() * 3.f * size / 4.f);
s_primaryColor = Color::Red;
DrawCone(position + Vector3f::UnitX() * size, EulerAnglesf(0.f, 90.f, 0.f), 15, size / 4.f);
s_primaryColor = Color::Green;
DrawCone(position + Vector3f::UnitY() * size, EulerAnglesf(-90.f, 0.f, 0.f), 15, size / 4.f);
s_primaryColor = Color::Blue;
DrawCone(position + Vector3f::UnitZ() * size, EulerAnglesf(0.f, 0.f, 0.f), 15, size / 4.f);
s_primaryColor = oldPrimaryColor;
}
void DebugDrawer::DrawBinormals(const StaticMesh* subMesh)
{
if (!Initialize())
{
NazaraError("Failed to initialize Debug Drawer");
return;
}
unsigned int normalCount = subMesh->GetVertexCount();
unsigned int vertexCount = normalCount*2;
if (s_vertexBuffer.GetVertexCount() < vertexCount)
{
NazaraError("Debug buffer not large enougth to draw object");
return;
}
BufferMapper<VertexBuffer> inputMapper(subMesh->GetVertexBuffer(), BufferAccess_ReadOnly);
BufferMapper<VertexBuffer> outputMapper(s_vertexBuffer, BufferAccess_DiscardAndWrite, 0, vertexCount);
MeshVertex* inputVertex = static_cast<MeshVertex*>(inputMapper.GetPointer());
VertexStruct_XYZ* outputVertex = static_cast<VertexStruct_XYZ*>(outputMapper.GetPointer());
for (unsigned int i = 0; i < normalCount; ++i)
{
outputVertex->position = inputVertex->position;
outputVertex++;
outputVertex->position = inputVertex->position + Vector3f::CrossProduct(inputVertex->normal, inputVertex->tangent)*0.01f;
outputVertex++;
inputVertex++;
}
inputMapper.Unmap();
outputMapper.Unmap();
if (vertexCount > 0)
{
Renderer::SetRenderStates(s_renderStates);
Renderer::SetShader(s_shader);
Renderer::SetVertexBuffer(&s_vertexBuffer);
s_shader->SendColor(s_colorLocation, s_primaryColor);
Renderer::DrawPrimitives(PrimitiveMode_LineList, 0, vertexCount);
}
}
void DebugDrawer::DrawCone(const Vector3f& origin, const Quaternionf& rotation, float angle, float length)
{
if (!Initialize())
{
NazaraError("Failed to initialize Debug Drawer");
return;
}
Matrix4f transformMatrix;
transformMatrix.MakeIdentity();
transformMatrix.SetRotation(rotation);
transformMatrix.SetTranslation(origin);
BufferMapper<VertexBuffer> mapper(s_vertexBuffer, BufferAccess_DiscardAndWrite, 0, 16);
VertexStruct_XYZ* vertex = static_cast<VertexStruct_XYZ*>(mapper.GetPointer());
// On calcule le reste des points
Vector3f base(Vector3f::Forward()*length);
// Il nous faut maintenant le rayon du cercle projeté à cette distance
// Tangente = Opposé/Adjaçent <=> Opposé = Adjaçent*Tangente
float radius = length*std::tan(DegreeToRadian(angle));
Vector3f lExtend = Vector3f::Left()*radius;
Vector3f uExtend = Vector3f::Up()*radius;
vertex->position.Set(transformMatrix * Vector3f::Zero());
vertex++;
vertex->position.Set(transformMatrix * (base + lExtend + uExtend));
vertex++;
vertex->position.Set(transformMatrix * (base + lExtend + uExtend));
vertex++;
vertex->position.Set(transformMatrix * (base + lExtend - uExtend));
vertex++;
vertex->position.Set(transformMatrix * Vector3f::Zero());
vertex++;
vertex->position.Set(transformMatrix * (base + lExtend - uExtend));
vertex++;
vertex->position.Set(transformMatrix * (base + lExtend - uExtend));
vertex++;
vertex->position.Set(transformMatrix * (base - lExtend - uExtend));
vertex++;
vertex->position.Set(transformMatrix * Vector3f::Zero());
vertex++;
vertex->position.Set(transformMatrix * (base - lExtend + uExtend));
vertex++;
vertex->position.Set(transformMatrix * (base - lExtend + uExtend));
vertex++;
vertex->position.Set(transformMatrix * (base - lExtend - uExtend));
vertex++;
vertex->position.Set(transformMatrix * Vector3f::Zero());
vertex++;
vertex->position.Set(transformMatrix * (base - lExtend - uExtend));
vertex++;
vertex->position.Set(transformMatrix * (base - lExtend + uExtend));
vertex++;
vertex->position.Set(transformMatrix * (base + lExtend + uExtend));
vertex++;
mapper.Unmap();
Renderer::SetRenderStates(s_renderStates);
Renderer::SetShader(s_shader);
Renderer::SetVertexBuffer(&s_vertexBuffer);
s_shader->SendColor(s_colorLocation, s_primaryColor);
Renderer::DrawPrimitives(PrimitiveMode_LineList, 0, 16);
}
void DebugDrawer::DrawLine(const Vector3f& p1, const Vector3f& p2)
{
if (!s_initialized && !Initialize())
{
NazaraError("Failed to initialize Debug Drawer");
return;
}
VertexStruct_XYZ buffer[2];
buffer[0].position = p1;
buffer[1].position = p2;
s_vertexBuffer.Fill(&buffer[0], 0, 2);
Renderer::SetRenderStates(s_renderStates);
Renderer::SetShader(s_shader);
Renderer::SetVertexBuffer(&s_vertexBuffer);
s_shader->SendColor(s_colorLocation, s_primaryColor);
Renderer::DrawPrimitives(PrimitiveMode_LineList, 0, 2);
}
void DebugDrawer::DrawPoints(const Vector3f* ptr, unsigned int pointCount)
{
static_assert(sizeof(VertexStruct_XYZ) == sizeof(Vector3f), "VertexStruct_XYZ is no longer equal to Vector3f, please rewrite this");
if (!s_initialized && !Initialize())
{
NazaraError("Failed to initialize Debug Drawer");
return;
}
if (pointCount > 0)
{
s_vertexBuffer.Fill(ptr, 0, pointCount);
Renderer::SetRenderStates(s_renderStates);
Renderer::SetShader(s_shader);
Renderer::SetVertexBuffer(&s_vertexBuffer);
s_shader->SendColor(s_colorLocation, s_primaryColor);
Renderer::DrawPrimitives(PrimitiveMode_PointList, 0, pointCount);
}
}
void DebugDrawer::DrawNormals(const StaticMesh* subMesh)
{
if (!s_initialized && !Initialize())
{
NazaraError("Failed to initialize Debug Drawer");
return;
}
unsigned int normalCount = subMesh->GetVertexCount();
unsigned int vertexCount = normalCount*2;
if (s_vertexBuffer.GetVertexCount() < vertexCount)
{
NazaraError("Debug buffer not large enougth to draw object");
return;
}
BufferMapper<VertexBuffer> inputMapper(subMesh->GetVertexBuffer(), BufferAccess_ReadOnly);
BufferMapper<VertexBuffer> outputMapper(s_vertexBuffer, BufferAccess_DiscardAndWrite, 0, vertexCount);
MeshVertex* inputVertex = static_cast<MeshVertex*>(inputMapper.GetPointer());
VertexStruct_XYZ* outputVertex = static_cast<VertexStruct_XYZ*>(outputMapper.GetPointer());
for (unsigned int i = 0; i < normalCount; ++i)
{
outputVertex->position = inputVertex->position;
outputVertex++;
outputVertex->position = inputVertex->position + inputVertex->normal*0.01f;
outputVertex++;
inputVertex++;
}
inputMapper.Unmap();
outputMapper.Unmap();
if (vertexCount > 0)
{
Renderer::SetRenderStates(s_renderStates);
Renderer::SetShader(s_shader);
Renderer::SetVertexBuffer(&s_vertexBuffer);
s_shader->SendColor(s_colorLocation, s_primaryColor);
Renderer::DrawPrimitives(PrimitiveMode_LineList, 0, vertexCount);
}
}
void DebugDrawer::DrawTangents(const StaticMesh* subMesh)
{
if (!s_initialized && !Initialize())
{
NazaraError("Failed to initialize Debug Drawer");
return;
}
unsigned int tangentCount = subMesh->GetVertexCount();
unsigned int vertexCount = tangentCount*2;
if (s_vertexBuffer.GetVertexCount() < vertexCount)
{
NazaraError("Debug buffer not large enougth to draw object");
return;
}
BufferMapper<VertexBuffer> inputMapper(subMesh->GetVertexBuffer(), BufferAccess_ReadOnly);
BufferMapper<VertexBuffer> outputMapper(s_vertexBuffer, BufferAccess_DiscardAndWrite, 0, vertexCount);
MeshVertex* inputVertex = static_cast<MeshVertex*>(inputMapper.GetPointer());
VertexStruct_XYZ* outputVertex = static_cast<VertexStruct_XYZ*>(outputMapper.GetPointer());
for (unsigned int i = 0; i < tangentCount; ++i)
{
outputVertex->position = inputVertex->position;
outputVertex++;
outputVertex->position = inputVertex->position + inputVertex->tangent*0.01f;
outputVertex++;
inputVertex++;
}
inputMapper.Unmap();
outputMapper.Unmap();
if (vertexCount > 0)
{
Renderer::SetRenderStates(s_renderStates);
Renderer::SetShader(s_shader);
Renderer::SetVertexBuffer(&s_vertexBuffer);
s_shader->SendColor(s_colorLocation, s_primaryColor);
Renderer::DrawPrimitives(PrimitiveMode_LineList, 0, vertexCount);
}
}
void DebugDrawer::EnableDepthBuffer(bool depthBuffer)
{
s_renderStates.depthBuffer = depthBuffer;
}
float DebugDrawer::GetLineWidth()
{
return s_renderStates.lineWidth;
}
float DebugDrawer::GetPointSize()
{
return s_renderStates.pointSize;
}
Color DebugDrawer::GetPrimaryColor()
{
return s_primaryColor;
}
Color DebugDrawer::GetSecondaryColor()
{
return s_secondaryColor;
}
bool DebugDrawer::Initialize()
{
if (!s_initialized)
{
// s_shader
s_shader = ShaderLibrary::Get("DebugSimple");
s_colorLocation = s_shader->GetUniformLocation("Color");
// s_vertexBuffer
try
{
ErrorFlags flags(ErrorFlag_ThrowException, true);
s_vertexBuffer.Reset(VertexDeclaration::Get(VertexLayout_XYZ), 65365, DataStorage_Hardware, BufferUsage_Dynamic);
}
catch (const std::exception& e)
{
NazaraError("Failed to create buffer: " + String(e.what()));
Uninitialize();
return false;
}
s_primaryColor = Color::Red;
s_renderStates.depthBuffer = true;
s_secondaryColor = Color::Green;
s_initialized = true;
}
return true;
}
bool DebugDrawer::IsDepthBufferEnabled()
{
return s_renderStates.depthBuffer;
}
void DebugDrawer::SetLineWidth(float width)
{
s_renderStates.lineWidth = width;
}
void DebugDrawer::SetPointSize(float size)
{
s_renderStates.pointSize = size;
}
void DebugDrawer::SetPrimaryColor(const Color& color)
{
s_primaryColor = color;
}
void DebugDrawer::SetSecondaryColor(const Color& color)
{
s_secondaryColor = color;
}
void DebugDrawer::Uninitialize()
{
s_shader = nullptr;
s_vertexBuffer.Reset();
s_initialized = false;
}
}