path: root/src/video_core/renderer_vulkan/fixed_pipeline_state.cpp

// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later

// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later

#include <algorithm>
#include <cstring>
#include <bit>
#include <numeric>
#include <ranges>
#include "common/cityhash.h"
#include "common/common_types.h"
#include "common/settings.h"
#include "video_core/engines/maxwell_3d.h"
#include "video_core/renderer_vulkan/fixed_pipeline_state.h"
#include "video_core/renderer_vulkan/vertex_repack.h"
#include "video_core/renderer_vulkan/vk_state_tracker.h"

namespace Vulkan {
namespace {
constexpr size_t POINT = 0;
constexpr size_t LINE = 1;
constexpr size_t POLYGON = 2;
constexpr std::array POLYGON_OFFSET_ENABLE_LUT = {
    POINT,   // Points
    LINE,    // Lines
    LINE,    // LineLoop
    LINE,    // LineStrip
    POLYGON, // Triangles
    POLYGON, // TriangleStrip
    POLYGON, // TriangleFan
    POLYGON, // Quads
    POLYGON, // QuadStrip
    POLYGON, // Polygon
    LINE,    // LinesAdjacency
    LINE,    // LineStripAdjacency
    POLYGON, // TrianglesAdjacency
    POLYGON, // TriangleStripAdjacency
    POLYGON, // Patches
};

constexpr std::array TOPOLOGY_CLASS_REPRESENTATIVE_LUT = {
    Maxwell::PrimitiveTopology::Points,              // Points
    Maxwell::PrimitiveTopology::Lines,               // Lines
    Maxwell::PrimitiveTopology::LineLoop,            // LineLoop
    Maxwell::PrimitiveTopology::LineStrip,           // LineStrip
    Maxwell::PrimitiveTopology::Triangles,           // Triangles
    Maxwell::PrimitiveTopology::Triangles,           // TriangleStrip
    Maxwell::PrimitiveTopology::Triangles,           // TriangleFan
    Maxwell::PrimitiveTopology::Triangles,           // Quads
    Maxwell::PrimitiveTopology::Triangles,           // QuadStrip
    Maxwell::PrimitiveTopology::Triangles,           // Polygon
    Maxwell::PrimitiveTopology::LinesAdjacency,      // LinesAdjacency
    Maxwell::PrimitiveTopology::LinesAdjacency,      // LineStripAdjacency
    Maxwell::PrimitiveTopology::TrianglesAdjacency,  // TrianglesAdjacency
    Maxwell::PrimitiveTopology::TrianglesAdjacency,  // TriangleStripAdjacency
    Maxwell::PrimitiveTopology::Patches,             // Patches
};

bool IsDualSourceBlendFactor(Maxwell::Blend::Factor factor) {
    using F = Maxwell::Blend::Factor;
    switch (factor) {
    case F::Source1Color_D3D:
    case F::OneMinusSource1Color_D3D:
    case F::Source1Alpha_D3D:
    case F::OneMinusSource1Alpha_D3D:
    case F::Source1Color_GL:
    case F::OneMinusSource1Color_GL:
    case F::Source1Alpha_GL:
    case F::OneMinusSource1Alpha_GL:
        return true;
    default:
        return false;
    }
}

bool ComputeAttachment0DualSourceBlend(const Maxwell& regs) {
    if (!regs.blend.enable[0]) {
        return false;
    }
    const auto uses_dual_source = [](const auto& blend) {
        return IsDualSourceBlendFactor(blend.color_source) ||
               IsDualSourceBlendFactor(blend.color_dest) ||
               IsDualSourceBlendFactor(blend.alpha_source) ||
               IsDualSourceBlendFactor(blend.alpha_dest);
    };
    return regs.blend_per_target_enabled ? uses_dual_source(regs.blend_per_target[0])
                                         : uses_dual_source(regs.blend);
}

void RefreshXfbState(VideoCommon::TransformFeedbackState& state, const Maxwell& regs) {
    std::ranges::transform(regs.transform_feedback.controls, state.layouts.begin(),
                           [](const auto& layout) {
                               return VideoCommon::TransformFeedbackState::Layout{
                                   .stream = layout.stream,
                                   .varying_count = layout.varying_count,
                                   .stride = layout.stride,
                               };
                           });
    state.varyings = regs.stream_out_layout;
}
} // Anonymous namespace

void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d, DynamicFeatures& features) {
    const Maxwell& regs = maxwell3d.regs;
    const auto topology_ = maxwell3d.draw_manager.draw_state.topology;

    driver_id = features.driver_id;
    driver_version = features.driver_version;

    raw1 = 0;
    extended_dynamic_state.Assign(features.has_extended_dynamic_state ? 1 : 0);
    extended_dynamic_state_2.Assign(features.has_extended_dynamic_state_2 ? 1 : 0);
    extended_dynamic_state_2_logic_op.Assign(features.has_extended_dynamic_state_2_logic_op ? 1 : 0);
    extended_dynamic_state_3_blend.Assign(features.has_extended_dynamic_state_3_blend ? 1 : 0);
    extended_dynamic_state_3_enables.Assign(features.has_extended_dynamic_state_3_enables ? 1 : 0);
    color_write_enable_dynamic.Assign(features.has_color_write_enable ? 1 : 0);
    dynamic_vertex_input.Assign(features.has_dynamic_vertex_input ? 1 : 0);
    xfb_enabled.Assign(regs.transform_feedback_enabled != 0);
    ndc_minus_one_to_one.Assign(regs.depth_mode == Maxwell::DepthMode::MinusOneToOne ? 1 : 0);
    polygon_mode.Assign(PackPolygonMode(regs.polygon_mode_front));
    tessellation_primitive.Assign(static_cast<u32>(regs.tessellation.params.domain_type.Value()));
    tessellation_spacing.Assign(static_cast<u32>(regs.tessellation.params.spacing.Value()));
    tessellation_clockwise.Assign(regs.tessellation.params.output_primitives.Value() ==
                                  Maxwell::Tessellation::OutputPrimitives::Triangles_CW);
    patch_control_points_minus_one.Assign(regs.patch_vertices - 1);
    const bool can_collapse_topology_class =
        features.has_extended_dynamic_state && features.has_extended_dynamic_state_2;
    topology.Assign(can_collapse_topology_class
                        ? TOPOLOGY_CLASS_REPRESENTATIVE_LUT[static_cast<size_t>(topology_)]
                        : topology_);
    msaa_mode.Assign(regs.anti_alias_samples_mode);
    attachment0_dual_source_blend.Assign(ComputeAttachment0DualSourceBlend(regs) ? 1 : 0);

    raw2 = 0;

    const auto test_func =
        regs.alpha_test_enabled != 0 ? regs.alpha_test_func : Maxwell::ComparisonOp::Always_GL;
    alpha_test_func.Assign(PackComparisonOp(test_func));
    early_z.Assign(regs.mandated_early_z != 0 ? 1 : 0);
    depth_enabled.Assign(regs.zeta_enable != 0 ? 1 : 0);
    depth_format.Assign(static_cast<u32>(regs.zeta.format));
    y_negate.Assign(regs.window_origin.mode != Maxwell::WindowOrigin::Mode::UpperLeft ? 1 : 0);

    bool use_last_provoking_vertex = false;
    const bool provoking_vertex_available = features.has_provoking_vertex;
    const bool supports_first_mode = features.has_provoking_vertex_first_mode;
    const bool supports_last_mode = features.has_provoking_vertex_last_mode;
    const bool transform_feedback_active = regs.transform_feedback_enabled != 0;
    const bool tf_preserves_provoking_vertex = features.has_provoking_vertex_tf_preserve;

    if (provoking_vertex_available && (supports_first_mode || supports_last_mode)) {
        use_last_provoking_vertex = regs.provoking_vertex == Maxwell::ProvokingVertex::Last;

        if (transform_feedback_active && !tf_preserves_provoking_vertex) {
            use_last_provoking_vertex = false;
        }

        if (use_last_provoking_vertex && !supports_last_mode) {
            use_last_provoking_vertex = false;
        } else if (!use_last_provoking_vertex && !supports_first_mode) {
            use_last_provoking_vertex = true;
        }
    }

    provoking_vertex_last.Assign(use_last_provoking_vertex ? 1 : 0);
    conservative_raster_enable.Assign(regs.conservative_raster_enable != 0 ? 1 : 0);
    smooth_lines.Assign(regs.line_anti_alias_enable != 0 ? 1 : 0);
    alpha_to_coverage_enabled.Assign(regs.anti_alias_alpha_control.alpha_to_coverage != 0 ? 1 : 0);
    alpha_to_one_enabled.Assign(regs.anti_alias_alpha_control.alpha_to_one != 0 ? 1 : 0);
    app_stage.Assign(maxwell3d.engine_state);

    depth_bounds_min = static_cast<u32>(regs.depth_bounds[0]);
    depth_bounds_max = static_cast<u32>(regs.depth_bounds[1]);

    line_stipple_factor = regs.line_stipple_params.factor;
    line_stipple_pattern = regs.line_stipple_params.pattern;

    for (size_t i = 0; i < regs.rt.size(); ++i) {
        color_formats[i] = static_cast<u8>(regs.rt[i].format);
    }
    // The reference is part of the pipeline only while the test compares with it: title 1
    // animates the register with the test off (text fading in and out), which made a new
    // pipeline, translated on the GPU thread, for every value (~84% of its runtime pipelines).
    const u32 packed_alpha_test = alpha_test_func.Value();
    alpha_test_ref = packed_alpha_test != PackComparisonOp(Maxwell::ComparisonOp::Never_GL) &&
                             packed_alpha_test != PackComparisonOp(Maxwell::ComparisonOp::Always_GL)
                         ? std::bit_cast<u32>(regs.alpha_test_ref)
                         : 0;
    point_size = std::bit_cast<u32>(regs.point_size);

    if (maxwell3d.dirty.flags[Dirty::VertexInput]) {
        if (features.has_dynamic_vertex_input) {
            // Dirty flag will be reset by the command buffer update
            static constexpr std::array LUT{
                0u, // Invalid
                1u, // SignedNorm
                1u, // UnsignedNorm
                2u, // SignedInt
                3u, // UnsignedInt
                1u, // UnsignedScaled
                1u, // SignedScaled
                1u, // Float
            };
            const auto& attrs = regs.vertex_attrib_format;
            attribute_types = 0;
            for (size_t i = 0; i < Maxwell::NumVertexAttributes; ++i) {
                const u32 mask = attrs[i].constant != 0 ? 0 : 3;
                const u32 type = LUT[static_cast<size_t>(attrs[i].type.Value())];
                attribute_types |= static_cast<u64>(type & mask) << (i * 2);
            }
        } else {
            maxwell3d.dirty.flags[Dirty::VertexInput] = false;
            enabled_divisors = 0;
            for (size_t index = 0; index < Maxwell::NumVertexArrays; ++index) {
                const bool is_enabled = regs.vertex_stream_instances.IsInstancingEnabled(index);
                binding_divisors[index] = is_enabled ? regs.vertex_streams[index].frequency : 0;
                enabled_divisors |= (is_enabled ? u64{1} : 0) << index;
            }
            for (size_t index = 0; index < Maxwell::NumVertexAttributes; ++index) {
                const auto& input = regs.vertex_attrib_format[index];
                auto& attribute = attributes[index];
                attribute.raw = 0;
                attribute.enabled.Assign(input.constant ? 0 : 1);
                attribute.buffer.Assign(input.buffer);
                attribute.offset.Assign(input.offset);
                attribute.type.Assign(static_cast<u32>(input.type.Value()));
                attribute.size.Assign(static_cast<u32>(input.size.Value()));
            }
        }
    }
    if (maxwell3d.dirty.flags[Dirty::ViewportSwizzles]) {
        maxwell3d.dirty.flags[Dirty::ViewportSwizzles] = false;
        const auto& transform = regs.viewport_transform;
        std::ranges::transform(transform, viewport_swizzles.begin(), [](const auto& viewport) {
            return static_cast<u16>(viewport.swizzle.raw);
        });
    }
    dynamic_state.raw1 = 0;
    dynamic_state.raw2 = 0;
    if (!extended_dynamic_state) {
        dynamic_state.Refresh(regs);
        std::ranges::transform(regs.vertex_streams, vertex_strides.begin(), [](const auto& array) {
            return static_cast<u16>(array.stride.Value());
        });
    }
    if (!extended_dynamic_state_2_logic_op) {
        dynamic_state.Refresh2(regs, topology_, extended_dynamic_state_2);
    }
    if (!extended_dynamic_state_3_blend) {
        if (maxwell3d.dirty.flags[Dirty::Blending]) {
            maxwell3d.dirty.flags[Dirty::Blending] = false;
            for (size_t index = 0; index < attachments.size(); ++index) {
                attachments[index].Refresh(regs, index);
                auto& attachment = attachments[index];
                if (color_write_enable_dynamic && attachment.mask_r == 0 &&
                    attachment.mask_g == 0 && attachment.mask_b == 0 &&
                    attachment.mask_a == 0) {
                    attachment.mask_r.Assign(1);
                    attachment.mask_g.Assign(1);
                    attachment.mask_b.Assign(1);
                    attachment.mask_a.Assign(1);
                }
            }
        }
    }
    dynamic_state.Refresh3(regs, features);
    if (xfb_enabled) {
        RefreshXfbState(xfb_state, regs);
    }
    if (!dynamic_vertex_input && features.has_static_vertex_repack) {
        const u32 repack_mask = VertexRepackMask(regs);
        // Refresh from guest values even when only the stride changed: offsets must not accumulate.
        for (size_t index = 0; index < attributes.size(); ++index) {
            const auto& input = regs.vertex_attrib_format[index];
            attributes[index].offset.Assign(RepackedVertexOffset(repack_mask, input.buffer, input.offset));
        }
        for (u32 binding = 0; binding < vertex_strides.size(); ++binding) {
            vertex_strides[binding] = static_cast<u16>(RepackedVertexStride(
                repack_mask, binding, regs.vertex_streams[binding].stride));
        }
    }
}

