Pipeline.hpp

Go to the documentation of this file.

#pragma once

#include <cstdint>
#include <functional>
#include <string>
#include <vector>

#include <lug/Graphics/Export.hpp>
#include <lug/Graphics/Renderer.hpp>
#include <lug/Graphics/Render/Technique/Type.hpp>
#include <lug/Graphics/Resource.hpp>
#include <lug/Graphics/Vulkan/API/GraphicsPipeline.hpp>

namespace lug {
namespace Graphics {

namespace Vulkan {

class Renderer;

namespace Render {

class LUG_GRAPHICS_API Pipeline : public Resource {
public:
    struct Id {
        struct PrimitivePart {
            union {
                struct {
                    uint32_t positionVertexData : 1;    
                    uint32_t normalVertexData : 1;      
                    uint32_t tangentVertexData : 1;     
                    uint32_t countTexCoord : 2;         
                    uint32_t countColor : 2;            
                    uint32_t primitiveMode : 3;         
                };

                uint32_t value;
            };

            explicit operator uint32_t() {
                return value;
            }
        };

        struct MaterialPart {
            union {
                struct {
                    uint32_t baseColorInfo : 2;             
                    uint32_t metallicRoughnessInfo : 2;     
                    uint32_t normalInfo : 2;                
                    uint32_t occlusionInfo : 2;             
                    uint32_t emissiveInfo : 2;              
                };

                uint32_t value;
            };

            explicit operator uint32_t() {
                return value;
            }
        };

        struct ExtraPart {
            union {
                struct {
                    uint32_t displayMode : 3;           
                    uint32_t irradianceMapInfo : 1;     
                    uint32_t prefilteredMapInfo : 1;    
                };

                uint32_t value;
            };

            explicit operator uint32_t() {
                return value;
            }
        };

        union {
            struct {
                uint32_t primitivePart : 10;
                uint32_t materialPart : 10;
                uint32_t extraPart : 5;
            };

            uint32_t value;
        };

        Id(uint32_t id = 0): value(id) {}

        explicit operator uint32_t() const {
            return value;
        }

        explicit operator bool() const {
            return value != 0;
        }

        bool operator==(const Id& other) const {
            return value == other.value;
        }

        bool operator!=(const Id& other) const {
            return value != other.value;
        }

        bool operator<(const Id& other) const {
            return value < other.value;
        }

        PrimitivePart getPrimitivePart() {
            PrimitivePart tmp;
            tmp.value = primitivePart;
            return tmp;
        }

        MaterialPart getMaterialPart() {
            MaterialPart tmp;
            tmp.value = materialPart;
            return tmp;
        }

        ExtraPart getExtraPart() {
            ExtraPart tmp;
            tmp.value = extraPart;
            return tmp;
        }

        static Id create(PrimitivePart primitivePart, MaterialPart materialPart, ExtraPart extraPart) {
            Id id;

            id.primitivePart = static_cast<uint32_t>(primitivePart);
            id.materialPart = static_cast<uint32_t>(materialPart);
            id.extraPart = static_cast<uint32_t>(extraPart);

            return id;
        };
    };

public:
    class LUG_GRAPHICS_API ShaderBuilder {
    public:
        enum class Type : uint8_t {
            Vertex,
            Fragment
        };

    public:
        ShaderBuilder() = delete;

        ShaderBuilder(const ShaderBuilder&) = delete;
        ShaderBuilder(ShaderBuilder&&) = delete;

        ShaderBuilder& operator=(const ShaderBuilder&) = delete;
        ShaderBuilder& operator=(ShaderBuilder&&) = delete;

        ~ShaderBuilder() = delete;

    public:
        static std::vector<uint32_t> buildShader(std::string shaderRoot, ::lug::Graphics::Render::Technique::Type technique, Type type, Pipeline::Id id);
        static std::vector<uint32_t> buildShaderFromFile(std::string filename, Type type, Pipeline::Id id);
        static std::vector<uint32_t> buildShaderFromString(std::string filename, std::string content, Type type, Pipeline::Id id);
    };

public:
    Pipeline(Renderer& renderer, Id id);

    Pipeline(const Pipeline&) = delete;
    Pipeline(Pipeline&&) = delete;

    Pipeline& operator=(const Pipeline&) = delete;
    Pipeline& operator=(Pipeline&&) = delete;

    ~Pipeline() = default;

    Id getId() const;
    static inline Id getBaseId();

    const API::GraphicsPipeline& getPipelineAPI();

    static Resource::SharedPtr<Pipeline> create(Renderer& renderer, Id id);

private:
    bool init();

private:
    Renderer& _renderer;
    Id _id;

    API::GraphicsPipeline _pipeline;
};

#include <lug/Graphics/Vulkan/Render/Pipeline.inl>

} // Render
} // Vulkan
} // Graphics
} // lug

// Make Pipeline Id hashable like a uint32_t
namespace std {
    template<> struct hash<lug::Graphics::Vulkan::Render::Pipeline::Id> {
        size_t operator()(const lug::Graphics::Vulkan::Render::Pipeline::Id& id) const {
            return hash<uint32_t>()(id.value);
        }
    };
}