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

Adding bindless material descriptors

Browse Source
This commit is contained in:
Dynamitos
2024-06-18 19:19:05 +02:00
parent cff14981ff
commit f6ebbc2067
23 changed files with 387 additions and 274 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Engine/Material/Material.cpp
+107 -63
View File
@@ -7,92 +7,141 @@
#include "Window/WindowManager.h"
#include <fstream>
using namespace Seele;
Array<Gfx::PTexture2D> Material::textures;
Array<Gfx::PSampler> Material::samplers;
Gfx::OShaderBuffer Material::floatBuffer;
Array<float> Material::floatData;
Gfx::ODescriptorLayout Material::layout;
Gfx::PDescriptorSet Material::set;
std::atomic_uint64_t Material::materialIdCounter = 0;
Array<PMaterial> Material::materials;
Material::Material() {}
Material::Material(Gfx::PGraphics graphics, Gfx::ODescriptorLayout layout, uint32 uniformDataSize, uint32 uniformBinding,
std::string materialName, Array<OShaderExpression> expressions, Array<std::string> parameter, MaterialNode brdf)
: graphics(graphics), uniformDataSize(uniformDataSize), uniformBinding(uniformBinding), instanceId(0), layout(std::move(layout)),
Material::Material(Gfx::PGraphics graphics, uint32 numTextures, uint32 numSamplers, uint32 numFloats, std::string materialName,
Array<OShaderExpression> expressions, Array<std::string> parameter, MaterialNode brdf)
: graphics(graphics), numTextures(numTextures), numSamplers(numSamplers), numFloats(numFloats), instanceId(0),
materialName(materialName), codeExpressions(std::move(expressions)), parameters(std::move(parameter)), brdf(std::move(brdf)),
materialId(materialIdCounter++) {
if (layout == nullptr) {
init(graphics);
}
materials.add(this);
}
Material::~Material() {}
void Material::init(Gfx::PGraphics graphics) {
layout = graphics->createDescriptorLayout("pMaterial");
layout->addDescriptorBinding(Gfx::DescriptorBinding{
.binding = 0,
.descriptorType = Gfx::SE_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
.descriptorCount = 2000,
.bindingFlags = Gfx::SE_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT | Gfx::SE_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
.shaderStages = Gfx::SE_SHADER_STAGE_FRAGMENT_BIT | Gfx::SE_SHADER_STAGE_CLOSEST_HIT_BIT_KHR,
});
layout->addDescriptorBinding(Gfx::DescriptorBinding{
.binding = 1,
.descriptorType = Gfx::SE_DESCRIPTOR_TYPE_SAMPLER,
.descriptorCount = 2000,
.bindingFlags = Gfx::SE_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT | Gfx::SE_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
.shaderStages = Gfx::SE_SHADER_STAGE_FRAGMENT_BIT | Gfx::SE_SHADER_STAGE_CLOSEST_HIT_BIT_KHR,
});
layout->addDescriptorBinding(Gfx::DescriptorBinding{
.binding = 2,
.descriptorType = Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER,
.descriptorCount = 1,
.bindingFlags = Gfx::SE_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT | Gfx::SE_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
.shaderStages = Gfx::SE_SHADER_STAGE_FRAGMENT_BIT | Gfx::SE_SHADER_STAGE_CLOSEST_HIT_BIT_KHR,
});
layout->create();
floatBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{
.dynamic = true,
.name = "MaterialFloatBuffer",
});
}
void Material::updateDescriptor() {
floatBuffer->rotateBuffer(floatData.size() * sizeof(float));
floatBuffer->updateContents(ShaderBufferCreateInfo{
.sourceData =
{
.size = floatData.size() * sizeof(float),
},
});
floatBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_SHADER_READ_BIT,
Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
layout->reset();
set = layout->allocateDescriptorSet();
for (uint32 i = 0; i < textures.size(); ++i)
{
set->updateTexture(0, i, textures[i]);
}
for (uint32 i = 0; i < samplers.size(); ++i)
{
set->updateSampler(1, i, samplers[i]);
}
set->updateBuffer(2, floatBuffer);
set->writeChanges();
}
void Material::updateTexture(uint32 index, Gfx::PTexture2D texture) { textures[index] = texture; }
void Material::updateSampler(uint32 index, Gfx::PSampler sampler) { samplers[index] = sampler; }
void Material::updateFloatData(uint32 offset, uint32 numFloats, float* data) {
std::memcpy(floatData.data() + offset, data, numFloats * sizeof(float));
}
uint32 Material::addTextures(uint32 numTextures) {
uint32 textureOffset = textures.size();
textures.resize(textures.size() + numTextures);
return textureOffset;
}
uint32 Material::addSamplers(uint32 numSamplers) {
uint32 samplerOffset = samplers.size();
samplers.resize(samplers.size() + numSamplers);
return samplerOffset;
}
uint32 Material::addFloats(uint32 numFloats) {
uint32 floatOffset = floatData.size();
floatData.resize(floatData.size() + numFloats);
return floatOffset;
}
OMaterialInstance Material::instantiate() {
return new MaterialInstance(instanceId++, graphics, codeExpressions, parameters, uniformBinding, uniformDataSize);
return new MaterialInstance(instanceId++, graphics, codeExpressions, parameters, numTextures, numSamplers, numFloats);
}
void Material::save(ArchiveBuffer& buffer) const {
Serialization::save(buffer, uniformDataSize);
Serialization::save(buffer, uniformBinding);
Serialization::save(buffer, numTextures);
Serialization::save(buffer, numSamplers);
Serialization::save(buffer, numFloats);
Serialization::save(buffer, instanceId);
Serialization::save(buffer, materialName);
Serialization::save(buffer, codeExpressions);
Serialization::save(buffer, parameters);
Serialization::save(buffer, brdf);
Serialization::save(buffer, layout->getName());
const auto& bindings = layout->getBindings();
Serialization::save(buffer, bindings.size());
for (const auto& binding : bindings) {
Serialization::save(buffer, binding.binding);
Serialization::save(buffer, binding.descriptorType);
Serialization::save(buffer, binding.textureType);
Serialization::save(buffer, binding.descriptorCount);
Serialization::save(buffer, binding.bindingFlags);
Serialization::save(buffer, binding.shaderStages);
}
}
void Material::load(ArchiveBuffer& buffer) {
graphics = buffer.getGraphics();
Serialization::load(buffer, uniformDataSize);
Serialization::load(buffer, uniformBinding);
if (layout == nullptr)
{
init(graphics);
}
Serialization::load(buffer, numTextures);
Serialization::load(buffer, numSamplers);
Serialization::load(buffer, numFloats);
Serialization::load(buffer, instanceId);
Serialization::load(buffer, materialName);
Serialization::load(buffer, codeExpressions);
Serialization::load(buffer, parameters);
Serialization::load(buffer, brdf);
std::string descriptorName;
Serialization::load(buffer, descriptorName);
uint64 numBindings;
Serialization::load(buffer, numBindings);
layout = graphics->createDescriptorLayout(descriptorName);
for (uint64 i = 0; i < numBindings; ++i) {
uint32 binding;
Serialization::load(buffer, binding);
Gfx::SeDescriptorType descriptorType;
Serialization::load(buffer, descriptorType);
Gfx::SeImageViewType textureType;
Serialization::load(buffer, textureType);
uint32 descriptorCount;
Serialization::load(buffer, descriptorCount);
Gfx::SeDescriptorBindingFlags bindingFlags;
Serialization::load(buffer, bindingFlags);
Gfx::SeShaderStageFlags shaderStages;
Serialization::load(buffer, shaderStages);
layout->addDescriptorBinding(Gfx::DescriptorBinding{
.binding = binding,
.descriptorType = descriptorType,
.textureType = textureType,
.descriptorCount = descriptorCount,
.bindingFlags = bindingFlags,
.shaderStages = shaderStages,
});
}
layout->create();
materialId = materialIdCounter++;
}
@@ -100,14 +149,10 @@ void Material::compile() {
std::ofstream codeStream("./shaders/generated/" + materialName + ".slang");
codeStream << "import BRDF;\n";
codeStream << "import MaterialParameter;\n";
codeStream << "struct " << materialName << "{\n";
for (const auto& parameter : parameters) {
PShaderParameter handle =
PShaderExpression(*codeExpressions.find([&parameter](const OShaderExpression& exp) { return exp->key == parameter; }));
handle->generateDeclaration(codeStream);
}
codeStream << "import Material;\n";
codeStream << "struct Material{\n";
codeStream << "\ttypedef " << brdf.profile << " BRDF;\n";
codeStream << "\t" << brdf.profile << " prepare(MaterialParameter input) {\n";
codeStream << "\tstatic " << brdf.profile << " prepare(MaterialParameter input) {\n";
codeStream << "\t\t" << brdf.profile << " result;\n";
Map<std::string, std::string> varState;
// initialize variable state
@@ -120,7 +165,6 @@ void Material::compile() {
codeStream << "\t\treturn result;\n";
codeStream << "\t}\n";
codeStream << "};\n";
codeStream << "layout(set=4)";
codeStream << "ParameterBlock<" << materialName << "> pMaterial;";
graphics->getShaderCompiler()->registerMaterial(this);
}
src/Engine/Material/Material.h
+22 -6
View File
@@ -5,14 +5,24 @@
namespace Seele {
DECLARE_REF(MaterialInstance)
DECLARE_NAME_REF(Gfx, Texture2D)
DECLARE_NAME_REF(Gfx, Sampler)
class Material {
public:
Material();
Material(Gfx::PGraphics graphics, Gfx::ODescriptorLayout layout, uint32 uniformDataSize, uint32 uniformBinding,
Material(Gfx::PGraphics graphics, uint32 numTextures, uint32 numSamplers, uint32 numFloats,
std::string materialName, Array<OShaderExpression> expressions, Array<std::string> parameter, MaterialNode brdf);
~Material();
const Gfx::PDescriptorLayout getDescriptorLayout() const { return layout; }
Gfx::PDescriptorLayout getDescriptorLayout() { return layout; }
static void init(Gfx::PGraphics graphics);
static Gfx::PDescriptorLayout getDescriptorLayout() { return layout; }
static Gfx::PDescriptorSet getDescriptorSet() { return set; }
static void updateDescriptor();
static void updateTexture(uint32 index, Gfx::PTexture2D texture);
static void updateSampler(uint32 index, Gfx::PSampler sampler);
static void updateFloatData(uint32 offset, uint32 numFloats, float* data);
static uint32 addTextures(uint32 numTextures);
static uint32 addSamplers(uint32 numSamplers);
static uint32 addFloats(uint32 numFloats);
OMaterialInstance instantiate();
const std::string& getName() const { return materialName; }
constexpr uint64 getId() const { return materialId; }
@@ -25,15 +35,21 @@ class Material {
private:
Gfx::PGraphics graphics;
uint32 uniformDataSize;
uint32 uniformBinding;
uint32 numTextures;
uint32 numSamplers;
uint32 numFloats;
uint64 instanceId;
uint64 materialId;
Gfx::ODescriptorLayout layout;
std::string materialName;
Array<OShaderExpression> codeExpressions;
Array<std::string> parameters;
MaterialNode brdf;
static Array<Gfx::PTexture2D> textures;
static Array<Gfx::PSampler> samplers;
static Gfx::OShaderBuffer floatBuffer;
static Array<float> floatData;
static Gfx::ODescriptorLayout layout;
static Gfx::PDescriptorSet set;
static std::atomic_uint64_t materialIdCounter;
static Array<PMaterial> materials;
};
src/Engine/Material/MaterialInstance.cpp
+16 -40
View File
@@ -8,18 +8,11 @@ using namespace Seele;
MaterialInstance::MaterialInstance() {}
MaterialInstance::MaterialInstance(uint64 id, Gfx::PGraphics graphics, Array<OShaderExpression>& expressions, Array<std::string> params,
uint32 uniformBinding, uint32 uniformSize)
: graphics(graphics), uniformBinding(uniformBinding), id(id) {
if (uniformSize > 0) {
uniformBuffer = graphics->createUniformBuffer(UniformBufferCreateInfo{
.sourceData =
{
.size = uniformSize,
},
.dynamic = true,
});
}
uniformData.resize(uniformSize);
uint32 numTextures, uint32 numSamplers, uint32 numFloats)
: graphics(graphics), numTextures(numTextures), numSamplers(numSamplers), numFloats(numFloats), id(id) {
texturesOffset = Material::addTextures(numTextures);
samplersOffset = Material::addSamplers(numSamplers);
floatBufferOffset = Material::addFloats(numFloats);
ArchiveBuffer buffer(graphics);
parameters.reserve(params.size());
for (size_t i = 0; i < params.size(); ++i) {
@@ -36,47 +29,30 @@ MaterialInstance::MaterialInstance(uint64 id, Gfx::PGraphics graphics, Array<OSh
MaterialInstance::~MaterialInstance() {}
void MaterialInstance::updateDescriptor() {
Gfx::PDescriptorLayout layout = baseMaterial->getMaterial()->getDescriptorLayout();
descriptor = layout->allocateDescriptorSet();
for (auto& param : parameters) {
param->updateDescriptorSet(descriptor, uniformData.data());
for (auto& p : parameters) {
p->updateDescriptorSet(texturesOffset, samplersOffset, floatBufferOffset);
}
if (uniformData.size() > 0) {
uniformBuffer->updateContents(DataSource{
.size = uniformData.size(),
.data = uniformData.data(),
});
descriptor->updateBuffer(uniformBinding, uniformBuffer);
}
descriptor->writeChanges();
}
Gfx::PDescriptorSet MaterialInstance::getDescriptorSet() const { return descriptor; }
void MaterialInstance::setBaseMaterial(PMaterialAsset asset) {
if (uniformData.size() > 0) {
uniformBuffer = graphics->createUniformBuffer(UniformBufferCreateInfo{
.sourceData =
{
.size = uniformData.size(),
},
.dynamic = true,
});
}
baseMaterial = asset;
}
void MaterialInstance::save(ArchiveBuffer& buffer) const {
Serialization::save(buffer, uniformData);
Serialization::save(buffer, uniformBinding);
Serialization::save(buffer, numTextures);
Serialization::save(buffer, numSamplers);
Serialization::save(buffer, numFloats);
Serialization::save(buffer, parameters);
Serialization::save(buffer, id);
}
void MaterialInstance::load(ArchiveBuffer& buffer) {
graphics = buffer.getGraphics();
Serialization::load(buffer, uniformData);
Serialization::load(buffer, uniformBinding);
Serialization::load(buffer, numTextures);
Serialization::load(buffer, numSamplers);
Serialization::load(buffer, numFloats);
Serialization::load(buffer, parameters);
Serialization::load(buffer, id);
texturesOffset = Material::addTextures(numTextures);
samplersOffset = Material::addSamplers(numSamplers);
floatBufferOffset = Material::addFloats(numFloats);
}
src/Engine/Material/MaterialInstance.h
+19 -6
View File
@@ -3,30 +3,43 @@
#include "Graphics/Buffer.h"
#include "Material.h"
namespace Seele {
struct MaterialOffsets {
uint32 textureOffset;
uint32 samplerOffset;
uint32 floatOffset;
};
class MaterialInstance {
public:
MaterialInstance();
MaterialInstance(uint64 id, Gfx::PGraphics graphics, Array<OShaderExpression>& expressions, Array<std::string> params,
uint32 uniformBinding, uint32 uniformSize);
uint32 numTextures, uint32 numSamplers, uint32 numFloats);
~MaterialInstance();
void updateDescriptor();
Gfx::PDescriptorSet getDescriptorSet() const;
PMaterial getBaseMaterial() const { return baseMaterial->getMaterial(); }
uint64 getId() const { return id; }
void setBaseMaterial(PMaterialAsset asset);
MaterialOffsets getMaterialOffsets() const {
return MaterialOffsets{
.textureOffset = texturesOffset,
.samplerOffset = samplersOffset,
.floatOffset = floatBufferOffset,
};
}
void save(ArchiveBuffer& buffer) const;
void load(ArchiveBuffer& buffer);
private:
Gfx::PGraphics graphics;
Array<uint8> uniformData;
uint32 uniformBinding;
Gfx::OUniformBuffer uniformBuffer;
Array<OShaderParameter> parameters;
uint32 numTextures;
uint32 numSamplers;
uint32 numFloats;
uint32 texturesOffset;
uint32 samplersOffset;
uint32 floatBufferOffset;
Gfx::PDescriptorSet descriptor;
PMaterialAsset baseMaterial;
uint64 id;
src/Engine/Material/ShaderExpression.cpp
+48 -36
View File
@@ -4,10 +4,10 @@
#include "Graphics/Descriptor.h"
#include "Graphics/Graphics.h"
#include "Graphics/Resources.h"
#include "Material/Material.h"
#include <fmt/core.h>
#include <fstream>
using namespace Seele;
void ExpressionInput::save(ArchiveBuffer& buffer) const {
@@ -48,36 +48,38 @@ void ShaderExpression::load(ArchiveBuffer& buffer) {
Serialization::load(buffer, key);
}
ShaderParameter::ShaderParameter(std::string name, uint32 byteOffset, uint32 binding)
: ShaderExpression(name), byteOffset(byteOffset), binding(binding) {}
ShaderParameter::ShaderParameter(std::string name, uint32 index) : ShaderExpression(name), index(index) {}
ShaderParameter::~ShaderParameter() {}
std::string ShaderParameter::evaluate(Map<std::string, std::string>& varState) const {
varState[key] = key;
return "";
}
void ShaderParameter::save(ArchiveBuffer& buffer) const {
ShaderExpression::save(buffer);
Serialization::save(buffer, byteOffset);
Serialization::save(buffer, binding);
Serialization::save(buffer, index);
}
void ShaderParameter::load(ArchiveBuffer& buffer) {
ShaderExpression::load(buffer);
Serialization::load(buffer, byteOffset);
Serialization::load(buffer, binding);
Serialization::load(buffer, index);
}
FloatParameter::FloatParameter(std::string name, float data, uint32 byteOffset, uint32 binding)
: ShaderParameter(name, byteOffset, binding), data(data) {
FloatParameter::FloatParameter(std::string name, float data, uint32 index) : ShaderParameter(name, index), data(data) {
output.name = name;
output.type = ExpressionType::FLOAT;
}
FloatParameter::~FloatParameter() {}
void FloatParameter::updateDescriptorSet(uint32 textureOffset, uint32 samplerOffset, uint32 floatOffset) {
Material::updateFloatData(floatOffset + index, 1, &data);
}
std::string FloatParameter::evaluate(Map<std::string, std::string>& varState) const
{
std::string varName = fmt::format("exp_{}", key);
varState[key] = varName;
return fmt::format("let {} = getMaterialFloatParameter({});\n", varName, index);
}
void FloatParameter::save(ArchiveBuffer& buffer) const {
ShaderParameter::save(buffer);
Serialization::save(buffer, data);
@@ -88,21 +90,23 @@ void FloatParameter::load(ArchiveBuffer& buffer) {
Serialization::load(buffer, data);
}
void FloatParameter::updateDescriptorSet(Gfx::PDescriptorSet, uint8* dst) { std::memcpy(dst + byteOffset, &data, sizeof(float)); }
void FloatParameter::generateDeclaration(std::ofstream& stream) const { stream << "\tfloat " << key << ";\n"; }
VectorParameter::VectorParameter(std::string name, Vector data, uint32 byteOffset, uint32 binding)
: ShaderParameter(name, byteOffset, binding), data(data) {
VectorParameter::VectorParameter(std::string name, Vector data, uint32 index)
: ShaderParameter(name, index), data(data) {
output.name = name;
output.type = ExpressionType::FLOAT3;
}
VectorParameter::~VectorParameter() {}
void VectorParameter::updateDescriptorSet(Gfx::PDescriptorSet, uint8* dst) { std::memcpy(dst + byteOffset, &data, sizeof(Vector)); }
void VectorParameter::updateDescriptorSet(uint32 textureOffset, uint32 samplerOffset, uint32 floatOffset) {
Material::updateFloatData(floatOffset + index, 3, (float*) & data);
}
void VectorParameter::generateDeclaration(std::ofstream& stream) const { stream << "\tfloat3 " << key << ";\n"; }
std::string VectorParameter::evaluate(Map<std::string, std::string>& varState) const {
std::string varName = fmt::format("exp_{}", key);
varState[key] = varName;
return fmt::format("let {} = getMaterialVectorParameter({});\n", varName, index);
}
void VectorParameter::save(ArchiveBuffer& buffer) const {
ShaderParameter::save(buffer);
@@ -114,18 +118,22 @@ void VectorParameter::load(ArchiveBuffer& buffer) {
Serialization::load(buffer, data);
}
TextureParameter::TextureParameter(std::string name, PTextureAsset asset, uint32 binding) : ShaderParameter(name, 0, binding), data(asset) {
TextureParameter::TextureParameter(std::string name, PTextureAsset asset, uint32 index) : ShaderParameter(name, index), data(asset) {
output.name = name;
output.type = ExpressionType::TEXTURE;
}
TextureParameter::~TextureParameter() {}
void TextureParameter::updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8*) {
descriptorSet->updateTexture(binding, data->getTexture());
void TextureParameter::updateDescriptorSet(uint32 textureOffset, uint32 samplerOffset, uint32 floatOffset) {
Material::updateTexture(textureOffset + index, data->getTexture());
}
void TextureParameter::generateDeclaration(std::ofstream& stream) const { stream << "\tTexture2D " << key << ";\n"; }
std::string TextureParameter::evaluate(Map<std::string, std::string>& varState) const {
std::string varName = fmt::format("exp_{}", key);
varState[key] = varName;
return fmt::format("let {} = getMaterialTextureParameter({});\n", varName, index);
}
void TextureParameter::save(ArchiveBuffer& buffer) const {
ShaderParameter::save(buffer);
@@ -142,17 +150,23 @@ void TextureParameter::load(ArchiveBuffer& buffer) {
data = AssetRegistry::findTexture(folder, filename);
}
SamplerParameter::SamplerParameter(std::string name, Gfx::OSampler sampler, uint32 binding)
: ShaderParameter(name, 0, binding), data(std::move(sampler)) {
SamplerParameter::SamplerParameter(std::string name, Gfx::OSampler sampler, uint32 index)
: ShaderParameter(name, index), data(std::move(sampler)) {
output.name = name;
output.type = ExpressionType::SAMPLER;
}
SamplerParameter::~SamplerParameter() {}
void SamplerParameter::updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8*) { descriptorSet->updateSampler(binding, data); }
void SamplerParameter::updateDescriptorSet(uint32 textureOffset, uint32 samplerOffset, uint32 floatOffset) {
Material::updateSampler(samplerOffset + index, data);
}
void SamplerParameter::generateDeclaration(std::ofstream& stream) const { stream << "\tSamplerState " << key << ";\n"; }
std::string SamplerParameter::evaluate(Map<std::string, std::string>& varState) const {
std::string varName = fmt::format("exp_{}", key);
varState[key] = varName;
return fmt::format("let {} = getMaterialSamplerParameter({});\n", varName, index);
}
void SamplerParameter::save(ArchiveBuffer& buffer) const { ShaderParameter::save(buffer); }
@@ -161,19 +175,17 @@ void SamplerParameter::load(ArchiveBuffer& buffer) {
data = buffer.getGraphics()->createSampler(SamplerCreateInfo{});
}
CombinedTextureParameter::CombinedTextureParameter(std::string name, PTextureAsset data, Gfx::OSampler sampler, uint32 binding)
: ShaderParameter(name, 0, binding), data(data), sampler(std::move(sampler)) {
CombinedTextureParameter::CombinedTextureParameter(std::string name, PTextureAsset data, Gfx::OSampler sampler, uint32 index)
: ShaderParameter(name, index), data(data), sampler(std::move(sampler)) {
output.name = name;
output.type = ExpressionType::TEXTURE;
}
CombinedTextureParameter::~CombinedTextureParameter() {}
void CombinedTextureParameter::updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8*) {
descriptorSet->updateTexture(binding, data->getTexture(), sampler);
}
void CombinedTextureParameter::updateDescriptorSet(uint32 textureOffset, uint32 samplerOffset, uint32 floatOffset) { assert(false); }
void CombinedTextureParameter::generateDeclaration(std::ofstream& stream) const { stream << "\tSampler2D " << key << ";\n"; }
std::string CombinedTextureParameter::evaluate(Map<std::string, std::string>& varState) const { return ""; }
void CombinedTextureParameter::save(ArchiveBuffer& buffer) const {
ShaderParameter::save(buffer);
src/Engine/Material/ShaderExpression.h
+19 -23
View File
@@ -43,18 +43,14 @@ class ShaderExpression {
};
DEFINE_REF(ShaderExpression)
DECLARE_NAME_REF(Gfx, DescriptorSet)
struct ShaderParameter : public ShaderExpression {
uint32 byteOffset = 0;
uint32 binding = 0;
uint32 index = 0;
ShaderParameter() {}
ShaderParameter(std::string name, uint32 byteOffset, uint32 binding);
ShaderParameter(std::string name, uint32 index);
virtual ~ShaderParameter();
// update a descriptorset, in case of a uniform buffer, copy the data to the dst + byteOffset
virtual void updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8* dst) = 0;
virtual void generateDeclaration(std::ofstream& stream) const = 0;
virtual void updateDescriptorSet(uint32 textureOffset, uint32 samplerOffset, uint32 floatOffset) = 0;
virtual uint64 getIdentifier() const override = 0;
virtual std::string evaluate(Map<std::string, std::string>& varState) const override;
virtual std::string evaluate(Map<std::string, std::string>& varState) const = 0;
virtual void save(ArchiveBuffer& buffer) const override;
virtual void load(ArchiveBuffer& buffer) override;
};
@@ -63,10 +59,10 @@ struct FloatParameter : public ShaderParameter {
static constexpr uint64 IDENTIFIER = 0x01;
float data = 0.0f;
FloatParameter() {}
FloatParameter(std::string name, float data, uint32 byteOffset, uint32 binding);
FloatParameter(std::string name, float data, uint32 index);
virtual ~FloatParameter();
virtual void updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8* dst) override;
virtual void generateDeclaration(std::ofstream& stream) const override;
virtual void updateDescriptorSet(uint32 textureOffset, uint32 samplerOffset, uint32 floatOffset) override;
virtual std::string evaluate(Map<std::string, std::string>& varState) const override;
virtual uint64 getIdentifier() const override { return IDENTIFIER; }
virtual void save(ArchiveBuffer& buffer) const override;
virtual void load(ArchiveBuffer& buffer) override;
@@ -76,10 +72,10 @@ struct VectorParameter : public ShaderParameter {
static constexpr uint64 IDENTIFIER = 0x02;
Vector data = Vector();
VectorParameter() {}
VectorParameter(std::string name, Vector data, uint32 byteOffset, uint32 binding);
VectorParameter(std::string name, Vector data, uint32 index);
virtual ~VectorParameter();
virtual void updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8* dst) override;
virtual void generateDeclaration(std::ofstream& stream) const override;
virtual void updateDescriptorSet(uint32 textureOffset, uint32 samplerOffset, uint32 floatOffset) override;
virtual std::string evaluate(Map<std::string, std::string>& varState) const override;
virtual uint64 getIdentifier() const override { return IDENTIFIER; }
virtual void save(ArchiveBuffer& buffer) const override;
virtual void load(ArchiveBuffer& buffer) override;
@@ -89,10 +85,10 @@ struct TextureParameter : public ShaderParameter {
static constexpr uint64 IDENTIFIER = 0x04;
PTextureAsset data = nullptr;
TextureParameter() {}
TextureParameter(std::string name, PTextureAsset data, uint32 binding);
TextureParameter(std::string name, PTextureAsset data, uint32 index);
virtual ~TextureParameter();
virtual void updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8* dst) override;
virtual void generateDeclaration(std::ofstream& stream) const override;
virtual void updateDescriptorSet(uint32 textureOffset, uint32 samplerOffset, uint32 floatOffset) override;
virtual std::string evaluate(Map<std::string, std::string>& varState) const override;
virtual uint64 getIdentifier() const override { return IDENTIFIER; }
virtual void save(ArchiveBuffer& buffer) const override;
virtual void load(ArchiveBuffer& buffer) override;
@@ -103,10 +99,10 @@ struct SamplerParameter : public ShaderParameter {
static constexpr uint64 IDENTIFIER = 0x08;
Gfx::OSampler data = nullptr;
SamplerParameter() {}
SamplerParameter(std::string name, Gfx::OSampler sampler, uint32 binding);
SamplerParameter(std::string name, Gfx::OSampler sampler, uint32 index);
virtual ~SamplerParameter();
virtual void updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8* dst) override;
virtual void generateDeclaration(std::ofstream& stream) const override;
virtual void updateDescriptorSet(uint32 textureOffset, uint32 samplerOffset, uint32 floatOffset) override;
virtual std::string evaluate(Map<std::string, std::string>& varState) const override;
virtual uint64 getIdentifier() const override { return IDENTIFIER; }
virtual void save(ArchiveBuffer& buffer) const override;
virtual void load(ArchiveBuffer& buffer) override;
@@ -117,10 +113,10 @@ struct CombinedTextureParameter : public ShaderParameter {
PTextureAsset data = nullptr;
Gfx::OSampler sampler = nullptr;
CombinedTextureParameter() {}
CombinedTextureParameter(std::string name, PTextureAsset data, Gfx::OSampler sampler, uint32 binding);
CombinedTextureParameter(std::string name, PTextureAsset data, Gfx::OSampler sampler, uint32 index);
virtual ~CombinedTextureParameter();
virtual void updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8* dst) override;
virtual void generateDeclaration(std::ofstream& stream) const override;
virtual void updateDescriptorSet(uint32 textureOffset, uint32 samplerOffset, uint32 floatOffset) override;
virtual std::string evaluate(Map<std::string, std::string>& varState) const override;
virtual uint64 getIdentifier() const override { return IDENTIFIER; }
virtual void save(ArchiveBuffer& buffer) const override;
virtual void load(ArchiveBuffer& buffer) override;