blob: 15d9d36eee1570baeb50eeb92ae1b0a547cfe258 [file] [log] [blame]
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +00001/*
2 * Copyright 2012 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
Mike Kleinc0bd9f92019-04-23 12:05:21 -05008#include "include/core/SkMatrix.h"
9#include "src/gpu/gl/GrGLGpu.h"
10#include "src/gpu/gl/GrGLProgramDataManager.h"
11#include "src/gpu/glsl/GrGLSLUniformHandler.h"
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +000012
commit-bot@chromium.orgd3baf202013-11-07 22:06:08 +000013#define ASSERT_ARRAY_UPLOAD_IN_BOUNDS(UNI, COUNT) \
cdalton8d988b32016-03-07 15:39:09 -080014 SkASSERT((COUNT) <= (UNI).fArrayCount || \
Brian Salomon99938a82016-11-21 13:41:08 -050015 (1 == (COUNT) && GrShaderVar::kNonArray == (UNI).fArrayCount))
commit-bot@chromium.orgd3baf202013-11-07 22:06:08 +000016
joshualittd8dd47b2015-09-11 11:45:01 -070017GrGLProgramDataManager::GrGLProgramDataManager(GrGLGpu* gpu, GrGLuint programID,
18 const UniformInfoArray& uniforms,
egdaniel0eafe792015-11-20 14:01:22 -080019 const VaryingInfoArray& pathProcVaryings)
joshualittd8dd47b2015-09-11 11:45:01 -070020 : fGpu(gpu)
21 , fProgramID(programID) {
joshualitt47bb3822014-10-07 16:43:25 -070022 int count = uniforms.count();
kkinnunendddc18a2014-08-03 23:19:46 -070023 fUniforms.push_back_n(count);
24 for (int i = 0; i < count; i++) {
25 Uniform& uniform = fUniforms[i];
joshualitt47bb3822014-10-07 16:43:25 -070026 const UniformInfo& builderUniform = uniforms[i];
Brian Salomon99938a82016-11-21 13:41:08 -050027 SkASSERT(GrShaderVar::kNonArray == builderUniform.fVariable.getArrayCount() ||
kkinnunendddc18a2014-08-03 23:19:46 -070028 builderUniform.fVariable.getArrayCount() > 0);
29 SkDEBUGCODE(
30 uniform.fArrayCount = builderUniform.fVariable.getArrayCount();
31 uniform.fType = builderUniform.fVariable.getType();
Brian Salomon23356442018-11-30 15:33:19 -050032 )
Brian Salomon101b8442016-11-18 11:58:54 -050033 uniform.fLocation = builderUniform.fLocation;
kkinnunendddc18a2014-08-03 23:19:46 -070034 }
joshualittd8dd47b2015-09-11 11:45:01 -070035
36 // NVPR programs have separable varyings
egdaniel0eafe792015-11-20 14:01:22 -080037 count = pathProcVaryings.count();
38 fPathProcVaryings.push_back_n(count);
joshualittd8dd47b2015-09-11 11:45:01 -070039 for (int i = 0; i < count; i++) {
40 SkASSERT(fGpu->glCaps().shaderCaps()->pathRenderingSupport());
egdaniel0eafe792015-11-20 14:01:22 -080041 PathProcVarying& pathProcVarying = fPathProcVaryings[i];
42 const VaryingInfo& builderPathProcVarying = pathProcVaryings[i];
Brian Salomon99938a82016-11-21 13:41:08 -050043 SkASSERT(GrShaderVar::kNonArray == builderPathProcVarying.fVariable.getArrayCount() ||
egdaniel0eafe792015-11-20 14:01:22 -080044 builderPathProcVarying.fVariable.getArrayCount() > 0);
joshualittd8dd47b2015-09-11 11:45:01 -070045 SkDEBUGCODE(
egdaniel0eafe792015-11-20 14:01:22 -080046 pathProcVarying.fArrayCount = builderPathProcVarying.fVariable.getArrayCount();
47 pathProcVarying.fType = builderPathProcVarying.fVariable.getType();
Brian Salomon23356442018-11-30 15:33:19 -050048 )
egdaniel0eafe792015-11-20 14:01:22 -080049 pathProcVarying.fLocation = builderPathProcVarying.fLocation;
joshualittd8dd47b2015-09-11 11:45:01 -070050 }
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +000051}
52
Greg Danielbc5d4d72017-05-05 10:28:42 -040053void GrGLProgramDataManager::setSamplerUniforms(const UniformInfoArray& samplers,
54 int startUnit) const {
egdaniel09aa1fc2016-04-20 07:09:46 -070055 for (int i = 0; i < samplers.count(); ++i) {
Brian Salomon101b8442016-11-18 11:58:54 -050056 const UniformInfo& sampler = samplers[i];
57 SkASSERT(sampler.fVisibility);
58 if (kUnusedUniform != sampler.fLocation) {
Greg Danielbc5d4d72017-05-05 10:28:42 -040059 GR_GL_CALL(fGpu->glInterface(), Uniform1i(sampler.fLocation, i + startUnit));
egdaniel09aa1fc2016-04-20 07:09:46 -070060 }
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +000061 }
62}
63
fmenozzi497e9e22016-06-21 09:42:12 -070064void GrGLProgramDataManager::set1i(UniformHandle u, int32_t i) const {
65 const Uniform& uni = fUniforms[u.toIndex()];
Ethan Nicholasf7b88202017-09-18 14:10:39 -040066 SkASSERT(uni.fType == kInt_GrSLType || uni.fType == kShort_GrSLType);
Brian Salomon99938a82016-11-21 13:41:08 -050067 SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
Brian Salomon101b8442016-11-18 11:58:54 -050068 if (kUnusedUniform != uni.fLocation) {
69 GR_GL_CALL(fGpu->glInterface(), Uniform1i(uni.fLocation, i));
fmenozzi497e9e22016-06-21 09:42:12 -070070 }
71}
72
fmenozzi35a98c72016-07-20 08:26:12 -070073void GrGLProgramDataManager::set1iv(UniformHandle u,
74 int arrayCount,
Michael Ludwig779ed022018-08-28 17:20:07 -040075 const int32_t v[]) const {
fmenozzi35a98c72016-07-20 08:26:12 -070076 const Uniform& uni = fUniforms[u.toIndex()];
Ethan Nicholasf7b88202017-09-18 14:10:39 -040077 SkASSERT(uni.fType == kInt_GrSLType || uni.fType == kShort_GrSLType);
fmenozzi35a98c72016-07-20 08:26:12 -070078 SkASSERT(arrayCount > 0);
79 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
Brian Salomon101b8442016-11-18 11:58:54 -050080 if (kUnusedUniform != uni.fLocation) {
81 GR_GL_CALL(fGpu->glInterface(), Uniform1iv(uni.fLocation, arrayCount, v));
fmenozzi35a98c72016-07-20 08:26:12 -070082 }
83}
84
egdaniel018fb622015-10-28 07:26:40 -070085void GrGLProgramDataManager::set1f(UniformHandle u, float v0) const {
joshualitte7afc2d2015-09-11 10:44:13 -070086 const Uniform& uni = fUniforms[u.toIndex()];
Ethan Nicholas8aa45692017-09-20 11:24:15 -040087 SkASSERT(uni.fType == kFloat_GrSLType || uni.fType == kHalf_GrSLType);
Brian Salomon99938a82016-11-21 13:41:08 -050088 SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
Brian Salomon101b8442016-11-18 11:58:54 -050089 if (kUnusedUniform != uni.fLocation) {
90 GR_GL_CALL(fGpu->glInterface(), Uniform1f(uni.fLocation, v0));
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +000091 }
92}
93
kkinnunen7510b222014-07-30 00:04:16 -070094void GrGLProgramDataManager::set1fv(UniformHandle u,
95 int arrayCount,
egdaniel018fb622015-10-28 07:26:40 -070096 const float v[]) const {
joshualitte7afc2d2015-09-11 10:44:13 -070097 const Uniform& uni = fUniforms[u.toIndex()];
Ethan Nicholas8aa45692017-09-20 11:24:15 -040098 SkASSERT(uni.fType == kFloat_GrSLType || uni.fType == kHalf_GrSLType);
tfarina@chromium.orgf6de4752013-08-17 00:02:59 +000099 SkASSERT(arrayCount > 0);
commit-bot@chromium.orgd3baf202013-11-07 22:06:08 +0000100 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000101 // This assert fires in some instances of the two-pt gradient for its VSParams.
102 // Once the uniform manager is responsible for inserting the duplicate uniform
103 // arrays in VS and FS driver bug workaround, this can be enabled.
joshualittaf2d56d2015-05-11 06:21:34 -0700104 // this->printUni(uni);
Brian Salomon101b8442016-11-18 11:58:54 -0500105 if (kUnusedUniform != uni.fLocation) {
106 GR_GL_CALL(fGpu->glInterface(), Uniform1fv(uni.fLocation, arrayCount, v));
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000107 }
108}
109
Michael Ludwig779ed022018-08-28 17:20:07 -0400110void GrGLProgramDataManager::set2i(UniformHandle u, int32_t i0, int32_t i1) const {
111 const Uniform& uni = fUniforms[u.toIndex()];
112 SkASSERT(uni.fType == kInt2_GrSLType || uni.fType == kShort2_GrSLType);
113 SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
114 if (kUnusedUniform != uni.fLocation) {
115 GR_GL_CALL(fGpu->glInterface(), Uniform2i(uni.fLocation, i0, i1));
116 }
117}
118
119void GrGLProgramDataManager::set2iv(UniformHandle u,
120 int arrayCount,
121 const int32_t v[]) const {
122 const Uniform& uni = fUniforms[u.toIndex()];
123 SkASSERT(uni.fType == kInt2_GrSLType || uni.fType == kShort2_GrSLType);
124 SkASSERT(arrayCount > 0);
125 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
126 if (kUnusedUniform != uni.fLocation) {
127 GR_GL_CALL(fGpu->glInterface(), Uniform2iv(uni.fLocation, arrayCount, v));
128 }
129}
130
egdaniel018fb622015-10-28 07:26:40 -0700131void GrGLProgramDataManager::set2f(UniformHandle u, float v0, float v1) const {
joshualitte7afc2d2015-09-11 10:44:13 -0700132 const Uniform& uni = fUniforms[u.toIndex()];
Ethan Nicholas8aa45692017-09-20 11:24:15 -0400133 SkASSERT(uni.fType == kFloat2_GrSLType || uni.fType == kHalf2_GrSLType);
Brian Salomon99938a82016-11-21 13:41:08 -0500134 SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
Brian Salomon101b8442016-11-18 11:58:54 -0500135 if (kUnusedUniform != uni.fLocation) {
136 GR_GL_CALL(fGpu->glInterface(), Uniform2f(uni.fLocation, v0, v1));
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000137 }
138}
139
kkinnunen7510b222014-07-30 00:04:16 -0700140void GrGLProgramDataManager::set2fv(UniformHandle u,
141 int arrayCount,
egdaniel018fb622015-10-28 07:26:40 -0700142 const float v[]) const {
joshualitte7afc2d2015-09-11 10:44:13 -0700143 const Uniform& uni = fUniforms[u.toIndex()];
Ethan Nicholas8aa45692017-09-20 11:24:15 -0400144 SkASSERT(uni.fType == kFloat2_GrSLType || uni.fType == kHalf2_GrSLType);
tfarina@chromium.orgf6de4752013-08-17 00:02:59 +0000145 SkASSERT(arrayCount > 0);
commit-bot@chromium.orgd3baf202013-11-07 22:06:08 +0000146 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
Brian Salomon101b8442016-11-18 11:58:54 -0500147 if (kUnusedUniform != uni.fLocation) {
148 GR_GL_CALL(fGpu->glInterface(), Uniform2fv(uni.fLocation, arrayCount, v));
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000149 }
150}
151
Michael Ludwig779ed022018-08-28 17:20:07 -0400152void GrGLProgramDataManager::set3i(UniformHandle u, int32_t i0, int32_t i1, int32_t i2) const {
153 const Uniform& uni = fUniforms[u.toIndex()];
154 SkASSERT(uni.fType == kInt3_GrSLType || uni.fType == kShort3_GrSLType);
155 SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
156 if (kUnusedUniform != uni.fLocation) {
157 GR_GL_CALL(fGpu->glInterface(), Uniform3i(uni.fLocation, i0, i1, i2));
158 }
159}
160
161void GrGLProgramDataManager::set3iv(UniformHandle u,
162 int arrayCount,
163 const int32_t v[]) const {
164 const Uniform& uni = fUniforms[u.toIndex()];
165 SkASSERT(uni.fType == kInt3_GrSLType || uni.fType == kShort3_GrSLType);
166 SkASSERT(arrayCount > 0);
167 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
168 if (kUnusedUniform != uni.fLocation) {
169 GR_GL_CALL(fGpu->glInterface(), Uniform3iv(uni.fLocation, arrayCount, v));
170 }
171}
172
egdaniel018fb622015-10-28 07:26:40 -0700173void GrGLProgramDataManager::set3f(UniformHandle u, float v0, float v1, float v2) const {
joshualitte7afc2d2015-09-11 10:44:13 -0700174 const Uniform& uni = fUniforms[u.toIndex()];
Ethan Nicholas8aa45692017-09-20 11:24:15 -0400175 SkASSERT(uni.fType == kFloat3_GrSLType || uni.fType == kHalf3_GrSLType);
Brian Salomon99938a82016-11-21 13:41:08 -0500176 SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
Brian Salomon101b8442016-11-18 11:58:54 -0500177 if (kUnusedUniform != uni.fLocation) {
178 GR_GL_CALL(fGpu->glInterface(), Uniform3f(uni.fLocation, v0, v1, v2));
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000179 }
180}
181
kkinnunen7510b222014-07-30 00:04:16 -0700182void GrGLProgramDataManager::set3fv(UniformHandle u,
183 int arrayCount,
egdaniel018fb622015-10-28 07:26:40 -0700184 const float v[]) const {
joshualitte7afc2d2015-09-11 10:44:13 -0700185 const Uniform& uni = fUniforms[u.toIndex()];
Ethan Nicholas8aa45692017-09-20 11:24:15 -0400186 SkASSERT(uni.fType == kFloat3_GrSLType || uni.fType == kHalf3_GrSLType);
tfarina@chromium.orgf6de4752013-08-17 00:02:59 +0000187 SkASSERT(arrayCount > 0);
commit-bot@chromium.orgd3baf202013-11-07 22:06:08 +0000188 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
Brian Salomon101b8442016-11-18 11:58:54 -0500189 if (kUnusedUniform != uni.fLocation) {
190 GR_GL_CALL(fGpu->glInterface(), Uniform3fv(uni.fLocation, arrayCount, v));
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000191 }
192}
193
Michael Ludwig779ed022018-08-28 17:20:07 -0400194void GrGLProgramDataManager::set4i(UniformHandle u,
195 int32_t i0,
196 int32_t i1,
197 int32_t i2,
198 int32_t i3) const {
199 const Uniform& uni = fUniforms[u.toIndex()];
200 SkASSERT(uni.fType == kInt4_GrSLType || uni.fType == kShort4_GrSLType);
201 SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
202 if (kUnusedUniform != uni.fLocation) {
203 GR_GL_CALL(fGpu->glInterface(), Uniform4i(uni.fLocation, i0, i1, i2, i3));
204 }
205}
206
207void GrGLProgramDataManager::set4iv(UniformHandle u,
208 int arrayCount,
209 const int32_t v[]) const {
210 const Uniform& uni = fUniforms[u.toIndex()];
211 SkASSERT(uni.fType == kInt4_GrSLType || uni.fType == kShort4_GrSLType);
212 SkASSERT(arrayCount > 0);
213 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
214 if (kUnusedUniform != uni.fLocation) {
215 GR_GL_CALL(fGpu->glInterface(), Uniform4iv(uni.fLocation, arrayCount, v));
216 }
217}
218
kkinnunen7510b222014-07-30 00:04:16 -0700219void GrGLProgramDataManager::set4f(UniformHandle u,
egdaniel018fb622015-10-28 07:26:40 -0700220 float v0,
221 float v1,
222 float v2,
223 float v3) const {
joshualitte7afc2d2015-09-11 10:44:13 -0700224 const Uniform& uni = fUniforms[u.toIndex()];
Ethan Nicholas8aa45692017-09-20 11:24:15 -0400225 SkASSERT(uni.fType == kFloat4_GrSLType || uni.fType == kHalf4_GrSLType);
Brian Salomon99938a82016-11-21 13:41:08 -0500226 SkASSERT(GrShaderVar::kNonArray == uni.fArrayCount);
Brian Salomon101b8442016-11-18 11:58:54 -0500227 if (kUnusedUniform != uni.fLocation) {
228 GR_GL_CALL(fGpu->glInterface(), Uniform4f(uni.fLocation, v0, v1, v2, v3));
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000229 }
230}
231
kkinnunen7510b222014-07-30 00:04:16 -0700232void GrGLProgramDataManager::set4fv(UniformHandle u,
233 int arrayCount,
egdaniel018fb622015-10-28 07:26:40 -0700234 const float v[]) const {
joshualitte7afc2d2015-09-11 10:44:13 -0700235 const Uniform& uni = fUniforms[u.toIndex()];
Ethan Nicholas8aa45692017-09-20 11:24:15 -0400236 SkASSERT(uni.fType == kFloat4_GrSLType || uni.fType == kHalf4_GrSLType);
tfarina@chromium.orgf6de4752013-08-17 00:02:59 +0000237 SkASSERT(arrayCount > 0);
commit-bot@chromium.orgd3baf202013-11-07 22:06:08 +0000238 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
Brian Salomon101b8442016-11-18 11:58:54 -0500239 if (kUnusedUniform != uni.fLocation) {
240 GR_GL_CALL(fGpu->glInterface(), Uniform4fv(uni.fLocation, arrayCount, v));
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000241 }
242}
243
cdalton8d988b32016-03-07 15:39:09 -0800244void GrGLProgramDataManager::setMatrix2f(UniformHandle u, const float matrix[]) const {
245 this->setMatrices<2>(u, 1, matrix);
246}
247
egdaniel018fb622015-10-28 07:26:40 -0700248void GrGLProgramDataManager::setMatrix3f(UniformHandle u, const float matrix[]) const {
cdalton8d988b32016-03-07 15:39:09 -0800249 this->setMatrices<3>(u, 1, matrix);
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000250}
251
egdaniel018fb622015-10-28 07:26:40 -0700252void GrGLProgramDataManager::setMatrix4f(UniformHandle u, const float matrix[]) const {
cdalton8d988b32016-03-07 15:39:09 -0800253 this->setMatrices<4>(u, 1, matrix);
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000254}
255
cdalton8d988b32016-03-07 15:39:09 -0800256void GrGLProgramDataManager::setMatrix2fv(UniformHandle u, int arrayCount, const float m[]) const {
257 this->setMatrices<2>(u, arrayCount, m);
258}
259
260void GrGLProgramDataManager::setMatrix3fv(UniformHandle u, int arrayCount, const float m[]) const {
261 this->setMatrices<3>(u, arrayCount, m);
262}
263
264void GrGLProgramDataManager::setMatrix4fv(UniformHandle u, int arrayCount, const float m[]) const {
265 this->setMatrices<4>(u, arrayCount, m);
266}
267
268template<int N> struct set_uniform_matrix;
269
270template<int N> inline void GrGLProgramDataManager::setMatrices(UniformHandle u,
271 int arrayCount,
272 const float matrices[]) const {
joshualitte7afc2d2015-09-11 10:44:13 -0700273 const Uniform& uni = fUniforms[u.toIndex()];
Ethan Nicholas8aa45692017-09-20 11:24:15 -0400274 SkASSERT(uni.fType == kFloat2x2_GrSLType + (N - 2) ||
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400275 uni.fType == kHalf2x2_GrSLType + (N - 2));
tfarina@chromium.orgf6de4752013-08-17 00:02:59 +0000276 SkASSERT(arrayCount > 0);
commit-bot@chromium.orgd3baf202013-11-07 22:06:08 +0000277 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount);
Brian Salomon101b8442016-11-18 11:58:54 -0500278 if (kUnusedUniform != uni.fLocation) {
279 set_uniform_matrix<N>::set(fGpu->glInterface(), uni.fLocation, arrayCount, matrices);
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000280 }
281}
282
cdalton8d988b32016-03-07 15:39:09 -0800283template<> struct set_uniform_matrix<2> {
284 inline static void set(const GrGLInterface* gli, const GrGLint loc, int cnt, const float m[]) {
285 GR_GL_CALL(gli, UniformMatrix2fv(loc, cnt, false, m));
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000286 }
cdalton8d988b32016-03-07 15:39:09 -0800287};
288
289template<> struct set_uniform_matrix<3> {
290 inline static void set(const GrGLInterface* gli, const GrGLint loc, int cnt, const float m[]) {
291 GR_GL_CALL(gli, UniformMatrix3fv(loc, cnt, false, m));
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000292 }
cdalton8d988b32016-03-07 15:39:09 -0800293};
294
295template<> struct set_uniform_matrix<4> {
296 inline static void set(const GrGLInterface* gli, const GrGLint loc, int cnt, const float m[]) {
297 GR_GL_CALL(gli, UniformMatrix4fv(loc, cnt, false, m));
298 }
299};
bsalomon@google.comdbbc4e22012-07-25 17:48:39 +0000300
egdaniel0eafe792015-11-20 14:01:22 -0800301void GrGLProgramDataManager::setPathFragmentInputTransform(VaryingHandle u,
joshualittd8dd47b2015-09-11 11:45:01 -0700302 int components,
303 const SkMatrix& matrix) const {
304 SkASSERT(fGpu->glCaps().shaderCaps()->pathRenderingSupport());
egdaniel0eafe792015-11-20 14:01:22 -0800305 const PathProcVarying& fragmentInput = fPathProcVaryings[u.toIndex()];
joshualittd8dd47b2015-09-11 11:45:01 -0700306
Ethan Nicholas8aa45692017-09-20 11:24:15 -0400307 SkASSERT((components == 2 && (fragmentInput.fType == kFloat2_GrSLType ||
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400308 fragmentInput.fType == kHalf2_GrSLType)) ||
Ethan Nicholas8aa45692017-09-20 11:24:15 -0400309 (components == 3 && (fragmentInput.fType == kFloat3_GrSLType ||
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400310 fragmentInput.fType == kHalf3_GrSLType)));
joshualittd8dd47b2015-09-11 11:45:01 -0700311
312 fGpu->glPathRendering()->setProgramPathFragmentInputTransform(fProgramID,
313 fragmentInput.fLocation,
314 GR_GL_OBJECT_LINEAR,
315 components,
316 matrix);
317}