XCEngine/engine/include/XCEngine/Rendering/RenderMaterialStateUtils.h

#pragma once

#include <XCEngine/RHI/RHITypes.h>
#include <XCEngine/Resources/Material/Material.h>

namespace XCEngine {
namespace Rendering {

inline RHI::CullMode ToRHICullMode(Resources::MaterialCullMode mode) {
    switch (mode) {
    case Resources::MaterialCullMode::Front:
        return RHI::CullMode::Front;
    case Resources::MaterialCullMode::Back:
        return RHI::CullMode::Back;
    case Resources::MaterialCullMode::None:
    default:
        return RHI::CullMode::None;
    }
}

inline RHI::ComparisonFunc ToRHIComparisonFunc(Resources::MaterialComparisonFunc func) {
    switch (func) {
    case Resources::MaterialComparisonFunc::Never:
        return RHI::ComparisonFunc::Never;
    case Resources::MaterialComparisonFunc::Equal:
        return RHI::ComparisonFunc::Equal;
    case Resources::MaterialComparisonFunc::LessEqual:
        return RHI::ComparisonFunc::LessEqual;
    case Resources::MaterialComparisonFunc::Greater:
        return RHI::ComparisonFunc::Greater;
    case Resources::MaterialComparisonFunc::NotEqual:
        return RHI::ComparisonFunc::NotEqual;
    case Resources::MaterialComparisonFunc::GreaterEqual:
        return RHI::ComparisonFunc::GreaterEqual;
    case Resources::MaterialComparisonFunc::Always:
        return RHI::ComparisonFunc::Always;
    case Resources::MaterialComparisonFunc::Less:
    default:
        return RHI::ComparisonFunc::Less;
    }
}

inline RHI::BlendFactor ToRHIBlendFactor(Resources::MaterialBlendFactor factor) {
    switch (factor) {
    case Resources::MaterialBlendFactor::Zero:
        return RHI::BlendFactor::Zero;
    case Resources::MaterialBlendFactor::SrcColor:
        return RHI::BlendFactor::SrcColor;
    case Resources::MaterialBlendFactor::InvSrcColor:
        return RHI::BlendFactor::InvSrcColor;
    case Resources::MaterialBlendFactor::SrcAlpha:
        return RHI::BlendFactor::SrcAlpha;
    case Resources::MaterialBlendFactor::InvSrcAlpha:
        return RHI::BlendFactor::InvSrcAlpha;
    case Resources::MaterialBlendFactor::DstAlpha:
        return RHI::BlendFactor::DstAlpha;
    case Resources::MaterialBlendFactor::InvDstAlpha:
        return RHI::BlendFactor::InvDstAlpha;
    case Resources::MaterialBlendFactor::DstColor:
        return RHI::BlendFactor::DstColor;
    case Resources::MaterialBlendFactor::InvDstColor:
        return RHI::BlendFactor::InvDstColor;
    case Resources::MaterialBlendFactor::SrcAlphaSat:
        return RHI::BlendFactor::SrcAlphaSat;
    case Resources::MaterialBlendFactor::BlendFactor:
        return RHI::BlendFactor::BlendFactor;
    case Resources::MaterialBlendFactor::InvBlendFactor:
        return RHI::BlendFactor::InvBlendFactor;
    case Resources::MaterialBlendFactor::Src1Color:
        return RHI::BlendFactor::Src1Color;
    case Resources::MaterialBlendFactor::InvSrc1Color:
        return RHI::BlendFactor::InvSrc1Color;
    case Resources::MaterialBlendFactor::Src1Alpha:
        return RHI::BlendFactor::Src1Alpha;
    case Resources::MaterialBlendFactor::InvSrc1Alpha:
        return RHI::BlendFactor::InvSrc1Alpha;
    case Resources::MaterialBlendFactor::One:
    default:
        return RHI::BlendFactor::One;
    }
}

inline RHI::BlendOp ToRHIBlendOp(Resources::MaterialBlendOp op) {
    switch (op) {
    case Resources::MaterialBlendOp::Subtract:
        return RHI::BlendOp::Subtract;
    case Resources::MaterialBlendOp::ReverseSubtract:
        return RHI::BlendOp::ReverseSubtract;
    case Resources::MaterialBlendOp::Min:
        return RHI::BlendOp::Min;
    case Resources::MaterialBlendOp::Max:
        return RHI::BlendOp::Max;
    case Resources::MaterialBlendOp::Add:
    default:
        return RHI::BlendOp::Add;
    }
}

inline RHI::RasterizerDesc BuildRasterizerState(const Resources::Material* material) {
    RHI::RasterizerDesc desc = {};
    desc.fillMode = static_cast<uint32_t>(RHI::FillMode::Solid);
    desc.cullMode = static_cast<uint32_t>(RHI::CullMode::None);
    desc.frontFace = static_cast<uint32_t>(RHI::FrontFace::CounterClockwise);
    desc.depthClipEnable = true;

    if (material != nullptr) {
        const Resources::MaterialRenderState& renderState = material->GetRenderState();
        desc.cullMode = static_cast<uint32_t>(ToRHICullMode(renderState.cullMode));
    }

    return desc;
}

inline RHI::BlendDesc BuildBlendState(const Resources::Material* material) {
    RHI::BlendDesc desc = {};
    if (material != nullptr) {
        const Resources::MaterialRenderState& renderState = material->GetRenderState();
        desc.blendEnable = renderState.blendEnable;
        desc.srcBlend = static_cast<uint32_t>(ToRHIBlendFactor(renderState.srcBlend));
        desc.dstBlend = static_cast<uint32_t>(ToRHIBlendFactor(renderState.dstBlend));
        desc.srcBlendAlpha = static_cast<uint32_t>(ToRHIBlendFactor(renderState.srcBlendAlpha));
        desc.dstBlendAlpha = static_cast<uint32_t>(ToRHIBlendFactor(renderState.dstBlendAlpha));
        desc.blendOp = static_cast<uint32_t>(ToRHIBlendOp(renderState.blendOp));
        desc.blendOpAlpha = static_cast<uint32_t>(ToRHIBlendOp(renderState.blendOpAlpha));
        desc.colorWriteMask = renderState.colorWriteMask;
    }

    return desc;
}

inline RHI::DepthStencilStateDesc BuildDepthStencilState(const Resources::Material* material) {
    RHI::DepthStencilStateDesc desc = {};
    desc.depthTestEnable = true;
    desc.depthWriteEnable = true;
    desc.depthFunc = static_cast<uint32_t>(RHI::ComparisonFunc::Less);
    desc.stencilEnable = false;

    if (material != nullptr) {
        const Resources::MaterialRenderState& renderState = material->GetRenderState();
        desc.depthTestEnable = renderState.depthTestEnable;
        desc.depthWriteEnable = renderState.depthWriteEnable;
        desc.depthFunc = static_cast<uint32_t>(ToRHIComparisonFunc(renderState.depthFunc));
    }

    return desc;
}

inline void ApplyMaterialRenderState(const Resources::Material* material, RHI::GraphicsPipelineDesc& pipelineDesc) {
    pipelineDesc.rasterizerState = BuildRasterizerState(material);
    pipelineDesc.blendState = BuildBlendState(material);
    pipelineDesc.depthStencilState = BuildDepthStencilState(material);
}

struct MaterialRenderStateHash {
    size_t operator()(const Resources::MaterialRenderState& state) const noexcept {
        size_t hash = 2166136261u;
        auto combine = [&hash](size_t value) {
            hash ^= value + 0x9e3779b9u + (hash << 6) + (hash >> 2);
        };

        combine(static_cast<size_t>(state.blendEnable));
        combine(static_cast<size_t>(state.srcBlend));
        combine(static_cast<size_t>(state.dstBlend));
        combine(static_cast<size_t>(state.srcBlendAlpha));
        combine(static_cast<size_t>(state.dstBlendAlpha));
        combine(static_cast<size_t>(state.blendOp));
        combine(static_cast<size_t>(state.blendOpAlpha));
        combine(static_cast<size_t>(state.colorWriteMask));
        combine(static_cast<size_t>(state.depthTestEnable));
        combine(static_cast<size_t>(state.depthWriteEnable));
        combine(static_cast<size_t>(state.depthFunc));
        combine(static_cast<size_t>(state.cullMode));
        return hash;
    }
};

} // namespace Rendering
} // namespace XCEngine