Seele/src/Engine/Material/MaterialInstance.cpp

#include "MaterialInstance.h"
#include "Graphics/Graphics.h"
#include "Material.h"


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);
    ArchiveBuffer buffer(graphics);
    parameters.reserve(params.size());
    for (size_t i = 0; i < params.size(); ++i) {
        const std::string& name = params[i];
        Serialization::save(buffer, *expressions.find([&name](const OShaderExpression& p) { return p->key == name; }));
        buffer.rewind();
        OShaderParameter param;
        Serialization::load(buffer, param);
        parameters.add(std::move(param));
        buffer.rewind();
    }
}

MaterialInstance::~MaterialInstance() {}

void MaterialInstance::updateDescriptor() {
    Gfx::PDescriptorLayout layout = baseMaterial->getMaterial()->getDescriptorLayout();
    descriptor = layout->allocateDescriptorSet();
    for (auto& param : parameters) {
        param->updateDescriptorSet(descriptor, uniformData.data());
    }
    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, parameters);
    Serialization::save(buffer, id);
}

void MaterialInstance::load(ArchiveBuffer& buffer) {
    graphics = buffer.getGraphics();
    Serialization::load(buffer, uniformData);
    Serialization::load(buffer, uniformBinding);
    Serialization::load(buffer, parameters);
    Serialization::load(buffer, id);
}