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

Added new abstract renderqueue rendering

Browse Source 
Former-commit-id: 35e66174ccc3de3b43571f12a149e6d3c59cc2c9
This commit is contained in:
Lynix
2014-05-28 01:00:18 +02:00
parent d09f6def2b
commit c901b5808e
7 changed files with 407 additions and 518 deletions
Download Patch File Download Diff File Expand all files Collapse all files

272
src/Nazara/Graphics/DeferredRenderQueue.cpp
View File

@@ -9,17 +9,15 @@
#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_IndexBuffer,
ResourceType_Material,
ResourceType_SkeletalMesh,
ResourceType_StaticMesh
ResourceType_VertexBuffer
};
}
@@ -66,6 +64,45 @@ void NzDeferredRenderQueue::AddLight(const NzLight* light)
m_forwardQueue->AddLight(light);
}
void NzDeferredRenderQueue::AddMesh(const NzMaterial* material, const NzMeshData& meshData, const NzBoxf& meshAABB, const NzMatrix4f& transformMatrix)
{
if (material->IsEnabled(nzRendererParameter_Blend))
m_forwardQueue->AddMesh(material, meshData, meshAABB, transformMatrix);
else
{
ModelBatches::iterator it = opaqueModels.find(material);
if (it == opaqueModels.end())
{
it = opaqueModels.insert(std::make_pair(material, ModelBatches::mapped_type())).first;
material->AddResourceListener(this, ResourceType_Material);
}
bool& used = std::get<0>(it->second);
bool& enableInstancing = std::get<1>(it->second);
MeshInstanceContainer& meshMap = std::get<2>(it->second);
used = true;
MeshInstanceContainer::iterator it2 = meshMap.find(meshData);
if (it2 == meshMap.end())
{
it2 = meshMap.insert(std::make_pair(meshData, MeshInstanceContainer::mapped_type())).first;
if (meshData.indexBuffer)
meshData.indexBuffer->AddResourceListener(this, ResourceType_IndexBuffer);
meshData.vertexBuffer->AddResourceListener(this, ResourceType_VertexBuffer);
}
std::vector<NzMatrix4f>& instances = it2->second;
instances.push_back(transformMatrix);
// Avons-nous suffisamment d'instances pour que le coût d'utilisation de l'instancing soit payé ?
if (instances.size() >= NAZARA_GRAPHICS_INSTANCING_MIN_INSTANCES_COUNT)
enableInstancing = true; // Apparemment oui, activons l'instancing avec ce matériau
}
}
void NzDeferredRenderQueue::AddSprite(const NzSprite* sprite)
{
#if NAZARA_GRAPHICS_SAFE
@@ -91,75 +128,6 @@ void NzDeferredRenderQueue::AddSprite(const NzSprite* sprite)
m_forwardQueue->AddSprite(sprite);
}
void NzDeferredRenderQueue::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:
{
if (material->IsEnabled(nzRendererParameter_Blend))
m_forwardQueue->AddSubMesh(material, subMesh, transformMatrix);
else
{
const NzStaticMesh* staticMesh = static_cast<const NzStaticMesh*>(subMesh);
auto it = opaqueModels.find(material);
if (it == opaqueModels.end())
{
it = opaqueModels.insert(std::make_pair(material, BatchedModelContainer::mapped_type())).first;
material->AddResourceListener(this, ResourceType_Material);
}
bool& used = std::get<0>(it->second);
bool& enableInstancing = std::get<1>(it->second);
used = true;
auto& meshMap = std::get<3>(it->second);
auto it2 = meshMap.find(staticMesh);
if (it2 == meshMap.end())
{
it2 = meshMap.insert(std::make_pair(staticMesh, BatchedStaticMeshContainer::mapped_type())).first;
staticMesh->AddResourceListener(this, ResourceType_StaticMesh);
}
std::vector<StaticData>& staticDataContainer = it2->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 NzDeferredRenderQueue::Clear(bool fully)
{
directionalLights.clear();
@@ -173,18 +141,15 @@ void NzDeferredRenderQueue::Clear(bool fully)
const NzMaterial* material = matIt.first;
material->RemoveResourceListener(this);
BatchedSkeletalMeshContainer& skeletalContainer = std::get<2>(matIt.second);
for (auto& meshIt : skeletalContainer)
MeshInstanceContainer& instances = std::get<2>(matIt.second);
for (auto& instanceIt : instances)
{
const NzSkeletalMesh* skeletalMesh = meshIt.first;
skeletalMesh->RemoveResourceListener(this);
}
const NzMeshData& renderData = instanceIt.first;
BatchedStaticMeshContainer& staticContainer = std::get<3>(matIt.second);
for (auto& meshIt : staticContainer)
{
const NzStaticMesh* staticMesh = meshIt.first;
staticMesh->RemoveResourceListener(this);
if (renderData.indexBuffer)
renderData.indexBuffer->RemoveResourceListener(this);
renderData.vertexBuffer->RemoveResourceListener(this);
}
}
@@ -199,23 +164,41 @@ bool NzDeferredRenderQueue::OnResourceDestroy(const NzResource* resource, int in
{
switch (index)
{
case ResourceType_IndexBuffer:
{
for (auto& modelPair : opaqueModels)
{
MeshInstanceContainer& meshes = std::get<2>(modelPair.second);
for (auto it = meshes.begin(); it != meshes.end();)
{
const NzMeshData& renderData = it->first;
if (renderData.indexBuffer == resource)
it = meshes.erase(it);
else
++it;
}
}
break;
}
case ResourceType_Material:
opaqueModels.erase(static_cast<const NzMaterial*>(resource));
break;
case ResourceType_SkeletalMesh:
case ResourceType_VertexBuffer:
{
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));
for (auto& modelPair : opaqueModels)
{
MeshInstanceContainer& meshes = std::get<2>(modelPair.second);
for (auto it = meshes.begin(); it != meshes.end();)
{
const NzMeshData& renderData = it->first;
if (renderData.vertexBuffer == resource)
it = meshes.erase(it);
else
++it;
}
}
break;
}
}
@@ -225,7 +208,58 @@ bool NzDeferredRenderQueue::OnResourceDestroy(const NzResource* resource, int in
void NzDeferredRenderQueue::OnResourceReleased(const NzResource* resource, int index)
{
OnResourceDestroy(resource, 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_IndexBuffer:
{
for (auto& modelPair : opaqueModels)
{
MeshInstanceContainer& meshes = std::get<2>(modelPair.second);
for (auto it = meshes.begin(); it != meshes.end();)
{
const NzMeshData& renderData = it->first;
if (renderData.indexBuffer == resource)
it = meshes.erase(it);
else
++it;
}
}
break;
}
case ResourceType_Material:
{
for (auto it = opaqueModels.begin(); it != opaqueModels.end(); ++it)
{
if (it->first == resource)
{
opaqueModels.erase(it);
break;
}
}
break;
}
case ResourceType_VertexBuffer:
{
for (auto& modelPair : opaqueModels)
{
MeshInstanceContainer& meshes = std::get<2>(modelPair.second);
for (auto it = meshes.begin(); it != meshes.end();)
{
const NzMeshData& renderData = it->first;
if (renderData.vertexBuffer == resource)
it = meshes.erase(it);
else
++it;
}
}
break;
}
}
}
bool NzDeferredRenderQueue::BatchedModelMaterialComparator::operator()(const NzMaterial* mat1, const NzMaterial* mat2)
@@ -237,7 +271,6 @@ bool NzDeferredRenderQueue::BatchedModelMaterialComparator::operator()(const NzM
const NzShader* shader1 = mat1->GetShaderInstance(nzShaderFlags_Deferred)->GetShader();
const NzShader* shader2 = mat2->GetShaderInstance(nzShaderFlags_Deferred)->GetShader();
if (shader1 != shader2)
return shader1 < shader2;
@@ -258,7 +291,6 @@ bool NzDeferredRenderQueue::BatchedSpriteMaterialComparator::operator()(const Nz
const NzShader* shader1 = mat1->GetShaderInstance(nzShaderFlags_Deferred)->GetShader();
const NzShader* shader2 = mat2->GetShaderInstance(nzShaderFlags_Deferred)->GetShader();
if (shader1 != shader2)
return shader1 < shader2;
@@ -270,38 +302,20 @@ bool NzDeferredRenderQueue::BatchedSpriteMaterialComparator::operator()(const Nz
return mat1 < mat2;
}
bool NzDeferredRenderQueue::BatchedSkeletalMeshComparator::operator()(const NzSkeletalMesh* subMesh1, const NzSkeletalMesh* subMesh2)
bool NzDeferredRenderQueue::MeshDataComparator::operator()(const NzMeshData& data1, const NzMeshData& data2)
{
const NzIndexBuffer* iBuffer1 = subMesh1->GetIndexBuffer();
const NzBuffer* buffer1 = (iBuffer1) ? iBuffer1->GetBuffer() : nullptr;
const NzBuffer* buffer1;
const NzBuffer* buffer2;
const NzIndexBuffer* iBuffer2 = subMesh1->GetIndexBuffer();
const NzBuffer* buffer2 = (iBuffer2) ? iBuffer2->GetBuffer() : nullptr;
if (buffer1 == buffer2)
return subMesh1 < subMesh2;
else
return buffer2 < buffer2;
}
bool NzDeferredRenderQueue::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
buffer1 = (data1.indexBuffer) ? data1.indexBuffer->GetBuffer() : nullptr;
buffer2 = (data2.indexBuffer) ? data2.indexBuffer->GetBuffer() : nullptr;
if (buffer1 != buffer2)
return buffer1 < buffer2;
buffer1 = data1.vertexBuffer->GetBuffer();
buffer2 = data2.vertexBuffer->GetBuffer();
if (buffer1 != buffer2)
return buffer1 < buffer2;
return data1.primitiveMode < data2.primitiveMode;
}