void FixedPipelineState::BlendingAttachment::Refresh(const Maxwell& regs, size_t index) {
    const auto& mask = regs.color_mask[regs.color_mask_common ? 0 : index];

    raw = 0;
    mask_r.Assign(mask.R);
    mask_g.Assign(mask.G);
    mask_b.Assign(mask.B);
    mask_a.Assign(mask.A);

    // TODO: C++20 Use templated lambda to deduplicate code
    if (!regs.blend.enable[index]) {
        return;
    }

    const auto setup_blend = [&]<typename T>(const T& src) {
        equation_rgb.Assign(PackBlendEquation(src.color_op));
        equation_a.Assign(PackBlendEquation(src.alpha_op));
        factor_source_rgb.Assign(PackBlendFactor(src.color_source));
        factor_dest_rgb.Assign(PackBlendFactor(src.color_dest));
        factor_source_a.Assign(PackBlendFactor(src.alpha_source));
        factor_dest_a.Assign(PackBlendFactor(src.alpha_dest));
        enable.Assign(1);
    };

    if (!regs.blend_per_target_enabled) {
        // Temporary workaround for games that use iterated blending
        // even when dynamic blending is off so overrides work with EDS = 0 as well
        if (regs.iterated_blend.enable && Settings::values.use_squashed_iterated_blend) {
            equation_rgb.Assign(PackBlendEquation(Maxwell::Blend::Equation::Add_GL));
            equation_a.Assign(PackBlendEquation(Maxwell::Blend::Equation::Add_GL));
            factor_source_rgb.Assign(PackBlendFactor(Maxwell::Blend::Factor::One_GL));
            factor_dest_rgb.Assign(PackBlendFactor(Maxwell::Blend::Factor::One_GL));
            factor_source_a.Assign(
                PackBlendFactor(Maxwell::Blend::Factor::OneMinusSourceColor_GL));
            factor_dest_a.Assign(PackBlendFactor(Maxwell::Blend::Factor::Zero_GL));
            enable.Assign(1);
            return;
        }
        setup_blend(regs.blend);
        return;
    }
    setup_blend(regs.blend_per_target[index]);
}

