GPUShader.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Common.hpp"
#include "Forward.hpp"
 
#include "GPUResource.hpp"
#include "GPUVertexFormat.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Flags.hpp"
#include "CeresEngine/Foundation/Hash.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/Material/ShaderSource.hpp"
 
#include <utility>
#include <variant>
 
namespace CeresEngine {
 
    enum class CE_SCRIPT_EXPORT() GPUPipelineStage : unsigned int {
        Vertex = (1u << 0u),
 
        TesselationControl = (1u << 1u),
 
        TesselationEvaluation = (1u << 2u),
 
        Geometry = (1u << 3u),
 
        Fragment = (1u << 4u),
 
        Compute = (1u << 5u),
 
        Task = (1u << 6u),
        
        Mesh = (1u << 7u),
 
        RayTracingRayGeneration = (1u << 8u),
        
        RayTracingAnyHit = (1u << 9u),
        
        RayTracingClosestHit = (1u << 10u),
        
        RayTracingMiss = (1u << 11u),
 
        RayTracingIntersection = (1u << 12u),
 
        RayTracingCallable = (1u << 13u),
 
        ReadOnlyResource = (1u << 31u),
 
        Tesselation = (TesselationControl | TesselationEvaluation),
 
        Graphics = (Vertex | Tesselation | Geometry | Fragment),
 
        All = (Graphics | Compute),
    };
 
    using GPUPipelineStages = Flags<GPUPipelineStage>;
    CE_FLAGS_OPERATORS(GPUPipelineStage);
 
    struct CE_SCRIPT_EXPORT() GPUShaderReflectionDescriptor final {
        struct DescriptorView final {
            CE_SCRIPT_EXPORT()
            String name;
 
            CE_SCRIPT_EXPORT()
            GPUResourceType type = GPUResourceType::Undefined;
 
            CE_SCRIPT_EXPORT()
            GPUPipelineStages stages = GPUPipelineStage::Graphics;
 
            CE_SCRIPT_EXPORT()
            UInt32 slot = 0;
 
            CE_SCRIPT_EXPORT()
            UInt32 set = 0;
 
            CE_SCRIPT_EXPORT()
            UInt32 arraySize = 1;
 
            CE_SCRIPT_EXPORT()
            UInt32 uniformBufferSize = 0;
 
            template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
                CE_REFL_DATA(name);
                CE_REFL_DATA(type);
                CE_REFL_DATA(stages);
                CE_REFL_DATA(slot);
                CE_REFL_DATA(set);
                CE_REFL_DATA(arraySize);
                CE_REFL_DATA(uniformBufferSize);
            }
        };
 
        Vector<GPUVertexAttribute> vertexAttributes;
 
