GraphicsPipeline.hpp

#pragma once
 
#include <string>
#include <vector>
#include <iostream>
#include <xkeycheck.h>
 
#include <Common/Hash.hpp>
#include "PipelineLayout.hpp"
#include "Formats.hpp"
 
namespace Grindstone::GraphicsAPI {
    class RenderPass;
    class DescriptorSetLayout;

    class GraphicsPipeline {
    public:
        struct ShaderStageData {
            const char* fileName;
            const char* content;
            uint32_t size;
            ShaderStage type;
 
            bool operator==(const ShaderStageData& o) const {
                return (strcmp(fileName, o.fileName) == 0)
                    && (strcmp(content, o.content) == 0)
                    && size == o.size
                    && type == o.type;
            }
 
            bool operator!=(const ShaderStageData& o) const {
                return !(*this == o);
            }
        };
 
        struct AttachmentData {
            BlendData blendData = BlendData::NoBlending();
            ColorMask colorMask = ColorMask::RGBA;
 
            bool operator==(const AttachmentData& o) const {
                return blendData == o.blendData && colorMask == o.colorMask;
            }
 
            bool operator!=(const AttachmentData& o) const {
                return !(*this == o);
            }
        };
 
        struct PipelineData {
            const char* debugName;
 
            GeometryType primitiveType;
            PolygonFillMode polygonFillMode;
            CullMode cullMode;
            RenderPass* renderPass;
            float width, height;
            int32_t scissorX = 0, scissorY = 0;
            uint32_t scissorW, scissorH;
            const ShaderStageData* shaderStageCreateInfos;
            uint32_t shaderStageCreateInfoCount;
 
            const AttachmentData* colorAttachmentData = nullptr;
            uint8_t colorAttachmentCount;
            CompareOperation depthCompareOp = CompareOperation::LessOrEqual;
            bool isDepthTestEnabled = true;
            bool isDepthWriteEnabled = true;
            bool isStencilEnabled = false;
            bool hasDynamicViewport = false;
            bool hasDynamicScissor = false;
            bool isDepthBiasEnabled = false;
            bool isDepthClampEnabled = false;
 
            float depthBiasConstantFactor = 1.25f;
            float depthBiasSlopeFactor = 1.75f;
            float depthBiasClamp = 0.0f;
 
            bool operator==(const PipelineData& o) const {
                if (shaderStageCreateInfoCount != o.shaderStageCreateInfoCount && colorAttachmentCount != o.colorAttachmentCount) {
                    return false;
                }
 
                for (uint32_t i = 0; i < shaderStageCreateInfoCount; ++i) {
                    if (shaderStageCreateInfos[i] != o.shaderStageCreateInfos[i]) {
                        return false;
                    }
                }
 
                for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
                    if (colorAttachmentData[i] != o.colorAttachmentData[i]) {
                        return false;
                    }
                }
 
                return primitiveType == o.primitiveType
                    && polygonFillMode == o.polygonFillMode
                    && cullMode == o.cullMode
                    && renderPass == o.renderPass
                    && width == o.width
                    && height == o.height
                    && scissorX == o.scissorX
                    && scissorY == o.scissorY
                    && scissorW == o.scissorW
                    && scissorH == o.scissorH
 
                    && depthCompareOp == o.depthCompareOp
                    && isDepthTestEnabled == o.isDepthTestEnabled
                    && isDepthWriteEnabled == o.isDepthWriteEnabled
                    && isStencilEnabled == o.isStencilEnabled
                    && hasDynamicViewport == o.hasDynamicViewport
                    && hasDynamicScissor == o.hasDynamicScissor
                    && isDepthBiasEnabled == o.isDepthBiasEnabled
                    && isDepthClampEnabled == o.isDepthClampEnabled
 
                    && depthBiasConstantFactor == o.depthBiasConstantFactor
                    && depthBiasSlopeFactor == o.depthBiasSlopeFactor
                    && depthBiasClamp == o.depthBiasClamp
 
                    && depthBiasConstantFactor == o.depthBiasConstantFactor
                    && depthBiasSlopeFactor == o.depthBiasSlopeFactor
                    && depthBiasClamp == o.depthBiasClamp;
            }
 
            bool operator!=(const PipelineData& o) {
                return !(*this == o);
            }
        };
 
        struct CreateInfo {
            Grindstone::GraphicsAPI::PipelineLayout* pipelineLayout = nullptr;
            VertexInputLayout vertexInputLayout;
            PipelineData pipelineData;
 