void FixedPipelineState::DynamicState::Refresh(const Maxwell& regs) {
    u32 packed_front_face = PackFrontFace(regs.gl_front_face);
    if (regs.window_origin.flip_y != 0) {
        // Flip front face
        packed_front_face = 1 - packed_front_face;
    }

    front.action_stencil_fail.Assign(PackStencilOp(regs.stencil_front_op.fail));
    front.action_depth_fail.Assign(PackStencilOp(regs.stencil_front_op.zfail));
    front.action_depth_pass.Assign(PackStencilOp(regs.stencil_front_op.zpass));
    front.test_func.Assign(PackComparisonOp(regs.stencil_front_op.func));
    if (regs.stencil_two_side_enable) {
        back.action_stencil_fail.Assign(PackStencilOp(regs.stencil_back_op.fail));
        back.action_depth_fail.Assign(PackStencilOp(regs.stencil_back_op.zfail));
        back.action_depth_pass.Assign(PackStencilOp(regs.stencil_back_op.zpass));
        back.test_func.Assign(PackComparisonOp(regs.stencil_back_op.func));
    } else {
        back.action_stencil_fail.Assign(front.action_stencil_fail);
        back.action_depth_fail.Assign(front.action_depth_fail);
        back.action_depth_pass.Assign(front.action_depth_pass);
        back.test_func.Assign(front.test_func);
    }
    stencil_enable.Assign(regs.stencil_enable);
    depth_write_enable.Assign(regs.depth_write_enabled);
    depth_bounds_enable.Assign(regs.depth_bounds_enable);
    depth_test_enable.Assign(regs.depth_test_enable);
    front_face.Assign(packed_front_face);
    depth_test_func.Assign(PackComparisonOp(regs.depth_test_func));
    cull_face.Assign(PackCullFace(regs.gl_cull_face));
    cull_enable.Assign(regs.gl_cull_test_enabled != 0 ? 1 : 0);
}

