← Back to branch summary

~gabriel1984sibiu/minitube/qt5.6

« back to all changes in this revision

Viewing changes to src/3rdparty/angle/src/libANGLE/renderer/d3d/VaryingPacking.h

  • Committer: Grevutiu Gabriel
  • Date: 2017-06-13 08:43:17 UTC
  • Revision ID: gabriel1984sibiu@gmail.com-20170613084317-ek0zqe0u9g3ocvi8
Original upstream code

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/3rdparty/angle/src/libANGLE/renderer/d3d/VaryingPacking.h
 
1
//
 
2
// Copyright 2015 The ANGLE Project Authors. All rights reserved.
 
3
// Use of this source code is governed by a BSD-style license that can be
 
4
// found in the LICENSE file.
 
5
//
 
6
// VaryingPacking:
 
7
//   Class which describes a mapping from varyings to registers in D3D
 
8
//   for linking between shader stages.
 
9
//
 
10
 
 
11
#ifndef LIBANGLE_RENDERER_D3D_VARYINGPACKING_H_
 
12
#define LIBANGLE_RENDERER_D3D_VARYINGPACKING_H_
 
13
 
 
14
#include "libANGLE/renderer/d3d/RendererD3D.h"
 
15
 
 
16
namespace rx
 
17
{
 
18
class ProgramD3DMetadata;
 
19
 
 
20
struct PackedVarying
 
21
{
 
22
    PackedVarying(const sh::ShaderVariable &varyingIn, sh::InterpolationType interpolationIn)
 
23
        : varying(&varyingIn), vertexOnly(false), interpolation(interpolationIn)
 
24
    {
 
25
    }
 
26
    PackedVarying(const sh::ShaderVariable &varyingIn,
 
27
                  sh::InterpolationType interpolationIn,
 
28
                  const std::string &parentStructNameIn)
 
29
        : varying(&varyingIn),
 
30
          vertexOnly(false),
 
31
          interpolation(interpolationIn),
 
32
          parentStructName(parentStructNameIn)
 
33
    {
 
34
    }
 
35
 
 
36
    bool isStructField() const { return !parentStructName.empty(); }
 
37
 
 
38
    const sh::ShaderVariable *varying;
 
39
 
 
40
    // Transform feedback varyings can be only referenced in the VS.
 
41
    bool vertexOnly;
 
42
 
 
43
    // Cached so we can store sh::ShaderVariable to point to varying fields.
 
44
    sh::InterpolationType interpolation;
 
45
 
 
46
    // Struct name
 
47
    std::string parentStructName;
 
48
};
 
49
 
 
50
struct PackedVaryingRegister final
 
51
{
 
52
    PackedVaryingRegister()
 
53
        : packedVarying(nullptr),
 
54
          varyingArrayIndex(0),
 
55
          varyingRowIndex(0),
 
56
          registerRow(0),
 
57
          registerColumn(0)
 
58
    {
 
59
    }
 
60
 
 
61
    PackedVaryingRegister(const PackedVaryingRegister &) = default;
 
62
    PackedVaryingRegister &operator=(const PackedVaryingRegister &) = default;
 
63
 
 
64
    bool operator<(const PackedVaryingRegister &other) const
 
65
    {
 
66
        return sortOrder() < other.sortOrder();
 
67
    }
 
68
 
 
69
    unsigned int sortOrder() const
 
70
    {
 
71
        // TODO(jmadill): Handle interpolation types
 
72
        return registerRow * 4 + registerColumn;
 
73
    }
 
74
 
 
75
    bool isStructField() const { return !structFieldName.empty(); }
 
76
 
 
77
    // Index to the array of varyings.
 
78
    const PackedVarying *packedVarying;
 
79
 
 
80
    // The array element of the packed varying.
 
81
    unsigned int varyingArrayIndex;
 
82
 
 
83
    // The row of the array element of the packed varying.
 
84
    unsigned int varyingRowIndex;
 
85
 
 
86
    // The register row to which we've assigned this packed varying.
 
87
    unsigned int registerRow;
 
88
 
 
89
    // The column of the register row into which we've packed this varying.
 
90
    unsigned int registerColumn;
 
91
 
 
92
    // Assigned after packing
 
93
    unsigned int semanticIndex;
 
94
 
 
95
    // Struct member this varying corresponds to.
 
96
    std::string structFieldName;
 
97
};
 
98
 
 
99
class VaryingPacking final : angle::NonCopyable
 
100
{
 
101
  public:
 
102
    VaryingPacking(GLuint maxVaryingVectors);
 
103
 
 
104
    bool packVaryings(gl::InfoLog &infoLog,
 
105
                      const std::vector<PackedVarying> &packedVaryings,
 
106
                      const std::vector<std::string> &transformFeedbackVaryings);
 
107
 
 
108
    struct Register
 
109
    {
 
110
        Register() { data[0] = data[1] = data[2] = data[3] = false; }
 
111
 
 
112
        bool &operator[](unsigned int index) { return data[index]; }
 
113
        bool operator[](unsigned int index) const { return data[index]; }
 
114
 
 
115
        bool data[4];
 
116
    };
 
117
 
 
118
    Register &operator[](unsigned int index) { return mRegisterMap[index]; }
 
119
    const Register &operator[](unsigned int index) const { return mRegisterMap[index]; }
 
120
 
 
121
    const std::vector<PackedVaryingRegister> &getRegisterList() const { return mRegisterList; }
 
122
    unsigned int getMaxSemanticIndex() const
 
123
    {
 
124
        return static_cast<unsigned int>(mRegisterList.size());
 
125
    }
 
126
    unsigned int getRegisterCount() const;
 
127
 
 
128
    void enableBuiltins(ShaderType shaderType, const ProgramD3DMetadata &programMetadata);
 
129
 
 
130
    struct BuiltinVarying final : angle::NonCopyable
 
131
    {
 
132
        BuiltinVarying();
 
133
 
 
134
        std::string str() const;
 
135
        void enableSystem(const std::string &systemValueSemantic);
 
136
        void enable(const std::string &semanticVal, unsigned int indexVal);
 
137
 
 
138
        bool enabled;
 
139
        std::string semantic;
 
140
        unsigned int index;
 
141
        bool systemValue;
 
142
    };
 
143
 
 
144
    struct BuiltinInfo
 
145
    {
 
146
        BuiltinVarying dxPosition;
 
147
        BuiltinVarying glPosition;
 
148
        BuiltinVarying glFragCoord;
 
149
        BuiltinVarying glPointCoord;
 
150
        BuiltinVarying glPointSize;
 
151
    };
 
152
 
 
153
    const BuiltinInfo &builtins(ShaderType shaderType) const { return mBuiltinInfo[shaderType]; }
 
154
 
 
155
    bool usesPointSize() const { return mBuiltinInfo[SHADER_VERTEX].glPointSize.enabled; }
 
156
 
 
157
  private:
 
158
    bool packVarying(const PackedVarying &packedVarying);
 
159
    bool isFree(unsigned int registerRow,
 
160
                unsigned int registerColumn,
 
161
                unsigned int varyingRows,
 
162
                unsigned int varyingColumns) const;
 
163
    void insert(unsigned int registerRow,
 
164
                unsigned int registerColumn,
 
165
                const PackedVarying &packedVarying);
 
166
 
 
167
    std::vector<Register> mRegisterMap;
 
168
    std::vector<PackedVaryingRegister> mRegisterList;
 
169
 
 
170
    std::vector<BuiltinInfo> mBuiltinInfo;
 
171
};
 
172
 
 
173
}  // namespace rx
 
174
 
 
175
#endif  // LIBANGLE_RENDERER_D3D_VARYINGPACKING_H_