metaforce/Shaders/shader_CFluidPlaneShader.hpp

#pragma once
#include "hecl/PipelineBase.hpp"
#include "athena/Global.hpp"
#include "hecl/hecl.hpp"

#ifndef URDE_MAX_LIGHTS
#define URDE_MAX_LIGHTS 8
#endif

enum class EFluidType
{
    NormalWater,
    PoisonWater,
    Lava,
    PhazonFluid,
    Four,
    ThickLava
};

struct SFluidPlaneShaderInfo
{
    EFluidType m_type;
    bool m_hasPatternTex1;
    bool m_hasPatternTex2;
    bool m_hasColorTex;
    bool m_hasBumpMap;
    bool m_hasEnvMap;
    bool m_hasEnvBumpMap;
    bool m_hasLightmap;
    bool m_tessellation;
    bool m_doubleLightmapBlend;
    bool m_additive;

    SFluidPlaneShaderInfo(EFluidType type, bool hasPatternTex1, bool hasPatternTex2, bool hasColorTex,
                          bool hasBumpMap, bool hasEnvMap, bool hasEnvBumpMap, bool hasLightmap,
                          bool tessellation, bool doubleLightmapBlend, bool additive)
        : m_type(type), m_hasPatternTex1(hasPatternTex1), m_hasPatternTex2(hasPatternTex2), m_hasColorTex(hasColorTex),
          m_hasBumpMap(hasBumpMap), m_hasEnvMap(hasEnvMap), m_hasEnvBumpMap(hasEnvBumpMap), m_hasLightmap(hasLightmap),
          m_tessellation(tessellation), m_doubleLightmapBlend(doubleLightmapBlend), m_additive(additive)
    {}
};

struct SFluidPlaneDoorShaderInfo
{
    bool m_hasPatternTex1;
    bool m_hasPatternTex2;
    bool m_hasColorTex;

    SFluidPlaneDoorShaderInfo(bool hasPatternTex1, bool hasPatternTex2, bool hasColorTex)
        : m_hasPatternTex1(hasPatternTex1), m_hasPatternTex2(hasPatternTex2), m_hasColorTex(hasColorTex)
    {}
};

class Shader_CFluidPlaneShader : public hecl::TessellationShader
{
    friend class Shader_CFluidPlaneDoorShader;
    static const boo::VertexElementDescriptor VtxFmtElems[5];
    static const boo::VertexElementDescriptor TessVtxFmtElems[3];
    const SFluidPlaneShaderInfo& m_info;
public:
    Shader_CFluidPlaneShader(const SFluidPlaneShaderInfo& in, bool tessellation)
    : m_info(in), VtxFmt(tessellation ? boo::VertexFormatInfo(TessVtxFmtElems) : boo::VertexFormatInfo(VtxFmtElems)),
    PipelineInfo({in.m_additive ? boo::BlendFactor::One : boo::BlendFactor::SrcAlpha,
                  in.m_additive ? boo::BlendFactor::One : boo::BlendFactor::InvSrcAlpha,
                  boo::Primitive::TriStrips, boo::ZTest::LEqual, false, true, false,
                  boo::CullMode::None, tessellation ? 1u : 0u}),
    HasTessellation(tessellation) {}

    const boo::VertexFormatInfo VtxFmt;
    const boo::AdditionalPipelineInfo PipelineInfo;
    bool HasTessellation;
    static constexpr bool HasHash = false;
    static constexpr uint64_t Hash() { return 0; }
    const SFluidPlaneShaderInfo& info() const { return m_info; }
};

template<typename P, typename S>
class StageObject_CFluidPlaneShader : public hecl::StageBinary<P, S>
{
    static std::string BuildShader(const SFluidPlaneShaderInfo& in, bool tessellation);
public:
    StageObject_CFluidPlaneShader(hecl::StageConverter<P, S>& conv, hecl::FactoryCtx& ctx,
                                  const Shader_CFluidPlaneShader& in)
    : hecl::StageBinary<P, S>(conv, ctx, hecl::StageSourceText<P, S>(BuildShader(in.info(), in.HasTessellation))) {}
};

class Shader_CFluidPlaneDoorShader : public hecl::GeneralShader
{
    const SFluidPlaneDoorShaderInfo& m_info;
public:
    explicit Shader_CFluidPlaneDoorShader(const SFluidPlaneDoorShaderInfo& in)
    : m_info(in), VtxFmt(boo::VertexFormatInfo(Shader_CFluidPlaneShader::VtxFmtElems)),
      PipelineInfo({boo::BlendFactor::SrcAlpha, boo::BlendFactor::InvSrcAlpha,
                    boo::Primitive::TriStrips, boo::ZTest::LEqual, false, true, false,
                    boo::CullMode::None}) {}

    const boo::VertexFormatInfo VtxFmt;
    const boo::AdditionalPipelineInfo PipelineInfo;
    static constexpr bool HasHash = false;
    static constexpr uint64_t Hash() { return 0; }
    const SFluidPlaneDoorShaderInfo& info() const { return m_info; }
};

template<typename P, typename S>
class StageObject_CFluidPlaneDoorShader : public hecl::StageBinary<P, S>
{
    static std::string BuildShader(const SFluidPlaneDoorShaderInfo& in);
public:
    StageObject_CFluidPlaneDoorShader(hecl::StageConverter<P, S>& conv, hecl::FactoryCtx& ctx,
                                      const Shader_CFluidPlaneDoorShader& in)
    : hecl::StageBinary<P, S>(conv, ctx, hecl::StageSourceText<P, S>(BuildShader(in.info()))) {}
};

#define UNIVERSAL_PIPELINES_shader_CFluidPlaneShader \
::Shader_CFluidPlaneShader \
::Shader_CFluidPlaneDoorShader
#define STAGES_shader_CFluidPlaneShader(P, S) \
::StageObject_CFluidPlaneShader<P, S>, \
::StageObject_CFluidPlaneDoorShader<P, S>,