void FixedPipelineState::DynamicState::Refresh2(const Maxwell& regs,
                                                Maxwell::PrimitiveTopology topology_,
                                                bool base_features_supported) {
    logic_op.Assign(PackLogicOp(regs.logic_op.op));

    if (base_features_supported) {
        return;
    }

    const std::array enabled_lut{
        regs.polygon_offset_point_enable,
        regs.polygon_offset_line_enable,
        regs.polygon_offset_fill_enable,
    };
    const u32 topology_index = static_cast<u32>(topology_);

    rasterize_enable.Assign(regs.rasterize_enable != 0 ? 1 : 0);
    primitive_restart_enable.Assign(regs.primitive_restart.enabled != 0 ? 1 : 0);
    depth_bias_enable.Assign(enabled_lut[POLYGON_OFFSET_ENABLE_LUT[topology_index]] != 0 ? 1 : 0);
}

void FixedPipelineState::DynamicState::Refresh3(const Maxwell& regs,
                                                const DynamicFeatures& features) {
    if (!features.has_dynamic_state3_logic_op_enable) {
        logic_op_enable.Assign(regs.logic_op.enable != 0 ? 1 : 0);
    }
    if (!features.has_dynamic_state3_depth_clamp_enable) {
        depth_clamp_disabled.Assign(regs.viewport_clip_control.geometry_clip ==
                                        Maxwell::ViewportClipControl::GeometryClip::Passthrough ||
                                    regs.viewport_clip_control.geometry_clip ==
                                        Maxwell::ViewportClipControl::GeometryClip::FrustumXYZ ||
                                    regs.viewport_clip_control.geometry_clip ==
                                        Maxwell::ViewportClipControl::GeometryClip::FrustumZ);
    }
    if (!features.has_dynamic_state3_line_stipple_enable) {
        line_stipple_enable.Assign(regs.line_stipple_enable);
    }
}

