TransformGPUBuffer.hpp

Go to the documentation of this file.

#pragma once
 
#include "component/Mesh.hpp"
#include "component/Transform.hpp"
#include "entity/Entity.hpp"
#include "exception/NonexistentComponentError.hpp"
#include "exception/UpdateBufferError.hpp"
#include "resource/AGPUBuffer.hpp"
#include <glm/gtc/type_ptr.hpp>
 
namespace DefaultPipeline::Resource {

struct TransformGPUData {
    glm::mat4 modelMatrix;
    glm::mat4 normalMatrix;
};
 
class TransformGPUBuffer : public Graphic::Resource::AGPUBuffer {
  public:
    explicit TransformGPUBuffer(Engine::Entity entity) : _entity(entity) {}
    ~TransformGPUBuffer() override { Destroy(); };
    void Create(Engine::Core &core) override
    {
        const auto &transformComponent = _entity.GetComponents<Object::Component::Transform>();
        const auto &context = core.GetResource<Graphic::Resource::Context>();
 
        _buffer = _CreateBuffer(context.deviceContext);
        _UpdateBuffer(transformComponent, context);
        _isCreated = true;
    };
    void Destroy(Engine::Core &core) override { Destroy(); };
 
    void Destroy()
    {
        if (_isCreated)
        {
            _isCreated = false;
            _buffer.release();
        }
    }
 
    bool IsCreated(Engine::Core &core) const override { return _isCreated; };
    void Update(Engine::Core &core) override
    {
        if (!_isCreated)
        {
            throw Graphic::Exception::UpdateBufferError("Cannot update a GPU transform buffer that is not created.");
        }
 
        const auto &transformComponent = _entity.GetComponents<Object::Component::Transform>();
        const auto &context = core.GetResource<Graphic::Resource::Context>();
        _UpdateBuffer(transformComponent, context);
    };
 
    const wgpu::Buffer &GetBuffer() const override { return _buffer; };
 
  private:
    wgpu::Buffer _CreateBuffer(const Graphic::Resource::DeviceContext &context)
    {
        wgpu::BufferDescriptor bufferDesc(wgpu::Default);
        bufferDesc.usage = wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::Uniform;
        bufferDesc.size = sizeof(TransformGPUData);
        const std::string label = fmt::format("TransformGPUBuffer_{}", _entity);
        bufferDesc.label = wgpu::StringView(label);
 
        return context.GetDevice()->createBuffer(bufferDesc);
    }

    void _UpdateBuffer(const Object::Component::Transform &transformComponent,
                       const Graphic::Resource::Context &context)
    {
        const glm::mat4 &modelMatrix = transformComponent.ComputeTransformationMatrix();
 
        const glm::mat4 normalMatrix = glm::transpose(glm::inverse(modelMatrix));
 
        TransformGPUData gpuData;
        gpuData.modelMatrix = modelMatrix;
        gpuData.normalMatrix = normalMatrix;
 
        context.queue->writeBuffer(_buffer, 0, &gpuData, sizeof(TransformGPUData));
    }
 
    wgpu::Buffer _buffer;
    bool _isCreated = false;
    Engine::Entity _entity;
};
} // namespace DefaultPipeline::Resource