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

Graphics: Move FramePipeline passes to separate classes

Browse Source
This commit is contained in:
Jérôme Leclercq
2022-02-16 18:29:27 +01:00
parent fb9aed2800
commit 5ce8120a0c
23 changed files with 1000 additions and 543 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
include/Nazara/Graphics/DepthPipelinePass.hpp Normal file
View File

@@ -0,0 +1,73 @@
// Copyright (C) 2022 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - Graphics module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_GRAPHICS_DEPTHPIPELINEPASS_HPP
#define NAZARA_GRAPHICS_DEPTHPIPELINEPASS_HPP
#include <Nazara/Prerequisites.hpp>
#include <Nazara/Graphics/Config.hpp>
#include <Nazara/Graphics/ElementRenderer.hpp>
#include <Nazara/Graphics/FramePipelinePass.hpp>
#include <Nazara/Graphics/MaterialPass.hpp>
#include <Nazara/Graphics/RenderElement.hpp>
#include <Nazara/Graphics/RenderQueue.hpp>
#include <Nazara/Graphics/RenderQueueRegistry.hpp>
#include <Nazara/Math/Frustum.hpp>
namespace Nz
{
class AbstractViewer;
class FrameGraph;
class FramePipeline;
class Material;
class NAZARA_GRAPHICS_API DepthPipelinePass : public FramePipelinePass
{
public:
DepthPipelinePass(FramePipeline& owner, AbstractViewer* viewer);
DepthPipelinePass(const DepthPipelinePass&) = delete;
DepthPipelinePass(DepthPipelinePass&&) = delete;
~DepthPipelinePass();
inline void ForceInvalidation();
void Prepare(RenderFrame& renderFrame, const Frustumf& frustum, const std::vector<FramePipelinePass::VisibleRenderable>& visibleRenderables, std::size_t visibilityHash);
void RegisterMaterial(const Material& material);
void RegisterToFrameGraph(FrameGraph& frameGraph, std::size_t depthBufferIndex);
void UnregisterMaterial(const Material& material);
DepthPipelinePass& operator=(const DepthPipelinePass&) = delete;
DepthPipelinePass& operator=(DepthPipelinePass&&) = delete;
private:
struct MaterialPassEntry
{
std::size_t usedCount = 1;
NazaraSlot(MaterialPass, OnMaterialPassPipelineInvalidated, onMaterialPipelineInvalidated);
NazaraSlot(MaterialPass, OnMaterialPassShaderBindingInvalidated, onMaterialShaderBindingInvalidated);
};
std::size_t m_depthPassIndex;
std::size_t m_lastVisibilityHash;
std::vector<std::unique_ptr<ElementRendererData>> m_elementRendererData;
std::vector<std::unique_ptr<RenderElement>> m_renderElements;
std::vector<ElementRenderer::RenderStates> m_renderStates;
std::unordered_map<MaterialPass*, MaterialPassEntry> m_materialPasses;
RenderQueue<RenderElement*> m_renderQueue;
RenderQueueRegistry m_renderQueueRegistry;
AbstractViewer* m_viewer;
FramePipeline& m_pipeline;
bool m_rebuildCommandBuffer;
bool m_rebuildElements;
};
}
#include <Nazara/Graphics/DepthPipelinePass.inl>
#endif // NAZARA_GRAPHICS_DEPTHPIPELINEPASS_HPP

16
include/Nazara/Graphics/DepthPipelinePass.inl Normal file
View File

@@ -0,0 +1,16 @@
// Copyright (C) 2022 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
// 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/DepthPipelinePass.hpp>
#include <Nazara/Graphics/Debug.hpp>
namespace Nz
{
inline void DepthPipelinePass::ForceInvalidation()
{
m_rebuildElements = true;
}
}
#include <Nazara/Graphics/DebugOff.hpp>

1
include/Nazara/Graphics/DirectionalLight.inl
View File

@@ -2,7 +2,6 @@
// 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/DirectionalLight.hpp>
#include <Nazara/Graphics/DirectionalLight.hpp>
#include <cassert>
#include <Nazara/Graphics/Debug.hpp>

65
include/Nazara/Graphics/ForwardFramePipeline.hpp
View File