size_t FixedPipelineState::Hash() const noexcept {
    const u64 hash = Common::CityHash64(reinterpret_cast<const char*>(this), Size());
    return static_cast<size_t>(hash);
}

bool FixedPipelineState::operator==(const FixedPipelineState& rhs) const noexcept {
    return std::memcmp(this, &rhs, Size()) == 0;
}

u32 FixedPipelineState::PackComparisonOp(Maxwell::ComparisonOp op) noexcept {
    // OpenGL enums go from 0x200 to 0x207 and the others from 1 to 8
    // If we subtract 0x200 to OpenGL enums and 1 to the others we get a 0-7 range.
    // Perfect for a hash.
    const u32 value = static_cast<u32>(op);
    return value - (value >= 0x200 ? 0x200 : 1);
}

Maxwell::ComparisonOp FixedPipelineState::UnpackComparisonOp(u32 packed) noexcept {
    // Read PackComparisonOp for the logic behind this.
    return static_cast<Maxwell::ComparisonOp>(packed + 1);
}

u32 FixedPipelineState::PackStencilOp(Maxwell::StencilOp::Op op) noexcept {
    switch (op) {
    case Maxwell::StencilOp::Op::Keep_D3D:
    case Maxwell::StencilOp::Op::Keep_GL:
        return 0;
    case Maxwell::StencilOp::Op::Zero_D3D:
    case Maxwell::StencilOp::Op::Zero_GL:
        return 1;
    case Maxwell::StencilOp::Op::Replace_D3D:
    case Maxwell::StencilOp::Op::Replace_GL:
        return 2;
    case Maxwell::StencilOp::Op::IncrSaturate_D3D:
    case Maxwell::StencilOp::Op::IncrSaturate_GL:
        return 3;
    case Maxwell::StencilOp::Op::DecrSaturate_D3D:
    case Maxwell::StencilOp::Op::DecrSaturate_GL:
        return 4;
    case Maxwell::StencilOp::Op::Invert_D3D:
    case Maxwell::StencilOp::Op::Invert_GL:
        return 5;
    case Maxwell::StencilOp::Op::Incr_D3D:
    case Maxwell::StencilOp::Op::Incr_GL:
        return 6;
    case Maxwell::StencilOp::Op::Decr_D3D:
    case Maxwell::StencilOp::Op::Decr_GL:
        return 7;
    }
    return 0;
}

