Flutter Engine
The Flutter Engine
Loading...
Searching...
No Matches
Classes | Macros
GrGLProgramDataManager.cpp File Reference
#include "include/core/SkMatrix.h"
#include "src/gpu/ganesh/gl/GrGLGpu.h"
#include "src/gpu/ganesh/gl/GrGLProgramDataManager.h"
#include "src/gpu/ganesh/glsl/GrGLSLUniformHandler.h"

Go to the source code of this file.

Classes

struct  set_uniform_matrix< 2 >
 
struct  set_uniform_matrix< 3 >
 
struct  set_uniform_matrix< 4 >
 

Macros

#define ASSERT_ARRAY_UPLOAD_IN_BOUNDS(UNI, COUNT)
 

Macro Definition Documentation

◆ ASSERT_ARRAY_UPLOAD_IN_BOUNDS

#define ASSERT_ARRAY_UPLOAD_IN_BOUNDS (   UNI,
  COUNT 
)
Value:
SkASSERT((COUNT) <= (UNI).fArrayCount || \
(1 == (COUNT) && GrShaderVar::kNonArray == (UNI).fArrayCount))
COUNT
#define COUNT(T)
Definition RecorderTest.cpp:25
SkASSERT
#define SkASSERT(cond)
Definition SkAssert.h:116

Definition at line 13 of file GrGLProgramDataManager.cpp.

