daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1 | // |
Geoff Lang | 48dcae7 | 2014-02-05 16:28:24 -0500 | [diff] [blame] | 2 | // Copyright (c) 2002-2014 The ANGLE Project Authors. All rights reserved. |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 3 | // Use of this source code is governed by a BSD-style license that can be |
| 4 | // found in the LICENSE file. |
| 5 | // |
| 6 | |
| 7 | // Program.cpp: Implements the gl::Program class. Implements GL program objects |
| 8 | // and related functionality. [OpenGL ES 2.0.24] section 2.10.3 page 28. |
| 9 | |
Geoff Lang | 2b5420c | 2014-11-19 14:20:15 -0500 | [diff] [blame] | 10 | #include "libANGLE/Program.h" |
Jamie Madill | 437d266 | 2014-12-05 14:23:35 -0500 | [diff] [blame] | 11 | |
Jamie Madill | 9e0478f | 2015-01-13 11:13:54 -0500 | [diff] [blame] | 12 | #include <algorithm> |
| 13 | |
Jamie Madill | 80a6fc0 | 2015-08-21 16:53:16 -0400 | [diff] [blame] | 14 | #include "common/BitSetIterator.h" |
Jamie Madill | 9e0478f | 2015-01-13 11:13:54 -0500 | [diff] [blame] | 15 | #include "common/debug.h" |
| 16 | #include "common/platform.h" |
| 17 | #include "common/utilities.h" |
| 18 | #include "common/version.h" |
| 19 | #include "compiler/translator/blocklayout.h" |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 20 | #include "libANGLE/Context.h" |
Jamie Madill | 437d266 | 2014-12-05 14:23:35 -0500 | [diff] [blame] | 21 | #include "libANGLE/ResourceManager.h" |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 22 | #include "libANGLE/features.h" |
Jamie Madill | 53ea9cc | 2016-05-17 10:12:52 -0400 | [diff] [blame] | 23 | #include "libANGLE/renderer/GLImplFactory.h" |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 24 | #include "libANGLE/renderer/ProgramImpl.h" |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 25 | #include "libANGLE/VaryingPacking.h" |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 26 | #include "libANGLE/queryconversions.h" |
Jamie Madill | 53ea9cc | 2016-05-17 10:12:52 -0400 | [diff] [blame] | 27 | #include "libANGLE/Uniform.h" |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 28 | |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 29 | namespace gl |
| 30 | { |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 31 | |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 32 | namespace |
| 33 | { |
| 34 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 35 | void WriteShaderVar(BinaryOutputStream *stream, const sh::ShaderVariable &var) |
| 36 | { |
| 37 | stream->writeInt(var.type); |
| 38 | stream->writeInt(var.precision); |
| 39 | stream->writeString(var.name); |
| 40 | stream->writeString(var.mappedName); |
| 41 | stream->writeInt(var.arraySize); |
| 42 | stream->writeInt(var.staticUse); |
| 43 | stream->writeString(var.structName); |
| 44 | ASSERT(var.fields.empty()); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 45 | } |
| 46 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 47 | void LoadShaderVar(BinaryInputStream *stream, sh::ShaderVariable *var) |
| 48 | { |
| 49 | var->type = stream->readInt<GLenum>(); |
| 50 | var->precision = stream->readInt<GLenum>(); |
| 51 | var->name = stream->readString(); |
| 52 | var->mappedName = stream->readString(); |
| 53 | var->arraySize = stream->readInt<unsigned int>(); |
| 54 | var->staticUse = stream->readBool(); |
| 55 | var->structName = stream->readString(); |
| 56 | } |
| 57 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 58 | // This simplified cast function doesn't need to worry about advanced concepts like |
| 59 | // depth range values, or casting to bool. |
| 60 | template <typename DestT, typename SrcT> |
| 61 | DestT UniformStateQueryCast(SrcT value); |
| 62 | |
| 63 | // From-Float-To-Integer Casts |
| 64 | template <> |
| 65 | GLint UniformStateQueryCast(GLfloat value) |
| 66 | { |
| 67 | return clampCast<GLint>(roundf(value)); |
| 68 | } |
| 69 | |
| 70 | template <> |
| 71 | GLuint UniformStateQueryCast(GLfloat value) |
| 72 | { |
| 73 | return clampCast<GLuint>(roundf(value)); |
| 74 | } |
| 75 | |
| 76 | // From-Integer-to-Integer Casts |
| 77 | template <> |
| 78 | GLint UniformStateQueryCast(GLuint value) |
| 79 | { |
| 80 | return clampCast<GLint>(value); |
| 81 | } |
| 82 | |
| 83 | template <> |
| 84 | GLuint UniformStateQueryCast(GLint value) |
| 85 | { |
| 86 | return clampCast<GLuint>(value); |
| 87 | } |
| 88 | |
| 89 | // From-Boolean-to-Anything Casts |
| 90 | template <> |
| 91 | GLfloat UniformStateQueryCast(GLboolean value) |
| 92 | { |
| 93 | return (value == GL_TRUE ? 1.0f : 0.0f); |
| 94 | } |
| 95 | |
| 96 | template <> |
| 97 | GLint UniformStateQueryCast(GLboolean value) |
| 98 | { |
| 99 | return (value == GL_TRUE ? 1 : 0); |
| 100 | } |
| 101 | |
| 102 | template <> |
| 103 | GLuint UniformStateQueryCast(GLboolean value) |
| 104 | { |
| 105 | return (value == GL_TRUE ? 1u : 0u); |
| 106 | } |
| 107 | |
| 108 | // Default to static_cast |
| 109 | template <typename DestT, typename SrcT> |
| 110 | DestT UniformStateQueryCast(SrcT value) |
| 111 | { |
| 112 | return static_cast<DestT>(value); |
| 113 | } |
| 114 | |
| 115 | template <typename SrcT, typename DestT> |
| 116 | void UniformStateQueryCastLoop(DestT *dataOut, const uint8_t *srcPointer, int components) |
| 117 | { |
| 118 | for (int comp = 0; comp < components; ++comp) |
| 119 | { |
| 120 | // We only work with strides of 4 bytes for uniform components. (GLfloat/GLint) |
| 121 | // Don't use SrcT stride directly since GLboolean has a stride of 1 byte. |
| 122 | size_t offset = comp * 4; |
| 123 | const SrcT *typedSrcPointer = reinterpret_cast<const SrcT *>(&srcPointer[offset]); |
| 124 | dataOut[comp] = UniformStateQueryCast<DestT>(*typedSrcPointer); |
| 125 | } |
| 126 | } |
| 127 | |
Jamie Madill | 3d3d2f2 | 2015-09-23 16:47:51 -0400 | [diff] [blame] | 128 | bool UniformInList(const std::vector<LinkedUniform> &list, const std::string &name) |
| 129 | { |
| 130 | for (const LinkedUniform &uniform : list) |
| 131 | { |
| 132 | if (uniform.name == name) |
| 133 | return true; |
| 134 | } |
| 135 | |
| 136 | return false; |
| 137 | } |
| 138 | |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 139 | // true if varying x has a higher priority in packing than y |
| 140 | bool ComparePackedVarying(const PackedVarying &x, const PackedVarying &y) |
| 141 | { |
| 142 | return gl::CompareShaderVar(*x.varying, *y.varying); |
| 143 | } |
| 144 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 145 | } // anonymous namespace |
| 146 | |
Jamie Madill | 4a3c234 | 2015-10-08 12:58:45 -0400 | [diff] [blame] | 147 | const char *const g_fakepath = "C:\\fakepath"; |
| 148 | |
Jamie Madill | 71c3b2c | 2015-05-07 11:49:20 -0400 | [diff] [blame] | 149 | InfoLog::InfoLog() |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 150 | { |
| 151 | } |
| 152 | |
| 153 | InfoLog::~InfoLog() |
| 154 | { |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 155 | } |
| 156 | |
Jamie Madill | 71c3b2c | 2015-05-07 11:49:20 -0400 | [diff] [blame] | 157 | size_t InfoLog::getLength() const |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 158 | { |
Jamie Madill | 71c3b2c | 2015-05-07 11:49:20 -0400 | [diff] [blame] | 159 | const std::string &logString = mStream.str(); |
| 160 | return logString.empty() ? 0 : logString.length() + 1; |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 161 | } |
| 162 | |
Geoff Lang | e1a2775 | 2015-10-05 13:16:04 -0400 | [diff] [blame] | 163 | void InfoLog::getLog(GLsizei bufSize, GLsizei *length, char *infoLog) const |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 164 | { |
Jamie Madill | 71c3b2c | 2015-05-07 11:49:20 -0400 | [diff] [blame] | 165 | size_t index = 0; |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 166 | |
| 167 | if (bufSize > 0) |
| 168 | { |
Jamie Madill | 71c3b2c | 2015-05-07 11:49:20 -0400 | [diff] [blame] | 169 | const std::string str(mStream.str()); |
| 170 | |
| 171 | if (!str.empty()) |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 172 | { |
Jamie Madill | 71c3b2c | 2015-05-07 11:49:20 -0400 | [diff] [blame] | 173 | index = std::min(static_cast<size_t>(bufSize) - 1, str.length()); |
| 174 | memcpy(infoLog, str.c_str(), index); |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 175 | } |
| 176 | |
| 177 | infoLog[index] = '\0'; |
| 178 | } |
| 179 | |
| 180 | if (length) |
| 181 | { |
Jamie Madill | 71c3b2c | 2015-05-07 11:49:20 -0400 | [diff] [blame] | 182 | *length = static_cast<GLsizei>(index); |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 183 | } |
| 184 | } |
| 185 | |
| 186 | // append a santized message to the program info log. |
Sami Väisänen | 46eaa94 | 2016-06-29 10:26:37 +0300 | [diff] [blame] | 187 | // The D3D compiler includes a fake file path in some of the warning or error |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 188 | // messages, so lets remove all occurrences of this fake file path from the log. |
| 189 | void InfoLog::appendSanitized(const char *message) |
| 190 | { |
| 191 | std::string msg(message); |
| 192 | |
| 193 | size_t found; |
| 194 | do |
| 195 | { |
| 196 | found = msg.find(g_fakepath); |
| 197 | if (found != std::string::npos) |
| 198 | { |
| 199 | msg.erase(found, strlen(g_fakepath)); |
| 200 | } |
| 201 | } |
| 202 | while (found != std::string::npos); |
| 203 | |
Jamie Madill | 71c3b2c | 2015-05-07 11:49:20 -0400 | [diff] [blame] | 204 | mStream << message << std::endl; |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 205 | } |
| 206 | |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 207 | void InfoLog::reset() |
| 208 | { |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 209 | } |
| 210 | |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 211 | VariableLocation::VariableLocation() : name(), element(0), index(0), used(false), ignored(false) |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 212 | { |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 213 | } |
| 214 | |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 215 | VariableLocation::VariableLocation(const std::string &name, |
| 216 | unsigned int element, |
| 217 | unsigned int index) |
| 218 | : name(name), element(element), index(index), used(true), ignored(false) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 219 | { |
| 220 | } |
| 221 | |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 222 | void Program::Bindings::bindLocation(GLuint index, const std::string &name) |
| 223 | { |
| 224 | mBindings[name] = index; |
| 225 | } |
| 226 | |
| 227 | int Program::Bindings::getBinding(const std::string &name) const |
| 228 | { |
| 229 | auto iter = mBindings.find(name); |
| 230 | return (iter != mBindings.end()) ? iter->second : -1; |
| 231 | } |
| 232 | |
| 233 | Program::Bindings::const_iterator Program::Bindings::begin() const |
| 234 | { |
| 235 | return mBindings.begin(); |
| 236 | } |
| 237 | |
| 238 | Program::Bindings::const_iterator Program::Bindings::end() const |
| 239 | { |
| 240 | return mBindings.end(); |
| 241 | } |
| 242 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 243 | ProgramState::ProgramState() |
Geoff Lang | 70d0f49 | 2015-12-10 17:45:46 -0500 | [diff] [blame] | 244 | : mLabel(), |
| 245 | mAttachedFragmentShader(nullptr), |
Jamie Madill | 5c6b7bf | 2015-08-17 12:53:35 -0400 | [diff] [blame] | 246 | mAttachedVertexShader(nullptr), |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 247 | mAttachedComputeShader(nullptr), |
Geoff Lang | c562975 | 2015-12-07 16:29:04 -0500 | [diff] [blame] | 248 | mTransformFeedbackBufferMode(GL_INTERLEAVED_ATTRIBS), |
Jamie Madill | e7d8432 | 2017-01-10 18:21:59 -0500 | [diff] [blame] | 249 | mSamplerUniformRange(0, 0), |
Geoff Lang | c562975 | 2015-12-07 16:29:04 -0500 | [diff] [blame] | 250 | mBinaryRetrieveableHint(false) |
Jamie Madill | 5c6b7bf | 2015-08-17 12:53:35 -0400 | [diff] [blame] | 251 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 252 | mComputeShaderLocalSize.fill(1); |
Jamie Madill | 5c6b7bf | 2015-08-17 12:53:35 -0400 | [diff] [blame] | 253 | } |
| 254 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 255 | ProgramState::~ProgramState() |
Jamie Madill | 5c6b7bf | 2015-08-17 12:53:35 -0400 | [diff] [blame] | 256 | { |
| 257 | if (mAttachedVertexShader != nullptr) |
| 258 | { |
| 259 | mAttachedVertexShader->release(); |
| 260 | } |
| 261 | |
| 262 | if (mAttachedFragmentShader != nullptr) |
| 263 | { |
| 264 | mAttachedFragmentShader->release(); |
| 265 | } |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 266 | |
| 267 | if (mAttachedComputeShader != nullptr) |
| 268 | { |
| 269 | mAttachedComputeShader->release(); |
| 270 | } |
Jamie Madill | 5c6b7bf | 2015-08-17 12:53:35 -0400 | [diff] [blame] | 271 | } |
| 272 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 273 | const std::string &ProgramState::getLabel() |
Geoff Lang | 70d0f49 | 2015-12-10 17:45:46 -0500 | [diff] [blame] | 274 | { |
| 275 | return mLabel; |
| 276 | } |
| 277 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 278 | const LinkedUniform *ProgramState::getUniformByName(const std::string &name) const |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 279 | { |
| 280 | for (const LinkedUniform &linkedUniform : mUniforms) |
| 281 | { |
| 282 | if (linkedUniform.name == name) |
| 283 | { |
| 284 | return &linkedUniform; |
| 285 | } |
| 286 | } |
| 287 | |
| 288 | return nullptr; |
| 289 | } |
| 290 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 291 | GLint ProgramState::getUniformLocation(const std::string &name) const |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 292 | { |
| 293 | size_t subscript = GL_INVALID_INDEX; |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 294 | std::string baseName = ParseUniformName(name, &subscript); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 295 | |
| 296 | for (size_t location = 0; location < mUniformLocations.size(); ++location) |
| 297 | { |
| 298 | const VariableLocation &uniformLocation = mUniformLocations[location]; |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 299 | if (!uniformLocation.used) |
| 300 | { |
| 301 | continue; |
| 302 | } |
| 303 | |
| 304 | const LinkedUniform &uniform = mUniforms[uniformLocation.index]; |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 305 | |
| 306 | if (uniform.name == baseName) |
| 307 | { |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 308 | if (uniform.isArray()) |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 309 | { |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 310 | if (uniformLocation.element == subscript || |
| 311 | (uniformLocation.element == 0 && subscript == GL_INVALID_INDEX)) |
| 312 | { |
| 313 | return static_cast<GLint>(location); |
| 314 | } |
| 315 | } |
| 316 | else |
| 317 | { |
| 318 | if (subscript == GL_INVALID_INDEX) |
| 319 | { |
| 320 | return static_cast<GLint>(location); |
| 321 | } |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 322 | } |
| 323 | } |
| 324 | } |
| 325 | |
| 326 | return -1; |
| 327 | } |
| 328 | |
Jamie Madill | e7d8432 | 2017-01-10 18:21:59 -0500 | [diff] [blame] | 329 | GLuint ProgramState::getUniformIndexFromName(const std::string &name) const |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 330 | { |
| 331 | size_t subscript = GL_INVALID_INDEX; |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 332 | std::string baseName = ParseUniformName(name, &subscript); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 333 | |
| 334 | // The app is not allowed to specify array indices other than 0 for arrays of basic types |
| 335 | if (subscript != 0 && subscript != GL_INVALID_INDEX) |
| 336 | { |
| 337 | return GL_INVALID_INDEX; |
| 338 | } |
| 339 | |
| 340 | for (size_t index = 0; index < mUniforms.size(); index++) |
| 341 | { |
| 342 | const LinkedUniform &uniform = mUniforms[index]; |
| 343 | if (uniform.name == baseName) |
| 344 | { |
| 345 | if (uniform.isArray() || subscript == GL_INVALID_INDEX) |
| 346 | { |
| 347 | return static_cast<GLuint>(index); |
| 348 | } |
| 349 | } |
| 350 | } |
| 351 | |
| 352 | return GL_INVALID_INDEX; |
| 353 | } |
| 354 | |
Jamie Madill | e7d8432 | 2017-01-10 18:21:59 -0500 | [diff] [blame] | 355 | GLuint ProgramState::getUniformIndexFromLocation(GLint location) const |
| 356 | { |
| 357 | ASSERT(location >= 0 && static_cast<size_t>(location) < mUniformLocations.size()); |
| 358 | return mUniformLocations[location].index; |
| 359 | } |
| 360 | |
| 361 | Optional<GLuint> ProgramState::getSamplerIndex(GLint location) const |
| 362 | { |
| 363 | GLuint index = getUniformIndexFromLocation(location); |
| 364 | if (!isSamplerUniformIndex(index)) |
| 365 | { |
| 366 | return Optional<GLuint>::Invalid(); |
| 367 | } |
| 368 | |
| 369 | return getSamplerIndexFromUniformIndex(index); |
| 370 | } |
| 371 | |
| 372 | bool ProgramState::isSamplerUniformIndex(GLuint index) const |
| 373 | { |
| 374 | return index >= mSamplerUniformRange.start && index < mSamplerUniformRange.end; |
| 375 | } |
| 376 | |
| 377 | GLuint ProgramState::getSamplerIndexFromUniformIndex(GLuint uniformIndex) const |
| 378 | { |
| 379 | ASSERT(isSamplerUniformIndex(uniformIndex)); |
| 380 | return uniformIndex - mSamplerUniformRange.start; |
| 381 | } |
| 382 | |
Jamie Madill | 7aea7e0 | 2016-05-10 10:39:45 -0400 | [diff] [blame] | 383 | Program::Program(rx::GLImplFactory *factory, ResourceManager *manager, GLuint handle) |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 384 | : mProgram(factory->createProgram(mState)), |
Jamie Madill | 5c6b7bf | 2015-08-17 12:53:35 -0400 | [diff] [blame] | 385 | mValidated(false), |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 386 | mLinked(false), |
| 387 | mDeleteStatus(false), |
| 388 | mRefCount(0), |
| 389 | mResourceManager(manager), |
Jamie Madill | e7d8432 | 2017-01-10 18:21:59 -0500 | [diff] [blame] | 390 | mHandle(handle) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 391 | { |
| 392 | ASSERT(mProgram); |
shannonwoods@chromium.org | 70eb1ea | 2013-05-30 00:07:20 +0000 | [diff] [blame] | 393 | |
| 394 | resetUniformBlockBindings(); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 395 | unlink(); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 396 | } |
| 397 | |
| 398 | Program::~Program() |
| 399 | { |
| 400 | unlink(true); |
daniel@transgaming.com | 71cd868 | 2010-04-29 03:35:25 +0000 | [diff] [blame] | 401 | |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 402 | SafeDelete(mProgram); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 403 | } |
| 404 | |
Geoff Lang | 70d0f49 | 2015-12-10 17:45:46 -0500 | [diff] [blame] | 405 | void Program::setLabel(const std::string &label) |
| 406 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 407 | mState.mLabel = label; |
Geoff Lang | 70d0f49 | 2015-12-10 17:45:46 -0500 | [diff] [blame] | 408 | } |
| 409 | |
| 410 | const std::string &Program::getLabel() const |
| 411 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 412 | return mState.mLabel; |
Geoff Lang | 70d0f49 | 2015-12-10 17:45:46 -0500 | [diff] [blame] | 413 | } |
| 414 | |
Jamie Madill | ef300b1 | 2016-10-07 15:12:09 -0400 | [diff] [blame] | 415 | void Program::attachShader(Shader *shader) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 416 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 417 | switch (shader->getType()) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 418 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 419 | case GL_VERTEX_SHADER: |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 420 | { |
Jamie Madill | ef300b1 | 2016-10-07 15:12:09 -0400 | [diff] [blame] | 421 | ASSERT(!mState.mAttachedVertexShader); |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 422 | mState.mAttachedVertexShader = shader; |
| 423 | mState.mAttachedVertexShader->addRef(); |
| 424 | break; |
| 425 | } |
| 426 | case GL_FRAGMENT_SHADER: |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 427 | { |
Jamie Madill | ef300b1 | 2016-10-07 15:12:09 -0400 | [diff] [blame] | 428 | ASSERT(!mState.mAttachedFragmentShader); |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 429 | mState.mAttachedFragmentShader = shader; |
| 430 | mState.mAttachedFragmentShader->addRef(); |
| 431 | break; |
| 432 | } |
| 433 | case GL_COMPUTE_SHADER: |
| 434 | { |
Jamie Madill | ef300b1 | 2016-10-07 15:12:09 -0400 | [diff] [blame] | 435 | ASSERT(!mState.mAttachedComputeShader); |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 436 | mState.mAttachedComputeShader = shader; |
| 437 | mState.mAttachedComputeShader->addRef(); |
| 438 | break; |
| 439 | } |
| 440 | default: |
| 441 | UNREACHABLE(); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 442 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 443 | } |
| 444 | |
| 445 | bool Program::detachShader(Shader *shader) |
| 446 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 447 | switch (shader->getType()) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 448 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 449 | case GL_VERTEX_SHADER: |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 450 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 451 | if (mState.mAttachedVertexShader != shader) |
| 452 | { |
| 453 | return false; |
| 454 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 455 | |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 456 | shader->release(); |
| 457 | mState.mAttachedVertexShader = nullptr; |
| 458 | break; |
| 459 | } |
| 460 | case GL_FRAGMENT_SHADER: |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 461 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 462 | if (mState.mAttachedFragmentShader != shader) |
| 463 | { |
| 464 | return false; |
| 465 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 466 | |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 467 | shader->release(); |
| 468 | mState.mAttachedFragmentShader = nullptr; |
| 469 | break; |
| 470 | } |
| 471 | case GL_COMPUTE_SHADER: |
| 472 | { |
| 473 | if (mState.mAttachedComputeShader != shader) |
| 474 | { |
| 475 | return false; |
| 476 | } |
| 477 | |
| 478 | shader->release(); |
| 479 | mState.mAttachedComputeShader = nullptr; |
| 480 | break; |
| 481 | } |
| 482 | default: |
| 483 | UNREACHABLE(); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 484 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 485 | |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 486 | return true; |
| 487 | } |
| 488 | |
daniel@transgaming.com | cba5057 | 2010-03-28 19:36:09 +0000 | [diff] [blame] | 489 | int Program::getAttachedShadersCount() const |
| 490 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 491 | return (mState.mAttachedVertexShader ? 1 : 0) + (mState.mAttachedFragmentShader ? 1 : 0) + |
| 492 | (mState.mAttachedComputeShader ? 1 : 0); |
daniel@transgaming.com | cba5057 | 2010-03-28 19:36:09 +0000 | [diff] [blame] | 493 | } |
| 494 | |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 495 | void Program::bindAttributeLocation(GLuint index, const char *name) |
| 496 | { |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 497 | mAttributeBindings.bindLocation(index, name); |
| 498 | } |
| 499 | |
| 500 | void Program::bindUniformLocation(GLuint index, const char *name) |
| 501 | { |
| 502 | // Bind the base uniform name only since array indices other than 0 cannot be bound |
| 503 | mUniformBindings.bindLocation(index, ParseUniformName(name, nullptr)); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 504 | } |
| 505 | |
Sami Väisänen | 46eaa94 | 2016-06-29 10:26:37 +0300 | [diff] [blame] | 506 | void Program::bindFragmentInputLocation(GLint index, const char *name) |
| 507 | { |
| 508 | mFragmentInputBindings.bindLocation(index, name); |
| 509 | } |
| 510 | |
| 511 | BindingInfo Program::getFragmentInputBindingInfo(GLint index) const |
| 512 | { |
| 513 | BindingInfo ret; |
| 514 | ret.type = GL_NONE; |
| 515 | ret.valid = false; |
| 516 | |
| 517 | const Shader *fragmentShader = mState.getAttachedFragmentShader(); |
| 518 | ASSERT(fragmentShader); |
| 519 | |
| 520 | // Find the actual fragment shader varying we're interested in |
| 521 | const std::vector<sh::Varying> &inputs = fragmentShader->getVaryings(); |
| 522 | |
| 523 | for (const auto &binding : mFragmentInputBindings) |
| 524 | { |
| 525 | if (binding.second != static_cast<GLuint>(index)) |
| 526 | continue; |
| 527 | |
| 528 | ret.valid = true; |
| 529 | |
| 530 | std::string originalName = binding.first; |
Geoff Lang | 3f6a398 | 2016-07-15 15:20:45 -0400 | [diff] [blame] | 531 | unsigned int arrayIndex = ParseAndStripArrayIndex(&originalName); |
Sami Väisänen | 46eaa94 | 2016-06-29 10:26:37 +0300 | [diff] [blame] | 532 | |
| 533 | for (const auto &in : inputs) |
| 534 | { |
| 535 | if (in.name == originalName) |
| 536 | { |
| 537 | if (in.isArray()) |
| 538 | { |
| 539 | // The client wants to bind either "name" or "name[0]". |
| 540 | // GL ES 3.1 spec refers to active array names with language such as: |
| 541 | // "if the string identifies the base name of an active array, where the |
| 542 | // string would exactly match the name of the variable if the suffix "[0]" |
| 543 | // were appended to the string". |
Geoff Lang | 3f6a398 | 2016-07-15 15:20:45 -0400 | [diff] [blame] | 544 | if (arrayIndex == GL_INVALID_INDEX) |
| 545 | arrayIndex = 0; |
Sami Väisänen | 46eaa94 | 2016-06-29 10:26:37 +0300 | [diff] [blame] | 546 | |
Corentin Wallez | 054f7ed | 2016-09-20 17:15:59 -0400 | [diff] [blame] | 547 | ret.name = in.mappedName + "[" + ToString(arrayIndex) + "]"; |
Sami Väisänen | 46eaa94 | 2016-06-29 10:26:37 +0300 | [diff] [blame] | 548 | } |
| 549 | else |
| 550 | { |
| 551 | ret.name = in.mappedName; |
| 552 | } |
| 553 | ret.type = in.type; |
| 554 | return ret; |
| 555 | } |
| 556 | } |
| 557 | } |
| 558 | |
| 559 | return ret; |
| 560 | } |
| 561 | |
| 562 | void Program::pathFragmentInputGen(GLint index, |
| 563 | GLenum genMode, |
| 564 | GLint components, |
| 565 | const GLfloat *coeffs) |
| 566 | { |
| 567 | // If the location is -1 then the command is silently ignored |
| 568 | if (index == -1) |
| 569 | return; |
| 570 | |
| 571 | const auto &binding = getFragmentInputBindingInfo(index); |
| 572 | |
| 573 | // If the input doesn't exist then then the command is silently ignored |
| 574 | // This could happen through optimization for example, the shader translator |
| 575 | // decides that a variable is not actually being used and optimizes it away. |
| 576 | if (binding.name.empty()) |
| 577 | return; |
| 578 | |
| 579 | mProgram->setPathFragmentInputGen(binding.name, genMode, components, coeffs); |
| 580 | } |
| 581 | |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 582 | // The attached shaders are checked for linking errors by matching up their variables. |
| 583 | // Uniform, input and output variables get collected. |
| 584 | // The code gets compiled into binaries. |
Jamie Madill | 9082b98 | 2016-04-27 15:21:51 -0400 | [diff] [blame] | 585 | Error Program::link(const ContextState &data) |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 586 | { |
| 587 | unlink(false); |
| 588 | |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 589 | mInfoLog.reset(); |
shannonwoods@chromium.org | 70eb1ea | 2013-05-30 00:07:20 +0000 | [diff] [blame] | 590 | resetUniformBlockBindings(); |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 591 | |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 592 | const Caps &caps = data.getCaps(); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 593 | |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 594 | auto vertexShader = mState.mAttachedVertexShader; |
| 595 | auto fragmentShader = mState.mAttachedFragmentShader; |
| 596 | auto computeShader = mState.mAttachedComputeShader; |
| 597 | |
| 598 | bool isComputeShaderAttached = (computeShader != nullptr); |
| 599 | bool nonComputeShadersAttached = (vertexShader != nullptr || fragmentShader != nullptr); |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 600 | // Check whether we both have a compute and non-compute shaders attached. |
| 601 | // If there are of both types attached, then linking should fail. |
| 602 | // OpenGL ES 3.10, 7.3 Program Objects, under LinkProgram |
| 603 | if (isComputeShaderAttached == true && nonComputeShadersAttached == true) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 604 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 605 | mInfoLog << "Both a compute and non-compute shaders are attached to the same program."; |
| 606 | return NoError(); |
Yuly Novikov | cfa48d3 | 2016-06-15 22:14:36 -0400 | [diff] [blame] | 607 | } |
| 608 | |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 609 | if (computeShader) |
Jamie Madill | 437d266 | 2014-12-05 14:23:35 -0500 | [diff] [blame] | 610 | { |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 611 | if (!computeShader->isCompiled()) |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 612 | { |
| 613 | mInfoLog << "Attached compute shader is not compiled."; |
| 614 | return NoError(); |
| 615 | } |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 616 | ASSERT(computeShader->getType() == GL_COMPUTE_SHADER); |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 617 | |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 618 | mState.mComputeShaderLocalSize = computeShader->getWorkGroupSize(); |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 619 | |
| 620 | // GLSL ES 3.10, 4.4.1.1 Compute Shader Inputs |
| 621 | // If the work group size is not specified, a link time error should occur. |
| 622 | if (!mState.mComputeShaderLocalSize.isDeclared()) |
| 623 | { |
| 624 | mInfoLog << "Work group size is not specified."; |
| 625 | return NoError(); |
| 626 | } |
| 627 | |
| 628 | if (!linkUniforms(mInfoLog, caps, mUniformBindings)) |
| 629 | { |
| 630 | return NoError(); |
| 631 | } |
| 632 | |
| 633 | if (!linkUniformBlocks(mInfoLog, caps)) |
| 634 | { |
| 635 | return NoError(); |
| 636 | } |
| 637 | |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 638 | gl::VaryingPacking noVaryingPacking(0, PackMode::ANGLE_RELAXED); |
| 639 | ANGLE_TRY_RESULT(mProgram->link(data, noVaryingPacking, mInfoLog), mLinked); |
Jamie Madill | b0a838b | 2016-11-13 20:02:12 -0500 | [diff] [blame] | 640 | if (!mLinked) |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 641 | { |
Jamie Madill | b0a838b | 2016-11-13 20:02:12 -0500 | [diff] [blame] | 642 | return NoError(); |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 643 | } |
| 644 | } |
| 645 | else |
| 646 | { |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 647 | if (!fragmentShader || !fragmentShader->isCompiled()) |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 648 | { |
| 649 | return NoError(); |
| 650 | } |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 651 | ASSERT(fragmentShader->getType() == GL_FRAGMENT_SHADER); |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 652 | |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 653 | if (!vertexShader || !vertexShader->isCompiled()) |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 654 | { |
| 655 | return NoError(); |
| 656 | } |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 657 | ASSERT(vertexShader->getType() == GL_VERTEX_SHADER); |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 658 | |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 659 | if (fragmentShader->getShaderVersion() != vertexShader->getShaderVersion()) |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 660 | { |
| 661 | mInfoLog << "Fragment shader version does not match vertex shader version."; |
| 662 | return NoError(); |
| 663 | } |
| 664 | |
Jamie Madill | eb979bf | 2016-11-15 12:28:46 -0500 | [diff] [blame] | 665 | if (!linkAttributes(data, mInfoLog)) |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 666 | { |
| 667 | return NoError(); |
| 668 | } |
| 669 | |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 670 | if (!linkVaryings(mInfoLog)) |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 671 | { |
| 672 | return NoError(); |
| 673 | } |
| 674 | |
| 675 | if (!linkUniforms(mInfoLog, caps, mUniformBindings)) |
| 676 | { |
| 677 | return NoError(); |
| 678 | } |
| 679 | |
| 680 | if (!linkUniformBlocks(mInfoLog, caps)) |
| 681 | { |
| 682 | return NoError(); |
| 683 | } |
| 684 | |
| 685 | const auto &mergedVaryings = getMergedVaryings(); |
| 686 | |
| 687 | if (!linkValidateTransformFeedback(mInfoLog, mergedVaryings, caps)) |
| 688 | { |
| 689 | return NoError(); |
| 690 | } |
| 691 | |
| 692 | linkOutputVariables(); |
| 693 | |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 694 | // Validate we can pack the varyings. |
| 695 | std::vector<PackedVarying> packedVaryings = getPackedVaryings(mergedVaryings); |
| 696 | |
| 697 | // Map the varyings to the register file |
| 698 | // In WebGL, we use a slightly different handling for packing variables. |
| 699 | auto packMode = data.getExtensions().webglCompatibility ? PackMode::WEBGL_STRICT |
| 700 | : PackMode::ANGLE_RELAXED; |
| 701 | VaryingPacking varyingPacking(data.getCaps().maxVaryingVectors, packMode); |
| 702 | if (!varyingPacking.packUserVaryings(mInfoLog, packedVaryings, |
| 703 | mState.getTransformFeedbackVaryingNames())) |
| 704 | { |
| 705 | return NoError(); |
| 706 | } |
| 707 | |
| 708 | ANGLE_TRY_RESULT(mProgram->link(data, varyingPacking, mInfoLog), mLinked); |
Jamie Madill | b0a838b | 2016-11-13 20:02:12 -0500 | [diff] [blame] | 709 | if (!mLinked) |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 710 | { |
Jamie Madill | b0a838b | 2016-11-13 20:02:12 -0500 | [diff] [blame] | 711 | return NoError(); |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 712 | } |
| 713 | |
| 714 | gatherTransformFeedbackVaryings(mergedVaryings); |
Jamie Madill | 437d266 | 2014-12-05 14:23:35 -0500 | [diff] [blame] | 715 | } |
| 716 | |
Jamie Madill | 4a3c234 | 2015-10-08 12:58:45 -0400 | [diff] [blame] | 717 | gatherInterfaceBlockInfo(); |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 718 | |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 719 | return NoError(); |
apatrick@chromium.org | 9a30b09 | 2012-06-06 20:21:55 +0000 | [diff] [blame] | 720 | } |
| 721 | |
daniel@transgaming.com | aa5e59b | 2011-10-04 18:43:12 +0000 | [diff] [blame] | 722 | // Returns the program object to an unlinked state, before re-linking, or at destruction |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 723 | void Program::unlink(bool destroy) |
| 724 | { |
| 725 | if (destroy) // Object being destructed |
| 726 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 727 | if (mState.mAttachedFragmentShader) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 728 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 729 | mState.mAttachedFragmentShader->release(); |
| 730 | mState.mAttachedFragmentShader = nullptr; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 731 | } |
| 732 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 733 | if (mState.mAttachedVertexShader) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 734 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 735 | mState.mAttachedVertexShader->release(); |
| 736 | mState.mAttachedVertexShader = nullptr; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 737 | } |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 738 | |
| 739 | if (mState.mAttachedComputeShader) |
| 740 | { |
| 741 | mState.mAttachedComputeShader->release(); |
| 742 | mState.mAttachedComputeShader = nullptr; |
| 743 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 744 | } |
| 745 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 746 | mState.mAttributes.clear(); |
| 747 | mState.mActiveAttribLocationsMask.reset(); |
| 748 | mState.mTransformFeedbackVaryingVars.clear(); |
| 749 | mState.mUniforms.clear(); |
| 750 | mState.mUniformLocations.clear(); |
| 751 | mState.mUniformBlocks.clear(); |
| 752 | mState.mOutputVariables.clear(); |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 753 | mState.mComputeShaderLocalSize.fill(1); |
Jamie Madill | e7d8432 | 2017-01-10 18:21:59 -0500 | [diff] [blame] | 754 | mState.mSamplerBindings.clear(); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 755 | |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 756 | mValidated = false; |
| 757 | |
daniel@transgaming.com | 716056c | 2012-07-24 18:38:59 +0000 | [diff] [blame] | 758 | mLinked = false; |
| 759 | } |
| 760 | |
Geoff Lang | e1a2775 | 2015-10-05 13:16:04 -0400 | [diff] [blame] | 761 | bool Program::isLinked() const |
daniel@transgaming.com | 716056c | 2012-07-24 18:38:59 +0000 | [diff] [blame] | 762 | { |
| 763 | return mLinked; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 764 | } |
| 765 | |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 766 | Error Program::loadBinary(const Context *context, |
| 767 | GLenum binaryFormat, |
| 768 | const void *binary, |
| 769 | GLsizei length) |
apatrick@chromium.org | 3ce8dbc | 2012-06-08 17:52:30 +0000 | [diff] [blame] | 770 | { |
| 771 | unlink(false); |
apatrick@chromium.org | 90080e3 | 2012-07-09 22:15:33 +0000 | [diff] [blame] | 772 | |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 773 | #if ANGLE_PROGRAM_BINARY_LOAD != ANGLE_ENABLED |
He Yunchao | acd1898 | 2017-01-04 10:46:42 +0800 | [diff] [blame] | 774 | return NoError(); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 775 | #else |
Geoff Lang | c46cc2f | 2015-10-01 17:16:20 -0400 | [diff] [blame] | 776 | ASSERT(binaryFormat == GL_PROGRAM_BINARY_ANGLE); |
| 777 | if (binaryFormat != GL_PROGRAM_BINARY_ANGLE) |
apatrick@chromium.org | 90080e3 | 2012-07-09 22:15:33 +0000 | [diff] [blame] | 778 | { |
Jamie Madill | f611316 | 2015-05-07 11:49:21 -0400 | [diff] [blame] | 779 | mInfoLog << "Invalid program binary format."; |
He Yunchao | acd1898 | 2017-01-04 10:46:42 +0800 | [diff] [blame] | 780 | return NoError(); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 781 | } |
| 782 | |
Geoff Lang | c46cc2f | 2015-10-01 17:16:20 -0400 | [diff] [blame] | 783 | BinaryInputStream stream(binary, length); |
| 784 | |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 785 | unsigned char commitString[ANGLE_COMMIT_HASH_SIZE]; |
| 786 | stream.readBytes(commitString, ANGLE_COMMIT_HASH_SIZE); |
| 787 | if (memcmp(commitString, ANGLE_COMMIT_HASH, sizeof(unsigned char) * ANGLE_COMMIT_HASH_SIZE) != |
| 788 | 0) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 789 | { |
Jamie Madill | f611316 | 2015-05-07 11:49:21 -0400 | [diff] [blame] | 790 | mInfoLog << "Invalid program binary version."; |
He Yunchao | acd1898 | 2017-01-04 10:46:42 +0800 | [diff] [blame] | 791 | return NoError(); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 792 | } |
| 793 | |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 794 | int majorVersion = stream.readInt<int>(); |
| 795 | int minorVersion = stream.readInt<int>(); |
| 796 | if (majorVersion != context->getClientMajorVersion() || |
| 797 | minorVersion != context->getClientMinorVersion()) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 798 | { |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 799 | mInfoLog << "Cannot load program binaries across different ES context versions."; |
He Yunchao | acd1898 | 2017-01-04 10:46:42 +0800 | [diff] [blame] | 800 | return NoError(); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 801 | } |
| 802 | |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 803 | mState.mComputeShaderLocalSize[0] = stream.readInt<int>(); |
| 804 | mState.mComputeShaderLocalSize[1] = stream.readInt<int>(); |
| 805 | mState.mComputeShaderLocalSize[2] = stream.readInt<int>(); |
| 806 | |
Jamie Madill | 63805b4 | 2015-08-25 13:17:39 -0400 | [diff] [blame] | 807 | static_assert(MAX_VERTEX_ATTRIBS <= sizeof(unsigned long) * 8, |
| 808 | "Too many vertex attribs for mask"); |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 809 | mState.mActiveAttribLocationsMask = stream.readInt<unsigned long>(); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 810 | |
Jamie Madill | 3da79b7 | 2015-04-27 11:09:17 -0400 | [diff] [blame] | 811 | unsigned int attribCount = stream.readInt<unsigned int>(); |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 812 | ASSERT(mState.mAttributes.empty()); |
Jamie Madill | 3da79b7 | 2015-04-27 11:09:17 -0400 | [diff] [blame] | 813 | for (unsigned int attribIndex = 0; attribIndex < attribCount; ++attribIndex) |
| 814 | { |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 815 | sh::Attribute attrib; |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 816 | LoadShaderVar(&stream, &attrib); |
| 817 | attrib.location = stream.readInt<int>(); |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 818 | mState.mAttributes.push_back(attrib); |
Jamie Madill | 3da79b7 | 2015-04-27 11:09:17 -0400 | [diff] [blame] | 819 | } |
| 820 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 821 | unsigned int uniformCount = stream.readInt<unsigned int>(); |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 822 | ASSERT(mState.mUniforms.empty()); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 823 | for (unsigned int uniformIndex = 0; uniformIndex < uniformCount; ++uniformIndex) |
| 824 | { |
| 825 | LinkedUniform uniform; |
| 826 | LoadShaderVar(&stream, &uniform); |
| 827 | |
| 828 | uniform.blockIndex = stream.readInt<int>(); |
| 829 | uniform.blockInfo.offset = stream.readInt<int>(); |
| 830 | uniform.blockInfo.arrayStride = stream.readInt<int>(); |
| 831 | uniform.blockInfo.matrixStride = stream.readInt<int>(); |
| 832 | uniform.blockInfo.isRowMajorMatrix = stream.readBool(); |
| 833 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 834 | mState.mUniforms.push_back(uniform); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 835 | } |
| 836 | |
| 837 | const unsigned int uniformIndexCount = stream.readInt<unsigned int>(); |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 838 | ASSERT(mState.mUniformLocations.empty()); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 839 | for (unsigned int uniformIndexIndex = 0; uniformIndexIndex < uniformIndexCount; |
| 840 | uniformIndexIndex++) |
| 841 | { |
| 842 | VariableLocation variable; |
| 843 | stream.readString(&variable.name); |
| 844 | stream.readInt(&variable.element); |
| 845 | stream.readInt(&variable.index); |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 846 | stream.readBool(&variable.used); |
| 847 | stream.readBool(&variable.ignored); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 848 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 849 | mState.mUniformLocations.push_back(variable); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 850 | } |
| 851 | |
| 852 | unsigned int uniformBlockCount = stream.readInt<unsigned int>(); |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 853 | ASSERT(mState.mUniformBlocks.empty()); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 854 | for (unsigned int uniformBlockIndex = 0; uniformBlockIndex < uniformBlockCount; |
| 855 | ++uniformBlockIndex) |
| 856 | { |
| 857 | UniformBlock uniformBlock; |
| 858 | stream.readString(&uniformBlock.name); |
| 859 | stream.readBool(&uniformBlock.isArray); |
| 860 | stream.readInt(&uniformBlock.arrayElement); |
| 861 | stream.readInt(&uniformBlock.dataSize); |
| 862 | stream.readBool(&uniformBlock.vertexStaticUse); |
| 863 | stream.readBool(&uniformBlock.fragmentStaticUse); |
| 864 | |
| 865 | unsigned int numMembers = stream.readInt<unsigned int>(); |
| 866 | for (unsigned int blockMemberIndex = 0; blockMemberIndex < numMembers; blockMemberIndex++) |
| 867 | { |
| 868 | uniformBlock.memberUniformIndexes.push_back(stream.readInt<unsigned int>()); |
| 869 | } |
| 870 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 871 | mState.mUniformBlocks.push_back(uniformBlock); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 872 | } |
| 873 | |
Jamie Madill | a7d12dc | 2016-12-13 15:08:19 -0500 | [diff] [blame] | 874 | for (GLuint bindingIndex = 0; bindingIndex < mState.mUniformBlockBindings.size(); |
| 875 | ++bindingIndex) |
| 876 | { |
| 877 | stream.readInt(&mState.mUniformBlockBindings[bindingIndex]); |
| 878 | mState.mActiveUniformBlockBindings.set(bindingIndex, |
| 879 | mState.mUniformBlockBindings[bindingIndex] != 0); |
| 880 | } |
| 881 | |
Brandon Jones | 1048ea7 | 2015-10-06 15:34:52 -0700 | [diff] [blame] | 882 | unsigned int transformFeedbackVaryingCount = stream.readInt<unsigned int>(); |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 883 | ASSERT(mState.mTransformFeedbackVaryingVars.empty()); |
Brandon Jones | 1048ea7 | 2015-10-06 15:34:52 -0700 | [diff] [blame] | 884 | for (unsigned int transformFeedbackVaryingIndex = 0; |
| 885 | transformFeedbackVaryingIndex < transformFeedbackVaryingCount; |
| 886 | ++transformFeedbackVaryingIndex) |
| 887 | { |
| 888 | sh::Varying varying; |
| 889 | stream.readInt(&varying.arraySize); |
| 890 | stream.readInt(&varying.type); |
| 891 | stream.readString(&varying.name); |
| 892 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 893 | mState.mTransformFeedbackVaryingVars.push_back(varying); |
Brandon Jones | 1048ea7 | 2015-10-06 15:34:52 -0700 | [diff] [blame] | 894 | } |
| 895 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 896 | stream.readInt(&mState.mTransformFeedbackBufferMode); |
Jamie Madill | ada9ecc | 2015-08-17 12:53:37 -0400 | [diff] [blame] | 897 | |
Jamie Madill | 80a6fc0 | 2015-08-21 16:53:16 -0400 | [diff] [blame] | 898 | unsigned int outputVarCount = stream.readInt<unsigned int>(); |
| 899 | for (unsigned int outputIndex = 0; outputIndex < outputVarCount; ++outputIndex) |
| 900 | { |
| 901 | int locationIndex = stream.readInt<int>(); |
| 902 | VariableLocation locationData; |
Jamie Madill | 3d3d2f2 | 2015-09-23 16:47:51 -0400 | [diff] [blame] | 903 | stream.readInt(&locationData.element); |
| 904 | stream.readInt(&locationData.index); |
| 905 | stream.readString(&locationData.name); |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 906 | mState.mOutputVariables[locationIndex] = locationData; |
Jamie Madill | 80a6fc0 | 2015-08-21 16:53:16 -0400 | [diff] [blame] | 907 | } |
| 908 | |
Jamie Madill | e7d8432 | 2017-01-10 18:21:59 -0500 | [diff] [blame] | 909 | stream.readInt(&mState.mSamplerUniformRange.start); |
| 910 | stream.readInt(&mState.mSamplerUniformRange.end); |
| 911 | |
| 912 | unsigned int samplerCount = stream.readInt<unsigned int>(); |
| 913 | for (unsigned int samplerIndex = 0; samplerIndex < samplerCount; ++samplerIndex) |
| 914 | { |
| 915 | GLenum textureType = stream.readInt<GLenum>(); |
| 916 | size_t bindingCount = stream.readInt<size_t>(); |
| 917 | mState.mSamplerBindings.emplace_back(SamplerBinding(textureType, bindingCount)); |
| 918 | } |
Jamie Madill | 3d3d2f2 | 2015-09-23 16:47:51 -0400 | [diff] [blame] | 919 | |
Jamie Madill | a7d12dc | 2016-12-13 15:08:19 -0500 | [diff] [blame] | 920 | ANGLE_TRY_RESULT(mProgram->load(context->getImplementation(), mInfoLog, &stream), mLinked); |
daniel@transgaming.com | 4c962bf | 2012-07-24 18:37:02 +0000 | [diff] [blame] | 921 | |
Jamie Madill | b0a838b | 2016-11-13 20:02:12 -0500 | [diff] [blame] | 922 | return NoError(); |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 923 | #endif // #if ANGLE_PROGRAM_BINARY_LOAD == ANGLE_ENABLED |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 924 | } |
| 925 | |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 926 | Error Program::saveBinary(const Context *context, |
| 927 | GLenum *binaryFormat, |
| 928 | void *binary, |
| 929 | GLsizei bufSize, |
| 930 | GLsizei *length) const |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 931 | { |
| 932 | if (binaryFormat) |
| 933 | { |
Geoff Lang | c46cc2f | 2015-10-01 17:16:20 -0400 | [diff] [blame] | 934 | *binaryFormat = GL_PROGRAM_BINARY_ANGLE; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 935 | } |
| 936 | |
| 937 | BinaryOutputStream stream; |
| 938 | |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 939 | stream.writeBytes(reinterpret_cast<const unsigned char*>(ANGLE_COMMIT_HASH), ANGLE_COMMIT_HASH_SIZE); |
| 940 | |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 941 | // nullptr context is supported when computing binary length. |
| 942 | if (context) |
| 943 | { |
| 944 | stream.writeInt(context->getClientVersion().major); |
| 945 | stream.writeInt(context->getClientVersion().minor); |
| 946 | } |
| 947 | else |
| 948 | { |
| 949 | stream.writeInt(2); |
| 950 | stream.writeInt(0); |
| 951 | } |
| 952 | |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 953 | stream.writeInt(mState.mComputeShaderLocalSize[0]); |
| 954 | stream.writeInt(mState.mComputeShaderLocalSize[1]); |
| 955 | stream.writeInt(mState.mComputeShaderLocalSize[2]); |
| 956 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 957 | stream.writeInt(mState.mActiveAttribLocationsMask.to_ulong()); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 958 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 959 | stream.writeInt(mState.mAttributes.size()); |
| 960 | for (const sh::Attribute &attrib : mState.mAttributes) |
Jamie Madill | 3da79b7 | 2015-04-27 11:09:17 -0400 | [diff] [blame] | 961 | { |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 962 | WriteShaderVar(&stream, attrib); |
Jamie Madill | 3da79b7 | 2015-04-27 11:09:17 -0400 | [diff] [blame] | 963 | stream.writeInt(attrib.location); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 964 | } |
| 965 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 966 | stream.writeInt(mState.mUniforms.size()); |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 967 | for (const LinkedUniform &uniform : mState.mUniforms) |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 968 | { |
| 969 | WriteShaderVar(&stream, uniform); |
| 970 | |
| 971 | // FIXME: referenced |
| 972 | |
| 973 | stream.writeInt(uniform.blockIndex); |
| 974 | stream.writeInt(uniform.blockInfo.offset); |
| 975 | stream.writeInt(uniform.blockInfo.arrayStride); |
| 976 | stream.writeInt(uniform.blockInfo.matrixStride); |
| 977 | stream.writeInt(uniform.blockInfo.isRowMajorMatrix); |
| 978 | } |
| 979 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 980 | stream.writeInt(mState.mUniformLocations.size()); |
| 981 | for (const auto &variable : mState.mUniformLocations) |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 982 | { |
| 983 | stream.writeString(variable.name); |
| 984 | stream.writeInt(variable.element); |
| 985 | stream.writeInt(variable.index); |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 986 | stream.writeInt(variable.used); |
| 987 | stream.writeInt(variable.ignored); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 988 | } |
| 989 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 990 | stream.writeInt(mState.mUniformBlocks.size()); |
| 991 | for (const UniformBlock &uniformBlock : mState.mUniformBlocks) |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 992 | { |
| 993 | stream.writeString(uniformBlock.name); |
| 994 | stream.writeInt(uniformBlock.isArray); |
| 995 | stream.writeInt(uniformBlock.arrayElement); |
| 996 | stream.writeInt(uniformBlock.dataSize); |
| 997 | |
| 998 | stream.writeInt(uniformBlock.vertexStaticUse); |
| 999 | stream.writeInt(uniformBlock.fragmentStaticUse); |
| 1000 | |
| 1001 | stream.writeInt(uniformBlock.memberUniformIndexes.size()); |
| 1002 | for (unsigned int memberUniformIndex : uniformBlock.memberUniformIndexes) |
| 1003 | { |
| 1004 | stream.writeInt(memberUniformIndex); |
| 1005 | } |
Jamie Madill | 3da79b7 | 2015-04-27 11:09:17 -0400 | [diff] [blame] | 1006 | } |
| 1007 | |
Jamie Madill | a7d12dc | 2016-12-13 15:08:19 -0500 | [diff] [blame] | 1008 | for (GLuint binding : mState.mUniformBlockBindings) |
| 1009 | { |
| 1010 | stream.writeInt(binding); |
| 1011 | } |
| 1012 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1013 | stream.writeInt(mState.mTransformFeedbackVaryingVars.size()); |
| 1014 | for (const sh::Varying &varying : mState.mTransformFeedbackVaryingVars) |
Brandon Jones | 1048ea7 | 2015-10-06 15:34:52 -0700 | [diff] [blame] | 1015 | { |
| 1016 | stream.writeInt(varying.arraySize); |
| 1017 | stream.writeInt(varying.type); |
| 1018 | stream.writeString(varying.name); |
| 1019 | } |
| 1020 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1021 | stream.writeInt(mState.mTransformFeedbackBufferMode); |
Jamie Madill | ada9ecc | 2015-08-17 12:53:37 -0400 | [diff] [blame] | 1022 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1023 | stream.writeInt(mState.mOutputVariables.size()); |
| 1024 | for (const auto &outputPair : mState.mOutputVariables) |
Jamie Madill | 80a6fc0 | 2015-08-21 16:53:16 -0400 | [diff] [blame] | 1025 | { |
| 1026 | stream.writeInt(outputPair.first); |
Jamie Madill | e2e406c | 2016-06-02 13:04:10 -0400 | [diff] [blame] | 1027 | stream.writeIntOrNegOne(outputPair.second.element); |
Jamie Madill | 80a6fc0 | 2015-08-21 16:53:16 -0400 | [diff] [blame] | 1028 | stream.writeInt(outputPair.second.index); |
| 1029 | stream.writeString(outputPair.second.name); |
| 1030 | } |
| 1031 | |
Jamie Madill | e7d8432 | 2017-01-10 18:21:59 -0500 | [diff] [blame] | 1032 | stream.writeInt(mState.mSamplerUniformRange.start); |
| 1033 | stream.writeInt(mState.mSamplerUniformRange.end); |
| 1034 | |
| 1035 | stream.writeInt(mState.mSamplerBindings.size()); |
| 1036 | for (const auto &samplerBinding : mState.mSamplerBindings) |
| 1037 | { |
| 1038 | stream.writeInt(samplerBinding.textureType); |
| 1039 | stream.writeInt(samplerBinding.boundTextureUnits.size()); |
| 1040 | } |
Jamie Madill | 3d3d2f2 | 2015-09-23 16:47:51 -0400 | [diff] [blame] | 1041 | |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 1042 | ANGLE_TRY(mProgram->save(&stream)); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1043 | |
Cooper Partin | 4d61f7e | 2015-08-12 10:56:50 -0700 | [diff] [blame] | 1044 | GLsizei streamLength = static_cast<GLsizei>(stream.length()); |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1045 | const void *streamState = stream.data(); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1046 | |
| 1047 | if (streamLength > bufSize) |
| 1048 | { |
| 1049 | if (length) |
| 1050 | { |
| 1051 | *length = 0; |
| 1052 | } |
| 1053 | |
| 1054 | // TODO: This should be moved to the validation layer but computing the size of the binary before saving |
| 1055 | // it causes the save to happen twice. It may be possible to write the binary to a separate buffer, validate |
| 1056 | // sizes and then copy it. |
| 1057 | return Error(GL_INVALID_OPERATION); |
| 1058 | } |
| 1059 | |
| 1060 | if (binary) |
| 1061 | { |
| 1062 | char *ptr = reinterpret_cast<char*>(binary); |
| 1063 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1064 | memcpy(ptr, streamState, streamLength); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1065 | ptr += streamLength; |
| 1066 | |
| 1067 | ASSERT(ptr - streamLength == binary); |
| 1068 | } |
| 1069 | |
| 1070 | if (length) |
| 1071 | { |
| 1072 | *length = streamLength; |
| 1073 | } |
| 1074 | |
He Yunchao | acd1898 | 2017-01-04 10:46:42 +0800 | [diff] [blame] | 1075 | return NoError(); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1076 | } |
| 1077 | |
| 1078 | GLint Program::getBinaryLength() const |
| 1079 | { |
| 1080 | GLint length; |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 1081 | Error error = saveBinary(nullptr, nullptr, nullptr, std::numeric_limits<GLint>::max(), &length); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1082 | if (error.isError()) |
| 1083 | { |
| 1084 | return 0; |
| 1085 | } |
| 1086 | |
| 1087 | return length; |
apatrick@chromium.org | 3ce8dbc | 2012-06-08 17:52:30 +0000 | [diff] [blame] | 1088 | } |
| 1089 | |
Geoff Lang | c562975 | 2015-12-07 16:29:04 -0500 | [diff] [blame] | 1090 | void Program::setBinaryRetrievableHint(bool retrievable) |
| 1091 | { |
| 1092 | // TODO(jmadill) : replace with dirty bits |
| 1093 | mProgram->setBinaryRetrievableHint(retrievable); |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1094 | mState.mBinaryRetrieveableHint = retrievable; |
Geoff Lang | c562975 | 2015-12-07 16:29:04 -0500 | [diff] [blame] | 1095 | } |
| 1096 | |
| 1097 | bool Program::getBinaryRetrievableHint() const |
| 1098 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1099 | return mState.mBinaryRetrieveableHint; |
Geoff Lang | c562975 | 2015-12-07 16:29:04 -0500 | [diff] [blame] | 1100 | } |
| 1101 | |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 1102 | void Program::release() |
| 1103 | { |
| 1104 | mRefCount--; |
| 1105 | |
| 1106 | if (mRefCount == 0 && mDeleteStatus) |
| 1107 | { |
| 1108 | mResourceManager->deleteProgram(mHandle); |
| 1109 | } |
| 1110 | } |
| 1111 | |
| 1112 | void Program::addRef() |
| 1113 | { |
| 1114 | mRefCount++; |
| 1115 | } |
| 1116 | |
| 1117 | unsigned int Program::getRefCount() const |
| 1118 | { |
| 1119 | return mRefCount; |
| 1120 | } |
| 1121 | |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1122 | int Program::getInfoLogLength() const |
| 1123 | { |
Jamie Madill | 71c3b2c | 2015-05-07 11:49:20 -0400 | [diff] [blame] | 1124 | return static_cast<int>(mInfoLog.getLength()); |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1125 | } |
| 1126 | |
Geoff Lang | e1a2775 | 2015-10-05 13:16:04 -0400 | [diff] [blame] | 1127 | void Program::getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog) const |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1128 | { |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 1129 | return mInfoLog.getLog(bufSize, length, infoLog); |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1130 | } |
| 1131 | |
Geoff Lang | e1a2775 | 2015-10-05 13:16:04 -0400 | [diff] [blame] | 1132 | void Program::getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shaders) const |
daniel@transgaming.com | 6c78521 | 2010-03-30 03:36:17 +0000 | [diff] [blame] | 1133 | { |
| 1134 | int total = 0; |
| 1135 | |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 1136 | if (mState.mAttachedComputeShader) |
| 1137 | { |
| 1138 | if (total < maxCount) |
| 1139 | { |
| 1140 | shaders[total] = mState.mAttachedComputeShader->getHandle(); |
| 1141 | total++; |
| 1142 | } |
| 1143 | } |
| 1144 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1145 | if (mState.mAttachedVertexShader) |
daniel@transgaming.com | 6c78521 | 2010-03-30 03:36:17 +0000 | [diff] [blame] | 1146 | { |
| 1147 | if (total < maxCount) |
| 1148 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1149 | shaders[total] = mState.mAttachedVertexShader->getHandle(); |
Olli Etuaho | 586bc55 | 2016-03-04 11:46:03 +0200 | [diff] [blame] | 1150 | total++; |
daniel@transgaming.com | 6c78521 | 2010-03-30 03:36:17 +0000 | [diff] [blame] | 1151 | } |
daniel@transgaming.com | 6c78521 | 2010-03-30 03:36:17 +0000 | [diff] [blame] | 1152 | } |
| 1153 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1154 | if (mState.mAttachedFragmentShader) |
daniel@transgaming.com | 6c78521 | 2010-03-30 03:36:17 +0000 | [diff] [blame] | 1155 | { |
| 1156 | if (total < maxCount) |
| 1157 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1158 | shaders[total] = mState.mAttachedFragmentShader->getHandle(); |
Olli Etuaho | 586bc55 | 2016-03-04 11:46:03 +0200 | [diff] [blame] | 1159 | total++; |
daniel@transgaming.com | 6c78521 | 2010-03-30 03:36:17 +0000 | [diff] [blame] | 1160 | } |
daniel@transgaming.com | 6c78521 | 2010-03-30 03:36:17 +0000 | [diff] [blame] | 1161 | } |
| 1162 | |
| 1163 | if (count) |
| 1164 | { |
| 1165 | *count = total; |
| 1166 | } |
| 1167 | } |
| 1168 | |
Geoff Lang | e1a2775 | 2015-10-05 13:16:04 -0400 | [diff] [blame] | 1169 | GLuint Program::getAttributeLocation(const std::string &name) const |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1170 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1171 | for (const sh::Attribute &attribute : mState.mAttributes) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1172 | { |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 1173 | if (attribute.name == name && attribute.staticUse) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1174 | { |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 1175 | return attribute.location; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1176 | } |
| 1177 | } |
| 1178 | |
Austin Kinross | b8af723 | 2015-03-16 22:33:25 -0700 | [diff] [blame] | 1179 | return static_cast<GLuint>(-1); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1180 | } |
| 1181 | |
Jamie Madill | 63805b4 | 2015-08-25 13:17:39 -0400 | [diff] [blame] | 1182 | bool Program::isAttribLocationActive(size_t attribLocation) const |
Jamie Madill | 56c6e3c | 2015-04-15 10:18:05 -0400 | [diff] [blame] | 1183 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1184 | ASSERT(attribLocation < mState.mActiveAttribLocationsMask.size()); |
| 1185 | return mState.mActiveAttribLocationsMask[attribLocation]; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1186 | } |
| 1187 | |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1188 | void Program::getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) |
| 1189 | { |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 1190 | if (!mLinked) |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1191 | { |
| 1192 | if (bufsize > 0) |
| 1193 | { |
| 1194 | name[0] = '\0'; |
| 1195 | } |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1196 | |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1197 | if (length) |
| 1198 | { |
| 1199 | *length = 0; |
| 1200 | } |
| 1201 | |
| 1202 | *type = GL_NONE; |
| 1203 | *size = 1; |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 1204 | return; |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1205 | } |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 1206 | |
| 1207 | size_t attributeIndex = 0; |
| 1208 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1209 | for (const sh::Attribute &attribute : mState.mAttributes) |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 1210 | { |
| 1211 | // Skip over inactive attributes |
| 1212 | if (attribute.staticUse) |
| 1213 | { |
| 1214 | if (static_cast<size_t>(index) == attributeIndex) |
| 1215 | { |
| 1216 | break; |
| 1217 | } |
| 1218 | attributeIndex++; |
| 1219 | } |
| 1220 | } |
| 1221 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1222 | ASSERT(index == attributeIndex && attributeIndex < mState.mAttributes.size()); |
| 1223 | const sh::Attribute &attrib = mState.mAttributes[attributeIndex]; |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 1224 | |
| 1225 | if (bufsize > 0) |
| 1226 | { |
| 1227 | const char *string = attrib.name.c_str(); |
| 1228 | |
| 1229 | strncpy(name, string, bufsize); |
| 1230 | name[bufsize - 1] = '\0'; |
| 1231 | |
| 1232 | if (length) |
| 1233 | { |
| 1234 | *length = static_cast<GLsizei>(strlen(name)); |
| 1235 | } |
| 1236 | } |
| 1237 | |
| 1238 | // Always a single 'type' instance |
| 1239 | *size = 1; |
| 1240 | *type = attrib.type; |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1241 | } |
| 1242 | |
Geoff Lang | e1a2775 | 2015-10-05 13:16:04 -0400 | [diff] [blame] | 1243 | GLint Program::getActiveAttributeCount() const |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1244 | { |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 1245 | if (!mLinked) |
Jamie Madill | 2d77318 | 2015-08-18 10:27:28 -0400 | [diff] [blame] | 1246 | { |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 1247 | return 0; |
| 1248 | } |
| 1249 | |
| 1250 | GLint count = 0; |
| 1251 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1252 | for (const sh::Attribute &attrib : mState.mAttributes) |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 1253 | { |
| 1254 | count += (attrib.staticUse ? 1 : 0); |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1255 | } |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1256 | |
| 1257 | return count; |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1258 | } |
| 1259 | |
Geoff Lang | e1a2775 | 2015-10-05 13:16:04 -0400 | [diff] [blame] | 1260 | GLint Program::getActiveAttributeMaxLength() const |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1261 | { |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 1262 | if (!mLinked) |
Jamie Madill | 2d77318 | 2015-08-18 10:27:28 -0400 | [diff] [blame] | 1263 | { |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 1264 | return 0; |
| 1265 | } |
| 1266 | |
| 1267 | size_t maxLength = 0; |
| 1268 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1269 | for (const sh::Attribute &attrib : mState.mAttributes) |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 1270 | { |
| 1271 | if (attrib.staticUse) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1272 | { |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 1273 | maxLength = std::max(attrib.name.length() + 1, maxLength); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1274 | } |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1275 | } |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1276 | |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 1277 | return static_cast<GLint>(maxLength); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1278 | } |
| 1279 | |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1280 | GLint Program::getFragDataLocation(const std::string &name) const |
| 1281 | { |
| 1282 | std::string baseName(name); |
| 1283 | unsigned int arrayIndex = ParseAndStripArrayIndex(&baseName); |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1284 | for (auto outputPair : mState.mOutputVariables) |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1285 | { |
Jamie Madill | 5c6b7bf | 2015-08-17 12:53:35 -0400 | [diff] [blame] | 1286 | const VariableLocation &outputVariable = outputPair.second; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1287 | if (outputVariable.name == baseName && (arrayIndex == GL_INVALID_INDEX || arrayIndex == outputVariable.element)) |
| 1288 | { |
Jamie Madill | 5c6b7bf | 2015-08-17 12:53:35 -0400 | [diff] [blame] | 1289 | return static_cast<GLint>(outputPair.first); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1290 | } |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1291 | } |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1292 | return -1; |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1293 | } |
| 1294 | |
Geoff Lang | e1a2775 | 2015-10-05 13:16:04 -0400 | [diff] [blame] | 1295 | void Program::getActiveUniform(GLuint index, |
| 1296 | GLsizei bufsize, |
| 1297 | GLsizei *length, |
| 1298 | GLint *size, |
| 1299 | GLenum *type, |
| 1300 | GLchar *name) const |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1301 | { |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1302 | if (mLinked) |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1303 | { |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1304 | // index must be smaller than getActiveUniformCount() |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1305 | ASSERT(index < mState.mUniforms.size()); |
| 1306 | const LinkedUniform &uniform = mState.mUniforms[index]; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1307 | |
| 1308 | if (bufsize > 0) |
| 1309 | { |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1310 | std::string string = uniform.name; |
| 1311 | if (uniform.isArray()) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1312 | { |
| 1313 | string += "[0]"; |
| 1314 | } |
| 1315 | |
| 1316 | strncpy(name, string.c_str(), bufsize); |
| 1317 | name[bufsize - 1] = '\0'; |
| 1318 | |
| 1319 | if (length) |
| 1320 | { |
Cooper Partin | 4d61f7e | 2015-08-12 10:56:50 -0700 | [diff] [blame] | 1321 | *length = static_cast<GLsizei>(strlen(name)); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1322 | } |
| 1323 | } |
| 1324 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1325 | *size = uniform.elementCount(); |
| 1326 | *type = uniform.type; |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1327 | } |
| 1328 | else |
| 1329 | { |
| 1330 | if (bufsize > 0) |
| 1331 | { |
| 1332 | name[0] = '\0'; |
| 1333 | } |
| 1334 | |
| 1335 | if (length) |
| 1336 | { |
| 1337 | *length = 0; |
| 1338 | } |
| 1339 | |
| 1340 | *size = 0; |
| 1341 | *type = GL_NONE; |
| 1342 | } |
| 1343 | } |
| 1344 | |
Geoff Lang | e1a2775 | 2015-10-05 13:16:04 -0400 | [diff] [blame] | 1345 | GLint Program::getActiveUniformCount() const |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1346 | { |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1347 | if (mLinked) |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1348 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1349 | return static_cast<GLint>(mState.mUniforms.size()); |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1350 | } |
| 1351 | else |
| 1352 | { |
| 1353 | return 0; |
| 1354 | } |
| 1355 | } |
| 1356 | |
Geoff Lang | e1a2775 | 2015-10-05 13:16:04 -0400 | [diff] [blame] | 1357 | GLint Program::getActiveUniformMaxLength() const |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1358 | { |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1359 | size_t maxLength = 0; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1360 | |
| 1361 | if (mLinked) |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1362 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1363 | for (const LinkedUniform &uniform : mState.mUniforms) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1364 | { |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1365 | if (!uniform.name.empty()) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1366 | { |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1367 | size_t length = uniform.name.length() + 1u; |
| 1368 | if (uniform.isArray()) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1369 | { |
| 1370 | length += 3; // Counting in "[0]". |
| 1371 | } |
| 1372 | maxLength = std::max(length, maxLength); |
| 1373 | } |
| 1374 | } |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1375 | } |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1376 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1377 | return static_cast<GLint>(maxLength); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1378 | } |
| 1379 | |
| 1380 | GLint Program::getActiveUniformi(GLuint index, GLenum pname) const |
| 1381 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1382 | ASSERT(static_cast<size_t>(index) < mState.mUniforms.size()); |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 1383 | const LinkedUniform &uniform = mState.mUniforms[index]; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1384 | switch (pname) |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1385 | { |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1386 | case GL_UNIFORM_TYPE: return static_cast<GLint>(uniform.type); |
| 1387 | case GL_UNIFORM_SIZE: return static_cast<GLint>(uniform.elementCount()); |
| 1388 | case GL_UNIFORM_NAME_LENGTH: return static_cast<GLint>(uniform.name.size() + 1 + (uniform.isArray() ? 3 : 0)); |
| 1389 | case GL_UNIFORM_BLOCK_INDEX: return uniform.blockIndex; |
| 1390 | case GL_UNIFORM_OFFSET: return uniform.blockInfo.offset; |
| 1391 | case GL_UNIFORM_ARRAY_STRIDE: return uniform.blockInfo.arrayStride; |
| 1392 | case GL_UNIFORM_MATRIX_STRIDE: return uniform.blockInfo.matrixStride; |
| 1393 | case GL_UNIFORM_IS_ROW_MAJOR: return static_cast<GLint>(uniform.blockInfo.isRowMajorMatrix); |
| 1394 | default: |
| 1395 | UNREACHABLE(); |
| 1396 | break; |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1397 | } |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1398 | return 0; |
| 1399 | } |
| 1400 | |
| 1401 | bool Program::isValidUniformLocation(GLint location) const |
| 1402 | { |
Jamie Madill | e2e406c | 2016-06-02 13:04:10 -0400 | [diff] [blame] | 1403 | ASSERT(angle::IsValueInRangeForNumericType<GLint>(mState.mUniformLocations.size())); |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1404 | return (location >= 0 && static_cast<size_t>(location) < mState.mUniformLocations.size() && |
| 1405 | mState.mUniformLocations[static_cast<size_t>(location)].used); |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 1406 | } |
| 1407 | |
| 1408 | bool Program::isIgnoredUniformLocation(GLint location) const |
| 1409 | { |
| 1410 | // Location is ignored if it is -1 or it was bound but non-existant in the shader or optimized |
| 1411 | // out |
| 1412 | return location == -1 || |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1413 | (location >= 0 && static_cast<size_t>(location) < mState.mUniformLocations.size() && |
| 1414 | mState.mUniformLocations[static_cast<size_t>(location)].ignored); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1415 | } |
| 1416 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1417 | const LinkedUniform &Program::getUniformByLocation(GLint location) const |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1418 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1419 | ASSERT(location >= 0 && static_cast<size_t>(location) < mState.mUniformLocations.size()); |
Jamie Madill | e7d8432 | 2017-01-10 18:21:59 -0500 | [diff] [blame] | 1420 | return mState.mUniforms[mState.getUniformIndexFromLocation(location)]; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1421 | } |
| 1422 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1423 | GLint Program::getUniformLocation(const std::string &name) const |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1424 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1425 | return mState.getUniformLocation(name); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1426 | } |
| 1427 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1428 | GLuint Program::getUniformIndex(const std::string &name) const |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1429 | { |
Jamie Madill | e7d8432 | 2017-01-10 18:21:59 -0500 | [diff] [blame] | 1430 | return mState.getUniformIndexFromName(name); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1431 | } |
| 1432 | |
| 1433 | void Program::setUniform1fv(GLint location, GLsizei count, const GLfloat *v) |
| 1434 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1435 | GLsizei clampedCount = setUniformInternal(location, count, 1, v); |
| 1436 | mProgram->setUniform1fv(location, clampedCount, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1437 | } |
| 1438 | |
| 1439 | void Program::setUniform2fv(GLint location, GLsizei count, const GLfloat *v) |
| 1440 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1441 | GLsizei clampedCount = setUniformInternal(location, count, 2, v); |
| 1442 | mProgram->setUniform2fv(location, clampedCount, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1443 | } |
| 1444 | |
| 1445 | void Program::setUniform3fv(GLint location, GLsizei count, const GLfloat *v) |
| 1446 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1447 | GLsizei clampedCount = setUniformInternal(location, count, 3, v); |
| 1448 | mProgram->setUniform3fv(location, clampedCount, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1449 | } |
| 1450 | |
| 1451 | void Program::setUniform4fv(GLint location, GLsizei count, const GLfloat *v) |
| 1452 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1453 | GLsizei clampedCount = setUniformInternal(location, count, 4, v); |
| 1454 | mProgram->setUniform4fv(location, clampedCount, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1455 | } |
| 1456 | |
| 1457 | void Program::setUniform1iv(GLint location, GLsizei count, const GLint *v) |
| 1458 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1459 | GLsizei clampedCount = setUniformInternal(location, count, 1, v); |
| 1460 | mProgram->setUniform1iv(location, clampedCount, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1461 | } |
| 1462 | |
| 1463 | void Program::setUniform2iv(GLint location, GLsizei count, const GLint *v) |
| 1464 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1465 | GLsizei clampedCount = setUniformInternal(location, count, 2, v); |
| 1466 | mProgram->setUniform2iv(location, clampedCount, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1467 | } |
| 1468 | |
| 1469 | void Program::setUniform3iv(GLint location, GLsizei count, const GLint *v) |
| 1470 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1471 | GLsizei clampedCount = setUniformInternal(location, count, 3, v); |
| 1472 | mProgram->setUniform3iv(location, clampedCount, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1473 | } |
| 1474 | |
| 1475 | void Program::setUniform4iv(GLint location, GLsizei count, const GLint *v) |
| 1476 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1477 | GLsizei clampedCount = setUniformInternal(location, count, 4, v); |
| 1478 | mProgram->setUniform4iv(location, clampedCount, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1479 | } |
| 1480 | |
| 1481 | void Program::setUniform1uiv(GLint location, GLsizei count, const GLuint *v) |
| 1482 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1483 | GLsizei clampedCount = setUniformInternal(location, count, 1, v); |
| 1484 | mProgram->setUniform1uiv(location, clampedCount, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1485 | } |
| 1486 | |
| 1487 | void Program::setUniform2uiv(GLint location, GLsizei count, const GLuint *v) |
| 1488 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1489 | GLsizei clampedCount = setUniformInternal(location, count, 2, v); |
| 1490 | mProgram->setUniform2uiv(location, clampedCount, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1491 | } |
| 1492 | |
| 1493 | void Program::setUniform3uiv(GLint location, GLsizei count, const GLuint *v) |
| 1494 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1495 | GLsizei clampedCount = setUniformInternal(location, count, 3, v); |
| 1496 | mProgram->setUniform3uiv(location, clampedCount, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1497 | } |
| 1498 | |
| 1499 | void Program::setUniform4uiv(GLint location, GLsizei count, const GLuint *v) |
| 1500 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1501 | GLsizei clampedCount = setUniformInternal(location, count, 4, v); |
| 1502 | mProgram->setUniform4uiv(location, clampedCount, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1503 | } |
| 1504 | |
| 1505 | void Program::setUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v) |
| 1506 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1507 | GLsizei clampedCount = setMatrixUniformInternal<2, 2>(location, count, transpose, v); |
| 1508 | mProgram->setUniformMatrix2fv(location, clampedCount, transpose, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1509 | } |
| 1510 | |
| 1511 | void Program::setUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v) |
| 1512 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1513 | GLsizei clampedCount = setMatrixUniformInternal<3, 3>(location, count, transpose, v); |
| 1514 | mProgram->setUniformMatrix3fv(location, clampedCount, transpose, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1515 | } |
| 1516 | |
| 1517 | void Program::setUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v) |
| 1518 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1519 | GLsizei clampedCount = setMatrixUniformInternal<4, 4>(location, count, transpose, v); |
| 1520 | mProgram->setUniformMatrix4fv(location, clampedCount, transpose, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1521 | } |
| 1522 | |
| 1523 | void Program::setUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v) |
| 1524 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1525 | GLsizei clampedCount = setMatrixUniformInternal<2, 3>(location, count, transpose, v); |
| 1526 | mProgram->setUniformMatrix2x3fv(location, clampedCount, transpose, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1527 | } |
| 1528 | |
| 1529 | void Program::setUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v) |
| 1530 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1531 | GLsizei clampedCount = setMatrixUniformInternal<2, 4>(location, count, transpose, v); |
| 1532 | mProgram->setUniformMatrix2x4fv(location, clampedCount, transpose, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1533 | } |
| 1534 | |
| 1535 | void Program::setUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v) |
| 1536 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1537 | GLsizei clampedCount = setMatrixUniformInternal<3, 2>(location, count, transpose, v); |
| 1538 | mProgram->setUniformMatrix3x2fv(location, clampedCount, transpose, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1539 | } |
| 1540 | |
| 1541 | void Program::setUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v) |
| 1542 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1543 | GLsizei clampedCount = setMatrixUniformInternal<3, 4>(location, count, transpose, v); |
| 1544 | mProgram->setUniformMatrix3x4fv(location, clampedCount, transpose, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1545 | } |
| 1546 | |
| 1547 | void Program::setUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v) |
| 1548 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1549 | GLsizei clampedCount = setMatrixUniformInternal<4, 2>(location, count, transpose, v); |
| 1550 | mProgram->setUniformMatrix4x2fv(location, clampedCount, transpose, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1551 | } |
| 1552 | |
| 1553 | void Program::setUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *v) |
| 1554 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 1555 | GLsizei clampedCount = setMatrixUniformInternal<4, 3>(location, count, transpose, v); |
| 1556 | mProgram->setUniformMatrix4x3fv(location, clampedCount, transpose, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1557 | } |
| 1558 | |
Geoff Lang | e1a2775 | 2015-10-05 13:16:04 -0400 | [diff] [blame] | 1559 | void Program::getUniformfv(GLint location, GLfloat *v) const |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1560 | { |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1561 | getUniformInternal(location, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1562 | } |
| 1563 | |
Geoff Lang | e1a2775 | 2015-10-05 13:16:04 -0400 | [diff] [blame] | 1564 | void Program::getUniformiv(GLint location, GLint *v) const |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1565 | { |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1566 | getUniformInternal(location, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1567 | } |
| 1568 | |
Geoff Lang | e1a2775 | 2015-10-05 13:16:04 -0400 | [diff] [blame] | 1569 | void Program::getUniformuiv(GLint location, GLuint *v) const |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1570 | { |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1571 | getUniformInternal(location, v); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1572 | } |
| 1573 | |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1574 | void Program::flagForDeletion() |
| 1575 | { |
| 1576 | mDeleteStatus = true; |
| 1577 | } |
| 1578 | |
| 1579 | bool Program::isFlaggedForDeletion() const |
| 1580 | { |
| 1581 | return mDeleteStatus; |
| 1582 | } |
daniel@transgaming.com | 86a7a13 | 2010-04-29 03:32:32 +0000 | [diff] [blame] | 1583 | |
Brandon Jones | 43a53e2 | 2014-08-28 16:23:22 -0700 | [diff] [blame] | 1584 | void Program::validate(const Caps &caps) |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 1585 | { |
| 1586 | mInfoLog.reset(); |
| 1587 | |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1588 | if (mLinked) |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 1589 | { |
Jamie Madill | 36cfd6a | 2015-08-18 10:46:20 -0400 | [diff] [blame] | 1590 | mValidated = (mProgram->validate(caps, &mInfoLog) == GL_TRUE); |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 1591 | } |
| 1592 | else |
| 1593 | { |
Jamie Madill | f611316 | 2015-05-07 11:49:21 -0400 | [diff] [blame] | 1594 | mInfoLog << "Program has not been successfully linked."; |
apatrick@chromium.org | 253b8d2 | 2012-06-22 19:27:21 +0000 | [diff] [blame] | 1595 | } |
| 1596 | } |
| 1597 | |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1598 | bool Program::validateSamplers(InfoLog *infoLog, const Caps &caps) |
| 1599 | { |
Jamie Madill | 3d3d2f2 | 2015-09-23 16:47:51 -0400 | [diff] [blame] | 1600 | // Skip cache if we're using an infolog, so we get the full error. |
| 1601 | // Also skip the cache if the sample mapping has changed, or if we haven't ever validated. |
| 1602 | if (infoLog == nullptr && mCachedValidateSamplersResult.valid()) |
| 1603 | { |
| 1604 | return mCachedValidateSamplersResult.value(); |
| 1605 | } |
| 1606 | |
| 1607 | if (mTextureUnitTypesCache.empty()) |
| 1608 | { |
| 1609 | mTextureUnitTypesCache.resize(caps.maxCombinedTextureImageUnits, GL_NONE); |
| 1610 | } |
| 1611 | else |
| 1612 | { |
| 1613 | std::fill(mTextureUnitTypesCache.begin(), mTextureUnitTypesCache.end(), GL_NONE); |
| 1614 | } |
| 1615 | |
| 1616 | // if any two active samplers in a program are of different types, but refer to the same |
| 1617 | // texture image unit, and this is the current program, then ValidateProgram will fail, and |
| 1618 | // DrawArrays and DrawElements will issue the INVALID_OPERATION error. |
Jamie Madill | e7d8432 | 2017-01-10 18:21:59 -0500 | [diff] [blame] | 1619 | for (const auto &samplerBinding : mState.mSamplerBindings) |
Jamie Madill | 3d3d2f2 | 2015-09-23 16:47:51 -0400 | [diff] [blame] | 1620 | { |
Jamie Madill | e7d8432 | 2017-01-10 18:21:59 -0500 | [diff] [blame] | 1621 | GLenum textureType = samplerBinding.textureType; |
Jamie Madill | 3d3d2f2 | 2015-09-23 16:47:51 -0400 | [diff] [blame] | 1622 | |
Jamie Madill | e7d8432 | 2017-01-10 18:21:59 -0500 | [diff] [blame] | 1623 | for (GLuint textureUnit : samplerBinding.boundTextureUnits) |
Jamie Madill | 3d3d2f2 | 2015-09-23 16:47:51 -0400 | [diff] [blame] | 1624 | { |
Jamie Madill | 3d3d2f2 | 2015-09-23 16:47:51 -0400 | [diff] [blame] | 1625 | if (textureUnit >= caps.maxCombinedTextureImageUnits) |
| 1626 | { |
| 1627 | if (infoLog) |
| 1628 | { |
| 1629 | (*infoLog) << "Sampler uniform (" << textureUnit |
| 1630 | << ") exceeds GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS (" |
| 1631 | << caps.maxCombinedTextureImageUnits << ")"; |
| 1632 | } |
| 1633 | |
| 1634 | mCachedValidateSamplersResult = false; |
| 1635 | return false; |
| 1636 | } |
| 1637 | |
| 1638 | if (mTextureUnitTypesCache[textureUnit] != GL_NONE) |
| 1639 | { |
| 1640 | if (textureType != mTextureUnitTypesCache[textureUnit]) |
| 1641 | { |
| 1642 | if (infoLog) |
| 1643 | { |
| 1644 | (*infoLog) << "Samplers of conflicting types refer to the same texture " |
| 1645 | "image unit (" |
| 1646 | << textureUnit << ")."; |
| 1647 | } |
| 1648 | |
| 1649 | mCachedValidateSamplersResult = false; |
| 1650 | return false; |
| 1651 | } |
| 1652 | } |
| 1653 | else |
| 1654 | { |
| 1655 | mTextureUnitTypesCache[textureUnit] = textureType; |
| 1656 | } |
| 1657 | } |
| 1658 | } |
| 1659 | |
| 1660 | mCachedValidateSamplersResult = true; |
| 1661 | return true; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1662 | } |
| 1663 | |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1664 | bool Program::isValidated() const |
| 1665 | { |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1666 | return mValidated; |
| 1667 | } |
| 1668 | |
Geoff Lang | e1a2775 | 2015-10-05 13:16:04 -0400 | [diff] [blame] | 1669 | GLuint Program::getActiveUniformBlockCount() const |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1670 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1671 | return static_cast<GLuint>(mState.mUniformBlocks.size()); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1672 | } |
| 1673 | |
| 1674 | void Program::getActiveUniformBlockName(GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName) const |
| 1675 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1676 | ASSERT( |
| 1677 | uniformBlockIndex < |
| 1678 | mState.mUniformBlocks.size()); // index must be smaller than getActiveUniformBlockCount() |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1679 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1680 | const UniformBlock &uniformBlock = mState.mUniformBlocks[uniformBlockIndex]; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1681 | |
| 1682 | if (bufSize > 0) |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1683 | { |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1684 | std::string string = uniformBlock.name; |
| 1685 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1686 | if (uniformBlock.isArray) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1687 | { |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1688 | string += ArrayString(uniformBlock.arrayElement); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1689 | } |
| 1690 | |
| 1691 | strncpy(uniformBlockName, string.c_str(), bufSize); |
| 1692 | uniformBlockName[bufSize - 1] = '\0'; |
| 1693 | |
| 1694 | if (length) |
| 1695 | { |
Cooper Partin | 4d61f7e | 2015-08-12 10:56:50 -0700 | [diff] [blame] | 1696 | *length = static_cast<GLsizei>(strlen(uniformBlockName)); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1697 | } |
apatrick@chromium.org | e2a59bb | 2012-06-07 21:09:53 +0000 | [diff] [blame] | 1698 | } |
| 1699 | } |
| 1700 | |
Geoff Lang | e1a2775 | 2015-10-05 13:16:04 -0400 | [diff] [blame] | 1701 | GLint Program::getActiveUniformBlockMaxLength() const |
shannonwoods@chromium.org | e684b58 | 2013-05-30 00:07:42 +0000 | [diff] [blame] | 1702 | { |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1703 | int maxLength = 0; |
| 1704 | |
| 1705 | if (mLinked) |
shannonwoods@chromium.org | e684b58 | 2013-05-30 00:07:42 +0000 | [diff] [blame] | 1706 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1707 | unsigned int numUniformBlocks = static_cast<unsigned int>(mState.mUniformBlocks.size()); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1708 | for (unsigned int uniformBlockIndex = 0; uniformBlockIndex < numUniformBlocks; uniformBlockIndex++) |
| 1709 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1710 | const UniformBlock &uniformBlock = mState.mUniformBlocks[uniformBlockIndex]; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1711 | if (!uniformBlock.name.empty()) |
| 1712 | { |
Cooper Partin | 4d61f7e | 2015-08-12 10:56:50 -0700 | [diff] [blame] | 1713 | const int length = static_cast<int>(uniformBlock.name.length()) + 1; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1714 | |
| 1715 | // Counting in "[0]". |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1716 | const int arrayLength = (uniformBlock.isArray ? 3 : 0); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1717 | |
| 1718 | maxLength = std::max(length + arrayLength, maxLength); |
| 1719 | } |
| 1720 | } |
shannonwoods@chromium.org | e684b58 | 2013-05-30 00:07:42 +0000 | [diff] [blame] | 1721 | } |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1722 | |
| 1723 | return maxLength; |
| 1724 | } |
| 1725 | |
Geoff Lang | e1a2775 | 2015-10-05 13:16:04 -0400 | [diff] [blame] | 1726 | GLuint Program::getUniformBlockIndex(const std::string &name) const |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1727 | { |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1728 | size_t subscript = GL_INVALID_INDEX; |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 1729 | std::string baseName = ParseUniformName(name, &subscript); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1730 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1731 | unsigned int numUniformBlocks = static_cast<unsigned int>(mState.mUniformBlocks.size()); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1732 | for (unsigned int blockIndex = 0; blockIndex < numUniformBlocks; blockIndex++) |
| 1733 | { |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 1734 | const UniformBlock &uniformBlock = mState.mUniformBlocks[blockIndex]; |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1735 | if (uniformBlock.name == baseName) |
| 1736 | { |
| 1737 | const bool arrayElementZero = |
| 1738 | (subscript == GL_INVALID_INDEX && |
| 1739 | (!uniformBlock.isArray || uniformBlock.arrayElement == 0)); |
| 1740 | if (subscript == uniformBlock.arrayElement || arrayElementZero) |
| 1741 | { |
| 1742 | return blockIndex; |
| 1743 | } |
| 1744 | } |
| 1745 | } |
| 1746 | |
| 1747 | return GL_INVALID_INDEX; |
shannonwoods@chromium.org | e684b58 | 2013-05-30 00:07:42 +0000 | [diff] [blame] | 1748 | } |
| 1749 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1750 | const UniformBlock &Program::getUniformBlockByIndex(GLuint index) const |
Gregoire Payen de La Garanderie | 68694e9 | 2015-03-24 14:03:37 +0000 | [diff] [blame] | 1751 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1752 | ASSERT(index < static_cast<GLuint>(mState.mUniformBlocks.size())); |
| 1753 | return mState.mUniformBlocks[index]; |
Gregoire Payen de La Garanderie | 68694e9 | 2015-03-24 14:03:37 +0000 | [diff] [blame] | 1754 | } |
| 1755 | |
shannonwoods@chromium.org | 70eb1ea | 2013-05-30 00:07:20 +0000 | [diff] [blame] | 1756 | void Program::bindUniformBlock(GLuint uniformBlockIndex, GLuint uniformBlockBinding) |
| 1757 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1758 | mState.mUniformBlockBindings[uniformBlockIndex] = uniformBlockBinding; |
Jamie Madill | a7d12dc | 2016-12-13 15:08:19 -0500 | [diff] [blame] | 1759 | mState.mActiveUniformBlockBindings.set(uniformBlockIndex, uniformBlockBinding != 0); |
Geoff Lang | 5d124a6 | 2015-09-15 13:03:27 -0400 | [diff] [blame] | 1760 | mProgram->setUniformBlockBinding(uniformBlockIndex, uniformBlockBinding); |
shannonwoods@chromium.org | 70eb1ea | 2013-05-30 00:07:20 +0000 | [diff] [blame] | 1761 | } |
| 1762 | |
| 1763 | GLuint Program::getUniformBlockBinding(GLuint uniformBlockIndex) const |
| 1764 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1765 | return mState.getUniformBlockBinding(uniformBlockIndex); |
shannonwoods@chromium.org | 70eb1ea | 2013-05-30 00:07:20 +0000 | [diff] [blame] | 1766 | } |
| 1767 | |
| 1768 | void Program::resetUniformBlockBindings() |
| 1769 | { |
| 1770 | for (unsigned int blockId = 0; blockId < IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS; blockId++) |
| 1771 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1772 | mState.mUniformBlockBindings[blockId] = 0; |
shannonwoods@chromium.org | 70eb1ea | 2013-05-30 00:07:20 +0000 | [diff] [blame] | 1773 | } |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1774 | mState.mActiveUniformBlockBindings.reset(); |
shannonwoods@chromium.org | 70eb1ea | 2013-05-30 00:07:20 +0000 | [diff] [blame] | 1775 | } |
| 1776 | |
Geoff Lang | 48dcae7 | 2014-02-05 16:28:24 -0500 | [diff] [blame] | 1777 | void Program::setTransformFeedbackVaryings(GLsizei count, const GLchar *const *varyings, GLenum bufferMode) |
| 1778 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1779 | mState.mTransformFeedbackVaryingNames.resize(count); |
Geoff Lang | 48dcae7 | 2014-02-05 16:28:24 -0500 | [diff] [blame] | 1780 | for (GLsizei i = 0; i < count; i++) |
| 1781 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1782 | mState.mTransformFeedbackVaryingNames[i] = varyings[i]; |
Geoff Lang | 48dcae7 | 2014-02-05 16:28:24 -0500 | [diff] [blame] | 1783 | } |
| 1784 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1785 | mState.mTransformFeedbackBufferMode = bufferMode; |
Geoff Lang | 48dcae7 | 2014-02-05 16:28:24 -0500 | [diff] [blame] | 1786 | } |
| 1787 | |
| 1788 | void Program::getTransformFeedbackVarying(GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name) const |
| 1789 | { |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1790 | if (mLinked) |
Geoff Lang | 48dcae7 | 2014-02-05 16:28:24 -0500 | [diff] [blame] | 1791 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1792 | ASSERT(index < mState.mTransformFeedbackVaryingVars.size()); |
| 1793 | const sh::Varying &varying = mState.mTransformFeedbackVaryingVars[index]; |
Geoff Lang | 48dcae7 | 2014-02-05 16:28:24 -0500 | [diff] [blame] | 1794 | GLsizei lastNameIdx = std::min(bufSize - 1, static_cast<GLsizei>(varying.name.length())); |
| 1795 | if (length) |
| 1796 | { |
| 1797 | *length = lastNameIdx; |
| 1798 | } |
| 1799 | if (size) |
| 1800 | { |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 1801 | *size = varying.elementCount(); |
Geoff Lang | 48dcae7 | 2014-02-05 16:28:24 -0500 | [diff] [blame] | 1802 | } |
| 1803 | if (type) |
| 1804 | { |
| 1805 | *type = varying.type; |
| 1806 | } |
| 1807 | if (name) |
| 1808 | { |
| 1809 | memcpy(name, varying.name.c_str(), lastNameIdx); |
| 1810 | name[lastNameIdx] = '\0'; |
| 1811 | } |
| 1812 | } |
| 1813 | } |
| 1814 | |
Geoff Lang | 1b6edcb | 2014-02-03 14:27:56 -0500 | [diff] [blame] | 1815 | GLsizei Program::getTransformFeedbackVaryingCount() const |
| 1816 | { |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1817 | if (mLinked) |
Geoff Lang | 48dcae7 | 2014-02-05 16:28:24 -0500 | [diff] [blame] | 1818 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1819 | return static_cast<GLsizei>(mState.mTransformFeedbackVaryingVars.size()); |
Geoff Lang | 48dcae7 | 2014-02-05 16:28:24 -0500 | [diff] [blame] | 1820 | } |
| 1821 | else |
| 1822 | { |
| 1823 | return 0; |
| 1824 | } |
Geoff Lang | 1b6edcb | 2014-02-03 14:27:56 -0500 | [diff] [blame] | 1825 | } |
| 1826 | |
| 1827 | GLsizei Program::getTransformFeedbackVaryingMaxLength() const |
| 1828 | { |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1829 | if (mLinked) |
Geoff Lang | 48dcae7 | 2014-02-05 16:28:24 -0500 | [diff] [blame] | 1830 | { |
| 1831 | GLsizei maxSize = 0; |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1832 | for (const sh::Varying &varying : mState.mTransformFeedbackVaryingVars) |
Geoff Lang | 48dcae7 | 2014-02-05 16:28:24 -0500 | [diff] [blame] | 1833 | { |
Geoff Lang | 48dcae7 | 2014-02-05 16:28:24 -0500 | [diff] [blame] | 1834 | maxSize = std::max(maxSize, static_cast<GLsizei>(varying.name.length() + 1)); |
| 1835 | } |
| 1836 | |
| 1837 | return maxSize; |
| 1838 | } |
| 1839 | else |
| 1840 | { |
| 1841 | return 0; |
| 1842 | } |
Geoff Lang | 1b6edcb | 2014-02-03 14:27:56 -0500 | [diff] [blame] | 1843 | } |
| 1844 | |
| 1845 | GLenum Program::getTransformFeedbackBufferMode() const |
| 1846 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1847 | return mState.mTransformFeedbackBufferMode; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1848 | } |
| 1849 | |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 1850 | bool Program::linkVaryings(InfoLog &infoLog) const |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1851 | { |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 1852 | const Shader *vertexShader = mState.mAttachedVertexShader; |
| 1853 | const Shader *fragmentShader = mState.mAttachedFragmentShader; |
| 1854 | |
Yuly Novikov | a1f6dc9 | 2016-06-15 23:27:04 -0400 | [diff] [blame] | 1855 | ASSERT(vertexShader->getShaderVersion() == fragmentShader->getShaderVersion()); |
| 1856 | |
Jamie Madill | 4cff247 | 2015-08-21 16:53:18 -0400 | [diff] [blame] | 1857 | const std::vector<sh::Varying> &vertexVaryings = vertexShader->getVaryings(); |
| 1858 | const std::vector<sh::Varying> &fragmentVaryings = fragmentShader->getVaryings(); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1859 | |
Sami Väisänen | 46eaa94 | 2016-06-29 10:26:37 +0300 | [diff] [blame] | 1860 | std::map<GLuint, std::string> staticFragmentInputLocations; |
| 1861 | |
Jamie Madill | 4cff247 | 2015-08-21 16:53:18 -0400 | [diff] [blame] | 1862 | for (const sh::Varying &output : fragmentVaryings) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1863 | { |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1864 | bool matched = false; |
| 1865 | |
| 1866 | // Built-in varyings obey special rules |
Jamie Madill | ada9ecc | 2015-08-17 12:53:37 -0400 | [diff] [blame] | 1867 | if (output.isBuiltIn()) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1868 | { |
| 1869 | continue; |
| 1870 | } |
| 1871 | |
Jamie Madill | 4cff247 | 2015-08-21 16:53:18 -0400 | [diff] [blame] | 1872 | for (const sh::Varying &input : vertexVaryings) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1873 | { |
Jamie Madill | ada9ecc | 2015-08-17 12:53:37 -0400 | [diff] [blame] | 1874 | if (output.name == input.name) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1875 | { |
Jamie Madill | ada9ecc | 2015-08-17 12:53:37 -0400 | [diff] [blame] | 1876 | ASSERT(!input.isBuiltIn()); |
Yuly Novikov | a1f6dc9 | 2016-06-15 23:27:04 -0400 | [diff] [blame] | 1877 | if (!linkValidateVaryings(infoLog, output.name, input, output, |
| 1878 | vertexShader->getShaderVersion())) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1879 | { |
| 1880 | return false; |
| 1881 | } |
| 1882 | |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1883 | matched = true; |
| 1884 | break; |
| 1885 | } |
| 1886 | } |
| 1887 | |
| 1888 | // We permit unmatched, unreferenced varyings |
Jamie Madill | ada9ecc | 2015-08-17 12:53:37 -0400 | [diff] [blame] | 1889 | if (!matched && output.staticUse) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1890 | { |
Jamie Madill | ada9ecc | 2015-08-17 12:53:37 -0400 | [diff] [blame] | 1891 | infoLog << "Fragment varying " << output.name << " does not match any vertex varying"; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1892 | return false; |
| 1893 | } |
Sami Väisänen | 46eaa94 | 2016-06-29 10:26:37 +0300 | [diff] [blame] | 1894 | |
| 1895 | // Check for aliased path rendering input bindings (if any). |
| 1896 | // If more than one binding refer statically to the same |
| 1897 | // location the link must fail. |
| 1898 | |
| 1899 | if (!output.staticUse) |
| 1900 | continue; |
| 1901 | |
| 1902 | const auto inputBinding = mFragmentInputBindings.getBinding(output.name); |
| 1903 | if (inputBinding == -1) |
| 1904 | continue; |
| 1905 | |
| 1906 | const auto it = staticFragmentInputLocations.find(inputBinding); |
| 1907 | if (it == std::end(staticFragmentInputLocations)) |
| 1908 | { |
| 1909 | staticFragmentInputLocations.insert(std::make_pair(inputBinding, output.name)); |
| 1910 | } |
| 1911 | else |
| 1912 | { |
| 1913 | infoLog << "Binding for fragment input " << output.name << " conflicts with " |
| 1914 | << it->second; |
| 1915 | return false; |
| 1916 | } |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1917 | } |
| 1918 | |
Jamie Madill | ada9ecc | 2015-08-17 12:53:37 -0400 | [diff] [blame] | 1919 | // TODO(jmadill): verify no unmatched vertex varyings? |
| 1920 | |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 1921 | return true; |
| 1922 | } |
| 1923 | |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 1924 | bool Program::validateVertexAndFragmentUniforms(InfoLog &infoLog) const |
Jamie Madill | ea918db | 2015-08-18 14:48:59 -0400 | [diff] [blame] | 1925 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 1926 | // Check that uniforms defined in the vertex and fragment shaders are identical |
| 1927 | std::map<std::string, LinkedUniform> linkedUniforms; |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1928 | const std::vector<sh::Uniform> &vertexUniforms = mState.mAttachedVertexShader->getUniforms(); |
| 1929 | const std::vector<sh::Uniform> &fragmentUniforms = |
| 1930 | mState.mAttachedFragmentShader->getUniforms(); |
Jamie Madill | ea918db | 2015-08-18 14:48:59 -0400 | [diff] [blame] | 1931 | |
Jamie Madill | ea918db | 2015-08-18 14:48:59 -0400 | [diff] [blame] | 1932 | for (const sh::Uniform &vertexUniform : vertexUniforms) |
| 1933 | { |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1934 | linkedUniforms[vertexUniform.name] = LinkedUniform(vertexUniform); |
Jamie Madill | ea918db | 2015-08-18 14:48:59 -0400 | [diff] [blame] | 1935 | } |
| 1936 | |
| 1937 | for (const sh::Uniform &fragmentUniform : fragmentUniforms) |
| 1938 | { |
| 1939 | auto entry = linkedUniforms.find(fragmentUniform.name); |
| 1940 | if (entry != linkedUniforms.end()) |
| 1941 | { |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1942 | LinkedUniform *vertexUniform = &entry->second; |
| 1943 | const std::string &uniformName = "uniform '" + vertexUniform->name + "'"; |
| 1944 | if (!linkValidateUniforms(infoLog, uniformName, *vertexUniform, fragmentUniform)) |
Jamie Madill | ea918db | 2015-08-18 14:48:59 -0400 | [diff] [blame] | 1945 | { |
| 1946 | return false; |
| 1947 | } |
| 1948 | } |
| 1949 | } |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 1950 | return true; |
| 1951 | } |
| 1952 | |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 1953 | bool Program::linkUniforms(InfoLog &infoLog, const Caps &caps, const Bindings &uniformBindings) |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 1954 | { |
| 1955 | if (mState.mAttachedVertexShader && mState.mAttachedFragmentShader) |
| 1956 | { |
| 1957 | ASSERT(mState.mAttachedComputeShader == nullptr); |
| 1958 | if (!validateVertexAndFragmentUniforms(infoLog)) |
| 1959 | { |
| 1960 | return false; |
| 1961 | } |
| 1962 | } |
Jamie Madill | ea918db | 2015-08-18 14:48:59 -0400 | [diff] [blame] | 1963 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1964 | // Flatten the uniforms list (nested fields) into a simple list (no nesting). |
| 1965 | // Also check the maximum uniform vector and sampler counts. |
| 1966 | if (!flattenUniformsAndCheckCaps(caps, infoLog)) |
| 1967 | { |
| 1968 | return false; |
| 1969 | } |
| 1970 | |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 1971 | if (!indexUniforms(infoLog, caps, uniformBindings)) |
| 1972 | { |
| 1973 | return false; |
| 1974 | } |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1975 | |
Jamie Madill | ea918db | 2015-08-18 14:48:59 -0400 | [diff] [blame] | 1976 | return true; |
| 1977 | } |
| 1978 | |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 1979 | bool Program::indexUniforms(InfoLog &infoLog, const Caps &caps, const Bindings &uniformBindings) |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1980 | { |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 1981 | // Uniforms awaiting a location |
| 1982 | std::vector<VariableLocation> unboundUniforms; |
| 1983 | std::map<GLuint, VariableLocation> boundUniforms; |
| 1984 | int maxUniformLocation = -1; |
| 1985 | |
| 1986 | // Gather bound and unbound uniforms |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 1987 | for (size_t uniformIndex = 0; uniformIndex < mState.mUniforms.size(); uniformIndex++) |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1988 | { |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 1989 | const LinkedUniform &uniform = mState.mUniforms[uniformIndex]; |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 1990 | |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 1991 | if (uniform.isBuiltIn()) |
| 1992 | { |
| 1993 | continue; |
| 1994 | } |
| 1995 | |
| 1996 | int bindingLocation = uniformBindings.getBinding(uniform.name); |
| 1997 | |
| 1998 | // Verify that this location isn't bound twice |
| 1999 | if (bindingLocation != -1 && boundUniforms.find(bindingLocation) != boundUniforms.end()) |
| 2000 | { |
| 2001 | infoLog << "Multiple uniforms bound to location " << bindingLocation << "."; |
| 2002 | return false; |
| 2003 | } |
| 2004 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2005 | for (unsigned int arrayIndex = 0; arrayIndex < uniform.elementCount(); arrayIndex++) |
| 2006 | { |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 2007 | VariableLocation location(uniform.name, arrayIndex, |
| 2008 | static_cast<unsigned int>(uniformIndex)); |
| 2009 | |
| 2010 | if (arrayIndex == 0 && bindingLocation != -1) |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2011 | { |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 2012 | boundUniforms[bindingLocation] = location; |
| 2013 | maxUniformLocation = std::max(maxUniformLocation, bindingLocation); |
| 2014 | } |
| 2015 | else |
| 2016 | { |
| 2017 | unboundUniforms.push_back(location); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2018 | } |
| 2019 | } |
| 2020 | } |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 2021 | |
| 2022 | // Gather the reserved bindings, ones that are bound but not referenced. Other uniforms should |
| 2023 | // not be assigned to those locations. |
| 2024 | std::set<GLuint> reservedLocations; |
| 2025 | for (const auto &binding : uniformBindings) |
| 2026 | { |
| 2027 | GLuint location = binding.second; |
| 2028 | if (boundUniforms.find(location) == boundUniforms.end()) |
| 2029 | { |
| 2030 | reservedLocations.insert(location); |
| 2031 | maxUniformLocation = std::max(maxUniformLocation, static_cast<int>(location)); |
| 2032 | } |
| 2033 | } |
| 2034 | |
| 2035 | // Make enough space for all uniforms, bound and unbound |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2036 | mState.mUniformLocations.resize( |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 2037 | std::max(unboundUniforms.size() + boundUniforms.size() + reservedLocations.size(), |
| 2038 | static_cast<size_t>(maxUniformLocation + 1))); |
| 2039 | |
| 2040 | // Assign bound uniforms |
| 2041 | for (const auto &boundUniform : boundUniforms) |
| 2042 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2043 | mState.mUniformLocations[boundUniform.first] = boundUniform.second; |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 2044 | } |
| 2045 | |
| 2046 | // Assign reserved uniforms |
| 2047 | for (const auto &reservedLocation : reservedLocations) |
| 2048 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2049 | mState.mUniformLocations[reservedLocation].ignored = true; |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 2050 | } |
| 2051 | |
| 2052 | // Assign unbound uniforms |
| 2053 | size_t nextUniformLocation = 0; |
| 2054 | for (const auto &unboundUniform : unboundUniforms) |
| 2055 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2056 | while (mState.mUniformLocations[nextUniformLocation].used || |
| 2057 | mState.mUniformLocations[nextUniformLocation].ignored) |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 2058 | { |
| 2059 | nextUniformLocation++; |
| 2060 | } |
| 2061 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2062 | ASSERT(nextUniformLocation < mState.mUniformLocations.size()); |
| 2063 | mState.mUniformLocations[nextUniformLocation] = unboundUniform; |
Geoff Lang | d860552 | 2016-04-13 10:19:12 -0400 | [diff] [blame] | 2064 | nextUniformLocation++; |
| 2065 | } |
| 2066 | |
| 2067 | return true; |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2068 | } |
| 2069 | |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2070 | bool Program::linkValidateInterfaceBlockFields(InfoLog &infoLog, |
| 2071 | const std::string &uniformName, |
| 2072 | const sh::InterfaceBlockField &vertexUniform, |
| 2073 | const sh::InterfaceBlockField &fragmentUniform) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2074 | { |
Jamie Madill | c4c74422 | 2015-11-04 09:39:47 -0500 | [diff] [blame] | 2075 | // We don't validate precision on UBO fields. See resolution of Khronos bug 10287. |
| 2076 | if (!linkValidateVariablesBase(infoLog, uniformName, vertexUniform, fragmentUniform, false)) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2077 | { |
| 2078 | return false; |
| 2079 | } |
| 2080 | |
| 2081 | if (vertexUniform.isRowMajorLayout != fragmentUniform.isRowMajorLayout) |
| 2082 | { |
Jamie Madill | f611316 | 2015-05-07 11:49:21 -0400 | [diff] [blame] | 2083 | infoLog << "Matrix packings for " << uniformName << " differ between vertex and fragment shaders"; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2084 | return false; |
| 2085 | } |
| 2086 | |
| 2087 | return true; |
| 2088 | } |
| 2089 | |
Jamie Madill | eb979bf | 2016-11-15 12:28:46 -0500 | [diff] [blame] | 2090 | // Assigns locations to all attributes from the bindings and program locations. |
| 2091 | bool Program::linkAttributes(const ContextState &data, InfoLog &infoLog) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2092 | { |
Jamie Madill | eb979bf | 2016-11-15 12:28:46 -0500 | [diff] [blame] | 2093 | const auto *vertexShader = mState.getAttachedVertexShader(); |
| 2094 | |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2095 | unsigned int usedLocations = 0; |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2096 | mState.mAttributes = vertexShader->getActiveAttributes(); |
Jamie Madill | dfde6ab | 2016-06-09 07:07:18 -0700 | [diff] [blame] | 2097 | GLuint maxAttribs = data.getCaps().maxVertexAttributes; |
Jamie Madill | 3da79b7 | 2015-04-27 11:09:17 -0400 | [diff] [blame] | 2098 | |
| 2099 | // TODO(jmadill): handle aliasing robustly |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2100 | if (mState.mAttributes.size() > maxAttribs) |
Jamie Madill | 3da79b7 | 2015-04-27 11:09:17 -0400 | [diff] [blame] | 2101 | { |
Jamie Madill | f611316 | 2015-05-07 11:49:21 -0400 | [diff] [blame] | 2102 | infoLog << "Too many vertex attributes."; |
Jamie Madill | 3da79b7 | 2015-04-27 11:09:17 -0400 | [diff] [blame] | 2103 | return false; |
| 2104 | } |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2105 | |
Jamie Madill | dfde6ab | 2016-06-09 07:07:18 -0700 | [diff] [blame] | 2106 | std::vector<sh::Attribute *> usedAttribMap(maxAttribs, nullptr); |
Jamie Madill | 4e10722 | 2015-08-24 14:12:17 +0000 | [diff] [blame] | 2107 | |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 2108 | // Link attributes that have a binding location |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2109 | for (sh::Attribute &attribute : mState.mAttributes) |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 2110 | { |
| 2111 | // TODO(jmadill): do staticUse filtering step here, or not at all |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2112 | ASSERT(attribute.staticUse); |
| 2113 | |
Jamie Madill | eb979bf | 2016-11-15 12:28:46 -0500 | [diff] [blame] | 2114 | int bindingLocation = mAttributeBindings.getBinding(attribute.name); |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 2115 | if (attribute.location == -1 && bindingLocation != -1) |
Jamie Madill | 2d77318 | 2015-08-18 10:27:28 -0400 | [diff] [blame] | 2116 | { |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 2117 | attribute.location = bindingLocation; |
| 2118 | } |
| 2119 | |
| 2120 | if (attribute.location != -1) |
| 2121 | { |
| 2122 | // Location is set by glBindAttribLocation or by location layout qualifier |
Jamie Madill | 63805b4 | 2015-08-25 13:17:39 -0400 | [diff] [blame] | 2123 | const int regs = VariableRegisterCount(attribute.type); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2124 | |
Jamie Madill | 63805b4 | 2015-08-25 13:17:39 -0400 | [diff] [blame] | 2125 | if (static_cast<GLuint>(regs + attribute.location) > maxAttribs) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2126 | { |
Jamie Madill | f611316 | 2015-05-07 11:49:21 -0400 | [diff] [blame] | 2127 | infoLog << "Active attribute (" << attribute.name << ") at location " |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 2128 | << attribute.location << " is too big to fit"; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2129 | |
| 2130 | return false; |
| 2131 | } |
| 2132 | |
Jamie Madill | 63805b4 | 2015-08-25 13:17:39 -0400 | [diff] [blame] | 2133 | for (int reg = 0; reg < regs; reg++) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2134 | { |
Jamie Madill | 63805b4 | 2015-08-25 13:17:39 -0400 | [diff] [blame] | 2135 | const int regLocation = attribute.location + reg; |
| 2136 | sh::ShaderVariable *linkedAttribute = usedAttribMap[regLocation]; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2137 | |
| 2138 | // In GLSL 3.00, attribute aliasing produces a link error |
Jamie Madill | 3da79b7 | 2015-04-27 11:09:17 -0400 | [diff] [blame] | 2139 | // In GLSL 1.00, attribute aliasing is allowed, but ANGLE currently has a bug |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 2140 | if (linkedAttribute) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2141 | { |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 2142 | // TODO(jmadill): fix aliasing on ES2 |
| 2143 | // if (mProgram->getShaderVersion() >= 300) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2144 | { |
Jamie Madill | 5c6b7bf | 2015-08-17 12:53:35 -0400 | [diff] [blame] | 2145 | infoLog << "Attribute '" << attribute.name << "' aliases attribute '" |
Jamie Madill | 63805b4 | 2015-08-25 13:17:39 -0400 | [diff] [blame] | 2146 | << linkedAttribute->name << "' at location " << regLocation; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2147 | return false; |
| 2148 | } |
| 2149 | } |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 2150 | else |
| 2151 | { |
Jamie Madill | 63805b4 | 2015-08-25 13:17:39 -0400 | [diff] [blame] | 2152 | usedAttribMap[regLocation] = &attribute; |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 2153 | } |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2154 | |
Jamie Madill | 63805b4 | 2015-08-25 13:17:39 -0400 | [diff] [blame] | 2155 | usedLocations |= 1 << regLocation; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2156 | } |
| 2157 | } |
| 2158 | } |
| 2159 | |
| 2160 | // Link attributes that don't have a binding location |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2161 | for (sh::Attribute &attribute : mState.mAttributes) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2162 | { |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2163 | ASSERT(attribute.staticUse); |
| 2164 | |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 2165 | // Not set by glBindAttribLocation or by location layout qualifier |
| 2166 | if (attribute.location == -1) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2167 | { |
Jamie Madill | 63805b4 | 2015-08-25 13:17:39 -0400 | [diff] [blame] | 2168 | int regs = VariableRegisterCount(attribute.type); |
| 2169 | int availableIndex = AllocateFirstFreeBits(&usedLocations, regs, maxAttribs); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2170 | |
Jamie Madill | 63805b4 | 2015-08-25 13:17:39 -0400 | [diff] [blame] | 2171 | if (availableIndex == -1 || static_cast<GLuint>(availableIndex + regs) > maxAttribs) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2172 | { |
Jamie Madill | f611316 | 2015-05-07 11:49:21 -0400 | [diff] [blame] | 2173 | infoLog << "Too many active attributes (" << attribute.name << ")"; |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 2174 | return false; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2175 | } |
| 2176 | |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 2177 | attribute.location = availableIndex; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2178 | } |
| 2179 | } |
| 2180 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2181 | for (const sh::Attribute &attribute : mState.mAttributes) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2182 | { |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 2183 | ASSERT(attribute.staticUse); |
Jamie Madill | 63805b4 | 2015-08-25 13:17:39 -0400 | [diff] [blame] | 2184 | ASSERT(attribute.location != -1); |
| 2185 | int regs = VariableRegisterCount(attribute.type); |
Jamie Madill | c349ec0 | 2015-08-21 16:53:12 -0400 | [diff] [blame] | 2186 | |
Jamie Madill | 63805b4 | 2015-08-25 13:17:39 -0400 | [diff] [blame] | 2187 | for (int r = 0; r < regs; r++) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2188 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2189 | mState.mActiveAttribLocationsMask.set(attribute.location + r); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2190 | } |
| 2191 | } |
| 2192 | |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2193 | return true; |
| 2194 | } |
| 2195 | |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2196 | bool Program::validateUniformBlocksCount(GLuint maxUniformBlocks, |
| 2197 | const std::vector<sh::InterfaceBlock> &intefaceBlocks, |
| 2198 | const std::string &errorMessage, |
| 2199 | InfoLog &infoLog) const |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2200 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2201 | GLuint blockCount = 0; |
| 2202 | for (const sh::InterfaceBlock &block : intefaceBlocks) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2203 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2204 | if (block.staticUse || block.layout != sh::BLOCKLAYOUT_PACKED) |
Jamie Madill | e473dee | 2015-08-18 14:49:01 -0400 | [diff] [blame] | 2205 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2206 | if (++blockCount > maxUniformBlocks) |
Jamie Madill | e473dee | 2015-08-18 14:49:01 -0400 | [diff] [blame] | 2207 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2208 | infoLog << errorMessage << maxUniformBlocks << ")"; |
Jamie Madill | e473dee | 2015-08-18 14:49:01 -0400 | [diff] [blame] | 2209 | return false; |
| 2210 | } |
| 2211 | } |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2212 | } |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2213 | return true; |
| 2214 | } |
Jamie Madill | e473dee | 2015-08-18 14:49:01 -0400 | [diff] [blame] | 2215 | |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2216 | bool Program::validateVertexAndFragmentInterfaceBlocks( |
| 2217 | const std::vector<sh::InterfaceBlock> &vertexInterfaceBlocks, |
| 2218 | const std::vector<sh::InterfaceBlock> &fragmentInterfaceBlocks, |
| 2219 | InfoLog &infoLog) const |
| 2220 | { |
| 2221 | // Check that interface blocks defined in the vertex and fragment shaders are identical |
| 2222 | typedef std::map<std::string, const sh::InterfaceBlock *> UniformBlockMap; |
| 2223 | UniformBlockMap linkedUniformBlocks; |
| 2224 | |
| 2225 | for (const sh::InterfaceBlock &vertexInterfaceBlock : vertexInterfaceBlocks) |
| 2226 | { |
| 2227 | linkedUniformBlocks[vertexInterfaceBlock.name] = &vertexInterfaceBlock; |
| 2228 | } |
| 2229 | |
Jamie Madill | e473dee | 2015-08-18 14:49:01 -0400 | [diff] [blame] | 2230 | for (const sh::InterfaceBlock &fragmentInterfaceBlock : fragmentInterfaceBlocks) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2231 | { |
Jamie Madill | e473dee | 2015-08-18 14:49:01 -0400 | [diff] [blame] | 2232 | auto entry = linkedUniformBlocks.find(fragmentInterfaceBlock.name); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2233 | if (entry != linkedUniformBlocks.end()) |
| 2234 | { |
| 2235 | const sh::InterfaceBlock &vertexInterfaceBlock = *entry->second; |
| 2236 | if (!areMatchingInterfaceBlocks(infoLog, vertexInterfaceBlock, fragmentInterfaceBlock)) |
| 2237 | { |
| 2238 | return false; |
| 2239 | } |
| 2240 | } |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2241 | } |
| 2242 | return true; |
| 2243 | } |
Jamie Madill | e473dee | 2015-08-18 14:49:01 -0400 | [diff] [blame] | 2244 | |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2245 | bool Program::linkUniformBlocks(InfoLog &infoLog, const Caps &caps) |
| 2246 | { |
| 2247 | if (mState.mAttachedComputeShader) |
| 2248 | { |
| 2249 | const Shader &computeShader = *mState.mAttachedComputeShader; |
| 2250 | const auto &computeInterfaceBlocks = computeShader.getInterfaceBlocks(); |
| 2251 | |
| 2252 | if (!validateUniformBlocksCount( |
| 2253 | caps.maxComputeUniformBlocks, computeInterfaceBlocks, |
| 2254 | "Compute shader uniform block count exceeds GL_MAX_COMPUTE_UNIFORM_BLOCKS (", |
| 2255 | infoLog)) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2256 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2257 | return false; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2258 | } |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2259 | return true; |
| 2260 | } |
| 2261 | |
| 2262 | const Shader &vertexShader = *mState.mAttachedVertexShader; |
| 2263 | const Shader &fragmentShader = *mState.mAttachedFragmentShader; |
| 2264 | |
| 2265 | const auto &vertexInterfaceBlocks = vertexShader.getInterfaceBlocks(); |
| 2266 | const auto &fragmentInterfaceBlocks = fragmentShader.getInterfaceBlocks(); |
| 2267 | |
| 2268 | if (!validateUniformBlocksCount( |
| 2269 | caps.maxVertexUniformBlocks, vertexInterfaceBlocks, |
| 2270 | "Vertex shader uniform block count exceeds GL_MAX_VERTEX_UNIFORM_BLOCKS (", infoLog)) |
| 2271 | { |
| 2272 | return false; |
| 2273 | } |
| 2274 | if (!validateUniformBlocksCount( |
| 2275 | caps.maxFragmentUniformBlocks, fragmentInterfaceBlocks, |
| 2276 | "Fragment shader uniform block count exceeds GL_MAX_FRAGMENT_UNIFORM_BLOCKS (", |
| 2277 | infoLog)) |
| 2278 | { |
| 2279 | |
| 2280 | return false; |
| 2281 | } |
| 2282 | if (!validateVertexAndFragmentInterfaceBlocks(vertexInterfaceBlocks, fragmentInterfaceBlocks, |
| 2283 | infoLog)) |
| 2284 | { |
| 2285 | return false; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2286 | } |
Jamie Madill | e473dee | 2015-08-18 14:49:01 -0400 | [diff] [blame] | 2287 | |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2288 | return true; |
| 2289 | } |
| 2290 | |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 2291 | bool Program::areMatchingInterfaceBlocks(InfoLog &infoLog, |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2292 | const sh::InterfaceBlock &vertexInterfaceBlock, |
| 2293 | const sh::InterfaceBlock &fragmentInterfaceBlock) const |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2294 | { |
| 2295 | const char* blockName = vertexInterfaceBlock.name.c_str(); |
| 2296 | // validate blocks for the same member types |
| 2297 | if (vertexInterfaceBlock.fields.size() != fragmentInterfaceBlock.fields.size()) |
| 2298 | { |
Jamie Madill | f611316 | 2015-05-07 11:49:21 -0400 | [diff] [blame] | 2299 | infoLog << "Types for interface block '" << blockName |
| 2300 | << "' differ between vertex and fragment shaders"; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2301 | return false; |
| 2302 | } |
| 2303 | if (vertexInterfaceBlock.arraySize != fragmentInterfaceBlock.arraySize) |
| 2304 | { |
Jamie Madill | f611316 | 2015-05-07 11:49:21 -0400 | [diff] [blame] | 2305 | infoLog << "Array sizes differ for interface block '" << blockName |
| 2306 | << "' between vertex and fragment shaders"; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2307 | return false; |
| 2308 | } |
| 2309 | if (vertexInterfaceBlock.layout != fragmentInterfaceBlock.layout || vertexInterfaceBlock.isRowMajorLayout != fragmentInterfaceBlock.isRowMajorLayout) |
| 2310 | { |
Jamie Madill | f611316 | 2015-05-07 11:49:21 -0400 | [diff] [blame] | 2311 | infoLog << "Layout qualifiers differ for interface block '" << blockName |
| 2312 | << "' between vertex and fragment shaders"; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2313 | return false; |
| 2314 | } |
Cooper Partin | 4d61f7e | 2015-08-12 10:56:50 -0700 | [diff] [blame] | 2315 | const unsigned int numBlockMembers = |
| 2316 | static_cast<unsigned int>(vertexInterfaceBlock.fields.size()); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2317 | for (unsigned int blockMemberIndex = 0; blockMemberIndex < numBlockMembers; blockMemberIndex++) |
| 2318 | { |
| 2319 | const sh::InterfaceBlockField &vertexMember = vertexInterfaceBlock.fields[blockMemberIndex]; |
| 2320 | const sh::InterfaceBlockField &fragmentMember = fragmentInterfaceBlock.fields[blockMemberIndex]; |
| 2321 | if (vertexMember.name != fragmentMember.name) |
| 2322 | { |
Jamie Madill | f611316 | 2015-05-07 11:49:21 -0400 | [diff] [blame] | 2323 | infoLog << "Name mismatch for field " << blockMemberIndex |
| 2324 | << " of interface block '" << blockName |
| 2325 | << "': (in vertex: '" << vertexMember.name |
| 2326 | << "', in fragment: '" << fragmentMember.name << "')"; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2327 | return false; |
| 2328 | } |
| 2329 | std::string memberName = "interface block '" + vertexInterfaceBlock.name + "' member '" + vertexMember.name + "'"; |
| 2330 | if (!linkValidateInterfaceBlockFields(infoLog, memberName, vertexMember, fragmentMember)) |
| 2331 | { |
| 2332 | return false; |
| 2333 | } |
| 2334 | } |
| 2335 | return true; |
| 2336 | } |
| 2337 | |
| 2338 | bool Program::linkValidateVariablesBase(InfoLog &infoLog, const std::string &variableName, const sh::ShaderVariable &vertexVariable, |
| 2339 | const sh::ShaderVariable &fragmentVariable, bool validatePrecision) |
| 2340 | { |
| 2341 | if (vertexVariable.type != fragmentVariable.type) |
| 2342 | { |
Jamie Madill | f611316 | 2015-05-07 11:49:21 -0400 | [diff] [blame] | 2343 | infoLog << "Types for " << variableName << " differ between vertex and fragment shaders"; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2344 | return false; |
| 2345 | } |
| 2346 | if (vertexVariable.arraySize != fragmentVariable.arraySize) |
| 2347 | { |
Jamie Madill | f611316 | 2015-05-07 11:49:21 -0400 | [diff] [blame] | 2348 | infoLog << "Array sizes for " << variableName << " differ between vertex and fragment shaders"; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2349 | return false; |
| 2350 | } |
| 2351 | if (validatePrecision && vertexVariable.precision != fragmentVariable.precision) |
| 2352 | { |
Jamie Madill | f611316 | 2015-05-07 11:49:21 -0400 | [diff] [blame] | 2353 | infoLog << "Precisions for " << variableName << " differ between vertex and fragment shaders"; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2354 | return false; |
| 2355 | } |
| 2356 | |
| 2357 | if (vertexVariable.fields.size() != fragmentVariable.fields.size()) |
| 2358 | { |
Jamie Madill | f611316 | 2015-05-07 11:49:21 -0400 | [diff] [blame] | 2359 | infoLog << "Structure lengths for " << variableName << " differ between vertex and fragment shaders"; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2360 | return false; |
| 2361 | } |
Cooper Partin | 4d61f7e | 2015-08-12 10:56:50 -0700 | [diff] [blame] | 2362 | const unsigned int numMembers = static_cast<unsigned int>(vertexVariable.fields.size()); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2363 | for (unsigned int memberIndex = 0; memberIndex < numMembers; memberIndex++) |
| 2364 | { |
| 2365 | const sh::ShaderVariable &vertexMember = vertexVariable.fields[memberIndex]; |
| 2366 | const sh::ShaderVariable &fragmentMember = fragmentVariable.fields[memberIndex]; |
| 2367 | |
| 2368 | if (vertexMember.name != fragmentMember.name) |
| 2369 | { |
Jamie Madill | f611316 | 2015-05-07 11:49:21 -0400 | [diff] [blame] | 2370 | infoLog << "Name mismatch for field '" << memberIndex |
| 2371 | << "' of " << variableName |
| 2372 | << ": (in vertex: '" << vertexMember.name |
| 2373 | << "', in fragment: '" << fragmentMember.name << "')"; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2374 | return false; |
| 2375 | } |
| 2376 | |
| 2377 | const std::string memberName = variableName.substr(0, variableName.length() - 1) + "." + |
| 2378 | vertexMember.name + "'"; |
| 2379 | |
| 2380 | if (!linkValidateVariablesBase(infoLog, vertexMember.name, vertexMember, fragmentMember, validatePrecision)) |
| 2381 | { |
| 2382 | return false; |
| 2383 | } |
| 2384 | } |
| 2385 | |
| 2386 | return true; |
| 2387 | } |
| 2388 | |
| 2389 | bool Program::linkValidateUniforms(InfoLog &infoLog, const std::string &uniformName, const sh::Uniform &vertexUniform, const sh::Uniform &fragmentUniform) |
| 2390 | { |
Cooper Partin | 1acf438 | 2015-06-12 12:38:57 -0700 | [diff] [blame] | 2391 | #if ANGLE_PROGRAM_LINK_VALIDATE_UNIFORM_PRECISION == ANGLE_ENABLED |
| 2392 | const bool validatePrecision = true; |
| 2393 | #else |
| 2394 | const bool validatePrecision = false; |
| 2395 | #endif |
| 2396 | |
| 2397 | if (!linkValidateVariablesBase(infoLog, uniformName, vertexUniform, fragmentUniform, validatePrecision)) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2398 | { |
| 2399 | return false; |
| 2400 | } |
| 2401 | |
| 2402 | return true; |
| 2403 | } |
| 2404 | |
Yuly Novikov | a1f6dc9 | 2016-06-15 23:27:04 -0400 | [diff] [blame] | 2405 | bool Program::linkValidateVaryings(InfoLog &infoLog, |
| 2406 | const std::string &varyingName, |
| 2407 | const sh::Varying &vertexVarying, |
| 2408 | const sh::Varying &fragmentVarying, |
| 2409 | int shaderVersion) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2410 | { |
| 2411 | if (!linkValidateVariablesBase(infoLog, varyingName, vertexVarying, fragmentVarying, false)) |
| 2412 | { |
| 2413 | return false; |
| 2414 | } |
| 2415 | |
Jamie Madill | e9cc469 | 2015-02-19 16:00:13 -0500 | [diff] [blame] | 2416 | if (!sh::InterpolationTypesMatch(vertexVarying.interpolation, fragmentVarying.interpolation)) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2417 | { |
Yuly Novikov | a1f6dc9 | 2016-06-15 23:27:04 -0400 | [diff] [blame] | 2418 | infoLog << "Interpolation types for " << varyingName |
| 2419 | << " differ between vertex and fragment shaders."; |
| 2420 | return false; |
| 2421 | } |
| 2422 | |
| 2423 | if (shaderVersion == 100 && vertexVarying.isInvariant != fragmentVarying.isInvariant) |
| 2424 | { |
| 2425 | infoLog << "Invariance for " << varyingName |
| 2426 | << " differs between vertex and fragment shaders."; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2427 | return false; |
| 2428 | } |
| 2429 | |
| 2430 | return true; |
| 2431 | } |
| 2432 | |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2433 | bool Program::linkValidateTransformFeedback(InfoLog &infoLog, |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 2434 | const Program::MergedVaryings &varyings, |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2435 | const Caps &caps) const |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2436 | { |
| 2437 | size_t totalComponents = 0; |
| 2438 | |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2439 | std::set<std::string> uniqueNames; |
| 2440 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2441 | for (const std::string &tfVaryingName : mState.mTransformFeedbackVaryingNames) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2442 | { |
| 2443 | bool found = false; |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 2444 | for (const auto &ref : varyings) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2445 | { |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 2446 | const sh::Varying *varying = ref.second.get(); |
| 2447 | |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2448 | if (tfVaryingName == varying->name) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2449 | { |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2450 | if (uniqueNames.count(tfVaryingName) > 0) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2451 | { |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2452 | infoLog << "Two transform feedback varyings specify the same output variable (" |
| 2453 | << tfVaryingName << ")."; |
| 2454 | return false; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2455 | } |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2456 | uniqueNames.insert(tfVaryingName); |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2457 | |
Geoff Lang | 1a68346 | 2015-09-29 15:09:59 -0400 | [diff] [blame] | 2458 | if (varying->isArray()) |
| 2459 | { |
| 2460 | infoLog << "Capture of arrays is undefined and not supported."; |
| 2461 | return false; |
| 2462 | } |
| 2463 | |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2464 | // TODO(jmadill): Investigate implementation limits on D3D11 |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 2465 | size_t componentCount = VariableComponentCount(varying->type); |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2466 | if (mState.mTransformFeedbackBufferMode == GL_SEPARATE_ATTRIBS && |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2467 | componentCount > caps.maxTransformFeedbackSeparateComponents) |
| 2468 | { |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2469 | infoLog << "Transform feedback varying's " << varying->name << " components (" |
| 2470 | << componentCount << ") exceed the maximum separate components (" |
Jamie Madill | f611316 | 2015-05-07 11:49:21 -0400 | [diff] [blame] | 2471 | << caps.maxTransformFeedbackSeparateComponents << ")."; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2472 | return false; |
| 2473 | } |
| 2474 | |
| 2475 | totalComponents += componentCount; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2476 | found = true; |
| 2477 | break; |
| 2478 | } |
| 2479 | } |
| 2480 | |
Jamie Madill | 89bb70e | 2015-08-31 14:18:39 -0400 | [diff] [blame] | 2481 | if (tfVaryingName.find('[') != std::string::npos) |
| 2482 | { |
Geoff Lang | 1a68346 | 2015-09-29 15:09:59 -0400 | [diff] [blame] | 2483 | infoLog << "Capture of array elements is undefined and not supported."; |
Jamie Madill | 89bb70e | 2015-08-31 14:18:39 -0400 | [diff] [blame] | 2484 | return false; |
| 2485 | } |
| 2486 | |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2487 | // All transform feedback varyings are expected to exist since packVaryings checks for them. |
| 2488 | ASSERT(found); |
| 2489 | } |
| 2490 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2491 | if (mState.mTransformFeedbackBufferMode == GL_INTERLEAVED_ATTRIBS && |
Jamie Madill | f611316 | 2015-05-07 11:49:21 -0400 | [diff] [blame] | 2492 | totalComponents > caps.maxTransformFeedbackInterleavedComponents) |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2493 | { |
Jamie Madill | f611316 | 2015-05-07 11:49:21 -0400 | [diff] [blame] | 2494 | infoLog << "Transform feedback varying total components (" << totalComponents |
| 2495 | << ") exceed the maximum interleaved components (" |
| 2496 | << caps.maxTransformFeedbackInterleavedComponents << ")."; |
Geoff Lang | 7dd2e10 | 2014-11-10 15:19:26 -0500 | [diff] [blame] | 2497 | return false; |
| 2498 | } |
| 2499 | |
| 2500 | return true; |
Geoff Lang | 1b6edcb | 2014-02-03 14:27:56 -0500 | [diff] [blame] | 2501 | } |
| 2502 | |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 2503 | void Program::gatherTransformFeedbackVaryings(const Program::MergedVaryings &varyings) |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2504 | { |
| 2505 | // Gather the linked varyings that are used for transform feedback, they should all exist. |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2506 | mState.mTransformFeedbackVaryingVars.clear(); |
| 2507 | for (const std::string &tfVaryingName : mState.mTransformFeedbackVaryingNames) |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2508 | { |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 2509 | for (const auto &ref : varyings) |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2510 | { |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 2511 | const sh::Varying *varying = ref.second.get(); |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2512 | if (tfVaryingName == varying->name) |
| 2513 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2514 | mState.mTransformFeedbackVaryingVars.push_back(*varying); |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2515 | break; |
| 2516 | } |
| 2517 | } |
| 2518 | } |
| 2519 | } |
| 2520 | |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 2521 | Program::MergedVaryings Program::getMergedVaryings() const |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2522 | { |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 2523 | MergedVaryings merged; |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2524 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2525 | for (const sh::Varying &varying : mState.mAttachedVertexShader->getVaryings()) |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2526 | { |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 2527 | merged[varying.name].vertex = &varying; |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2528 | } |
| 2529 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2530 | for (const sh::Varying &varying : mState.mAttachedFragmentShader->getVaryings()) |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2531 | { |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 2532 | merged[varying.name].fragment = &varying; |
| 2533 | } |
| 2534 | |
| 2535 | return merged; |
| 2536 | } |
| 2537 | |
| 2538 | std::vector<PackedVarying> Program::getPackedVaryings( |
| 2539 | const Program::MergedVaryings &mergedVaryings) const |
| 2540 | { |
| 2541 | const std::vector<std::string> &tfVaryings = mState.getTransformFeedbackVaryingNames(); |
| 2542 | std::vector<PackedVarying> packedVaryings; |
| 2543 | |
| 2544 | for (const auto &ref : mergedVaryings) |
| 2545 | { |
| 2546 | const sh::Varying *input = ref.second.vertex; |
| 2547 | const sh::Varying *output = ref.second.fragment; |
| 2548 | |
| 2549 | // Only pack varyings that have a matched input or output, plus special builtins. |
| 2550 | if ((input && output) || (output && output->isBuiltIn())) |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2551 | { |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 2552 | // Will get the vertex shader interpolation by default. |
| 2553 | auto interpolation = ref.second.get()->interpolation; |
| 2554 | |
| 2555 | // Interpolation qualifiers must match. |
| 2556 | if (output->isStruct()) |
| 2557 | { |
| 2558 | ASSERT(!output->isArray()); |
| 2559 | for (const auto &field : output->fields) |
| 2560 | { |
| 2561 | ASSERT(!field.isStruct() && !field.isArray()); |
| 2562 | packedVaryings.push_back(PackedVarying(field, interpolation, output->name)); |
| 2563 | } |
| 2564 | } |
| 2565 | else |
| 2566 | { |
| 2567 | packedVaryings.push_back(PackedVarying(*output, interpolation)); |
| 2568 | } |
| 2569 | continue; |
| 2570 | } |
| 2571 | |
| 2572 | // Keep Transform FB varyings in the merged list always. |
| 2573 | if (!input) |
| 2574 | { |
| 2575 | continue; |
| 2576 | } |
| 2577 | |
| 2578 | for (const std::string &tfVarying : tfVaryings) |
| 2579 | { |
| 2580 | if (tfVarying == input->name) |
| 2581 | { |
| 2582 | // Transform feedback for varying structs is underspecified. |
| 2583 | // See Khronos bug 9856. |
| 2584 | // TODO(jmadill): Figure out how to be spec-compliant here. |
| 2585 | if (!input->isStruct()) |
| 2586 | { |
| 2587 | packedVaryings.push_back(PackedVarying(*input, input->interpolation)); |
| 2588 | packedVaryings.back().vertexOnly = true; |
| 2589 | } |
| 2590 | break; |
| 2591 | } |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2592 | } |
| 2593 | } |
| 2594 | |
Jamie Madill | 192745a | 2016-12-22 15:58:21 -0500 | [diff] [blame] | 2595 | std::sort(packedVaryings.begin(), packedVaryings.end(), ComparePackedVarying); |
| 2596 | |
| 2597 | return packedVaryings; |
Jamie Madill | ccdf74b | 2015-08-18 10:46:12 -0400 | [diff] [blame] | 2598 | } |
Jamie Madill | 80a6fc0 | 2015-08-21 16:53:16 -0400 | [diff] [blame] | 2599 | |
| 2600 | void Program::linkOutputVariables() |
| 2601 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2602 | const Shader *fragmentShader = mState.mAttachedFragmentShader; |
Jamie Madill | 80a6fc0 | 2015-08-21 16:53:16 -0400 | [diff] [blame] | 2603 | ASSERT(fragmentShader != nullptr); |
| 2604 | |
| 2605 | // Skip this step for GLES2 shaders. |
| 2606 | if (fragmentShader->getShaderVersion() == 100) |
| 2607 | return; |
| 2608 | |
Jamie Madill | a0a9e12 | 2015-09-02 15:54:30 -0400 | [diff] [blame] | 2609 | const auto &shaderOutputVars = fragmentShader->getActiveOutputVariables(); |
Jamie Madill | 80a6fc0 | 2015-08-21 16:53:16 -0400 | [diff] [blame] | 2610 | |
| 2611 | // TODO(jmadill): any caps validation here? |
| 2612 | |
| 2613 | for (unsigned int outputVariableIndex = 0; outputVariableIndex < shaderOutputVars.size(); |
| 2614 | outputVariableIndex++) |
| 2615 | { |
Jamie Madill | a0a9e12 | 2015-09-02 15:54:30 -0400 | [diff] [blame] | 2616 | const sh::OutputVariable &outputVariable = shaderOutputVars[outputVariableIndex]; |
Jamie Madill | 80a6fc0 | 2015-08-21 16:53:16 -0400 | [diff] [blame] | 2617 | |
| 2618 | // Don't store outputs for gl_FragDepth, gl_FragColor, etc. |
| 2619 | if (outputVariable.isBuiltIn()) |
| 2620 | continue; |
| 2621 | |
| 2622 | // Since multiple output locations must be specified, use 0 for non-specified locations. |
| 2623 | int baseLocation = (outputVariable.location == -1 ? 0 : outputVariable.location); |
| 2624 | |
| 2625 | ASSERT(outputVariable.staticUse); |
| 2626 | |
| 2627 | for (unsigned int elementIndex = 0; elementIndex < outputVariable.elementCount(); |
| 2628 | elementIndex++) |
| 2629 | { |
| 2630 | const int location = baseLocation + elementIndex; |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2631 | ASSERT(mState.mOutputVariables.count(location) == 0); |
Jamie Madill | 80a6fc0 | 2015-08-21 16:53:16 -0400 | [diff] [blame] | 2632 | unsigned int element = outputVariable.isArray() ? elementIndex : GL_INVALID_INDEX; |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2633 | mState.mOutputVariables[location] = |
Jamie Madill | 80a6fc0 | 2015-08-21 16:53:16 -0400 | [diff] [blame] | 2634 | VariableLocation(outputVariable.name, element, outputVariableIndex); |
| 2635 | } |
| 2636 | } |
| 2637 | } |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2638 | |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 2639 | bool Program::flattenUniformsAndCheckCapsForShader(const Shader &shader, |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2640 | GLuint maxUniformComponents, |
| 2641 | GLuint maxTextureImageUnits, |
| 2642 | const std::string &componentsErrorMessage, |
| 2643 | const std::string &samplerErrorMessage, |
| 2644 | std::vector<LinkedUniform> &samplerUniforms, |
| 2645 | InfoLog &infoLog) |
| 2646 | { |
| 2647 | VectorAndSamplerCount vasCount; |
| 2648 | for (const sh::Uniform &uniform : shader.getUniforms()) |
| 2649 | { |
| 2650 | if (uniform.staticUse) |
| 2651 | { |
| 2652 | vasCount += flattenUniform(uniform, uniform.name, &samplerUniforms); |
| 2653 | } |
| 2654 | } |
| 2655 | |
| 2656 | if (vasCount.vectorCount > maxUniformComponents) |
| 2657 | { |
| 2658 | infoLog << componentsErrorMessage << maxUniformComponents << ")."; |
| 2659 | return false; |
| 2660 | } |
| 2661 | |
| 2662 | if (vasCount.samplerCount > maxTextureImageUnits) |
| 2663 | { |
| 2664 | infoLog << samplerErrorMessage << maxTextureImageUnits << ")."; |
| 2665 | return false; |
| 2666 | } |
| 2667 | |
| 2668 | return true; |
| 2669 | } |
| 2670 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2671 | bool Program::flattenUniformsAndCheckCaps(const Caps &caps, InfoLog &infoLog) |
| 2672 | { |
Jamie Madill | 3d3d2f2 | 2015-09-23 16:47:51 -0400 | [diff] [blame] | 2673 | std::vector<LinkedUniform> samplerUniforms; |
| 2674 | |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2675 | if (mState.mAttachedComputeShader) |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2676 | { |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 2677 | const Shader *computeShader = mState.getAttachedComputeShader(); |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2678 | |
| 2679 | // TODO (mradev): check whether we need finer-grained component counting |
| 2680 | if (!flattenUniformsAndCheckCapsForShader( |
| 2681 | *computeShader, caps.maxComputeUniformComponents / 4, |
| 2682 | caps.maxComputeTextureImageUnits, |
| 2683 | "Compute shader active uniforms exceed MAX_COMPUTE_UNIFORM_COMPONENTS (", |
| 2684 | "Compute shader sampler count exceeds MAX_COMPUTE_TEXTURE_IMAGE_UNITS (", |
| 2685 | samplerUniforms, infoLog)) |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2686 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2687 | return false; |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2688 | } |
| 2689 | } |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2690 | else |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2691 | { |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 2692 | const Shader *vertexShader = mState.getAttachedVertexShader(); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2693 | |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2694 | if (!flattenUniformsAndCheckCapsForShader( |
| 2695 | *vertexShader, caps.maxVertexUniformVectors, caps.maxVertexTextureImageUnits, |
| 2696 | "Vertex shader active uniforms exceed MAX_VERTEX_UNIFORM_VECTORS (", |
| 2697 | "Vertex shader sampler count exceeds MAX_VERTEX_TEXTURE_IMAGE_UNITS (", |
| 2698 | samplerUniforms, infoLog)) |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2699 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2700 | return false; |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2701 | } |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 2702 | const Shader *fragmentShader = mState.getAttachedFragmentShader(); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2703 | |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2704 | if (!flattenUniformsAndCheckCapsForShader( |
| 2705 | *fragmentShader, caps.maxFragmentUniformVectors, caps.maxTextureImageUnits, |
| 2706 | "Fragment shader active uniforms exceed MAX_FRAGMENT_UNIFORM_VECTORS (", |
| 2707 | "Fragment shader sampler count exceeds MAX_TEXTURE_IMAGE_UNITS (", samplerUniforms, |
| 2708 | infoLog)) |
| 2709 | { |
| 2710 | return false; |
| 2711 | } |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2712 | } |
| 2713 | |
Jamie Madill | e7d8432 | 2017-01-10 18:21:59 -0500 | [diff] [blame] | 2714 | mState.mSamplerUniformRange.start = static_cast<unsigned int>(mState.mUniforms.size()); |
| 2715 | mState.mSamplerUniformRange.end = |
| 2716 | mState.mSamplerUniformRange.start + static_cast<unsigned int>(samplerUniforms.size()); |
Jamie Madill | 3d3d2f2 | 2015-09-23 16:47:51 -0400 | [diff] [blame] | 2717 | |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2718 | mState.mUniforms.insert(mState.mUniforms.end(), samplerUniforms.begin(), samplerUniforms.end()); |
Jamie Madill | 3d3d2f2 | 2015-09-23 16:47:51 -0400 | [diff] [blame] | 2719 | |
Jamie Madill | e7d8432 | 2017-01-10 18:21:59 -0500 | [diff] [blame] | 2720 | // If uniform is a sampler type, insert it into the mSamplerBindings array. |
| 2721 | for (const auto &samplerUniform : samplerUniforms) |
| 2722 | { |
| 2723 | GLenum textureType = SamplerTypeToTextureType(samplerUniform.type); |
| 2724 | mState.mSamplerBindings.emplace_back( |
| 2725 | SamplerBinding(textureType, samplerUniform.elementCount())); |
| 2726 | } |
| 2727 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2728 | return true; |
| 2729 | } |
| 2730 | |
| 2731 | Program::VectorAndSamplerCount Program::flattenUniform(const sh::ShaderVariable &uniform, |
Jamie Madill | 3d3d2f2 | 2015-09-23 16:47:51 -0400 | [diff] [blame] | 2732 | const std::string &fullName, |
| 2733 | std::vector<LinkedUniform> *samplerUniforms) |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2734 | { |
| 2735 | VectorAndSamplerCount vectorAndSamplerCount; |
| 2736 | |
| 2737 | if (uniform.isStruct()) |
| 2738 | { |
| 2739 | for (unsigned int elementIndex = 0; elementIndex < uniform.elementCount(); elementIndex++) |
| 2740 | { |
| 2741 | const std::string &elementString = (uniform.isArray() ? ArrayString(elementIndex) : ""); |
| 2742 | |
| 2743 | for (size_t fieldIndex = 0; fieldIndex < uniform.fields.size(); fieldIndex++) |
| 2744 | { |
| 2745 | const sh::ShaderVariable &field = uniform.fields[fieldIndex]; |
| 2746 | const std::string &fieldFullName = (fullName + elementString + "." + field.name); |
| 2747 | |
Jamie Madill | 3d3d2f2 | 2015-09-23 16:47:51 -0400 | [diff] [blame] | 2748 | vectorAndSamplerCount += flattenUniform(field, fieldFullName, samplerUniforms); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2749 | } |
| 2750 | } |
| 2751 | |
| 2752 | return vectorAndSamplerCount; |
| 2753 | } |
| 2754 | |
| 2755 | // Not a struct |
Jamie Madill | 3d3d2f2 | 2015-09-23 16:47:51 -0400 | [diff] [blame] | 2756 | bool isSampler = IsSamplerType(uniform.type); |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2757 | if (!UniformInList(mState.getUniforms(), fullName) && |
| 2758 | !UniformInList(*samplerUniforms, fullName)) |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2759 | { |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 2760 | LinkedUniform linkedUniform(uniform.type, uniform.precision, fullName, uniform.arraySize, |
| 2761 | -1, sh::BlockMemberInfo::getDefaultBlockInfo()); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2762 | linkedUniform.staticUse = true; |
Jamie Madill | 3d3d2f2 | 2015-09-23 16:47:51 -0400 | [diff] [blame] | 2763 | |
| 2764 | // Store sampler uniforms separately, so we'll append them to the end of the list. |
| 2765 | if (isSampler) |
| 2766 | { |
| 2767 | samplerUniforms->push_back(linkedUniform); |
| 2768 | } |
| 2769 | else |
| 2770 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2771 | mState.mUniforms.push_back(linkedUniform); |
Jamie Madill | 3d3d2f2 | 2015-09-23 16:47:51 -0400 | [diff] [blame] | 2772 | } |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2773 | } |
| 2774 | |
Jamie Madill | 3d3d2f2 | 2015-09-23 16:47:51 -0400 | [diff] [blame] | 2775 | unsigned int elementCount = uniform.elementCount(); |
Austin Kinross | 7a3e8e2 | 2015-10-08 15:50:06 -0700 | [diff] [blame] | 2776 | |
| 2777 | // Samplers aren't "real" uniforms, so they don't count towards register usage. |
| 2778 | // Likewise, don't count "real" uniforms towards sampler count. |
| 2779 | vectorAndSamplerCount.vectorCount = |
| 2780 | (isSampler ? 0 : (VariableRegisterCount(uniform.type) * elementCount)); |
Jamie Madill | 3d3d2f2 | 2015-09-23 16:47:51 -0400 | [diff] [blame] | 2781 | vectorAndSamplerCount.samplerCount = (isSampler ? elementCount : 0); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2782 | |
| 2783 | return vectorAndSamplerCount; |
| 2784 | } |
| 2785 | |
| 2786 | void Program::gatherInterfaceBlockInfo() |
| 2787 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2788 | ASSERT(mState.mUniformBlocks.empty()); |
| 2789 | |
| 2790 | if (mState.mAttachedComputeShader) |
| 2791 | { |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 2792 | const Shader *computeShader = mState.getAttachedComputeShader(); |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2793 | |
| 2794 | for (const sh::InterfaceBlock &computeBlock : computeShader->getInterfaceBlocks()) |
| 2795 | { |
| 2796 | |
| 2797 | // Only 'packed' blocks are allowed to be considered inactive. |
| 2798 | if (!computeBlock.staticUse && computeBlock.layout == sh::BLOCKLAYOUT_PACKED) |
| 2799 | continue; |
| 2800 | |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 2801 | for (UniformBlock &block : mState.mUniformBlocks) |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2802 | { |
| 2803 | if (block.name == computeBlock.name) |
| 2804 | { |
| 2805 | block.computeStaticUse = computeBlock.staticUse; |
| 2806 | } |
| 2807 | } |
| 2808 | |
| 2809 | defineUniformBlock(computeBlock, GL_COMPUTE_SHADER); |
| 2810 | } |
| 2811 | return; |
| 2812 | } |
| 2813 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2814 | std::set<std::string> visitedList; |
| 2815 | |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 2816 | const Shader *vertexShader = mState.getAttachedVertexShader(); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2817 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2818 | for (const sh::InterfaceBlock &vertexBlock : vertexShader->getInterfaceBlocks()) |
| 2819 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2820 | // Only 'packed' blocks are allowed to be considered inactive. |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2821 | if (!vertexBlock.staticUse && vertexBlock.layout == sh::BLOCKLAYOUT_PACKED) |
| 2822 | continue; |
| 2823 | |
| 2824 | if (visitedList.count(vertexBlock.name) > 0) |
| 2825 | continue; |
| 2826 | |
| 2827 | defineUniformBlock(vertexBlock, GL_VERTEX_SHADER); |
| 2828 | visitedList.insert(vertexBlock.name); |
| 2829 | } |
| 2830 | |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 2831 | const Shader *fragmentShader = mState.getAttachedFragmentShader(); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2832 | |
| 2833 | for (const sh::InterfaceBlock &fragmentBlock : fragmentShader->getInterfaceBlocks()) |
| 2834 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2835 | // Only 'packed' blocks are allowed to be considered inactive. |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2836 | if (!fragmentBlock.staticUse && fragmentBlock.layout == sh::BLOCKLAYOUT_PACKED) |
| 2837 | continue; |
| 2838 | |
| 2839 | if (visitedList.count(fragmentBlock.name) > 0) |
| 2840 | { |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 2841 | for (UniformBlock &block : mState.mUniformBlocks) |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2842 | { |
| 2843 | if (block.name == fragmentBlock.name) |
| 2844 | { |
| 2845 | block.fragmentStaticUse = fragmentBlock.staticUse; |
| 2846 | } |
| 2847 | } |
| 2848 | |
| 2849 | continue; |
| 2850 | } |
| 2851 | |
| 2852 | defineUniformBlock(fragmentBlock, GL_FRAGMENT_SHADER); |
| 2853 | visitedList.insert(fragmentBlock.name); |
| 2854 | } |
| 2855 | } |
| 2856 | |
Jamie Madill | 4a3c234 | 2015-10-08 12:58:45 -0400 | [diff] [blame] | 2857 | template <typename VarT> |
| 2858 | void Program::defineUniformBlockMembers(const std::vector<VarT> &fields, |
| 2859 | const std::string &prefix, |
| 2860 | int blockIndex) |
| 2861 | { |
| 2862 | for (const VarT &field : fields) |
| 2863 | { |
| 2864 | const std::string &fullName = (prefix.empty() ? field.name : prefix + "." + field.name); |
| 2865 | |
| 2866 | if (field.isStruct()) |
| 2867 | { |
| 2868 | for (unsigned int arrayElement = 0; arrayElement < field.elementCount(); arrayElement++) |
| 2869 | { |
| 2870 | const std::string uniformElementName = |
| 2871 | fullName + (field.isArray() ? ArrayString(arrayElement) : ""); |
| 2872 | defineUniformBlockMembers(field.fields, uniformElementName, blockIndex); |
| 2873 | } |
| 2874 | } |
| 2875 | else |
| 2876 | { |
| 2877 | // If getBlockMemberInfo returns false, the uniform is optimized out. |
| 2878 | sh::BlockMemberInfo memberInfo; |
| 2879 | if (!mProgram->getUniformBlockMemberInfo(fullName, &memberInfo)) |
| 2880 | { |
| 2881 | continue; |
| 2882 | } |
| 2883 | |
| 2884 | LinkedUniform newUniform(field.type, field.precision, fullName, field.arraySize, |
| 2885 | blockIndex, memberInfo); |
| 2886 | |
| 2887 | // Since block uniforms have no location, we don't need to store them in the uniform |
| 2888 | // locations list. |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2889 | mState.mUniforms.push_back(newUniform); |
Jamie Madill | 4a3c234 | 2015-10-08 12:58:45 -0400 | [diff] [blame] | 2890 | } |
| 2891 | } |
| 2892 | } |
| 2893 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2894 | void Program::defineUniformBlock(const sh::InterfaceBlock &interfaceBlock, GLenum shaderType) |
| 2895 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2896 | int blockIndex = static_cast<int>(mState.mUniformBlocks.size()); |
Jamie Madill | 4a3c234 | 2015-10-08 12:58:45 -0400 | [diff] [blame] | 2897 | size_t blockSize = 0; |
| 2898 | |
| 2899 | // Don't define this block at all if it's not active in the implementation. |
Qin Jiajia | 0350a64 | 2016-11-01 17:01:51 +0800 | [diff] [blame] | 2900 | std::stringstream blockNameStr; |
| 2901 | blockNameStr << interfaceBlock.name; |
| 2902 | if (interfaceBlock.arraySize > 0) |
| 2903 | { |
| 2904 | blockNameStr << "[0]"; |
| 2905 | } |
| 2906 | if (!mProgram->getUniformBlockSize(blockNameStr.str(), &blockSize)) |
Jamie Madill | 4a3c234 | 2015-10-08 12:58:45 -0400 | [diff] [blame] | 2907 | { |
| 2908 | return; |
| 2909 | } |
| 2910 | |
| 2911 | // Track the first and last uniform index to determine the range of active uniforms in the |
| 2912 | // block. |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2913 | size_t firstBlockUniformIndex = mState.mUniforms.size(); |
Jamie Madill | 3904616 | 2016-02-08 15:05:17 -0500 | [diff] [blame] | 2914 | defineUniformBlockMembers(interfaceBlock.fields, interfaceBlock.fieldPrefix(), blockIndex); |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2915 | size_t lastBlockUniformIndex = mState.mUniforms.size(); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2916 | |
| 2917 | std::vector<unsigned int> blockUniformIndexes; |
| 2918 | for (size_t blockUniformIndex = firstBlockUniformIndex; |
| 2919 | blockUniformIndex < lastBlockUniformIndex; ++blockUniformIndex) |
| 2920 | { |
| 2921 | blockUniformIndexes.push_back(static_cast<unsigned int>(blockUniformIndex)); |
| 2922 | } |
| 2923 | |
| 2924 | if (interfaceBlock.arraySize > 0) |
| 2925 | { |
| 2926 | for (unsigned int arrayElement = 0; arrayElement < interfaceBlock.arraySize; ++arrayElement) |
| 2927 | { |
| 2928 | UniformBlock block(interfaceBlock.name, true, arrayElement); |
| 2929 | block.memberUniformIndexes = blockUniformIndexes; |
| 2930 | |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2931 | switch (shaderType) |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2932 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2933 | case GL_VERTEX_SHADER: |
| 2934 | { |
| 2935 | block.vertexStaticUse = interfaceBlock.staticUse; |
| 2936 | break; |
| 2937 | } |
| 2938 | case GL_FRAGMENT_SHADER: |
| 2939 | { |
| 2940 | block.fragmentStaticUse = interfaceBlock.staticUse; |
| 2941 | break; |
| 2942 | } |
| 2943 | case GL_COMPUTE_SHADER: |
| 2944 | { |
| 2945 | block.computeStaticUse = interfaceBlock.staticUse; |
| 2946 | break; |
| 2947 | } |
| 2948 | default: |
| 2949 | UNREACHABLE(); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2950 | } |
| 2951 | |
Qin Jiajia | 0350a64 | 2016-11-01 17:01:51 +0800 | [diff] [blame] | 2952 | // Since all block elements in an array share the same active uniforms, they will all be |
| 2953 | // active once any uniform member is used. So, since interfaceBlock.name[0] was active, |
| 2954 | // here we will add every block element in the array. |
| 2955 | block.dataSize = static_cast<unsigned int>(blockSize); |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2956 | mState.mUniformBlocks.push_back(block); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2957 | } |
| 2958 | } |
| 2959 | else |
| 2960 | { |
| 2961 | UniformBlock block(interfaceBlock.name, false, 0); |
| 2962 | block.memberUniformIndexes = blockUniformIndexes; |
| 2963 | |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2964 | switch (shaderType) |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2965 | { |
Martin Radev | 4c4c8e7 | 2016-08-04 12:25:34 +0300 | [diff] [blame] | 2966 | case GL_VERTEX_SHADER: |
| 2967 | { |
| 2968 | block.vertexStaticUse = interfaceBlock.staticUse; |
| 2969 | break; |
| 2970 | } |
| 2971 | case GL_FRAGMENT_SHADER: |
| 2972 | { |
| 2973 | block.fragmentStaticUse = interfaceBlock.staticUse; |
| 2974 | break; |
| 2975 | } |
| 2976 | case GL_COMPUTE_SHADER: |
| 2977 | { |
| 2978 | block.computeStaticUse = interfaceBlock.staticUse; |
| 2979 | break; |
| 2980 | } |
| 2981 | default: |
| 2982 | UNREACHABLE(); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2983 | } |
| 2984 | |
Jamie Madill | 4a3c234 | 2015-10-08 12:58:45 -0400 | [diff] [blame] | 2985 | block.dataSize = static_cast<unsigned int>(blockSize); |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 2986 | mState.mUniformBlocks.push_back(block); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 2987 | } |
| 2988 | } |
| 2989 | |
Jamie Madill | e7d8432 | 2017-01-10 18:21:59 -0500 | [diff] [blame] | 2990 | template <> |
| 2991 | void Program::updateSamplerUniform(const VariableLocation &locationInfo, |
| 2992 | const uint8_t *destPointer, |
| 2993 | GLsizei clampedCount, |
| 2994 | const GLint *v) |
| 2995 | { |
| 2996 | // Invalidate the validation cache only if we modify the sampler data. |
| 2997 | if (mState.isSamplerUniformIndex(locationInfo.index) && |
| 2998 | memcmp(destPointer, v, sizeof(GLint) * clampedCount) != 0) |
| 2999 | { |
| 3000 | GLuint samplerIndex = mState.getSamplerIndexFromUniformIndex(locationInfo.index); |
| 3001 | std::vector<GLuint> *boundTextureUnits = |
| 3002 | &mState.mSamplerBindings[samplerIndex].boundTextureUnits; |
| 3003 | |
| 3004 | std::copy(v, v + clampedCount, boundTextureUnits->begin() + locationInfo.element); |
| 3005 | mCachedValidateSamplersResult.reset(); |
| 3006 | } |
| 3007 | } |
| 3008 | |
| 3009 | template <typename T> |
| 3010 | void Program::updateSamplerUniform(const VariableLocation &locationInfo, |
| 3011 | const uint8_t *destPointer, |
| 3012 | GLsizei clampedCount, |
| 3013 | const T *v) |
| 3014 | { |
| 3015 | } |
| 3016 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 3017 | template <typename T> |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 3018 | GLsizei Program::setUniformInternal(GLint location, GLsizei countIn, int vectorSize, const T *v) |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 3019 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 3020 | const VariableLocation &locationInfo = mState.mUniformLocations[location]; |
| 3021 | LinkedUniform *linkedUniform = &mState.mUniforms[locationInfo.index]; |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 3022 | uint8_t *destPointer = linkedUniform->getDataPtrToElement(locationInfo.element); |
| 3023 | |
Corentin Wallez | 15ac534 | 2016-11-03 17:06:39 -0400 | [diff] [blame] | 3024 | // OpenGL ES 3.0.4 spec pg 67: "Values for any array element that exceeds the highest array |
| 3025 | // element index used, as reported by GetActiveUniform, will be ignored by the GL." |
| 3026 | unsigned int remainingElements = linkedUniform->elementCount() - locationInfo.element; |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 3027 | GLsizei maxElementCount = |
| 3028 | static_cast<GLsizei>(remainingElements * linkedUniform->getElementComponents()); |
| 3029 | |
| 3030 | GLsizei count = countIn; |
| 3031 | GLsizei clampedCount = count * vectorSize; |
| 3032 | if (clampedCount > maxElementCount) |
| 3033 | { |
| 3034 | clampedCount = maxElementCount; |
| 3035 | count = maxElementCount / vectorSize; |
| 3036 | } |
Corentin Wallez | 15ac534 | 2016-11-03 17:06:39 -0400 | [diff] [blame] | 3037 | |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 3038 | if (VariableComponentType(linkedUniform->type) == GL_BOOL) |
| 3039 | { |
| 3040 | // Do a cast conversion for boolean types. From the spec: |
| 3041 | // "The uniform is set to FALSE if the input value is 0 or 0.0f, and set to TRUE otherwise." |
| 3042 | GLint *destAsInt = reinterpret_cast<GLint *>(destPointer); |
Corentin Wallez | 15ac534 | 2016-11-03 17:06:39 -0400 | [diff] [blame] | 3043 | for (GLsizei component = 0; component < clampedCount; ++component) |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 3044 | { |
| 3045 | destAsInt[component] = (v[component] != static_cast<T>(0) ? GL_TRUE : GL_FALSE); |
| 3046 | } |
| 3047 | } |
| 3048 | else |
| 3049 | { |
Jamie Madill | e7d8432 | 2017-01-10 18:21:59 -0500 | [diff] [blame] | 3050 | updateSamplerUniform(locationInfo, destPointer, clampedCount, v); |
Corentin Wallez | 15ac534 | 2016-11-03 17:06:39 -0400 | [diff] [blame] | 3051 | memcpy(destPointer, v, sizeof(T) * clampedCount); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 3052 | } |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 3053 | |
| 3054 | return count; |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 3055 | } |
| 3056 | |
| 3057 | template <size_t cols, size_t rows, typename T> |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 3058 | GLsizei Program::setMatrixUniformInternal(GLint location, |
| 3059 | GLsizei count, |
| 3060 | GLboolean transpose, |
| 3061 | const T *v) |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 3062 | { |
| 3063 | if (!transpose) |
| 3064 | { |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 3065 | return setUniformInternal(location, count, cols * rows, v); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 3066 | } |
| 3067 | |
| 3068 | // Perform a transposing copy. |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 3069 | const VariableLocation &locationInfo = mState.mUniformLocations[location]; |
| 3070 | LinkedUniform *linkedUniform = &mState.mUniforms[locationInfo.index]; |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 3071 | T *destPtr = reinterpret_cast<T *>(linkedUniform->getDataPtrToElement(locationInfo.element)); |
Corentin Wallez | 15ac534 | 2016-11-03 17:06:39 -0400 | [diff] [blame] | 3072 | |
| 3073 | // OpenGL ES 3.0.4 spec pg 67: "Values for any array element that exceeds the highest array |
| 3074 | // element index used, as reported by GetActiveUniform, will be ignored by the GL." |
| 3075 | unsigned int remainingElements = linkedUniform->elementCount() - locationInfo.element; |
| 3076 | GLsizei clampedCount = std::min(count, static_cast<GLsizei>(remainingElements)); |
| 3077 | |
| 3078 | for (GLsizei element = 0; element < clampedCount; ++element) |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 3079 | { |
| 3080 | size_t elementOffset = element * rows * cols; |
| 3081 | |
| 3082 | for (size_t row = 0; row < rows; ++row) |
| 3083 | { |
| 3084 | for (size_t col = 0; col < cols; ++col) |
| 3085 | { |
| 3086 | destPtr[col * rows + row + elementOffset] = v[row * cols + col + elementOffset]; |
| 3087 | } |
| 3088 | } |
| 3089 | } |
Corentin Wallez | 8b7d814 | 2016-11-15 13:40:37 -0500 | [diff] [blame] | 3090 | |
| 3091 | return clampedCount; |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 3092 | } |
| 3093 | |
| 3094 | template <typename DestT> |
| 3095 | void Program::getUniformInternal(GLint location, DestT *dataOut) const |
| 3096 | { |
Jamie Madill | 48ef11b | 2016-04-27 15:21:52 -0400 | [diff] [blame] | 3097 | const VariableLocation &locationInfo = mState.mUniformLocations[location]; |
| 3098 | const LinkedUniform &uniform = mState.mUniforms[locationInfo.index]; |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 3099 | |
| 3100 | const uint8_t *srcPointer = uniform.getDataPtrToElement(locationInfo.element); |
| 3101 | |
| 3102 | GLenum componentType = VariableComponentType(uniform.type); |
| 3103 | if (componentType == GLTypeToGLenum<DestT>::value) |
| 3104 | { |
| 3105 | memcpy(dataOut, srcPointer, uniform.getElementSize()); |
| 3106 | return; |
| 3107 | } |
| 3108 | |
Corentin Wallez | 6596c46 | 2016-03-17 17:26:58 -0400 | [diff] [blame] | 3109 | int components = VariableComponentCount(uniform.type); |
Jamie Madill | 62d31cb | 2015-09-11 13:25:51 -0400 | [diff] [blame] | 3110 | |
| 3111 | switch (componentType) |
| 3112 | { |
| 3113 | case GL_INT: |
| 3114 | UniformStateQueryCastLoop<GLint>(dataOut, srcPointer, components); |
| 3115 | break; |
| 3116 | case GL_UNSIGNED_INT: |
| 3117 | UniformStateQueryCastLoop<GLuint>(dataOut, srcPointer, components); |
| 3118 | break; |
| 3119 | case GL_BOOL: |
| 3120 | UniformStateQueryCastLoop<GLboolean>(dataOut, srcPointer, components); |
| 3121 | break; |
| 3122 | case GL_FLOAT: |
| 3123 | UniformStateQueryCastLoop<GLfloat>(dataOut, srcPointer, components); |
| 3124 | break; |
| 3125 | default: |
| 3126 | UNREACHABLE(); |
| 3127 | } |
| 3128 | } |
Jamie Madill | a2c7498 | 2016-12-12 11:20:42 -0500 | [diff] [blame] | 3129 | } // namespace gl |