@@ -10,7 +10,9 @@
#include <Nazara/Prerequisites.hpp>
#include <Nazara/Graphics/BakedFrameGraph.hpp>
#include <Nazara/Graphics/Config.hpp>
#include <Nazara/Graphics/DepthPipelinePass.hpp>
#include <Nazara/Graphics/ElementRenderer.hpp>
#include <Nazara/Graphics/ForwardPipelinePass.hpp>
#include <Nazara/Graphics/FramePipeline.hpp>
#include <Nazara/Graphics/InstancedRenderable.hpp>
#include <Nazara/Graphics/Light.hpp>
@@ -37,33 +39,29 @@ namespace Nz
ForwardFramePipeline();
ForwardFramePipeline(const ForwardFramePipeline&) = delete;
ForwardFramePipeline(ForwardFramePipeline&&) = delete;
~ForwardFramePipeline() = default;
~ForwardFramePipeline();
void InvalidateViewer(AbstractViewer* viewerInstance) override;
void InvalidateWorldInstance(WorldInstance* worldInstance) override;
void RegisterInstancedDrawable(WorldInstancePtr worldInstance, const InstancedRenderable* instancedRenderable, UInt32 renderMask) override;
void RegisterLight(std::shared_ptr<Light> light, UInt32 renderMask) override;
void RegisterMaterialPass(MaterialPass* materialPass) override;
void RegisterViewer(AbstractViewer* viewerInstance, Int32 renderOrder) override;
void Render(RenderFrame& renderFrame) override;
void UnregisterInstancedDrawable(const WorldInstancePtr& worldInstance, const InstancedRenderable* instancedRenderable) override;
void UnregisterLight(Light* light) override;
void UnregisterMaterialPass(MaterialPass* material) override;
void UnregisterViewer(AbstractViewer* viewerInstance) override;
ForwardFramePipeline& operator=(const ForwardFramePipeline&) = delete;
ForwardFramePipeline& operator=(ForwardFramePipeline&&) = delete;
static constexpr std::size_t MaxLightCountPerDraw = 3;
private:
BakedFrameGraph BuildFrameGraph();
void RegisterMaterialPass(MaterialPass* material);
template<typename F> void ProcessRenderQueue(const RenderQueue<RenderElement*>& renderQueue, F&& callback);
void UnregisterMaterialPass(MaterialPass* material);
struct ViewerData;
struct LightData
@@ -74,30 +72,11 @@ namespace Nz
NazaraSlot(Light, OnLightDataInvalided, onLightInvalidated);
};
using LightKey = std::array<const Light*, MaxLightCountPerDraw>;
struct LightKeyHasher
{
inline std::size_t operator()(const LightKey& lightKey) const;
};
struct LightDataUbo
{
std::shared_ptr<RenderBuffer> renderBuffer;
std::size_t offset = 0;
UploadPool::Allocation* allocation = nullptr;
};
struct LightUboPool
{
std::vector<std::shared_ptr<RenderBuffer>> lightUboBuffers;
};
struct MaterialData
struct MaterialPassData
{
std::size_t usedCount = 0;
NazaraSlot(MaterialPass, OnMaterialInvalidated, onMaterialInvalided);
NazaraSlot(MaterialPass, OnMaterialPassInvalidated, onMaterialPassInvalided);
};
struct RenderableData
@@ -115,51 +94,31 @@ namespace Nz
ShaderBindingPtr blitShaderBinding;
};
struct VisibleRenderable
{
const InstancedRenderable* instancedRenderable;
const WorldInstance* worldInstance;
};
struct ViewerData
{
std::size_t colorAttachment;
std::size_t depthStencilAttachment;
std::size_t visibilityHash = 0;
std::unordered_map<const RenderElement*, RenderBufferView> lightPerRenderElement;
std::unordered_map<LightKey, RenderBufferView, LightKeyHasher> lightBufferPerLights;
std::vector<std::unique_ptr<RenderElement>> depthPrepassRenderElements;
std::vector<std::unique_ptr<RenderElement>> forwardRenderElements;
std::vector<std::unique_ptr<ElementRendererData>> elementRendererData;
std::unique_ptr<DepthPipelinePass> depthPrepass;
std::unique_ptr<ForwardPipelinePass> forwardPass;
Int32 renderOrder = 0;
RenderQueueRegistry depthPrepassRegistry;
RenderQueueRegistry forwardRegistry;
RenderQueue<RenderElement*> depthPrepassRenderQueue;
RenderQueue<RenderElement*> forwardRenderQueue;
ShaderBindingPtr blitShaderBinding;
bool prepare = true;
bool rebuildDepthPrepass = true;
bool rebuildForwardPass = true;
};
std::size_t m_depthPassIndex;
std::size_t m_forwardPassIndex;
std::shared_ptr<LightUboPool> m_lightUboPool;
std::unordered_map<AbstractViewer*, ViewerData> m_viewers;
std::unordered_map<Light*, LightData> m_lights;
std::unordered_map<MaterialPass*, MaterialData> m_materials;
std::unordered_map<MaterialPass*, MaterialPassData> m_activeMaterialPasses;
std::unordered_map<WorldInstancePtr, std::unordered_map<const InstancedRenderable*, RenderableData>> m_renderables;
std::unordered_map<const RenderTarget*, RenderTargetData> m_renderTargets;
std::unordered_set<AbstractViewer*> m_invalidatedViewerInstances;
std::unordered_set<MaterialPass*> m_invalidatedMaterials;
std::unordered_set<MaterialPass*> m_invalidatedMaterialPasses;
std::unordered_set<WorldInstance*> m_invalidatedWorldInstances;
std::unordered_set<WorldInstancePtr> m_removedWorldInstances;
std::vector<std::unique_ptr<ElementRenderer>> m_elementRenderers;
std::vector<ElementRenderer::RenderStates> m_renderStates;
std::vector<const Light*> m_renderableLights;
std::vector<FramePipelinePass::VisibleRenderable> m_visibleRenderables;
std::vector<const Light*> m_visibleLights;
std::vector<LightDataUbo> m_lightDataBuffers;
std::vector<VisibleRenderable> m_visibleRenderables;
BakedFrameGraph m_bakedFrameGraph;
RenderFrame* m_currentRenderFrame;
bool m_rebuildFrameGraph;