Maxwell::StencilOp::Op FixedPipelineState::UnpackStencilOp(u32 packed) noexcept {
    static constexpr std::array LUT = {
        Maxwell::StencilOp::Op::Keep_D3D,         Maxwell::StencilOp::Op::Zero_D3D,
        Maxwell::StencilOp::Op::Replace_D3D,      Maxwell::StencilOp::Op::IncrSaturate_D3D,
        Maxwell::StencilOp::Op::DecrSaturate_D3D, Maxwell::StencilOp::Op::Invert_D3D,
        Maxwell::StencilOp::Op::Incr_D3D,         Maxwell::StencilOp::Op::Decr_D3D};
    return LUT[packed];
}

u32 FixedPipelineState::PackCullFace(Maxwell::CullFace cull) noexcept {
    // FrontAndBack is 0x408, by subtracting 0x406 in it we get 2.
    // Individual cull faces are in 0x404 and 0x405, subtracting 0x404 we get 0 and 1.
    const u32 value = static_cast<u32>(cull);
    return value - (value == 0x408 ? 0x406 : 0x404);
}

Maxwell::CullFace FixedPipelineState::UnpackCullFace(u32 packed) noexcept {
    static constexpr std::array LUT = {Maxwell::CullFace::Front, Maxwell::CullFace::Back,
                                       Maxwell::CullFace::FrontAndBack};
    return LUT[packed];
}