            bool operator==(const CreateInfo& o) {
                return pipelineLayout == o.pipelineLayout
                    && vertexInputLayout == o.vertexInputLayout
                    && pipelineData == o.pipelineData;
            }
 
            bool operator!=(const CreateInfo& o) {
                return !(*this == o);
            }
        };
 
        Grindstone::GraphicsAPI::PipelineLayout* pipelineLayout = nullptr;
    };
}
 
namespace std {
    template<>
    struct std::hash<Grindstone::GraphicsAPI::GraphicsPipeline::ShaderStageData> {
        std::size_t operator()(const Grindstone::GraphicsAPI::GraphicsPipeline::ShaderStageData& stage) const noexcept {
            size_t result = stage.size;
            result ^= std::hash<uint8_t>{}(static_cast<uint8_t>(stage.type));
 
            return result;
        }
    };
 
    template<>
    struct std::hash<Grindstone::GraphicsAPI::GraphicsPipeline::AttachmentData> {
        std::size_t operator()(const Grindstone::GraphicsAPI::GraphicsPipeline::AttachmentData& attachment) const noexcept {
            size_t result =
                static_cast<size_t>(attachment.colorMask) |
                static_cast<size_t>(attachment.blendData.alphaFactorDst) << 8 |
                static_cast<size_t>(attachment.blendData.alphaFactorSrc) << 16 |
                static_cast<size_t>(attachment.blendData.alphaOperation) << 24 |
                static_cast<size_t>(attachment.blendData.colorFactorDst) << 32 |
                static_cast<size_t>(attachment.blendData.colorFactorSrc) << 40 |
                static_cast<size_t>(attachment.blendData.colorOperation) << 48;
            return result;
        }
    };
 
    template<>
    struct std::hash<Grindstone::GraphicsAPI::GraphicsPipeline::PipelineData> {
        std::size_t operator()(const Grindstone::GraphicsAPI::GraphicsPipeline::PipelineData& pipelineData) const noexcept {
            size_t result =
                static_cast<size_t>(pipelineData.cullMode) |
                static_cast<size_t>(pipelineData.depthCompareOp) << 8 |
                static_cast<size_t>(pipelineData.primitiveType) << 16 |
                static_cast<size_t>(pipelineData.polygonFillMode) << 24 |
                static_cast<size_t>(pipelineData.isDepthTestEnabled ? 1 : 0) << 32 |
                static_cast<size_t>(pipelineData.isDepthWriteEnabled ? 1 : 0) << 33 |
                static_cast<size_t>(pipelineData.isStencilEnabled ? 1 : 0) << 34 |
                static_cast<size_t>(pipelineData.hasDynamicViewport ? 1 : 0) << 35 |
                static_cast<size_t>(pipelineData.hasDynamicScissor ? 1 : 0) << 36 |
                static_cast<size_t>(pipelineData.isDepthBiasEnabled ? 1 : 0) << 37 |
                static_cast<size_t>(pipelineData.isDepthClampEnabled ? 1 : 0) << 38;
 
            result ^= static_cast<size_t>(pipelineData.width) | (static_cast<size_t>(pipelineData.height) << 32);
            result ^= static_cast<size_t>(pipelineData.scissorX) | (static_cast<size_t>(pipelineData.scissorY) << 32);
            result ^= static_cast<size_t>(pipelineData.scissorW) | (static_cast<size_t>(pipelineData.scissorH) << 32);
            result ^= static_cast<size_t>(pipelineData.depthBiasConstantFactor) | (static_cast<size_t>(pipelineData.depthBiasSlopeFactor) << 32);
            result ^= static_cast<size_t>(pipelineData.depthBiasClamp);
 
            result ^= std::hash<uint32_t>{}(pipelineData.colorAttachmentCount);
            for (uint8_t i = 0; i < pipelineData.colorAttachmentCount; ++i) {
                result ^= std::hash<Grindstone::GraphicsAPI::GraphicsPipeline::AttachmentData>{}(pipelineData.colorAttachmentData[i]);
            }
 
            result ^= std::hash<uint32_t>{}(pipelineData.shaderStageCreateInfoCount);
            for (uint8_t i = 0; i < pipelineData.shaderStageCreateInfoCount; ++i) {
                result ^= std::hash<Grindstone::GraphicsAPI::GraphicsPipeline::ShaderStageData>{}(pipelineData.shaderStageCreateInfos[i]);
            }
 
            return result;
        }
    };
}