14
include/Nazara/Graphics/ForwardFramePipeline.inl
View File

@@ -8,20 +8,6 @@
namespace Nz
{
inline std::size_t ForwardFramePipeline::LightKeyHasher::operator()(const LightKey& lightKey) const
{
std::size_t lightHash = 5;
auto CombineHash = [](std::size_t currentHash, std::size_t newHash)
{
return currentHash * 23 + newHash;
};
std::hash<const Light*> lightPtrHasher;
for (std::size_t i = 0; i < lightKey.size(); ++i)
lightHash = CombineHash(lightHash, lightPtrHasher(lightKey[i]));
return lightHash;
}
}
#include <Nazara/Graphics/DebugOff.hpp>

102
include/Nazara/Graphics/ForwardPipelinePass.hpp Normal file
View File

@@ -0,0 +1,102 @@
// Copyright (C) 2022 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - Graphics module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_GRAPHICS_FORWARDPIPELINEPASS_HPP
#define NAZARA_GRAPHICS_FORWARDPIPELINEPASS_HPP
#include <Nazara/Prerequisites.hpp>
#include <Nazara/Graphics/Config.hpp>
#include <Nazara/Graphics/ElementRenderer.hpp>
#include <Nazara/Graphics/FramePipelinePass.hpp>
#include <Nazara/Graphics/Light.hpp>
#include <Nazara/Graphics/MaterialPass.hpp>
#include <Nazara/Graphics/RenderElement.hpp>
#include <Nazara/Graphics/RenderQueue.hpp>
#include <Nazara/Graphics/RenderQueueRegistry.hpp>
#include <Nazara/Math/Frustum.hpp>
#include <Nazara/Renderer/UploadPool.hpp>
namespace Nz
{
class AbstractViewer;
class FrameGraph;
class FramePipeline;
class Light;
class Material;
class NAZARA_GRAPHICS_API ForwardPipelinePass : public FramePipelinePass
{
public:
ForwardPipelinePass(FramePipeline& owner, AbstractViewer* viewer);
ForwardPipelinePass(const ForwardPipelinePass&) = delete;
ForwardPipelinePass(ForwardPipelinePass&&) = delete;
~ForwardPipelinePass();
inline void ForceInvalidation();
void Prepare(RenderFrame& renderFrame, const Frustumf& frustum, const std::vector<FramePipelinePass::VisibleRenderable>& visibleRenderables, const std::vector<const Light*>& visibleLights, std::size_t visibilityHash);
void RegisterMaterial(const Material& material);
void RegisterToFrameGraph(FrameGraph& frameGraph, std::size_t colorBufferIndex, std::size_t depthBufferIndex);
void UnregisterMaterial(const Material& material);
ForwardPipelinePass& operator=(const ForwardPipelinePass&) = delete;
ForwardPipelinePass& operator=(ForwardPipelinePass&&) = delete;
static constexpr std::size_t MaxLightCountPerDraw = 3;
private:
struct MaterialPassEntry
{
std::size_t usedCount = 1;
NazaraSlot(MaterialPass, OnMaterialPassPipelineInvalidated, onMaterialPipelineInvalidated);
NazaraSlot(MaterialPass, OnMaterialPassShaderBindingInvalidated, onMaterialShaderBindingInvalidated);
};
using LightKey = std::array<const Light*, MaxLightCountPerDraw>;
struct LightKeyHasher
{
inline std::size_t operator()(const LightKey& lightKey) const;
};
struct LightDataUbo
{
std::shared_ptr<RenderBuffer> renderBuffer;
std::size_t offset = 0;
UploadPool::Allocation* allocation = nullptr;
};
struct LightUboPool
{
std::vector<std::shared_ptr<RenderBuffer>> lightUboBuffers;
};
std::size_t m_forwardPassIndex;
std::size_t m_lastVisibilityHash;
std::shared_ptr<LightUboPool> m_lightUboPool;
std::vector<std::unique_ptr<ElementRendererData>> m_elementRendererData;
std::vector<std::unique_ptr<RenderElement>> m_renderElements;
std::vector<ElementRenderer::RenderStates> m_renderStates;
std::unordered_map<MaterialPass*, MaterialPassEntry> m_materialPasses;
std::unordered_map<const RenderElement*, RenderBufferView> m_lightPerRenderElement;
std::unordered_map<LightKey, RenderBufferView, LightKeyHasher> m_lightBufferPerLights;
std::vector<LightDataUbo> m_lightDataBuffers;
std::vector<const Light*> m_renderableLights;
RenderQueue<RenderElement*> m_renderQueue;
RenderQueueRegistry m_renderQueueRegistry;
AbstractViewer* m_viewer;
FramePipeline& m_pipeline;
bool m_rebuildCommandBuffer;
bool m_rebuildElements;
};
}
#include <Nazara/Graphics/ForwardPipelinePass.inl>
#endif // NAZARA_GRAPHICS_FORWARDPIPELINEPASS_HPP