        Vector<DescriptorView> descriptorViews;
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(vertexAttributes);
            CE_REFL_DATA(descriptorViews);
        }
    };
 
    struct CE_SCRIPT_EXPORT() GPUShaderDescriptor final {
        CE_SCRIPT_EXPORT()
        ShaderType type = ShaderType::Undefined;
 
        CE_SCRIPT_EXPORT()
        String source = "";
 
        CE_SCRIPT_EXPORT()
        ShaderSourceType sourceType = ShaderSourceType::Binary;
 
        CE_SCRIPT_EXPORT()
        String profile = "";
 
        CE_SCRIPT_EXPORT()
        String name;
 
        CE_SCRIPT_EXPORT()
        GPUShaderDescriptor() = default;
 
        CE_SCRIPT_EXPORT()
        GPUShaderDescriptor(const GPUShaderDescriptor&) = default;
        GPUShaderDescriptor& operator=(const GPUShaderDescriptor&) = default;
 
        CE_SCRIPT_EXPORT()
        inline GPUShaderDescriptor(const ShaderType type, String source) : type{type}, source{std::move(source)} {}
 
        CE_SCRIPT_EXPORT()
        inline GPUShaderDescriptor(const ShaderType type, String source, String profile) : type{type}, source{std::move(source)}, profile{std::move(profile)} {}
 
        CE_SCRIPT_EXPORT()
        CE_EXPLICIT(false) inline GPUShaderDescriptor(const ShaderBinary& binary) // NOLINT
                : type(binary.type), source(binary.data.data(), binary.data.size()), sourceType(ShaderSourceType::Binary) {}
 
        CE_SCRIPT_EXPORT()
        CE_EXPLICIT(false) inline GPUShaderDescriptor(const ShaderSource& source) // NOLINT
                : type(source.type), source(source.source), sourceType(ShaderSourceType::Source) {}
 
    public:
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(type);
            CE_REFL_DATA(source);
            CE_REFL_DATA(sourceType);
            CE_REFL_DATA(profile);
            CE_REFL_DATA(name);
        }
    };
 
    class CE_SCRIPT_EXPORT() GPUShader : public TDeviceObject<GPUShaderDescriptor> {
    public:
        const GPUShaderReflectionDescriptor& reflection;
 
    public:
        explicit GPUShader(GPUDevice& device, const Descriptor& descriptor, const GPUShaderReflectionDescriptor& reflection)
                : TDeviceObject(device, descriptor), reflection(reflection) {}
 
        GPUShader(const GPUShader&) = delete;
        GPUShader& operator=(const GPUShader&) = delete;
 
        GPUShader(GPUShader&&) = delete;
        GPUShader& operator=(GPUShader&&) = delete;
 
    public:
        [[nodiscard]] CE_SCRIPT_EXPORT()
        const GPUShaderReflectionDescriptor& reflect() const { return reflection; }
    };
 
    struct CE_SCRIPT_EXPORT() GPUShaderProgramStageDescriptor {
        CE_SCRIPT_EXPORT()
        GPUShaderPtr shader = nullptr;
 
        CE_SCRIPT_EXPORT()
        String entryPoint = "";
 
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(shader);
            CE_REFL_DATA(entryPoint);
        }
    };
 
    struct CE_SCRIPT_EXPORT() GPUShaderProgramDescriptor final {
        CE_SCRIPT_EXPORT()
        GPUShaderProgramStageDescriptor vertex;
 
        CE_SCRIPT_EXPORT()
        GPUShaderProgramStageDescriptor tesselationControl;
 
        CE_SCRIPT_EXPORT()
        GPUShaderProgramStageDescriptor tesselationEvaluation;
 
        CE_SCRIPT_EXPORT()
        GPUShaderProgramStageDescriptor geometry;
 
        CE_SCRIPT_EXPORT()
        GPUShaderProgramStageDescriptor fragment;
 
        CE_SCRIPT_EXPORT()
        GPUShaderProgramStageDescriptor compute;
 
        CE_SCRIPT_EXPORT()
        String name;
 
    public:
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(vertex);
            CE_REFL_DATA(tesselationControl);
            CE_REFL_DATA(tesselationEvaluation);
            CE_REFL_DATA(geometry);
            CE_REFL_DATA(fragment);
            CE_REFL_DATA(compute);
            CE_REFL_DATA(name);
        }
    };
 
    class CE_SCRIPT_EXPORT() GPUShaderProgram : public TDeviceObject<GPUShaderProgramDescriptor> {
    public:
        const GPUShaderReflectionDescriptor& reflection;
 
    public:
        explicit GPUShaderProgram(GPUDevice& device, const Descriptor& descriptor, const GPUShaderReflectionDescriptor& reflection)
                : TDeviceObject(device, descriptor), reflection(reflection) {}
 
        using TDeviceObject::TDeviceObject;
 
        GPUShaderProgram(const GPUShaderProgram&) = delete;
        GPUShaderProgram& operator=(const GPUShaderProgram&) = delete;
 
        GPUShaderProgram(GPUShaderProgram&&) = delete;
        GPUShaderProgram& operator=(GPUShaderProgram&&) = delete;
 
    public:
        [[nodiscard]] CE_SCRIPT_EXPORT()
        const GPUShaderReflectionDescriptor& reflect() const { return reflection; }
 
        [[nodiscard]] virtual GPUPipelineLayoutPtr getPipelineLayout() const = 0;
    };
 
} // namespace CeresEngine
 
CE_REFLECT_HASH(CeresEngine::GPUShaderReflectionDescriptor::DescriptorView);
 
CE_REFLECT_HASH(CeresEngine::GPUShaderReflectionDescriptor);
 
CE_REFLECT_HASH(CeresEngine::ShaderBinary);
 
CE_REFLECT_HASH(CeresEngine::ShaderSource);
 
CE_REFLECT_HASH(CeresEngine::GPUShaderDescriptor);
 
CE_REFLECT_HASH(CeresEngine::GPUShaderProgramStageDescriptor);
 
CE_REFLECT_HASH(CeresEngine::GPUShaderProgramDescriptor);