409 lines
11 KiB
C++
409 lines
11 KiB
C++
// Copyright (C) 2012 Jérôme Leclercq
|
|
// This file is part of the "Nazara Engine - 3D Module"
|
|
// For conditions of distribution and use, see copyright notice in Config.hpp
|
|
|
|
#include <Nazara/3D/Scene.hpp>
|
|
#include <Nazara/2D/Drawable.hpp>
|
|
#include <Nazara/3D/Camera.hpp>
|
|
#include <Nazara/3D/Light.hpp>
|
|
#include <Nazara/3D/Model.hpp>
|
|
#include <Nazara/3D/RenderQueue.hpp>
|
|
#include <Nazara/3D/SceneRoot.hpp>
|
|
#include <Nazara/Core/Clock.hpp>
|
|
#include <Nazara/Core/Error.hpp>
|
|
#include <Nazara/Renderer/Config.hpp>
|
|
#include <Nazara/Renderer/Renderer.hpp>
|
|
#include <Nazara/Renderer/Shader.hpp>
|
|
#include <Nazara/Renderer/ShaderBuilder.hpp>
|
|
#include <Nazara/Utility/BufferMapper.hpp>
|
|
#include <Nazara/Utility/SkeletalMesh.hpp>
|
|
#include <Nazara/Utility/StaticMesh.hpp>
|
|
#include <functional>
|
|
#include <set>
|
|
#include <vector>
|
|
#include <Nazara/3D/Debug.hpp>
|
|
|
|
namespace
|
|
{
|
|
const unsigned int maxLights = 8; ///TODO: Config
|
|
|
|
struct LightComparator
|
|
{
|
|
bool operator()(const NzLight* light1, const NzLight* light2)
|
|
{
|
|
return light1->GetPosition().SquaredDistance(pos) < light2->GetPosition().SquaredDistance(pos);
|
|
}
|
|
|
|
NzVector3f pos;
|
|
};
|
|
|
|
void RecursiveFrustumCull(NzRenderQueue& renderQueue, const NzFrustumf& frustum, NzSceneNode* node)
|
|
{
|
|
for (NzNode* child : node->GetChilds())
|
|
{
|
|
if (child->GetNodeType() == nzNodeType_Scene)
|
|
{
|
|
NzSceneNode* sceneNode = static_cast<NzSceneNode*>(child);
|
|
///TODO: Empêcher le rendu des enfants si le parent est cullé selon un flag
|
|
if (sceneNode->IsVisible(frustum))
|
|
sceneNode->AddToRenderQueue(renderQueue);
|
|
|
|
if (sceneNode->HasChilds())
|
|
RecursiveFrustumCull(renderQueue, frustum, sceneNode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
struct NzSceneImpl
|
|
{
|
|
NzSceneImpl(NzScene* scene) :
|
|
root(scene)
|
|
{
|
|
}
|
|
|
|
std::set<NzUpdatable*> updateList;
|
|
std::vector<NzRenderer::InstancingData> instancingData;
|
|
NzClock updateClock;
|
|
NzColor ambientColor = NzColor(25,25,25);
|
|
NzRenderQueue renderQueue;
|
|
NzSceneRoot root;
|
|
const NzCamera* activeCamera;
|
|
NzVertexBuffer* skinningBuffer;
|
|
bool update = true;
|
|
float frameTime;
|
|
float updateTime;
|
|
unsigned int updatePerSecond = 60;
|
|
};
|
|
|
|
NzScene::NzScene()
|
|
{
|
|
m_impl = new NzSceneImpl(this);
|
|
m_impl->skinningBuffer = new NzVertexBuffer(NzMesh::GetDeclaration(), 20000, nzBufferStorage_Hardware, nzBufferUsage_Dynamic);
|
|
|
|
if (NzRenderer::HasCapability(nzRendererCap_Instancing))
|
|
m_impl->instancingData.resize(NAZARA_RENDERER_INSTANCING_MAX);
|
|
}
|
|
|
|
NzScene::~NzScene()
|
|
{
|
|
for (NzNode* child : m_impl->root.GetChilds())
|
|
{
|
|
if (child->GetNodeType() == nzNodeType_Scene)
|
|
static_cast<NzSceneNode*>(child)->SetScene(nullptr);
|
|
}
|
|
|
|
delete m_impl->skinningBuffer;
|
|
delete m_impl;
|
|
}
|
|
|
|
void NzScene::Cull()
|
|
{
|
|
m_impl->renderQueue.Clear();
|
|
|
|
// Frustum culling
|
|
RecursiveFrustumCull(m_impl->renderQueue, m_impl->activeCamera->GetFrustum(), &m_impl->root);
|
|
}
|
|
|
|
void NzScene::Draw()
|
|
{
|
|
LightComparator lightComparator;
|
|
|
|
// Pour les meshs squelettiques, on utilise un buffer commun
|
|
NzRenderer::SetVertexBuffer(m_impl->skinningBuffer);
|
|
for (auto matIt : m_impl->renderQueue.visibleSkeletalModels)
|
|
{
|
|
// On applique le shader du matériau
|
|
nzUInt32 shaderFlags = matIt.first->GetShaderFlags();
|
|
|
|
const NzShader* shader = NzShaderBuilder::Get(shaderFlags);
|
|
|
|
NzRenderer::SetShader(shader);
|
|
matIt.first->Apply(shader);
|
|
|
|
// Position de la caméra
|
|
int camPosLocation = shader->GetUniformLocation("CameraPosition");
|
|
if (camPosLocation != -1)
|
|
shader->SendVector(camPosLocation, m_impl->activeCamera->GetPosition());
|
|
|
|
// Couleur ambiante de la scène
|
|
int sceneAmbientLocation = shader->GetUniformLocation("SceneAmbient");
|
|
if (sceneAmbientLocation != -1)
|
|
shader->SendColor(sceneAmbientLocation, m_impl->ambientColor);
|
|
|
|
// Gestion des lumières (D'abord directionnelles)
|
|
int lightCountLocation = shader->GetUniformLocation("LightCount");
|
|
|
|
unsigned int lightIndex = 0;
|
|
if (lightCountLocation != -1)
|
|
{
|
|
for (const NzLight* light : m_impl->renderQueue.directionnalLights)
|
|
{
|
|
light->Apply(shader, lightIndex++);
|
|
if (lightIndex > maxLights)
|
|
break; // N'arrivera jamais mais pourrait résulter en un bug
|
|
}
|
|
}
|
|
|
|
for (auto subMeshIt : matIt.second)
|
|
{
|
|
const NzSkeletalMesh* skeletalMesh = subMeshIt.first;
|
|
const NzIndexBuffer* indexBuffer = skeletalMesh->GetIndexBuffer();
|
|
|
|
unsigned int vertexCount = skeletalMesh->GetVertexCount();
|
|
|
|
// Gestion du draw call avant la boucle de rendu
|
|
std::function<void(nzPrimitiveType, unsigned int, unsigned int)> drawFunc;
|
|
nzPrimitiveType primitiveType = skeletalMesh->GetPrimitiveType();
|
|
unsigned int indexCount;
|
|
if (indexBuffer)
|
|
{
|
|
drawFunc = NzRenderer::DrawIndexedPrimitives;
|
|
indexCount = indexBuffer->GetIndexCount();
|
|
NzRenderer::SetIndexBuffer(indexBuffer);
|
|
}
|
|
else
|
|
{
|
|
drawFunc = NzRenderer::DrawPrimitives;
|
|
indexCount = skeletalMesh->GetVertexCount();
|
|
}
|
|
|
|
for (const NzRenderQueue::SkeletalData& data : subMeshIt.second)
|
|
{
|
|
// Transfert du résultat du skinning vers notre buffer hardware
|
|
NzBufferMapper<NzVertexBuffer> outputMapper(m_impl->skinningBuffer, nzBufferAccess_DiscardAndWrite, 0, vertexCount);
|
|
std::memcpy(outputMapper.GetPointer(), &data.skinnedVertices[0], vertexCount*sizeof(NzMeshVertex));
|
|
outputMapper.Unmap();
|
|
|
|
// Calcul des lumières les plus proches (TODO: LightManager ?)
|
|
if (lightCountLocation != -1)
|
|
{
|
|
auto visibleLights = m_impl->renderQueue.visibleLights;
|
|
lightComparator.pos = data.transformMatrix.GetTranslation();
|
|
std::sort(visibleLights.begin(), visibleLights.end(), lightComparator);
|
|
|
|
const unsigned int maxLightPerObject = 3; ///TODO: Config
|
|
unsigned int max = std::min(std::min(maxLights - lightIndex, maxLightPerObject), visibleLights.size());
|
|
for (unsigned int i = 0; i < max; ++i)
|
|
visibleLights[i]->Apply(shader, lightIndex + i);
|
|
|
|
shader->SendInteger(lightCountLocation, lightIndex + max);
|
|
}
|
|
|
|
NzRenderer::SetMatrix(nzMatrixType_World, data.transformMatrix);
|
|
|
|
drawFunc(primitiveType, 0, indexCount);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pour les meshs statiques, on utilise le buffer du mesh
|
|
for (auto matIt : m_impl->renderQueue.visibleStaticModels)
|
|
{
|
|
// On applique le shader du matériau
|
|
nzUInt32 shaderFlags = matIt.first->GetShaderFlags();
|
|
if (NzRenderer::HasCapability(nzRendererCap_Instancing) && m_impl->renderQueue.visibleLights.empty())
|
|
shaderFlags |= nzShaderFlags_Instancing;
|
|
|
|
const NzShader* shader = NzShaderBuilder::Get(shaderFlags);
|
|
|
|
NzRenderer::SetShader(shader);
|
|
matIt.first->Apply(shader);
|
|
|
|
bool instancing = shader->GetFlags() & nzShaderFlags_Instancing;
|
|
|
|
// Position de la caméra
|
|
int camPosLocation = shader->GetUniformLocation("CameraPosition");
|
|
if (camPosLocation != -1)
|
|
shader->SendVector(camPosLocation, m_impl->activeCamera->GetPosition());
|
|
|
|
// Couleur ambiante de la scène
|
|
int sceneAmbientLocation = shader->GetUniformLocation("SceneAmbient");
|
|
if (sceneAmbientLocation != -1)
|
|
shader->SendColor(sceneAmbientLocation, m_impl->ambientColor);
|
|
|
|
// Gestion des lumières (D'abord directionnelles)
|
|
int lightCountLocation = shader->GetUniformLocation("LightCount");
|
|
|
|
unsigned int lightIndex = 0;
|
|
if (lightCountLocation != -1)
|
|
{
|
|
for (const NzLight* light : m_impl->renderQueue.directionnalLights)
|
|
{
|
|
light->Apply(shader, lightIndex++);
|
|
if (lightIndex > maxLights)
|
|
break; // N'arrivera probablement jamais mais pourrait résulter en un bug
|
|
}
|
|
}
|
|
|
|
for (auto subMeshIt : matIt.second)
|
|
{
|
|
NzStaticMesh* staticMesh = subMeshIt.first;
|
|
|
|
const NzIndexBuffer* indexBuffer = staticMesh->GetIndexBuffer();
|
|
const NzVertexBuffer* vertexBuffer = staticMesh->GetVertexBuffer();
|
|
|
|
NzRenderer::SetVertexBuffer(vertexBuffer);
|
|
|
|
// Gestion du draw call avant la boucle de rendu
|
|
std::function<void(nzPrimitiveType, unsigned int, unsigned int)> draw;
|
|
std::function<void(unsigned int, nzPrimitiveType, unsigned int, unsigned int)> instancedDraw;
|
|
nzPrimitiveType primitiveType = staticMesh->GetPrimitiveType();
|
|
unsigned int indexCount;
|
|
if (indexBuffer)
|
|
{
|
|
draw = NzRenderer::DrawIndexedPrimitives;
|
|
indexCount = indexBuffer->GetIndexCount();
|
|
instancedDraw = NzRenderer::DrawIndexedPrimitivesInstanced;
|
|
NzRenderer::SetIndexBuffer(indexBuffer);
|
|
}
|
|
else
|
|
{
|
|
draw = NzRenderer::DrawPrimitives;
|
|
indexCount = vertexBuffer->GetVertexCount();
|
|
instancedDraw = NzRenderer::DrawPrimitivesInstanced;
|
|
}
|
|
|
|
if (instancing)
|
|
{
|
|
shader->SendInteger(lightCountLocation, lightIndex);
|
|
|
|
unsigned int count = 0;
|
|
for (const NzMatrix4f& matrix : subMeshIt.second)
|
|
{
|
|
m_impl->instancingData[count++].worldMatrix = matrix;
|
|
if (count == m_impl->instancingData.size())
|
|
{
|
|
NzRenderer::FillInstancingBuffer(&m_impl->instancingData[0], count);
|
|
instancedDraw(count, primitiveType, 0, indexCount);
|
|
|
|
count = 0;
|
|
}
|
|
}
|
|
|
|
if (count > 0)
|
|
{
|
|
NzRenderer::FillInstancingBuffer(&m_impl->instancingData[0], count);
|
|
instancedDraw(count, primitiveType, 0, indexCount);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (const NzMatrix4f& matrix : subMeshIt.second)
|
|
{
|
|
// Calcul des lumières les plus proches (TODO: LightManager ?)
|
|
if (lightCountLocation != -1)
|
|
{
|
|
std::vector<const NzLight*>& visibleLights = m_impl->renderQueue.visibleLights;
|
|
lightComparator.pos = matrix.GetTranslation();
|
|
std::sort(visibleLights.begin(), visibleLights.end(), lightComparator);
|
|
|
|
const unsigned int maxLightPerObject = 3; ///TODO: Config
|
|
unsigned int max = std::min(std::min(maxLights - lightIndex, maxLightPerObject), visibleLights.size());
|
|
for (unsigned int i = 0; i < max; ++i)
|
|
visibleLights[i]->Apply(shader, lightIndex + i);
|
|
|
|
shader->SendInteger(lightCountLocation, lightIndex + max);
|
|
}
|
|
|
|
NzRenderer::SetMatrix(nzMatrixType_World, matrix);
|
|
|
|
draw(primitiveType, 0, indexCount);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Les autres drawables (Exemple: Terrain)
|
|
for (const NzDrawable* drawable : m_impl->renderQueue.otherDrawables)
|
|
drawable->Draw();
|
|
}
|
|
|
|
NzSceneNode& NzScene::GetRoot() const
|
|
{
|
|
return m_impl->root;
|
|
}
|
|
|
|
float NzScene::GetUpdateTime() const
|
|
{
|
|
return m_impl->updateTime;
|
|
}
|
|
|
|
unsigned int NzScene::GetUpdatePerSecond() const
|
|
{
|
|
return m_impl->updatePerSecond;
|
|
}
|
|
|
|
void NzScene::RegisterForUpdate(NzUpdatable* object)
|
|
{
|
|
#if NAZARA_3D_SAFE
|
|
if (!object)
|
|
{
|
|
NazaraError("Invalid object");
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
m_impl->updateList.insert(object);
|
|
}
|
|
|
|
void NzScene::SetAmbientColor(const NzColor& color)
|
|
{
|
|
m_impl->ambientColor = color;
|
|
}
|
|
|
|
void NzScene::SetUpdatePerSecond(unsigned int updatePerSecond)
|
|
{
|
|
m_impl->updatePerSecond = updatePerSecond;
|
|
}
|
|
|
|
void NzScene::UnregisterForUpdate(NzUpdatable* object)
|
|
{
|
|
#if NAZARA_3D_SAFE
|
|
if (!object)
|
|
{
|
|
NazaraError("Invalid object");
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
m_impl->updateList.erase(object);
|
|
}
|
|
|
|
void NzScene::Update()
|
|
{
|
|
if (m_impl->updatePerSecond == 0 || m_impl->updateClock.GetMilliseconds() > 1000/m_impl->updatePerSecond)
|
|
{
|
|
m_impl->updateTime = m_impl->updateClock.GetSeconds();
|
|
m_impl->updateClock.Restart();
|
|
|
|
for (NzUpdatable* updatable : m_impl->updateList)
|
|
{
|
|
///TODO: Multihreading
|
|
updatable->Update();
|
|
}
|
|
}
|
|
}
|
|
|
|
void NzScene::UpdateVisible()
|
|
{/*
|
|
if (m_impl->update)
|
|
{
|
|
for (NzSceneNode* node : m_impl->visibleNodes)
|
|
{
|
|
if (node->ShouldUpdateWhenVisible())
|
|
node->Update();
|
|
}
|
|
}*/
|
|
}
|
|
|
|
NzScene::operator const NzSceneNode&() const
|
|
{
|
|
return m_impl->root;
|
|
}
|
|
|
|
void NzScene::SetActiveCamera(const NzCamera* camera)
|
|
{
|
|
m_impl->activeCamera = camera;
|
|
}
|