u32 FixedPipelineState::PackFrontFace(Maxwell::FrontFace face) noexcept {
    return static_cast<u32>(face) - 0x900;
}

Maxwell::FrontFace FixedPipelineState::UnpackFrontFace(u32 packed) noexcept {
    return static_cast<Maxwell::FrontFace>(packed + 0x900);
}

u32 FixedPipelineState::PackPolygonMode(Maxwell::PolygonMode mode) noexcept {
    return static_cast<u32>(mode) - 0x1B00;
}

Maxwell::PolygonMode FixedPipelineState::UnpackPolygonMode(u32 packed) noexcept {
    return static_cast<Maxwell::PolygonMode>(packed + 0x1B00);
}

u32 FixedPipelineState::PackLogicOp(Maxwell::LogicOp::Op op) noexcept {
    return static_cast<u32>(op) - 0x1500;
}

Maxwell::LogicOp::Op FixedPipelineState::UnpackLogicOp(u32 packed) noexcept {
    return static_cast<Maxwell::LogicOp::Op>(packed + 0x1500);
}

u32 FixedPipelineState::PackBlendEquation(Maxwell::Blend::Equation equation) noexcept {
    switch (equation) {
    case Maxwell::Blend::Equation::Add_D3D:
    case Maxwell::Blend::Equation::Add_GL:
        return 0;
    case Maxwell::Blend::Equation::Subtract_D3D:
    case Maxwell::Blend::Equation::Subtract_GL:
        return 1;
    case Maxwell::Blend::Equation::ReverseSubtract_D3D:
    case Maxwell::Blend::Equation::ReverseSubtract_GL:
        return 2;
    case Maxwell::Blend::Equation::Min_D3D:
    case Maxwell::Blend::Equation::Min_GL:
        return 3;
    case Maxwell::Blend::Equation::Max_D3D:
    case Maxwell::Blend::Equation::Max_GL:
        return 4;
    }
    return 0;
}

Maxwell::Blend::Equation FixedPipelineState::UnpackBlendEquation(u32 packed) noexcept {
    static constexpr std::array LUT = {
        Maxwell::Blend::Equation::Add_D3D, Maxwell::Blend::Equation::Subtract_D3D,
        Maxwell::Blend::Equation::ReverseSubtract_D3D, Maxwell::Blend::Equation::Min_D3D,
        Maxwell::Blend::Equation::Max_D3D};
    return LUT[packed];
}