17 : fGpu(gpu) {
18 fUniforms.push_back_n(uniforms.count());
19 int i = 0;
20 for (const GLUniformInfo& builderUniform : uniforms.items()) {
21 Uniform& uniform = fUniforms[i++];
22 SkASSERT(GrShaderVar::kNonArray == builderUniform.fVariable.getArrayCount() ||
23 builderUniform.fVariable.getArrayCount() > 0);
24 SkDEBUGCODE(
25 uniform.fArrayCount = builderUniform.fVariable.getArrayCount();
26 uniform.fType = builderUniform.fVariable.getType();
27 )
28 uniform.fLocation = builderUniform.fLocation;
29 }
30}
31
32void GrGLProgramDataManager::setSamplerUniforms(const UniformInfoArray& samplers,
33 int startUnit) const {
34 int i = 0;
35 for (const GLUniformInfo& sampler : samplers.items()) {
36 SkASSERT(sampler.fVisibility);
37 if (kUnusedUniform != sampler.fLocation) {
38 GR_GL_CALL(fGpu->glInterface(), Uniform1i(sampler.fLocation, i + startUnit));
39 }
40 ++i;
41 }
42}
43
44void GrGLProgramDataManager::set1i(UniformHandle u, int32_t i) const {
45 const Uniform& uni = fUniforms[u.toIndex()];
46 SkASSERT(uni.fType == SkSLType::kInt || uni.fType == SkSLType::kShort);
47 SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
48 if (kUnusedUniform != uni.fLocation) {
49 GR_GL_CALL(fGpu->glInterface(), Uniform1i(uni.fLocation, i));
50 }
51}
52
53void GrGLProgramDataManager::set1iv(UniformHandle u,
54 int arrayCount,
55 const int32_t v[]) const {
56 const Uniform& uni = fUniforms[u.toIndex()];
57 SkASSERT(uni.fType == SkSLType::kInt || uni.fType == SkSLType::kShort);
58 SkASSERT(arrayCount > 0);
59 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
60 if (kUnusedUniform != uni.fLocation) {
61 GR_GL_CALL(fGpu->glInterface(), Uniform1iv(uni.fLocation, arrayCount, v));
62 }
63}
64
65void GrGLProgramDataManager::set1f(UniformHandle u, float v0) const {
66 const Uniform& uni = fUniforms[u.toIndex()];
67 SkASSERT(uni.fType == SkSLType::kFloat || uni.fType == SkSLType::kHalf);
68 SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
69 if (kUnusedUniform != uni.fLocation) {
70 GR_GL_CALL(fGpu->glInterface(), Uniform1f(uni.fLocation, v0));
71 }
72}
73
74void GrGLProgramDataManager::set1fv(UniformHandle u,
75 int arrayCount,
76 const float v[]) const {
77 const Uniform& uni = fUniforms[u.toIndex()];
78 SkASSERT(uni.fType == SkSLType::kFloat || uni.fType == SkSLType::kHalf);
79 SkASSERT(arrayCount > 0);
80 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
81 // This assert fires in some instances of the two-pt gradient for its VSParams.
82 // Once the uniform manager is responsible for inserting the duplicate uniform
83 // arrays in VS and FS driver bug workaround, this can be enabled.
84 // this->printUni(uni);
85 if (kUnusedUniform != uni.fLocation) {
86 GR_GL_CALL(fGpu->glInterface(), Uniform1fv(uni.fLocation, arrayCount, v));
87 }
88}
89
90void GrGLProgramDataManager::set2i(UniformHandle u, int32_t i0, int32_t i1) const {
91 const Uniform& uni = fUniforms[u.toIndex()];
92 SkASSERT(uni.fType == SkSLType::kInt2 || uni.fType == SkSLType::kShort2);
93 SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
94 if (kUnusedUniform != uni.fLocation) {
95 GR_GL_CALL(fGpu->glInterface(), Uniform2i(uni.fLocation, i0, i1));
96 }
97}
98
99void GrGLProgramDataManager::set2iv(UniformHandle u,
100 int arrayCount,
101 const int32_t v[]) const {
102 const Uniform& uni = fUniforms[u.toIndex()];
103 SkASSERT(uni.fType == SkSLType::kInt2 || uni.fType == SkSLType::kShort2);
104 SkASSERT(arrayCount > 0);
105 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
106 if (kUnusedUniform != uni.fLocation) {
107 GR_GL_CALL(fGpu->glInterface(), Uniform2iv(uni.fLocation, arrayCount, v));
108 }
109}
110
111void GrGLProgramDataManager::set2f(UniformHandle u, float v0, float v1) const {
112 const Uniform& uni = fUniforms[u.toIndex()];
113 SkASSERT(uni.fType == SkSLType::kFloat2 || uni.fType == SkSLType::kHalf2);
114 SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
115 if (kUnusedUniform != uni.fLocation) {
116 GR_GL_CALL(fGpu->glInterface(), Uniform2f(uni.fLocation, v0, v1));
117 }
118}
119
120void GrGLProgramDataManager::set2fv(UniformHandle u,
121 int arrayCount,
122 const float v[]) const {
123 const Uniform& uni = fUniforms[u.toIndex()];
124 SkASSERT(uni.fType == SkSLType::kFloat2 || uni.fType == SkSLType::kHalf2);
125 SkASSERT(arrayCount > 0);
126 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
127 if (kUnusedUniform != uni.fLocation) {
128 GR_GL_CALL(fGpu->glInterface(), Uniform2fv(uni.fLocation, arrayCount, v));
129 }
130}
131
132void GrGLProgramDataManager::set3i(UniformHandle u, int32_t i0, int32_t i1, int32_t i2) const {
133 const Uniform& uni = fUniforms[u.toIndex()];
134 SkASSERT(uni.fType == SkSLType::kInt3 || uni.fType == SkSLType::kShort3);
135 SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
136 if (kUnusedUniform != uni.fLocation) {
137 GR_GL_CALL(fGpu->glInterface(), Uniform3i(uni.fLocation, i0, i1, i2));
138 }
139}
140
141void GrGLProgramDataManager::set3iv(UniformHandle u,
142 int arrayCount,
143 const int32_t v[]) const {
144 const Uniform& uni = fUniforms[u.toIndex()];
145 SkASSERT(uni.fType == SkSLType::kInt3 || uni.fType == SkSLType::kShort3);
146 SkASSERT(arrayCount > 0);
147 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
148 if (kUnusedUniform != uni.fLocation) {
149 GR_GL_CALL(fGpu->glInterface(), Uniform3iv(uni.fLocation, arrayCount, v));
150 }
151}
152
153void GrGLProgramDataManager::set3f(UniformHandle u, float v0, float v1, float v2) const {
154 const Uniform& uni = fUniforms[u.toIndex()];
155 SkASSERT(uni.fType == SkSLType::kFloat3 || uni.fType == SkSLType::kHalf3);
156 SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
157 if (kUnusedUniform != uni.fLocation) {
158 GR_GL_CALL(fGpu->glInterface(), Uniform3f(uni.fLocation, v0, v1, v2));
159 }
160}
161
162void GrGLProgramDataManager::set3fv(UniformHandle u,
163 int arrayCount,
164 const float v[]) const {
165 const Uniform& uni = fUniforms[u.toIndex()];
166 SkASSERT(uni.fType == SkSLType::kFloat3 || uni.fType == SkSLType::kHalf3);
167 SkASSERT(arrayCount > 0);
168 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
169 if (kUnusedUniform != uni.fLocation) {
170 GR_GL_CALL(fGpu->glInterface(), Uniform3fv(uni.fLocation, arrayCount, v));
171 }
172}
173
174void GrGLProgramDataManager::set4i(UniformHandle u,
175 int32_t i0,
176 int32_t i1,
177 int32_t i2,
178 int32_t i3) const {
179 const Uniform& uni = fUniforms[u.toIndex()];
180 SkASSERT(uni.fType == SkSLType::kInt4 || uni.fType == SkSLType::kShort4);
181 SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
182 if (kUnusedUniform != uni.fLocation) {
183 GR_GL_CALL(fGpu->glInterface(), Uniform4i(uni.fLocation, i0, i1, i2, i3));
184 }
185}
186
187void GrGLProgramDataManager::set4iv(UniformHandle u,
188 int arrayCount,
189 const int32_t v[]) const {
190 const Uniform& uni = fUniforms[u.toIndex()];
191 SkASSERT(uni.fType == SkSLType::kInt4 || uni.fType == SkSLType::kShort4);
192 SkASSERT(arrayCount > 0);
193 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
194 if (kUnusedUniform != uni.fLocation) {
195 GR_GL_CALL(fGpu->glInterface(), Uniform4iv(uni.fLocation, arrayCount, v));
196 }
197}
198
199void GrGLProgramDataManager::set4f(UniformHandle u,
200 float v0,
201 float v1,
202 float v2,
203 float v3) const {
204 const Uniform& uni = fUniforms[u.toIndex()];
205 SkASSERT(uni.fType == SkSLType::kFloat4 || uni.fType == SkSLType::kHalf4);
206 SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
207 if (kUnusedUniform != uni.fLocation) {
208 GR_GL_CALL(fGpu->glInterface(), Uniform4f(uni.fLocation, v0, v1, v2, v3));
209 }
210}
211
212void GrGLProgramDataManager::set4fv(UniformHandle u,
213 int arrayCount,
214 const float v[]) const {
215 const Uniform& uni = fUniforms[u.toIndex()];
216 SkASSERT(uni.fType == SkSLType::kFloat4 || uni.fType == SkSLType::kHalf4);
217 SkASSERT(arrayCount > 0);
218 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
219 if (kUnusedUniform != uni.fLocation) {
220 GR_GL_CALL(fGpu->glInterface(), Uniform4fv(uni.fLocation, arrayCount, v));
221 }
222}
223
224void GrGLProgramDataManager::setMatrix2f(UniformHandle u, const float matrix[]) const {
225 this->setMatrices<2>(u, 1, matrix);
226}
227
228void GrGLProgramDataManager::setMatrix3f(UniformHandle u, const float matrix[]) const {
229 this->setMatrices<3>(u, 1, matrix);
230}
231
232void GrGLProgramDataManager::setMatrix4f(UniformHandle u, const float matrix[]) const {
233 this->setMatrices<4>(u, 1, matrix);
234}
235
236void GrGLProgramDataManager::setMatrix2fv(UniformHandle u, int arrayCount, const float m[]) const {
237 this->setMatrices<2>(u, arrayCount, m);
238}
239
240void GrGLProgramDataManager::setMatrix3fv(UniformHandle u, int arrayCount, const float m[]) const {
241 this->setMatrices<3>(u, arrayCount, m);
242}
243
244void GrGLProgramDataManager::setMatrix4fv(UniformHandle u, int arrayCount, const float m[]) const {
245 this->setMatrices<4>(u, arrayCount, m);
246}
247
248template<int N> struct set_uniform_matrix;
249
250template<int N> inline void GrGLProgramDataManager::setMatrices(UniformHandle u,
251 int arrayCount,
252 const float matrices[]) const {
253 const Uniform& uni = fUniforms[u.toIndex()];
254 SkASSERT(static_cast<int>(uni.fType) == static_cast<int>(SkSLType::kFloat2x2) + (N - 2) ||
255 static_cast<int>(uni.fType) == static_cast<int>(SkSLType::kHalf2x2) + (N - 2));
256 SkASSERT(arrayCount > 0);
257 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
258 if (kUnusedUniform != uni.fLocation) {
259 set_uniform_matrix<N>::set(fGpu->glInterface(), uni.fLocation, arrayCount, matrices);
260 }
261}
262
263template<> struct set_uniform_matrix<2> {
264 inline static void set(const GrGLInterface* gli, const GrGLint loc, int cnt, const float m[]) {
265 GR_GL_CALL(gli, UniformMatrix2fv(loc, cnt, false, m));
266 }
267};
268
269template<> struct set_uniform_matrix<3> {
270 inline static void set(const GrGLInterface* gli, const GrGLint loc, int cnt, const float m[]) {
271 GR_GL_CALL(gli, UniformMatrix3fv(loc, cnt, false, m));
272 }
273};
274
275template<> struct set_uniform_matrix<4> {
276 inline static void set(const GrGLInterface* gli, const GrGLint loc, int cnt, const float m[]) {
277 GR_GL_CALL(gli, UniformMatrix4fv(loc, cnt, false, m));
278 }
279};
ASSERT_ARRAY_UPLOAD_IN_BOUNDS
#define ASSERT_ARRAY_UPLOAD_IN_BOUNDS(UNI, COUNT)
Definition GrGLProgramDataManager.cpp:13
GrGLint
int GrGLint
Definition GrGLTypes.h:108
GR_GL_CALL
#define GR_GL_CALL(IFACE, X)
Definition GrGLUtil.h:381
SkDEBUGCODE
#define SkDEBUGCODE(...)
Definition SkDebug.h:23
v2
Vec2Value v2
Definition Vec2KeyframeAnimator.cpp:40
N
#define N
Definition beziers.cpp:19
GrGLGpu::glInterface
const GrGLInterface * glInterface() const
Definition GrGLGpu.h:103
GrGLProgramDataManager::set1iv
void set1iv(UniformHandle, int arrayCount, const int32_t v[]) const override
Definition GrGLProgramDataManager.cpp:54
GrGLProgramDataManager::setMatrix4fv
void setMatrix4fv(UniformHandle, int arrayCount, const float matrices[]) const override
Definition GrGLProgramDataManager.cpp:245
GrGLProgramDataManager::set2i
void set2i(UniformHandle, int32_t, int32_t) const override
Definition GrGLProgramDataManager.cpp:91
GrGLProgramDataManager::set3iv
void set3iv(UniformHandle, int arrayCount, const int32_t v[]) const override
Definition GrGLProgramDataManager.cpp:142
GrGLProgramDataManager::set4fv
void set4fv(UniformHandle, int arrayCount, const float v[]) const override
Definition GrGLProgramDataManager.cpp:213
GrGLProgramDataManager::set4iv
void set4iv(UniformHandle, int arrayCount, const int32_t v[]) const override
Definition GrGLProgramDataManager.cpp:188
GrGLProgramDataManager::setMatrix3fv
void setMatrix3fv(UniformHandle, int arrayCount, const float matrices[]) const override
Definition GrGLProgramDataManager.cpp:241
GrGLProgramDataManager::setMatrix3f
void setMatrix3f(UniformHandle, const float matrix[]) const override
Definition GrGLProgramDataManager.cpp:229
GrGLProgramDataManager::setSamplerUniforms
void setSamplerUniforms(const UniformInfoArray &samplers, int startUnit) const
Definition GrGLProgramDataManager.cpp:33
GrGLProgramDataManager::set3f
void set3f(UniformHandle, float, float, float) const override
Definition GrGLProgramDataManager.cpp:154
GrGLProgramDataManager::setMatrix2fv
void setMatrix2fv(UniformHandle, int arrayCount, const float matrices[]) const override
Definition GrGLProgramDataManager.cpp:237
GrGLProgramDataManager::setMatrix2f
void setMatrix2f(UniformHandle, const float matrix[]) const override
Definition GrGLProgramDataManager.cpp:225
GrGLProgramDataManager::setMatrix4f
void setMatrix4f(UniformHandle, const float matrix[]) const override
Definition GrGLProgramDataManager.cpp:233
GrGLProgramDataManager::set4i
void set4i(UniformHandle, int32_t, int32_t, int32_t, int32_t) const override
Definition GrGLProgramDataManager.cpp:175
GrGLProgramDataManager::set3fv
void set3fv(UniformHandle, int arrayCount, const float v[]) const override
Definition GrGLProgramDataManager.cpp:163
GrGLProgramDataManager::set4f
void set4f(UniformHandle, float, float, float, float) const override
Definition GrGLProgramDataManager.cpp:200
GrGLProgramDataManager::set1i
void set1i(UniformHandle, int32_t) const override
Definition GrGLProgramDataManager.cpp:45
GrGLProgramDataManager::set1f
void set1f(UniformHandle, float v0) const override
Definition GrGLProgramDataManager.cpp:66
GrGLProgramDataManager::set2f
void set2f(UniformHandle, float, float) const override
Definition GrGLProgramDataManager.cpp:112
GrGLProgramDataManager::set1fv
void set1fv(UniformHandle, int arrayCount, const float v[]) const override
Definition GrGLProgramDataManager.cpp:75
GrGLProgramDataManager::set2iv
void set2iv(UniformHandle, int arrayCount, const int32_t v[]) const override
Definition GrGLProgramDataManager.cpp:100
GrGLProgramDataManager::set2fv
void set2fv(UniformHandle, int arrayCount, const float v[]) const override
Definition GrGLProgramDataManager.cpp:121
GrGLProgramDataManager::set3i
void set3i(UniformHandle, int32_t, int32_t, int32_t) const override
Definition GrGLProgramDataManager.cpp:133
dart_profiler_symbols.m
m
Definition dart_profiler_symbols.py:64
set_uniform_matrix
Definition GrGLProgramDataManager.cpp:249
Generated on Fri Apr 26 2024 06:18:46 for Flutter Engine by doxygen 1.9.8