31
include/Nazara/Graphics/ForwardPipelinePass.inl Normal file
View File

@@ -0,0 +1,31 @@
// Copyright (C) 2022 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
// 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/ForwardPipelinePass.hpp>
#include <Nazara/Graphics/Debug.hpp>
namespace Nz
{
inline void ForwardPipelinePass::ForceInvalidation()
{
m_rebuildElements = true;
}
inline std::size_t ForwardPipelinePass::LightKeyHasher::operator()(const LightKey& lightKey) const
{
std::size_t lightHash = 5;
auto CombineHash = [](std::size_t currentHash, std::size_t newHash)
{
return currentHash * 23 + newHash;
};
std::hash<const Light*> lightPtrHasher;
for (std::size_t i = 0; i < lightKey.size(); ++i)
lightHash = CombineHash(lightHash, lightPtrHasher(lightKey[i]));
return lightHash;
}
}
#include <Nazara/Graphics/DebugOff.hpp>

20
include/Nazara/Graphics/FramePipeline.hpp
View File

@@ -9,38 +9,56 @@
#include <Nazara/Prerequisites.hpp>
#include <Nazara/Graphics/Config.hpp>
#include <Nazara/Graphics/RenderElement.hpp>
#include <Nazara/Graphics/RenderQueue.hpp>
#include <Nazara/Graphics/WorldInstance.hpp>
#include <memory>
#include <vector>
namespace Nz
{
class AbstractViewer;
class ElementRenderer;
class InstancedRenderable;
class Light;
class MaterialPass;
class RenderFrame;
class NAZARA_GRAPHICS_API FramePipeline
{
public:
FramePipeline() = default;
FramePipeline();
FramePipeline(const FramePipeline&) = delete;
FramePipeline(FramePipeline&&) noexcept = default;
virtual ~FramePipeline();
template<typename F> void ForEachElementRenderer(F&& callback);
inline ElementRenderer& GetElementRenderer(std::size_t elementIndex);
inline std::size_t GetElementRendererCount() const;
virtual void InvalidateViewer(AbstractViewer* viewerInstance) = 0;
virtual void InvalidateWorldInstance(WorldInstance* worldInstance) = 0;
template<typename F> void ProcessRenderQueue(const RenderQueue<RenderElement*>& renderQueue, F&& callback);
virtual void RegisterInstancedDrawable(WorldInstancePtr worldInstance, const InstancedRenderable* instancedRenderable, UInt32 renderMask) = 0;
virtual void RegisterLight(std::shared_ptr<Light> light, UInt32 renderMask) = 0;
virtual void RegisterMaterialPass(MaterialPass* materialPass) = 0;
virtual void RegisterViewer(AbstractViewer* viewerInstance, Int32 renderOrder) = 0;
virtual void Render(RenderFrame& renderFrame) = 0;
virtual void UnregisterInstancedDrawable(const WorldInstancePtr& worldInstance, const InstancedRenderable* instancedRenderable) = 0;
virtual void UnregisterLight(Light* light) = 0;
virtual void UnregisterMaterialPass(MaterialPass* materialPass) = 0;
virtual void UnregisterViewer(AbstractViewer* viewerInstance) = 0;
FramePipeline& operator=(const FramePipeline&) = delete;
FramePipeline& operator=(FramePipeline&&) noexcept = default;
private:
std::vector<std::unique_ptr<ElementRenderer>> m_elementRenderers;
};
}

