The Tor Browser / file comparison
comparison: gfx/skia/trunk/src/gpu/gl/GrGLUniformManager.cpp
gfx/skia/trunk/src/gpu/gl/GrGLUniformManager.cpp
- branch
- TOR_BUG_3246
- changeset 7
- 129ffea94266
equal
deleted
inserted
replaced
| -1:000000000000 | 0:f4873ff9c0c0 |
|---|---|
| 1 /* | |
| 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 | |
| 8 #include "gl/GrGLShaderBuilder.h" | |
| 9 #include "gl/GrGLProgram.h" | |
| 10 #include "gl/GrGLUniformHandle.h" | |
| 11 #include "gl/GrGpuGL.h" | |
| 12 #include "SkMatrix.h" | |
| 13 | |
| 14 #define ASSERT_ARRAY_UPLOAD_IN_BOUNDS(UNI, COUNT) \ | |
| 15 SkASSERT(arrayCount <= uni.fArrayCount || \ | |
| 16 (1 == arrayCount && GrGLShaderVar::kNonArray == uni.fArrayCount)) | |
| 17 | |
| 18 GrGLUniformManager::GrGLUniformManager(GrGpuGL* gpu) : fGpu(gpu) { | |
| 19 // skbug.com/2056 | |
| 20 fUsingBindUniform = fGpu->glInterface()->fFunctions.fBindUniformLocation != NULL; | |
| 21 } | |
| 22 | |
| 23 GrGLUniformManager::UniformHandle GrGLUniformManager::appendUniform(GrSLType type, int arrayCount) { | |
| 24 int idx = fUniforms.count(); | |
| 25 Uniform& uni = fUniforms.push_back(); | |
| 26 SkASSERT(GrGLShaderVar::kNonArray == arrayCount || arrayCount > 0); | |
| 27 uni.fArrayCount = arrayCount; | |
| 28 uni.fType = type; | |
| 29 uni.fVSLocation = kUnusedUniform; | |
| 30 uni.fFSLocation = kUnusedUniform; | |
| 31 return GrGLUniformManager::UniformHandle::CreateFromUniformIndex(idx); | |
| 32 } | |
| 33 | |
| 34 void GrGLUniformManager::setSampler(UniformHandle u, GrGLint texUnit) const { | |
| 35 const Uniform& uni = fUniforms[u.toUniformIndex()]; | |
| 36 SkASSERT(uni.fType == kSampler2D_GrSLType); | |
| 37 SkASSERT(GrGLShaderVar::kNonArray == uni.fArrayCount); | |
| 38 // FIXME: We still insert a single sampler uniform for every stage. If the shader does not | |
| 39 // reference the sampler then the compiler may have optimized it out. Uncomment this assert | |
| 40 // once stages insert their own samplers. | |
| 41 // SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation); | |
| 42 if (kUnusedUniform != uni.fFSLocation) { | |
| 43 GR_GL_CALL(fGpu->glInterface(), Uniform1i(uni.fFSLocation, texUnit)); | |
| 44 } | |
| 45 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) { | |
| 46 GR_GL_CALL(fGpu->glInterface(), Uniform1i(uni.fVSLocation, texUnit)); | |
| 47 } | |
| 48 } | |
| 49 | |
| 50 void GrGLUniformManager::set1f(UniformHandle u, GrGLfloat v0) const { | |
| 51 const Uniform& uni = fUniforms[u.toUniformIndex()]; | |
| 52 SkASSERT(uni.fType == kFloat_GrSLType); | |
| 53 SkASSERT(GrGLShaderVar::kNonArray == uni.fArrayCount); | |
| 54 SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation); | |
| 55 if (kUnusedUniform != uni.fFSLocation) { | |
| 56 GR_GL_CALL(fGpu->glInterface(), Uniform1f(uni.fFSLocation, v0)); | |
| 57 } | |
| 58 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) { | |
| 59 GR_GL_CALL(fGpu->glInterface(), Uniform1f(uni.fVSLocation, v0)); | |
| 60 } | |
| 61 } | |
| 62 | |
| 63 void GrGLUniformManager::set1fv(UniformHandle u, | |
| 64 int arrayCount, | |
| 65 const GrGLfloat v[]) const { | |
| 66 const Uniform& uni = fUniforms[u.toUniformIndex()]; | |
| 67 SkASSERT(uni.fType == kFloat_GrSLType); | |
| 68 SkASSERT(arrayCount > 0); | |
| 69 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount); | |
| 70 // This assert fires in some instances of the two-pt gradient for its VSParams. | |
| 71 // Once the uniform manager is responsible for inserting the duplicate uniform | |
| 72 // arrays in VS and FS driver bug workaround, this can be enabled. | |
| 73 //SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation); | |
| 74 if (kUnusedUniform != uni.fFSLocation) { | |
| 75 GR_GL_CALL(fGpu->glInterface(), Uniform1fv(uni.fFSLocation, arrayCount, v)); | |
| 76 } | |
| 77 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) { | |
| 78 GR_GL_CALL(fGpu->glInterface(), Uniform1fv(uni.fVSLocation, arrayCount, v)); | |
| 79 } | |
| 80 } | |
| 81 | |
| 82 void GrGLUniformManager::set2f(UniformHandle u, GrGLfloat v0, GrGLfloat v1) const { | |
| 83 const Uniform& uni = fUniforms[u.toUniformIndex()]; | |
| 84 SkASSERT(uni.fType == kVec2f_GrSLType); | |
| 85 SkASSERT(GrGLShaderVar::kNonArray == uni.fArrayCount); | |
| 86 SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation); | |
| 87 if (kUnusedUniform != uni.fFSLocation) { | |
| 88 GR_GL_CALL(fGpu->glInterface(), Uniform2f(uni.fFSLocation, v0, v1)); | |
| 89 } | |
| 90 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) { | |
| 91 GR_GL_CALL(fGpu->glInterface(), Uniform2f(uni.fVSLocation, v0, v1)); | |
| 92 } | |
| 93 } | |
| 94 | |
| 95 void GrGLUniformManager::set2fv(UniformHandle u, | |
| 96 int arrayCount, | |
| 97 const GrGLfloat v[]) const { | |
| 98 const Uniform& uni = fUniforms[u.toUniformIndex()]; | |
| 99 SkASSERT(uni.fType == kVec2f_GrSLType); | |
| 100 SkASSERT(arrayCount > 0); | |
| 101 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount); | |
| 102 SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation); | |
| 103 if (kUnusedUniform != uni.fFSLocation) { | |
| 104 GR_GL_CALL(fGpu->glInterface(), Uniform2fv(uni.fFSLocation, arrayCount, v)); | |
| 105 } | |
| 106 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) { | |
| 107 GR_GL_CALL(fGpu->glInterface(), Uniform2fv(uni.fVSLocation, arrayCount, v)); | |
| 108 } | |
| 109 } | |
| 110 | |
| 111 void GrGLUniformManager::set3f(UniformHandle u, GrGLfloat v0, GrGLfloat v1, GrGLfloat v2) const { | |
| 112 const Uniform& uni = fUniforms[u.toUniformIndex()]; | |
| 113 SkASSERT(uni.fType == kVec3f_GrSLType); | |
| 114 SkASSERT(GrGLShaderVar::kNonArray == uni.fArrayCount); | |
| 115 SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation); | |
| 116 if (kUnusedUniform != uni.fFSLocation) { | |
| 117 GR_GL_CALL(fGpu->glInterface(), Uniform3f(uni.fFSLocation, v0, v1, v2)); | |
| 118 } | |
| 119 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) { | |
| 120 GR_GL_CALL(fGpu->glInterface(), Uniform3f(uni.fVSLocation, v0, v1, v2)); | |
| 121 } | |
| 122 } | |
| 123 | |
| 124 void GrGLUniformManager::set3fv(UniformHandle u, | |
| 125 int arrayCount, | |
| 126 const GrGLfloat v[]) const { | |
| 127 const Uniform& uni = fUniforms[u.toUniformIndex()]; | |
| 128 SkASSERT(uni.fType == kVec3f_GrSLType); | |
| 129 SkASSERT(arrayCount > 0); | |
| 130 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount); | |
| 131 SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation); | |
| 132 if (kUnusedUniform != uni.fFSLocation) { | |
| 133 GR_GL_CALL(fGpu->glInterface(), Uniform3fv(uni.fFSLocation, arrayCount, v)); | |
| 134 } | |
| 135 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) { | |
| 136 GR_GL_CALL(fGpu->glInterface(), Uniform3fv(uni.fVSLocation, arrayCount, v)); | |
| 137 } | |
| 138 } | |
| 139 | |
| 140 void GrGLUniformManager::set4f(UniformHandle u, | |
| 141 GrGLfloat v0, | |
| 142 GrGLfloat v1, | |
| 143 GrGLfloat v2, | |
| 144 GrGLfloat v3) const { | |
| 145 const Uniform& uni = fUniforms[u.toUniformIndex()]; | |
| 146 SkASSERT(uni.fType == kVec4f_GrSLType); | |
| 147 SkASSERT(GrGLShaderVar::kNonArray == uni.fArrayCount); | |
| 148 SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation); | |
| 149 if (kUnusedUniform != uni.fFSLocation) { | |
| 150 GR_GL_CALL(fGpu->glInterface(), Uniform4f(uni.fFSLocation, v0, v1, v2, v3)); | |
| 151 } | |
| 152 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) { | |
| 153 GR_GL_CALL(fGpu->glInterface(), Uniform4f(uni.fVSLocation, v0, v1, v2, v3)); | |
| 154 } | |
| 155 } | |
| 156 | |
| 157 void GrGLUniformManager::set4fv(UniformHandle u, | |
| 158 int arrayCount, | |
| 159 const GrGLfloat v[]) const { | |
| 160 const Uniform& uni = fUniforms[u.toUniformIndex()]; | |
| 161 SkASSERT(uni.fType == kVec4f_GrSLType); | |
| 162 SkASSERT(arrayCount > 0); | |
| 163 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount); | |
| 164 SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation); | |
| 165 if (kUnusedUniform != uni.fFSLocation) { | |
| 166 GR_GL_CALL(fGpu->glInterface(), Uniform4fv(uni.fFSLocation, arrayCount, v)); | |
| 167 } | |
| 168 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) { | |
| 169 GR_GL_CALL(fGpu->glInterface(), Uniform4fv(uni.fVSLocation, arrayCount, v)); | |
| 170 } | |
| 171 } | |
| 172 | |
| 173 void GrGLUniformManager::setMatrix3f(UniformHandle u, const GrGLfloat matrix[]) const { | |
| 174 const Uniform& uni = fUniforms[u.toUniformIndex()]; | |
| 175 SkASSERT(uni.fType == kMat33f_GrSLType); | |
| 176 SkASSERT(GrGLShaderVar::kNonArray == uni.fArrayCount); | |
| 177 // TODO: Re-enable this assert once texture matrices aren't forced on all effects | |
| 178 // SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation); | |
| 179 if (kUnusedUniform != uni.fFSLocation) { | |
| 180 GR_GL_CALL(fGpu->glInterface(), UniformMatrix3fv(uni.fFSLocation, 1, false, matrix)); | |
| 181 } | |
| 182 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) { | |
| 183 GR_GL_CALL(fGpu->glInterface(), UniformMatrix3fv(uni.fVSLocation, 1, false, matrix)); | |
| 184 } | |
| 185 } | |
| 186 | |
| 187 void GrGLUniformManager::setMatrix4f(UniformHandle u, const GrGLfloat matrix[]) const { | |
| 188 const Uniform& uni = fUniforms[u.toUniformIndex()]; | |
| 189 SkASSERT(uni.fType == kMat44f_GrSLType); | |
| 190 SkASSERT(GrGLShaderVar::kNonArray == uni.fArrayCount); | |
| 191 SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation); | |
| 192 if (kUnusedUniform != uni.fFSLocation) { | |
| 193 GR_GL_CALL(fGpu->glInterface(), UniformMatrix4fv(uni.fFSLocation, 1, false, matrix)); | |
| 194 } | |
| 195 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) { | |
| 196 GR_GL_CALL(fGpu->glInterface(), UniformMatrix4fv(uni.fVSLocation, 1, false, matrix)); | |
| 197 } | |
| 198 } | |
| 199 | |
| 200 void GrGLUniformManager::setMatrix3fv(UniformHandle u, | |
| 201 int arrayCount, | |
| 202 const GrGLfloat matrices[]) const { | |
| 203 const Uniform& uni = fUniforms[u.toUniformIndex()]; | |
| 204 SkASSERT(uni.fType == kMat33f_GrSLType); | |
| 205 SkASSERT(arrayCount > 0); | |
| 206 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount); | |
| 207 SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation); | |
| 208 if (kUnusedUniform != uni.fFSLocation) { | |
| 209 GR_GL_CALL(fGpu->glInterface(), | |
| 210 UniformMatrix3fv(uni.fFSLocation, arrayCount, false, matrices)); | |
| 211 } | |
| 212 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) { | |
| 213 GR_GL_CALL(fGpu->glInterface(), | |
| 214 UniformMatrix3fv(uni.fVSLocation, arrayCount, false, matrices)); | |
| 215 } | |
| 216 } | |
| 217 | |
| 218 void GrGLUniformManager::setMatrix4fv(UniformHandle u, | |
| 219 int arrayCount, | |
| 220 const GrGLfloat matrices[]) const { | |
| 221 const Uniform& uni = fUniforms[u.toUniformIndex()]; | |
| 222 SkASSERT(uni.fType == kMat44f_GrSLType); | |
| 223 SkASSERT(arrayCount > 0); | |
| 224 ASSERT_ARRAY_UPLOAD_IN_BOUNDS(uni, arrayCount); | |
| 225 SkASSERT(kUnusedUniform != uni.fFSLocation || kUnusedUniform != uni.fVSLocation); | |
| 226 if (kUnusedUniform != uni.fFSLocation) { | |
| 227 GR_GL_CALL(fGpu->glInterface(), | |
| 228 UniformMatrix4fv(uni.fFSLocation, arrayCount, false, matrices)); | |
| 229 } | |
| 230 if (kUnusedUniform != uni.fVSLocation && uni.fVSLocation != uni.fFSLocation) { | |
| 231 GR_GL_CALL(fGpu->glInterface(), | |
| 232 UniformMatrix4fv(uni.fVSLocation, arrayCount, false, matrices)); | |
| 233 } | |
| 234 } | |
| 235 | |
| 236 void GrGLUniformManager::setSkMatrix(UniformHandle u, const SkMatrix& matrix) const { | |
| 237 GrGLfloat mt[] = { | |
| 238 matrix.get(SkMatrix::kMScaleX), | |
| 239 matrix.get(SkMatrix::kMSkewY), | |
| 240 matrix.get(SkMatrix::kMPersp0), | |
| 241 matrix.get(SkMatrix::kMSkewX), | |
| 242 matrix.get(SkMatrix::kMScaleY), | |
| 243 matrix.get(SkMatrix::kMPersp1), | |
| 244 matrix.get(SkMatrix::kMTransX), | |
| 245 matrix.get(SkMatrix::kMTransY), | |
| 246 matrix.get(SkMatrix::kMPersp2), | |
| 247 }; | |
| 248 this->setMatrix3f(u, mt); | |
| 249 } | |
| 250 | |
| 251 | |
| 252 void GrGLUniformManager::getUniformLocations(GrGLuint programID, const BuilderUniformArray& uniforms) { | |
| 253 SkASSERT(uniforms.count() == fUniforms.count()); | |
| 254 int count = fUniforms.count(); | |
| 255 for (int i = 0; i < count; ++i) { | |
| 256 SkASSERT(uniforms[i].fVariable.getType() == fUniforms[i].fType); | |
| 257 SkASSERT(uniforms[i].fVariable.getArrayCount() == fUniforms[i].fArrayCount); | |
| 258 GrGLint location; | |
| 259 // TODO: Move the Xoom uniform array in both FS and VS bug workaround here. | |
| 260 if (fUsingBindUniform) { | |
| 261 location = i; | |
| 262 GR_GL_CALL(fGpu->glInterface(), | |
| 263 BindUniformLocation(programID, location, uniforms[i].fVariable.c_str())); | |
| 264 } else { | |
| 265 GR_GL_CALL_RET(fGpu->glInterface(), location, | |
| 266 GetUniformLocation(programID, uniforms[i].fVariable.c_str())); | |
| 267 } | |
| 268 if (GrGLShaderBuilder::kVertex_Visibility & uniforms[i].fVisibility) { | |
| 269 fUniforms[i].fVSLocation = location; | |
| 270 } | |
| 271 if (GrGLShaderBuilder::kFragment_Visibility & uniforms[i].fVisibility) { | |
| 272 fUniforms[i].fFSLocation = location; | |
| 273 } | |
| 274 } | |
| 275 } | |
| 276 | |
| 277 const GrGLUniformManager::BuilderUniform& | |
| 278 GrGLUniformManager::getBuilderUniform(const BuilderUniformArray& array, UniformHandle handle) const { | |
| 279 return array[handle.toUniformIndex()]; | |
| 280 } |
