Dynamitos/Seele
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reworking VertexData

Browse Source
This commit is contained in:
Dynamitos
2023-10-24 15:01:09 +02:00
parent a47f17481b
commit 28e5c9ff01
61 changed files with 1157 additions and 1144 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Engine/Material/CMakeLists.txt
+2 -3
View File
@@ -4,8 +4,8 @@ target_sources(Engine
Material.cpp
MaterialInstance.h
MaterialInstance.cpp
MaterialInterface.h
MaterialInterface.cpp
ShaderExpression.h
ShaderExpression.cpp)
@@ -14,6 +14,5 @@ target_sources(Engine
FILES
Material.h
MaterialInstance.h
MaterialInterface.h
ShaderExpression.h)
src/Engine/Material/Material.cpp
+5 -20
View File
@@ -1,13 +1,10 @@
#include "Material.h"
#include "Window/WindowManager.h"
#include "MaterialInstance.h"
#include "Graphics/VertexShaderInput.h"
#include "Graphics/Graphics.h"
using namespace Seele;
Gfx::ShaderMap Material::shaderMap;
std::mutex Material::shaderMapLock;
Material::Material(Gfx::PGraphics graphics,
Array<PShaderParameter> parameter,
@@ -17,11 +14,15 @@ Material::Material(Gfx::PGraphics graphics,
std::string materialName,
Array<PShaderExpression> expressions,
MaterialNode brdf)
: MaterialInterface(graphics, parameter, uniformDataSize, uniformBinding)
: graphics(graphics)
, parameters(parameter)
, uniformDataSize(uniformDataSize)
, uniformBinding(uniformBinding)
, layout(layout)
, materialName(materialName)
, codeExpressions(expressions)
, brdf(brdf)
, instanceId(0)
{
}
@@ -129,19 +130,3 @@ void Material::compile()
codeStream << "\t}\n";
codeStream << "};\n";
}
const Gfx::ShaderCollection* Material::getShaders(Gfx::RenderPassType renderPass, VertexInputType* vertexInput) const
{
Gfx::ShaderPermutation permutation;
permutation.passType = renderPass;
std::string vertexInputName = vertexInput->getName();
std::strncpy(permutation.materialName, materialName.c_str(), sizeof(permutation.materialName));
std::strncpy(permutation.vertexInputName, vertexInputName.c_str(), sizeof(permutation.vertexInputName));
return shaderMap.findShaders(Gfx::PermutationId(permutation));
}
Gfx::ShaderCollection& Material::createShaders(Gfx::PGraphics graphics, Gfx::RenderPassType renderPass, VertexInputType* vertexInput)
{
std::scoped_lock l(shaderMapLock);
return shaderMap.createShaders(graphics, renderPass, this, vertexInput, false);
}
src/Engine/Material/Material.h
+15 -18
View File
@@ -1,13 +1,13 @@
#pragma once
#include "MaterialInterface.h"
#include "ShaderExpression.h"
#include "Graphics/GraphicsResources.h"
namespace Seele
{
DECLARE_REF(MaterialInstance)
class Material : public MaterialInterface
class Material
{
public:
Material() {}
Material(Gfx::PGraphics graphics,
Array<PShaderParameter> parameter,
Gfx::PDescriptorLayout layout,
@@ -16,30 +16,27 @@ public:
std::string materialName,
Array<PShaderExpression> expressions,
MaterialNode brdf);
virtual ~Material();
virtual Gfx::PDescriptorSet createDescriptorSet();
virtual Gfx::PDescriptorLayout getDescriptorLayout() const { return layout; }
virtual const std::string& getName() { return materialName; }
~Material();
Gfx::PDescriptorLayout getDescriptorLayout() const { return layout; }
PMaterialInstance instantiate();
const std::string& getName() { return materialName; }
virtual void save(ArchiveBuffer& buffer) const;
virtual void load(ArchiveBuffer& buffer);
void save(ArchiveBuffer& buffer) const;
void load(ArchiveBuffer& buffer);
void compile();
virtual const Gfx::ShaderCollection* getShaders(Gfx::RenderPassType renderPass, VertexInputType* vertexInput) const;
virtual Gfx::ShaderCollection& createShaders(Gfx::PGraphics graphics, Gfx::RenderPassType renderPass, VertexInputType* vertexInput);
private:
static Gfx::ShaderMap shaderMap;
static std::mutex shaderMapLock;
Gfx::PGraphics graphics;
std::string brdfName;
uint32 uniformDataSize;
uint32 uniformBinding;
uint64 instanceId;
Gfx::PDescriptorLayout layout;
std::string materialName;
Array<PShaderExpression> codeExpressions;
Array<PShaderParameter> parameters;
MaterialNode brdf;
// With draw-indirect, we batch vertex data into big vertex buffers
// Gfx::PVertexDataManager vertexData;
friend class MaterialInstance;
};
DEFINE_REF(Material)
src/Engine/Material/MaterialInstance.cpp
+11 -43
View File
@@ -4,52 +4,20 @@
using namespace Seele;
MaterialInstance::MaterialInstance(Gfx::PGraphics graphics, PMaterial baseMaterial)
: MaterialInterface(graphics, baseMaterial->parameters, baseMaterial->uniformDataSize, baseMaterial->uniformBinding)
, baseMaterial(baseMaterial)
MaterialInstance::MaterialInstance(uint64 id, Gfx::PGraphics graphics, PMaterial baseMaterial, Gfx::PDescriptorSet descriptor, Array<PShaderParameter> params, uint32 uniformBinding, uint32 uniformSize)
: id(id), graphics(graphics), baseMaterial(baseMaterial), descriptor(descriptor), parameters(params), uniformBinding(uniformBinding)
{
uniformBuffer = graphics->createUniformBuffer(UniformBufferCreateInfo{
.resourceData = {
.size = uniformSize,
},
.bDynamic = true,
}
);
uniformData.resize(uniformSize);
}
MaterialInstance::~MaterialInstance()
{
}
Gfx::PDescriptorSet MaterialInstance::createDescriptorSet()
{
Gfx::PDescriptorSet descriptorSet = baseMaterial->layout->allocateDescriptorSet();
BulkResourceData uniformUpdate;
uniformUpdate.size = uniformDataSize;
uniformUpdate.data = (uint8*)uniformData.data();
for(auto param : parameters)
{
param->updateDescriptorSet(descriptorSet, uniformData.data());
}
if(uniformUpdate.size != 0)
{
uniformBuffer->updateContents(uniformUpdate);
descriptorSet->updateBuffer(uniformBinding, uniformBuffer);
}
descriptorSet->writeChanges();
return descriptorSet;
}
Gfx::PDescriptorLayout MaterialInstance::getDescriptorLayout() const
{
return baseMaterial->getDescriptorLayout();
}
const std::string& MaterialInstance::getName()
{
return baseMaterial->getName();
}
const Gfx::ShaderCollection* Seele::MaterialInstance::getShaders(Gfx::RenderPassType renderPass, VertexInputType* vertexInput) const
{
return baseMaterial->getShaders(renderPass, vertexInput);
}
Gfx::ShaderCollection& Seele::MaterialInstance::createShaders(Gfx::PGraphics graphics, Gfx::RenderPassType renderPass, VertexInputType* vertexInput)
{
return baseMaterial->createShaders(graphics, renderPass, vertexInput);
}
}
src/Engine/Material/MaterialInstance.h
+15 -13
View File
@@ -1,24 +1,26 @@
#pragma once
#include "MaterialInterface.h"
#include "Material.h"
namespace Seele
{
DECLARE_REF(Material)
class MaterialInstance : public MaterialInterface
class MaterialInstance
{
public:
MaterialInstance(Gfx::PGraphics graphics, PMaterial baseMaterial);
virtual ~MaterialInstance();
virtual Gfx::PDescriptorSet createDescriptorSet();
virtual Gfx::PDescriptorLayout getDescriptorLayout() const;
// The name of the generated material shader, opposed to the name of the .asset file
virtual const std::string& getName();
virtual const Gfx::ShaderCollection* getShaders(Gfx::RenderPassType renderPass, VertexInputType* vertexInput) const;
virtual Gfx::ShaderCollection& createShaders(Gfx::PGraphics graphics, Gfx::RenderPassType renderPass, VertexInputType* vertexInput);
MaterialInstance(uint64 id, Gfx::PGraphics graphics, PMaterial baseMaterial, Gfx::PDescriptorSet descriptor, Array<PShaderParameter> params, uint32 uniformBinding, uint32 uniformSize);
~MaterialInstance();
void updateDescriptor();
Gfx::PDescriptorSet getDescriptorSet() const;
PMaterial getBaseMaterial() const { return baseMaterial; }
uint64 getId() const { return id; }
private:
Gfx::PGraphics graphics;
Array<uint8> uniformData;
uint32 uniformBinding;
Gfx::PUniformBuffer uniformBuffer;
Array<PShaderParameter> parameters;
Gfx::PDescriptorSet descriptor;
PMaterial baseMaterial;
uint64 id;
};
DEFINE_REF(MaterialInstance)
} // namespace Seele
src/Engine/Material/MaterialInterface.cpp
-79
View File
@@ -1,79 +0,0 @@
#include "MaterialInterface.h"
#include "Window/WindowManager.h"
#include "Graphics/Graphics.h"
using namespace Seele;
MaterialInterface::MaterialInterface(Gfx::PGraphics graphics, Array<PShaderParameter> parameter, uint32 uniformDataSize, uint32 uniformBinding)
: graphics(graphics)
, parameters(parameter)
, uniformDataSize(uniformDataSize)
, uniformBinding(uniformBinding)
{
if(uniformDataSize != 0)
{
uniformData.resize(uniformDataSize);
UniformBufferCreateInfo uniformInitializer = {
.resourceData = {
.size = uniformDataSize,
.data = nullptr,
}
};
uniformBuffer = graphics->createUniformBuffer(uniformInitializer);
}
}
MaterialInterface::~MaterialInterface()
{
}
PShaderParameter MaterialInterface::getParameter(const std::string& name)
{
for (const auto& param : parameters)
{
if(param->name.compare(name) == 0)
{
return param;
}
}
return nullptr;
}
void MaterialInterface::save(ArchiveBuffer& buffer) const
{
Serialization::save(buffer, uniformDataSize);
Serialization::save(buffer, uniformBinding);
uint64 length = parameters.size();
Serialization::save(buffer, length);
for (const auto& param : parameters)
{
Serialization::save(buffer, param);
}
}
void MaterialInterface::load(ArchiveBuffer& buffer)
{
graphics = buffer.getGraphics();
Serialization::load(buffer, uniformDataSize);
Serialization::load(buffer, uniformBinding);
if (uniformDataSize != 0)
{
uniformData.resize(uniformDataSize);
UniformBufferCreateInfo uniformInitializer = {
.resourceData = {
.size = uniformDataSize,
.data = nullptr,
}
};
uniformBuffer = graphics->createUniformBuffer(uniformInitializer);
}
uint64 length;
Serialization::load(buffer, length);
parameters.resize(length);
for (auto& param : parameters)
{
Serialization::load(buffer, param);
}
}
src/Engine/Material/MaterialInterface.h
-36
View File
@@ -1,36 +0,0 @@
#pragma once
#include "ShaderExpression.h"
#include "Graphics/GraphicsResources.h"
namespace Seele
{
DECLARE_NAME_REF(Gfx, DescriptorLayout)
DECLARE_NAME_REF(Gfx, UniformBuffer)
class MaterialInterface
{
public:
MaterialInterface() {}
MaterialInterface(Gfx::PGraphics graphics, Array<PShaderParameter> parameter, uint32 uniformDataSize, uint32 uniformBinding);
virtual ~MaterialInterface();
PShaderParameter getParameter(const std::string& name);
virtual Gfx::PDescriptorSet createDescriptorSet() = 0;
virtual Gfx::PDescriptorLayout getDescriptorLayout() const = 0;
virtual void save(ArchiveBuffer& buffer) const;
virtual void load(ArchiveBuffer& buffer);
// The name of the generated material shader, opposed to the name of the .asset file
virtual const std::string& getName() = 0;
virtual const Gfx::ShaderCollection* getShaders(Gfx::RenderPassType renderPass, VertexInputType* vertexInput) const = 0;
virtual Gfx::ShaderCollection& createShaders(Gfx::PGraphics graphics, Gfx::RenderPassType renderPass, VertexInputType* vertexInput) = 0;
protected:
Gfx::PGraphics graphics;
std::string brdfName;
Array<PShaderParameter> parameters;
Gfx::PUniformBuffer uniformBuffer;
uint32 uniformDataSize;
Array<uint8> uniformData;
int32 uniformBinding;
};
DEFINE_REF(MaterialInterface)
} // namespace Seele