48
include/Nazara/Graphics/FramePipeline.inl
View File

@@ -3,10 +3,58 @@
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Graphics/FramePipeline.hpp>
#include <cassert>
#include <Nazara/Graphics/Debug.hpp>
namespace Nz
{
inline ElementRenderer& FramePipeline::GetElementRenderer(std::size_t elementIndex)
{
assert(elementIndex < m_elementRenderers.size());
return *m_elementRenderers[elementIndex];
}
inline std::size_t FramePipeline::GetElementRendererCount() const
{
return m_elementRenderers.size();
}
template<typename F>
void FramePipeline::ForEachElementRenderer(F&& callback)
{
for (std::size_t i = 0; i < m_elementRenderers.size(); ++i)
{
if (m_elementRenderers[i])
callback(i, *m_elementRenderers[i]);
}
}
template<typename F>
void FramePipeline::ProcessRenderQueue(const RenderQueue<RenderElement*>& renderQueue, F&& callback)
{
if (renderQueue.empty())
return;
auto it = renderQueue.begin();
auto itEnd = renderQueue.end();
while (it != itEnd)
{
const RenderElement* element = *it;
UInt8 elementType = element->GetElementType();
const Pointer<RenderElement>* first = it;
++it;
while (it != itEnd && (*it)->GetElementType() == elementType)
++it;
std::size_t count = it - first;
if (elementType >= m_elementRenderers.size() || !m_elementRenderers[elementType])
continue;
callback(elementType, first, count);
}
}
}
#include <Nazara/Graphics/DebugOff.hpp>

39
include/Nazara/Graphics/FramePipelinePass.hpp Normal file
View File

@@ -0,0 +1,39 @@
// Copyright (C) 2022 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
// This file is part of the "Nazara Engine - Graphics module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_GRAPHICS_FRAMEPIPELINEPASS_HPP
#define NAZARA_GRAPHICS_FRAMEPIPELINEPASS_HPP
#include <Nazara/Prerequisites.hpp>
#include <Nazara/Graphics/Config.hpp>
namespace Nz
{
class InstancedRenderable;
class WorldInstance;
class NAZARA_GRAPHICS_API FramePipelinePass
{
public:
FramePipelinePass() = default;
FramePipelinePass(const FramePipelinePass&) = delete;
FramePipelinePass(FramePipelinePass&&) = delete;
virtual ~FramePipelinePass();
FramePipelinePass& operator=(const FramePipelinePass&) = delete;
FramePipelinePass& operator=(FramePipelinePass&&) = delete;
struct VisibleRenderable
{
const InstancedRenderable* instancedRenderable;
const WorldInstance* worldInstance;
};
};
}
#include <Nazara/Graphics/FramePipelinePass.inl>
#endif // NAZARA_GRAPHICS_FRAMEPIPELINEPASS_HPP

12
include/Nazara/Graphics/FramePipelinePass.inl Normal file
View File

@@ -0,0 +1,12 @@
// Copyright (C) 2022 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
// 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/FramePipelinePass.hpp>
#include <Nazara/Graphics/Debug.hpp>
namespace Nz
{
}
#include <Nazara/Graphics/DebugOff.hpp>

4
include/Nazara/Graphics/Material.hpp
View File

