397 lines
11 KiB
C++
397 lines
11 KiB
C++
// Copyright (C) 2014 Jérôme Leclercq
|
|
// This file is part of the "Nazara Engine - Graphics module"
|
|
// For conditions of distribution and use, see copyright notice in Config.hpp
|
|
|
|
#include <Nazara/Graphics/ForwardRenderQueue.hpp>
|
|
#include <Nazara/Graphics/AbstractViewer.hpp>
|
|
#include <Nazara/Graphics/Light.hpp>
|
|
#include <Nazara/Graphics/Material.hpp>
|
|
#include <Nazara/Graphics/Model.hpp>
|
|
#include <Nazara/Graphics/Sprite.hpp>
|
|
#include <Nazara/Utility/SkeletalMesh.hpp>
|
|
#include <Nazara/Utility/StaticMesh.hpp>
|
|
#include <Nazara/Graphics/Debug.hpp>
|
|
|
|
namespace
|
|
{
|
|
enum ResourceType
|
|
{
|
|
ResourceType_Material,
|
|
ResourceType_SkeletalMesh,
|
|
ResourceType_StaticMesh
|
|
};
|
|
}
|
|
|
|
NzForwardRenderQueue::~NzForwardRenderQueue()
|
|
{
|
|
Clear(true);
|
|
}
|
|
|
|
void NzForwardRenderQueue::AddDrawable(const NzDrawable* drawable)
|
|
{
|
|
#if NAZARA_GRAPHICS_SAFE
|
|
if (!drawable)
|
|
{
|
|
NazaraError("Invalid drawable");
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
otherDrawables.push_back(drawable);
|
|
}
|
|
|
|
void NzForwardRenderQueue::AddLight(const NzLight* light)
|
|
{
|
|
#if NAZARA_GRAPHICS_SAFE
|
|
if (!light)
|
|
{
|
|
NazaraError("Invalid light");
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
switch (light->GetLightType())
|
|
{
|
|
case nzLightType_Directional:
|
|
directionalLights.push_back(light);
|
|
break;
|
|
|
|
case nzLightType_Point:
|
|
case nzLightType_Spot:
|
|
lights.push_back(light);
|
|
break;
|
|
|
|
#ifdef NAZARA_DEBUG
|
|
default:
|
|
NazaraError("Light type not handled (0x" + NzString::Number(light->GetLightType(), 16) + ')');
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void NzForwardRenderQueue::AddSprite(const NzSprite* sprite)
|
|
{
|
|
#if NAZARA_GRAPHICS_SAFE
|
|
if (!sprite)
|
|
{
|
|
NazaraError("Invalid sprite");
|
|
return;
|
|
}
|
|
|
|
if (!sprite->IsDrawable())
|
|
{
|
|
NazaraError("Sprite is not drawable");
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
sprites[sprite->GetMaterial()].push_back(sprite);
|
|
}
|
|
|
|
void NzForwardRenderQueue::AddSubMesh(const NzMaterial* material, const NzSubMesh* subMesh, const NzMatrix4f& transformMatrix)
|
|
{
|
|
switch (subMesh->GetAnimationType())
|
|
{
|
|
case nzAnimationType_Skeletal:
|
|
{
|
|
///TODO
|
|
/*
|
|
** Il y a ici deux choses importantes à gérer:
|
|
** -Pour commencer, la mise en cache de std::vector suffisamment grands pour contenir le résultat du skinning
|
|
** l'objectif ici est d'éviter une allocation à chaque frame, donc de réutiliser un tableau existant
|
|
** Note: Il faudrait évaluer aussi la possibilité de conserver le buffer d'une frame à l'autre.
|
|
** Ceci permettant de ne pas skinner inutilement ce qui ne bouge pas, ou de skinner partiellement un mesh.
|
|
** Il faut cependant voir où stocker ce set de buffers, qui doit être communs à toutes les RQ d'une même scène.
|
|
**
|
|
** -Ensuite, la possibilité de regrouper les modèles skinnés identiques, une centaine de soldats marchant au pas
|
|
** ne devrait requérir qu'un skinning.
|
|
*/
|
|
NazaraError("Skeletal mesh not supported yet, sorry");
|
|
break;
|
|
}
|
|
|
|
case nzAnimationType_Static:
|
|
{
|
|
const NzStaticMesh* staticMesh = static_cast<const NzStaticMesh*>(subMesh);
|
|
|
|
if (material->IsEnabled(nzRendererParameter_Blend))
|
|
{
|
|
unsigned int index = transparentStaticModels.size();
|
|
transparentStaticModels.resize(index+1);
|
|
|
|
const NzBoxf& aabb = staticMesh->GetAABB();
|
|
|
|
TransparentStaticModel& data = transparentStaticModels.back();
|
|
data.boundingSphere = NzSpheref(transformMatrix.GetTranslation() + aabb.GetCenter(), aabb.GetSquaredRadius());
|
|
data.material = material;
|
|
data.mesh = staticMesh;
|
|
data.transformMatrix = transformMatrix;
|
|
|
|
transparentsModels.push_back(std::make_pair(index, true));
|
|
}
|
|
else
|
|
{
|
|
auto pair = opaqueModels.insert(std::make_pair(material, BatchedModelContainer::mapped_type()));
|
|
if (pair.second)
|
|
material->AddResourceListener(this, ResourceType_Material);
|
|
|
|
bool& used = std::get<0>(pair.first->second);
|
|
bool& enableInstancing = std::get<1>(pair.first->second);
|
|
|
|
used = true;
|
|
|
|
auto& meshMap = std::get<3>(pair.first->second);
|
|
|
|
auto pair2 = meshMap.insert(std::make_pair(staticMesh, BatchedStaticMeshContainer::mapped_type()));
|
|
if (pair2.second)
|
|
{
|
|
staticMesh->AddResourceListener(this, ResourceType_StaticMesh);
|
|
|
|
NzSpheref& squaredBoundingSphere = pair2.first->second.first;
|
|
squaredBoundingSphere.Set(staticMesh->GetAABB().GetSquaredBoundingSphere());
|
|
///TODO: Écouter le StaticMesh pour repérer tout changement de géométrie
|
|
}
|
|
|
|
std::vector<StaticData>& staticDataContainer = pair2.first->second.second;
|
|
|
|
unsigned int instanceCount = staticDataContainer.size() + 1;
|
|
|
|
// Avons-nous suffisamment d'instances pour que le coût d'utilisation de l'instancing soit payé ?
|
|
if (instanceCount >= NAZARA_GRAPHICS_INSTANCING_MIN_INSTANCES_COUNT)
|
|
enableInstancing = true; // Apparemment oui, activons l'instancing avec ce matériau
|
|
|
|
staticDataContainer.resize(instanceCount);
|
|
StaticData& data = staticDataContainer.back();
|
|
data.transformMatrix = transformMatrix;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void NzForwardRenderQueue::Clear(bool fully)
|
|
{
|
|
directionalLights.clear();
|
|
lights.clear();
|
|
otherDrawables.clear();
|
|
transparentsModels.clear();
|
|
transparentSkeletalModels.clear();
|
|
transparentStaticModels.clear();
|
|
|
|
if (fully)
|
|
{
|
|
for (auto& matIt : opaqueModels)
|
|
{
|
|
const NzMaterial* material = matIt.first;
|
|
material->RemoveResourceListener(this);
|
|
|
|
BatchedSkeletalMeshContainer& skeletalContainer = std::get<2>(matIt.second);
|
|
for (auto& meshIt : skeletalContainer)
|
|
{
|
|
const NzSkeletalMesh* skeletalMesh = meshIt.first;
|
|
skeletalMesh->RemoveResourceListener(this);
|
|
}
|
|
|
|
BatchedStaticMeshContainer& staticContainer = std::get<3>(matIt.second);
|
|
for (auto& meshIt : staticContainer)
|
|
{
|
|
const NzStaticMesh* staticMesh = meshIt.first;
|
|
staticMesh->RemoveResourceListener(this);
|
|
}
|
|
}
|
|
opaqueModels.clear();
|
|
sprites.clear();
|
|
}
|
|
}
|
|
|
|
void NzForwardRenderQueue::Sort(const NzAbstractViewer* viewer)
|
|
{
|
|
struct TransparentModelComparator
|
|
{
|
|
bool operator()(const std::pair<unsigned int, bool>& index1, const std::pair<unsigned int, bool>& index2)
|
|
{
|
|
const NzSpheref& sphere1 = (index1.second) ?
|
|
queue->transparentStaticModels[index1.first].boundingSphere :
|
|
queue->transparentSkeletalModels[index1.first].boundingSphere;
|
|
|
|
const NzSpheref& sphere2 = (index2.second) ?
|
|
queue->transparentStaticModels[index2.first].boundingSphere :
|
|
queue->transparentSkeletalModels[index2.first].boundingSphere;
|
|
|
|
NzVector3f position1 = sphere1.GetNegativeVertex(viewerNormal);
|
|
NzVector3f position2 = sphere2.GetNegativeVertex(viewerNormal);
|
|
|
|
return nearPlane.Distance(position1) > nearPlane.Distance(position2);
|
|
}
|
|
|
|
NzForwardRenderQueue* queue;
|
|
NzPlanef nearPlane;
|
|
NzVector3f viewerNormal;
|
|
};
|
|
|
|
TransparentModelComparator comparator {this, viewer->GetFrustum().GetPlane(nzFrustumPlane_Near), viewer->GetForward()};
|
|
std::sort(transparentsModels.begin(), transparentsModels.end(), comparator);
|
|
}
|
|
|
|
bool NzForwardRenderQueue::OnResourceDestroy(const NzResource* resource, int index)
|
|
{
|
|
switch (index)
|
|
{
|
|
case ResourceType_Material:
|
|
opaqueModels.erase(static_cast<const NzMaterial*>(resource));
|
|
break;
|
|
|
|
case ResourceType_SkeletalMesh:
|
|
{
|
|
for (auto& pair : opaqueModels)
|
|
std::get<2>(pair.second).erase(static_cast<const NzSkeletalMesh*>(resource));
|
|
|
|
break;
|
|
}
|
|
|
|
case ResourceType_StaticMesh:
|
|
{
|
|
for (auto& pair : opaqueModels)
|
|
std::get<3>(pair.second).erase(static_cast<const NzStaticMesh*>(resource));
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return false; // Nous ne voulons plus recevoir d'évènement de cette ressource
|
|
}
|
|
|
|
void NzForwardRenderQueue::OnResourceReleased(const NzResource* resource, int index)
|
|
{
|
|
// La ressource vient d'être libérée, nous ne pouvons donc plus utiliser la méthode traditionnelle de recherche
|
|
// des pointeurs stockés (À cause de la fonction de triage utilisant des spécificités des ressources)
|
|
|
|
switch (index)
|
|
{
|
|
case ResourceType_Material:
|
|
for (auto it = opaqueModels.begin(); it != opaqueModels.end(); ++it)
|
|
{
|
|
if (it->first == resource)
|
|
{
|
|
opaqueModels.erase(it);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ResourceType_SkeletalMesh:
|
|
{
|
|
for (auto& pair : opaqueModels)
|
|
{
|
|
BatchedSkeletalMeshContainer& container = std::get<2>(pair.second);
|
|
|
|
for (auto it = container.begin(); it != container.end(); ++it)
|
|
{
|
|
if (it->first == resource)
|
|
{
|
|
container.erase(it);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case ResourceType_StaticMesh:
|
|
{
|
|
for (auto& pair : opaqueModels)
|
|
{
|
|
BatchedStaticMeshContainer& container = std::get<3 >(pair.second);
|
|
|
|
for (auto it = container.begin(); it != container.end(); ++it)
|
|
{
|
|
if (it->first == resource)
|
|
{
|
|
container.erase(it);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool NzForwardRenderQueue::BatchedModelMaterialComparator::operator()(const NzMaterial* mat1, const NzMaterial* mat2)
|
|
{
|
|
const NzUberShader* uberShader1 = mat1->GetShader();
|
|
const NzUberShader* uberShader2 = mat2->GetShader();
|
|
if (uberShader1 != uberShader2)
|
|
return uberShader1 < uberShader2;
|
|
|
|
const NzShader* shader1 = mat1->GetShaderInstance()->GetShader();
|
|
const NzShader* shader2 = mat2->GetShaderInstance()->GetShader();
|
|
|
|
if (shader1 != shader2)
|
|
return shader1 < shader2;
|
|
|
|
const NzTexture* diffuseMap1 = mat1->GetDiffuseMap();
|
|
const NzTexture* diffuseMap2 = mat2->GetDiffuseMap();
|
|
if (diffuseMap1 != diffuseMap2)
|
|
return diffuseMap1 < diffuseMap2;
|
|
|
|
return mat1 < mat2;
|
|
}
|
|
|
|
bool NzForwardRenderQueue::BatchedSpriteMaterialComparator::operator()(const NzMaterial* mat1, const NzMaterial* mat2)
|
|
{
|
|
const NzUberShader* uberShader1 = mat1->GetShader();
|
|
const NzUberShader* uberShader2 = mat2->GetShader();
|
|
if (uberShader1 != uberShader2)
|
|
return uberShader1 < uberShader2;
|
|
|
|
const NzShader* shader1 = mat1->GetShaderInstance(nzShaderFlags_Deferred)->GetShader();
|
|
const NzShader* shader2 = mat2->GetShaderInstance(nzShaderFlags_Deferred)->GetShader();
|
|
|
|
if (shader1 != shader2)
|
|
return shader1 < shader2;
|
|
|
|
const NzTexture* diffuseMap1 = mat1->GetDiffuseMap();
|
|
const NzTexture* diffuseMap2 = mat2->GetDiffuseMap();
|
|
if (diffuseMap1 != diffuseMap2)
|
|
return diffuseMap1 < diffuseMap2;
|
|
|
|
return mat1 < mat2;
|
|
}
|
|
|
|
bool NzForwardRenderQueue::BatchedSkeletalMeshComparator::operator()(const NzSkeletalMesh* subMesh1, const NzSkeletalMesh* subMesh2)
|
|
{
|
|
const NzIndexBuffer* iBuffer1 = subMesh1->GetIndexBuffer();
|
|
const NzBuffer* buffer1 = (iBuffer1) ? iBuffer1->GetBuffer() : nullptr;
|
|
|
|
const NzIndexBuffer* iBuffer2 = subMesh1->GetIndexBuffer();
|
|
const NzBuffer* buffer2 = (iBuffer2) ? iBuffer2->GetBuffer() : nullptr;
|
|
|
|
if (buffer1 == buffer2)
|
|
return subMesh1 < subMesh2;
|
|
else
|
|
return buffer2 < buffer2;
|
|
}
|
|
|
|
bool NzForwardRenderQueue::BatchedStaticMeshComparator::operator()(const NzStaticMesh* subMesh1, const NzStaticMesh* subMesh2)
|
|
{
|
|
const NzIndexBuffer* iBuffer1 = subMesh1->GetIndexBuffer();
|
|
const NzBuffer* buffer1 = (iBuffer1) ? iBuffer1->GetBuffer() : nullptr;
|
|
|
|
const NzIndexBuffer* iBuffer2 = subMesh2->GetIndexBuffer();
|
|
const NzBuffer* buffer2 = (iBuffer2) ? iBuffer2->GetBuffer() : nullptr;
|
|
|
|
if (buffer1 == buffer2)
|
|
{
|
|
buffer1 = subMesh1->GetVertexBuffer()->GetBuffer();
|
|
buffer2 = subMesh2->GetVertexBuffer()->GetBuffer();
|
|
|
|
if (buffer1 == buffer2)
|
|
return subMesh1 < subMesh2;
|
|
else
|
|
return buffer1 < buffer2;
|
|
}
|
|
else
|
|
return buffer1 < buffer2;
|
|
}
|