u32 FixedPipelineState::PackBlendFactor(Maxwell::Blend::Factor factor) noexcept {
    switch (factor) {
    case Maxwell::Blend::Factor::Zero_D3D:
    case Maxwell::Blend::Factor::Zero_GL:
        return 0;
    case Maxwell::Blend::Factor::One_D3D:
    case Maxwell::Blend::Factor::One_GL:
        return 1;
    case Maxwell::Blend::Factor::SourceColor_D3D:
    case Maxwell::Blend::Factor::SourceColor_GL:
        return 2;
    case Maxwell::Blend::Factor::OneMinusSourceColor_D3D:
    case Maxwell::Blend::Factor::OneMinusSourceColor_GL:
        return 3;
    case Maxwell::Blend::Factor::SourceAlpha_D3D:
    case Maxwell::Blend::Factor::SourceAlpha_GL:
        return 4;
    case Maxwell::Blend::Factor::OneMinusSourceAlpha_D3D:
    case Maxwell::Blend::Factor::OneMinusSourceAlpha_GL:
        return 5;
    case Maxwell::Blend::Factor::DestAlpha_D3D:
    case Maxwell::Blend::Factor::DestAlpha_GL:
        return 6;
    case Maxwell::Blend::Factor::OneMinusDestAlpha_D3D:
    case Maxwell::Blend::Factor::OneMinusDestAlpha_GL:
        return 7;
    case Maxwell::Blend::Factor::DestColor_D3D:
    case Maxwell::Blend::Factor::DestColor_GL:
        return 8;
    case Maxwell::Blend::Factor::OneMinusDestColor_D3D:
    case Maxwell::Blend::Factor::OneMinusDestColor_GL:
        return 9;
    case Maxwell::Blend::Factor::SourceAlphaSaturate_D3D:
    case Maxwell::Blend::Factor::SourceAlphaSaturate_GL:
        return 10;
    case Maxwell::Blend::Factor::Source1Color_D3D:
    case Maxwell::Blend::Factor::Source1Color_GL:
        return 11;
    case Maxwell::Blend::Factor::OneMinusSource1Color_D3D:
    case Maxwell::Blend::Factor::OneMinusSource1Color_GL:
        return 12;
    case Maxwell::Blend::Factor::Source1Alpha_D3D:
    case Maxwell::Blend::Factor::Source1Alpha_GL:
        return 13;
    case Maxwell::Blend::Factor::OneMinusSource1Alpha_D3D:
    case Maxwell::Blend::Factor::OneMinusSource1Alpha_GL:
        return 14;
    case Maxwell::Blend::Factor::BlendFactor_D3D:
    case Maxwell::Blend::Factor::ConstantColor_GL:
        return 15;
    case Maxwell::Blend::Factor::OneMinusBlendFactor_D3D:
    case Maxwell::Blend::Factor::OneMinusConstantColor_GL:
        return 16;
    case Maxwell::Blend::Factor::BothSourceAlpha_D3D:
    case Maxwell::Blend::Factor::ConstantAlpha_GL:
        return 17;
    case Maxwell::Blend::Factor::OneMinusBothSourceAlpha_D3D:
    case Maxwell::Blend::Factor::OneMinusConstantAlpha_GL:
        return 18;
    }
    UNIMPLEMENTED_MSG("Unknown blend factor {}", static_cast<u32>(factor));
    return 0;
}

Maxwell::Blend::Factor FixedPipelineState::UnpackBlendFactor(u32 packed) noexcept {
    static constexpr std::array LUT = {
        Maxwell::Blend::Factor::Zero_D3D,
        Maxwell::Blend::Factor::One_D3D,
        Maxwell::Blend::Factor::SourceColor_D3D,
        Maxwell::Blend::Factor::OneMinusSourceColor_D3D,
        Maxwell::Blend::Factor::SourceAlpha_D3D,
        Maxwell::Blend::Factor::OneMinusSourceAlpha_D3D,
        Maxwell::Blend::Factor::DestAlpha_D3D,
        Maxwell::Blend::Factor::OneMinusDestAlpha_D3D,
        Maxwell::Blend::Factor::DestColor_D3D,
        Maxwell::Blend::Factor::OneMinusDestColor_D3D,
        Maxwell::Blend::Factor::SourceAlphaSaturate_D3D,
        Maxwell::Blend::Factor::Source1Color_D3D,
        Maxwell::Blend::Factor::OneMinusSource1Color_D3D,
        Maxwell::Blend::Factor::Source1Alpha_D3D,
        Maxwell::Blend::Factor::OneMinusSource1Alpha_D3D,
        Maxwell::Blend::Factor::BlendFactor_D3D,
        Maxwell::Blend::Factor::OneMinusBlendFactor_D3D,
        Maxwell::Blend::Factor::BothSourceAlpha_D3D,
        Maxwell::Blend::Factor::OneMinusBothSourceAlpha_D3D,
    };
    ASSERT(packed < LUT.size());
    return LUT[packed];
}

} // namespace Vulkan