@@ -16,7 +16,7 @@ namespace Nz
class NAZARA_GRAPHICS_API Material : public Resource
{
public:
Material();
Material() = default;
~Material() = default;
inline void AddPass(std::size_t passIndex, std::shared_ptr<MaterialPass> pass);
@@ -24,6 +24,8 @@ namespace Nz
inline const std::shared_ptr<MaterialPass>& FindPass(const std::string& passName) const;
template<typename F> void ForEachPass(F&& callback);
inline const std::shared_ptr<MaterialPass>& GetPass(std::size_t passIndex) const;
inline bool HasPass(std::size_t passIndex) const;

10
include/Nazara/Graphics/Material.inl
View File

@@ -27,6 +27,16 @@ namespace Nz
return GetPass(registry.GetPassIndex(passName));
}
template<typename F>
void Material::ForEachPass(F&& callback)
{
for (std::size_t i = 0; i < m_passes.size(); ++i)
{
if (m_passes[i])
callback(i, m_passes[i]);
}
}
inline const std::shared_ptr<MaterialPass>& Material::GetPass(std::size_t passIndex) const
{
if (passIndex >= m_passes.size())

11
include/Nazara/Graphics/MaterialPass.hpp
View File

@@ -103,15 +103,17 @@ namespace Nz
inline void SetTextureSampler(std::size_t textureIndex, TextureSamplerInfo samplerInfo);
inline void SetUniformBuffer(std::size_t bufferIndex, std::shared_ptr<RenderBuffer> uniformBuffer);
bool Update(RenderFrame& renderFrame, CommandBufferBuilder& builder);
void Update(RenderFrame& renderFrame, CommandBufferBuilder& builder);
// Signals:
NazaraSignal(OnMaterialInvalidated, const MaterialPass* /*material*/);
NazaraSignal(OnMaterialRelease, const MaterialPass* /*material*/);
NazaraSignal(OnMaterialPassInvalidated, const MaterialPass* /*materialPass*/);
NazaraSignal(OnMaterialPassPipelineInvalidated, const MaterialPass* /*materialPass*/);
NazaraSignal(OnMaterialPassShaderBindingInvalidated, const MaterialPass* /*materialPass*/);
NazaraSignal(OnMaterialPassRelease, const MaterialPass* /*materialPass*/);
private:
inline void InvalidateCommandBuffer();
inline void InvalidatePipeline();
inline void InvalidateShaderBinding();
inline void InvalidateTextureSampler(std::size_t textureIndex);
inline void InvalidateUniformData(std::size_t uniformBufferIndex);
void UpdatePipeline() const;
@@ -137,7 +139,6 @@ namespace Nz
mutable std::shared_ptr<MaterialPipeline> m_pipeline;
mutable MaterialPipelineInfo m_pipelineInfo;
MaterialPassFlags m_flags;
bool m_forceCommandBufferRegeneration;
mutable bool m_pipelineUpdated;
};
}

24
include/Nazara/Graphics/MaterialPass.inl
View File

@@ -16,7 +16,7 @@ namespace Nz
*/
inline MaterialPass::~MaterialPass()
{
OnMaterialRelease(this);
OnMaterialPassRelease(this);
}
/*!
@@ -609,7 +609,7 @@ namespace Nz
{
m_textures[textureIndex].texture = std::move(texture);
InvalidateCommandBuffer();
InvalidateShaderBinding();
}
}
@@ -632,22 +632,20 @@ namespace Nz
m_uniformBuffers[bufferIndex].buffer = std::move(uniformBuffer);
m_uniformBuffers[bufferIndex].dataInvalidated = true;
InvalidateCommandBuffer();
InvalidateShaderBinding();
}
}
inline void MaterialPass::InvalidateCommandBuffer()
{
m_forceCommandBufferRegeneration = true;
OnMaterialInvalidated(this);
}
inline void MaterialPass::InvalidatePipeline()
{
m_forceCommandBufferRegeneration = true;
m_pipelineUpdated = false;
OnMaterialInvalidated(this);
OnMaterialPassPipelineInvalidated(this);
}
inline void MaterialPass::InvalidateShaderBinding()
{
OnMaterialPassShaderBindingInvalidated(this);
}
inline void MaterialPass::InvalidateTextureSampler(std::size_t textureIndex)
@@ -655,7 +653,7 @@ namespace Nz
assert(textureIndex < m_textures.size());
m_textures[textureIndex].sampler.reset();
InvalidateCommandBuffer();
InvalidateShaderBinding();
}
inline void MaterialPass::InvalidateUniformData(std::size_t uniformBufferIndex)
@@ -664,7 +662,7 @@ namespace Nz
UniformBuffer& uboEntry = m_uniformBuffers[uniformBufferIndex];
uboEntry.dataInvalidated = true;
OnMaterialInvalidated(this);
OnMaterialPassInvalidated(this);
}
}