summaryrefslogtreecommitdiffstats
path: root/src/shader_recompiler/varying_state.h
blob: 7b28a285f9a44a35de7cdcf6bd84f51150b1774a (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later

#pragma once

#include <bitset>
#include <cstddef>

#include "shader_recompiler/frontend/ir/attribute.h"

namespace Shader {

struct VaryingState {
    std::bitset<256> mask{};

    void Set(IR::Attribute attribute, bool state = true) {
        mask[static_cast<size_t>(attribute)] = state;
    }

    [[nodiscard]] bool operator[](IR::Attribute attribute) const noexcept {
        return mask[static_cast<size_t>(attribute)];
    }

    [[nodiscard]] bool AnyComponent(IR::Attribute base) const noexcept {
        return mask[static_cast<size_t>(base) + 0] || mask[static_cast<size_t>(base) + 1] ||
               mask[static_cast<size_t>(base) + 2] || mask[static_cast<size_t>(base) + 3];
    }

    [[nodiscard]] bool AllComponents(IR::Attribute base) const noexcept {
        return mask[static_cast<size_t>(base) + 0] && mask[static_cast<size_t>(base) + 1] &&
               mask[static_cast<size_t>(base) + 2] && mask[static_cast<size_t>(base) + 3];
    }

    [[nodiscard]] bool IsUniform(IR::Attribute base) const noexcept {
        return AnyComponent(base) == AllComponents(base);
    }

    [[nodiscard]] bool Generic(size_t index, size_t component) const noexcept {
        return mask[static_cast<size_t>(IR::Attribute::Generic0X) + index * 4 + component];
    }

    [[nodiscard]] bool Generic(size_t index) const noexcept {
        return Generic(index, 0) || Generic(index, 1) || Generic(index, 2) || Generic(index, 3);
    }

    [[nodiscard]] bool ClipDistances() const noexcept {
        return AnyComponent(IR::Attribute::ClipDistance0) ||
               AnyComponent(IR::Attribute::ClipDistance4);
    }

    [[nodiscard]] bool Legacy() const noexcept {
        return AnyComponent(IR::Attribute::ColorFrontDiffuseR) ||
               AnyComponent(IR::Attribute::ColorFrontSpecularR) ||
               AnyComponent(IR::Attribute::ColorBackDiffuseR) ||
               AnyComponent(IR::Attribute::ColorBackSpecularR) || FixedFunctionTexture() ||
               mask[static_cast<size_t>(IR::Attribute::FogCoordinate)];
    }

    [[nodiscard]] bool FixedFunctionTexture() const noexcept {
        for (size_t index = 0; index < 10; ++index) {
            if (AnyComponent(IR::Attribute::FixedFncTexture0S + index * 4)) {
                return true;
            }
        }
        return false;
    }
};

} // namespace Shader