diff options
Diffstat (limited to 'dom/canvas/WebGLProgram.cpp')
| -rw-r--r-- | dom/canvas/WebGLProgram.cpp | 1213 |
1 files changed, 1213 insertions, 0 deletions
diff --git a/dom/canvas/WebGLProgram.cpp b/dom/canvas/WebGLProgram.cpp new file mode 100644 index 0000000000..f29d3d1c14 --- /dev/null +++ b/dom/canvas/WebGLProgram.cpp @@ -0,0 +1,1213 @@ +/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "WebGLProgram.h" + +#include "GLContext.h" +#include "mozilla/CheckedInt.h" +#include "mozilla/dom/WebGL2RenderingContextBinding.h" +#include "mozilla/dom/WebGLRenderingContextBinding.h" +#include "mozilla/gfx/Logging.h" +#include "mozilla/RefPtr.h" +#include "nsPrintfCString.h" +#include "WebGLBuffer.h" +#include "WebGLContext.h" +#include "WebGLShader.h" +#include "WebGLShaderValidator.h" +#include "WebGLTransformFeedback.h" +#include "WebGLValidateStrings.h" +#include "WebGLVertexArray.h" + +namespace mozilla { + +static bool IsShadowSampler(const GLenum elemType) { + switch (elemType) { + case LOCAL_GL_SAMPLER_2D_SHADOW: + case LOCAL_GL_SAMPLER_CUBE_SHADOW: + case LOCAL_GL_SAMPLER_2D_ARRAY_SHADOW: + return true; + default: + return false; + } +} + +static Maybe<webgl::TextureBaseType> SamplerBaseType(const GLenum elemType) { + switch (elemType) { + case LOCAL_GL_SAMPLER_2D: + case LOCAL_GL_SAMPLER_3D: + case LOCAL_GL_SAMPLER_CUBE: + case LOCAL_GL_SAMPLER_2D_ARRAY: + case LOCAL_GL_SAMPLER_2D_SHADOW: + case LOCAL_GL_SAMPLER_CUBE_SHADOW: + case LOCAL_GL_SAMPLER_2D_ARRAY_SHADOW: + return Some(webgl::TextureBaseType::Float); + + case LOCAL_GL_INT_SAMPLER_2D: + case LOCAL_GL_INT_SAMPLER_3D: + case LOCAL_GL_INT_SAMPLER_CUBE: + case LOCAL_GL_INT_SAMPLER_2D_ARRAY: + return Some(webgl::TextureBaseType::Int); + + case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D: + case LOCAL_GL_UNSIGNED_INT_SAMPLER_3D: + case LOCAL_GL_UNSIGNED_INT_SAMPLER_CUBE: + case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D_ARRAY: + return Some(webgl::TextureBaseType::UInt); + + default: + return {}; + } +} + +////////// + +static webgl::TextureBaseType FragOutputBaseType(const GLenum type) { + switch (type) { + case LOCAL_GL_FLOAT: + case LOCAL_GL_FLOAT_VEC2: + case LOCAL_GL_FLOAT_VEC3: + case LOCAL_GL_FLOAT_VEC4: + return webgl::TextureBaseType::Float; + + case LOCAL_GL_INT: + case LOCAL_GL_INT_VEC2: + case LOCAL_GL_INT_VEC3: + case LOCAL_GL_INT_VEC4: + return webgl::TextureBaseType::Int; + + case LOCAL_GL_UNSIGNED_INT: + case LOCAL_GL_UNSIGNED_INT_VEC2: + case LOCAL_GL_UNSIGNED_INT_VEC3: + case LOCAL_GL_UNSIGNED_INT_VEC4: + return webgl::TextureBaseType::UInt; + + default: + break; + } + + const auto& str = EnumString(type); + gfxCriticalError() << "Unhandled enum for FragOutputBaseType: " + << str.c_str(); + return webgl::TextureBaseType::Float; +} + +// ----------------------------------------- + +namespace webgl { + +void UniformAs1fv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniform1fv(location, count, static_cast<const float*>(any)); +} +void UniformAs2fv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniform2fv(location, count, static_cast<const float*>(any)); +} +void UniformAs3fv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniform3fv(location, count, static_cast<const float*>(any)); +} +void UniformAs4fv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniform4fv(location, count, static_cast<const float*>(any)); +} + +void UniformAs1iv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniform1iv(location, count, static_cast<const int32_t*>(any)); +} +void UniformAs2iv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniform2iv(location, count, static_cast<const int32_t*>(any)); +} +void UniformAs3iv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniform3iv(location, count, static_cast<const int32_t*>(any)); +} +void UniformAs4iv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniform4iv(location, count, static_cast<const int32_t*>(any)); +} + +void UniformAs1uiv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniform1uiv(location, count, static_cast<const uint32_t*>(any)); +} +void UniformAs2uiv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniform2uiv(location, count, static_cast<const uint32_t*>(any)); +} +void UniformAs3uiv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniform3uiv(location, count, static_cast<const uint32_t*>(any)); +} +void UniformAs4uiv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniform4uiv(location, count, static_cast<const uint32_t*>(any)); +} + +void UniformAsMatrix2x2fv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniformMatrix2fv(location, count, transpose, + static_cast<const float*>(any)); +} +void UniformAsMatrix2x3fv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniformMatrix2x3fv(location, count, transpose, + static_cast<const float*>(any)); +} +void UniformAsMatrix2x4fv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniformMatrix2x4fv(location, count, transpose, + static_cast<const float*>(any)); +} + +void UniformAsMatrix3x2fv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniformMatrix3x2fv(location, count, transpose, + static_cast<const float*>(any)); +} +void UniformAsMatrix3x3fv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniformMatrix3fv(location, count, transpose, + static_cast<const float*>(any)); +} +void UniformAsMatrix3x4fv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniformMatrix3x4fv(location, count, transpose, + static_cast<const float*>(any)); +} + +void UniformAsMatrix4x2fv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniformMatrix4x2fv(location, count, transpose, + static_cast<const float*>(any)); +} +void UniformAsMatrix4x3fv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniformMatrix4x3fv(location, count, transpose, + static_cast<const float*>(any)); +} +void UniformAsMatrix4x4fv(gl::GLContext& gl, GLint location, GLsizei count, + bool transpose, const void* any) { + gl.fUniformMatrix4fv(location, count, transpose, + static_cast<const float*>(any)); +} + +// - + +static bool EndsWith(const std::string& str, const std::string& needle) { + if (str.length() < needle.length()) return false; + return str.compare(str.length() - needle.length(), needle.length(), needle) == + 0; +} + +webgl::ActiveUniformValidationInfo webgl::ActiveUniformValidationInfo::Make( + const webgl::ActiveUniformInfo& info) { + auto ret = webgl::ActiveUniformValidationInfo{info}; + ret.isArray = EndsWith(info.name, "[0]"); + + switch (info.elemType) { + case LOCAL_GL_FLOAT: + ret.channelsPerElem = 1; + ret.pfn = &UniformAs1fv; + break; + case LOCAL_GL_FLOAT_VEC2: + ret.channelsPerElem = 2; + ret.pfn = &UniformAs2fv; + break; + case LOCAL_GL_FLOAT_VEC3: + ret.channelsPerElem = 3; + ret.pfn = &UniformAs3fv; + break; + case LOCAL_GL_FLOAT_VEC4: + ret.channelsPerElem = 4; + ret.pfn = &UniformAs4fv; + break; + + case LOCAL_GL_SAMPLER_2D: + case LOCAL_GL_SAMPLER_3D: + case LOCAL_GL_SAMPLER_CUBE: + case LOCAL_GL_SAMPLER_2D_SHADOW: + case LOCAL_GL_SAMPLER_2D_ARRAY: + case LOCAL_GL_SAMPLER_2D_ARRAY_SHADOW: + case LOCAL_GL_SAMPLER_CUBE_SHADOW: + case LOCAL_GL_INT_SAMPLER_2D: + case LOCAL_GL_INT_SAMPLER_3D: + case LOCAL_GL_INT_SAMPLER_CUBE: + case LOCAL_GL_INT_SAMPLER_2D_ARRAY: + case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D: + case LOCAL_GL_UNSIGNED_INT_SAMPLER_3D: + case LOCAL_GL_UNSIGNED_INT_SAMPLER_CUBE: + case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D_ARRAY: + case LOCAL_GL_BOOL: + case LOCAL_GL_INT: + ret.channelsPerElem = 1; + ret.pfn = &UniformAs1iv; + break; + case LOCAL_GL_BOOL_VEC2: + case LOCAL_GL_INT_VEC2: + ret.channelsPerElem = 2; + ret.pfn = &UniformAs2iv; + break; + case LOCAL_GL_BOOL_VEC3: + case LOCAL_GL_INT_VEC3: + ret.channelsPerElem = 3; + ret.pfn = &UniformAs3iv; + break; + case LOCAL_GL_BOOL_VEC4: + case LOCAL_GL_INT_VEC4: + ret.channelsPerElem = 4; + ret.pfn = &UniformAs4iv; + break; + + case LOCAL_GL_UNSIGNED_INT: + ret.channelsPerElem = 1; + ret.pfn = &UniformAs1uiv; + break; + case LOCAL_GL_UNSIGNED_INT_VEC2: + ret.channelsPerElem = 2; + ret.pfn = &UniformAs2uiv; + break; + case LOCAL_GL_UNSIGNED_INT_VEC3: + ret.channelsPerElem = 3; + ret.pfn = &UniformAs3uiv; + break; + case LOCAL_GL_UNSIGNED_INT_VEC4: + ret.channelsPerElem = 4; + ret.pfn = &UniformAs4uiv; + break; + + // - + + case LOCAL_GL_FLOAT_MAT2: + ret.channelsPerElem = 2 * 2; + ret.pfn = &UniformAsMatrix2x2fv; + break; + case LOCAL_GL_FLOAT_MAT2x3: + ret.channelsPerElem = 2 * 3; + ret.pfn = &UniformAsMatrix2x3fv; + break; + case LOCAL_GL_FLOAT_MAT2x4: + ret.channelsPerElem = 2 * 4; + ret.pfn = &UniformAsMatrix2x4fv; + break; + + case LOCAL_GL_FLOAT_MAT3x2: + ret.channelsPerElem = 3 * 2; + ret.pfn = &UniformAsMatrix3x2fv; + break; + case LOCAL_GL_FLOAT_MAT3: + ret.channelsPerElem = 3 * 3; + ret.pfn = &UniformAsMatrix3x3fv; + break; + case LOCAL_GL_FLOAT_MAT3x4: + ret.channelsPerElem = 3 * 4; + ret.pfn = &UniformAsMatrix3x4fv; + break; + + case LOCAL_GL_FLOAT_MAT4x2: + ret.channelsPerElem = 4 * 2; + ret.pfn = &UniformAsMatrix4x2fv; + break; + case LOCAL_GL_FLOAT_MAT4x3: + ret.channelsPerElem = 4 * 3; + ret.pfn = &UniformAsMatrix4x3fv; + break; + case LOCAL_GL_FLOAT_MAT4: + ret.channelsPerElem = 4 * 4; + ret.pfn = &UniformAsMatrix4x4fv; + break; + + default: + gfxCriticalError() << "Bad `elemType`: " << EnumString(info.elemType); + MOZ_CRASH("`elemType`"); + } + return ret; +} + +} // namespace webgl + +// ------------------------- + +// #define DUMP_SHADERVAR_MAPPINGS + +RefPtr<const webgl::LinkedProgramInfo> QueryProgramInfo(WebGLProgram* prog, + gl::GLContext* gl) { + WebGLContext* const webgl = prog->mContext; + + RefPtr<webgl::LinkedProgramInfo> info(new webgl::LinkedProgramInfo(prog)); + + // Frag outputs + + { + const auto& fragShader = prog->FragShader(); + const auto& compileResults = fragShader->CompileResults(); + const auto version = compileResults->mShaderVersion; + + const auto fnAddInfo = [&](const webgl::FragOutputInfo& x) { + info->hasOutput[x.loc] = true; + info->fragOutputs.insert({x.loc, x}); + }; + + if (version == 300) { + for (const auto& cur : compileResults->mOutputVariables) { + auto loc = cur.location; + if (loc == -1) loc = 0; + + const auto info = + webgl::FragOutputInfo{uint8_t(loc), cur.name, cur.mappedName, + FragOutputBaseType(cur.type)}; + if (!cur.isArray()) { + fnAddInfo(info); + continue; + } + MOZ_ASSERT(cur.arraySizes.size() == 1); + for (uint32_t i = 0; i < cur.arraySizes[0]; ++i) { + const auto indexStr = std::string("[") + std::to_string(i) + "]"; + + const auto userName = info.userName + indexStr; + const auto mappedName = info.mappedName + indexStr; + + const auto indexedInfo = webgl::FragOutputInfo{ + uint8_t(info.loc + i), userName, mappedName, info.baseType}; + fnAddInfo(indexedInfo); + } + } + } else { + // ANGLE's translator doesn't tell us about non-user frag outputs. :( + + const auto& translatedSource = compileResults->mObjectCode; + uint32_t drawBuffers = 1; + if (translatedSource.find("(gl_FragData[1]") != std::string::npos || + translatedSource.find("(webgl_FragData[1]") != std::string::npos) { + // The matching with the leading '(' prevents cleverly-named user vars + // breaking this. Since ANGLE initializes all outputs, if this is an MRT + // shader, FragData[1] will be present. FragData[0] is valid for non-MRT + // shaders. + drawBuffers = webgl->GLMaxDrawBuffers(); + } else if (translatedSource.find("(gl_FragColor") == std::string::npos && + translatedSource.find("(webgl_FragColor") == + std::string::npos && + translatedSource.find("(gl_FragData") == std::string::npos && + translatedSource.find("(webgl_FragData") == + std::string::npos) { + // We have to support no-color-output shaders? + drawBuffers = 0; + } + + for (uint32_t i = 0; i < drawBuffers; ++i) { + const auto name = std::string("gl_FragData[") + std::to_string(i) + "]"; + const auto info = webgl::FragOutputInfo{uint8_t(i), name, name, + webgl::TextureBaseType::Float}; + fnAddInfo(info); + } + } + } + + const auto& vertShader = prog->VertShader(); + const auto& vertCompileResults = vertShader->CompileResults(); + const auto numViews = vertCompileResults->mVertexShaderNumViews; + if (numViews != -1) { + info->zLayerCount = AssertedCast<uint8_t>(numViews); + } + + // - + + auto& nameMap = info->nameMap; + + const auto fnAccum = [&](WebGLShader& shader) { + const auto& compRes = shader.CompileResults(); + for (const auto& pair : compRes->mNameMap) { + nameMap.insert(pair); + } + }; + fnAccum(*prog->VertShader()); + fnAccum(*prog->FragShader()); + + // - + + std::unordered_map<std::string, std::string> nameUnmap; + for (const auto& pair : nameMap) { + nameUnmap.insert({pair.second, pair.first}); + } + + info->active = + GetLinkActiveInfo(*gl, prog->mGLName, webgl->IsWebGL2(), nameUnmap); + + // - + + for (const auto& attrib : info->active.activeAttribs) { + if (attrib.location == 0) { + info->attrib0Active = true; + break; + } + } + + info->webgl_gl_VertexID_Offset = + gl->fGetUniformLocation(prog->mGLName, "webgl_gl_VertexID_Offset"); + + // - + + for (const auto& uniform : info->active.activeUniforms) { + const auto& elemType = uniform.elemType; + webgl::SamplerUniformInfo* samplerInfo = nullptr; + const auto baseType = SamplerBaseType(elemType); + if (baseType) { + const bool isShadowSampler = IsShadowSampler(elemType); + + auto* texList = &webgl->mBound2DTextures; + + switch (elemType) { + case LOCAL_GL_SAMPLER_2D: + case LOCAL_GL_SAMPLER_2D_SHADOW: + case LOCAL_GL_INT_SAMPLER_2D: + case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D: + break; + + case LOCAL_GL_SAMPLER_CUBE: + case LOCAL_GL_SAMPLER_CUBE_SHADOW: + case LOCAL_GL_INT_SAMPLER_CUBE: + case LOCAL_GL_UNSIGNED_INT_SAMPLER_CUBE: + texList = &webgl->mBoundCubeMapTextures; + break; + + case LOCAL_GL_SAMPLER_3D: + case LOCAL_GL_INT_SAMPLER_3D: + case LOCAL_GL_UNSIGNED_INT_SAMPLER_3D: + texList = &webgl->mBound3DTextures; + break; + + case LOCAL_GL_SAMPLER_2D_ARRAY: + case LOCAL_GL_SAMPLER_2D_ARRAY_SHADOW: + case LOCAL_GL_INT_SAMPLER_2D_ARRAY: + case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D_ARRAY: + texList = &webgl->mBound2DArrayTextures; + break; + } + + auto curInfo = std::unique_ptr<webgl::SamplerUniformInfo>( + new webgl::SamplerUniformInfo{*texList, *baseType, isShadowSampler}); + MOZ_RELEASE_ASSERT(curInfo->texUnits.resize(uniform.elemCount)); + samplerInfo = curInfo.get(); + info->samplerUniforms.push_back(std::move(curInfo)); + } + + const auto valInfo = webgl::ActiveUniformValidationInfo::Make(uniform); + + for (const auto& pair : uniform.locByIndex) { + info->locationMap.insert( + {pair.second, {valInfo, pair.first, samplerInfo}}); + } + } + + // - + + { + const auto& activeBlocks = info->active.activeUniformBlocks; + info->uniformBlocks.reserve(activeBlocks.size()); + for (const auto& cur : activeBlocks) { + const auto curInfo = webgl::UniformBlockInfo{ + cur, &webgl->mIndexedUniformBufferBindings[0]}; + info->uniformBlocks.push_back(curInfo); + } + } + + return info; +} + +//////////////////////////////////////////////////////////////////////////////// + +webgl::LinkedProgramInfo::LinkedProgramInfo(WebGLProgram* prog) + : prog(prog), + transformFeedbackBufferMode(prog->mNextLink_TransformFeedbackBufferMode) { +} + +webgl::LinkedProgramInfo::~LinkedProgramInfo() = default; + +webgl::AttribBaseType webgl::ToAttribBaseType(const GLenum elemType) { + switch (elemType) { + case LOCAL_GL_BOOL: + case LOCAL_GL_BOOL_VEC2: + case LOCAL_GL_BOOL_VEC3: + case LOCAL_GL_BOOL_VEC4: + return webgl::AttribBaseType::Boolean; + + case LOCAL_GL_FLOAT: + case LOCAL_GL_FLOAT_VEC2: + case LOCAL_GL_FLOAT_VEC3: + case LOCAL_GL_FLOAT_VEC4: + case LOCAL_GL_FLOAT_MAT2: + case LOCAL_GL_FLOAT_MAT2x3: + case LOCAL_GL_FLOAT_MAT3x2: + case LOCAL_GL_FLOAT_MAT2x4: + case LOCAL_GL_FLOAT_MAT4x2: + case LOCAL_GL_FLOAT_MAT3: + case LOCAL_GL_FLOAT_MAT3x4: + case LOCAL_GL_FLOAT_MAT4x3: + case LOCAL_GL_FLOAT_MAT4: + return webgl::AttribBaseType::Float; + + case LOCAL_GL_INT: + case LOCAL_GL_INT_VEC2: + case LOCAL_GL_INT_VEC3: + case LOCAL_GL_INT_VEC4: + case LOCAL_GL_SAMPLER_2D: + case LOCAL_GL_SAMPLER_3D: + case LOCAL_GL_SAMPLER_CUBE: + case LOCAL_GL_SAMPLER_2D_SHADOW: + case LOCAL_GL_SAMPLER_2D_ARRAY: + case LOCAL_GL_SAMPLER_2D_ARRAY_SHADOW: + case LOCAL_GL_SAMPLER_CUBE_SHADOW: + case LOCAL_GL_INT_SAMPLER_2D: + case LOCAL_GL_INT_SAMPLER_3D: + case LOCAL_GL_INT_SAMPLER_CUBE: + case LOCAL_GL_INT_SAMPLER_2D_ARRAY: + case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D: + case LOCAL_GL_UNSIGNED_INT_SAMPLER_3D: + case LOCAL_GL_UNSIGNED_INT_SAMPLER_CUBE: + case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D_ARRAY: + return webgl::AttribBaseType::Int; + + case LOCAL_GL_UNSIGNED_INT: + case LOCAL_GL_UNSIGNED_INT_VEC2: + case LOCAL_GL_UNSIGNED_INT_VEC3: + case LOCAL_GL_UNSIGNED_INT_VEC4: + return webgl::AttribBaseType::Uint; + + default: + gfxCriticalError() << "Bad `elemType`: " << EnumString(elemType); + MOZ_CRASH("`elemType`"); + } +} + +const char* webgl::ToString(const webgl::AttribBaseType x) { + switch (x) { + case webgl::AttribBaseType::Float: + return "FLOAT"; + case webgl::AttribBaseType::Int: + return "INT"; + case webgl::AttribBaseType::Uint: + return "UINT"; + case webgl::AttribBaseType::Boolean: + return "BOOL"; + } + MOZ_CRASH("pacify gcc6 warning"); +} + +const char* webgl::ToString(const webgl::UniformBaseType x) { + switch (x) { + case webgl::UniformBaseType::Float: + return "FLOAT"; + case webgl::UniformBaseType::Int: + return "INT"; + case webgl::UniformBaseType::Uint: + return "UINT"; + } + MOZ_CRASH("pacify gcc6 warning"); +} + +const webgl::CachedDrawFetchLimits* +webgl::LinkedProgramInfo::GetDrawFetchLimits() const { + const auto& webgl = prog->mContext; + const auto& vao = webgl->mBoundVertexArray; + + { + // We have to ensure that every enabled attrib array (not just the active + // ones) has a non-null buffer. + const auto badIndex = vao->GetAttribIsArrayWithNullBuffer(); + if (badIndex) { + webgl->ErrorInvalidOperation( + "Vertex attrib array %u is enabled but" + " has no buffer bound.", + *badIndex); + return nullptr; + } + } + + const auto& activeAttribs = active.activeAttribs; + + webgl::CachedDrawFetchLimits fetchLimits; + fetchLimits.usedBuffers = + std::move(mScratchFetchLimits.usedBuffers); // Avoid realloc. + fetchLimits.usedBuffers.clear(); + fetchLimits.usedBuffers.reserve(activeAttribs.size()); + + bool hasActiveAttrib = false; + bool hasActiveDivisor0 = false; + + for (const auto& progAttrib : activeAttribs) { + const auto& loc = progAttrib.location; + if (loc == -1) continue; + hasActiveAttrib |= true; + + const auto& binding = vao->AttribBinding(loc); + const auto& buffer = binding.buffer; + const auto& layout = binding.layout; + hasActiveDivisor0 |= (layout.divisor == 0); + + webgl::AttribBaseType attribDataBaseType; + if (layout.isArray) { + MOZ_ASSERT(buffer); + fetchLimits.usedBuffers.push_back( + {buffer.get(), static_cast<uint32_t>(loc)}); + + attribDataBaseType = layout.baseType; + + const auto availBytes = buffer->ByteLength(); + const auto availElems = AvailGroups(availBytes, layout.byteOffset, + layout.byteSize, layout.byteStride); + if (layout.divisor) { + const auto availInstances = + CheckedInt<uint64_t>(availElems) * layout.divisor; + if (availInstances.isValid()) { + fetchLimits.maxInstances = + std::min(fetchLimits.maxInstances, availInstances.value()); + } // If not valid, it overflowed too large, so we're super safe. + } else { + fetchLimits.maxVerts = std::min(fetchLimits.maxVerts, availElems); + } + } else { + attribDataBaseType = webgl->mGenericVertexAttribTypes[loc]; + } + + const auto& progBaseType = progAttrib.baseType; + if ((attribDataBaseType != progBaseType) && + (progBaseType != webgl::AttribBaseType::Boolean)) { + const auto& dataType = ToString(attribDataBaseType); + const auto& progType = ToString(progBaseType); + webgl->ErrorInvalidOperation( + "Vertex attrib %u requires data of type %s," + " but is being supplied with type %s.", + loc, progType, dataType); + return nullptr; + } + } + + if (!webgl->IsWebGL2() && hasActiveAttrib && !hasActiveDivisor0) { + webgl->ErrorInvalidOperation( + "One active vertex attrib (if any are active)" + " must have a divisor of 0."); + return nullptr; + } + + // - + + mScratchFetchLimits = std::move(fetchLimits); + return &mScratchFetchLimits; +} + +//////////////////////////////////////////////////////////////////////////////// +// WebGLProgram + +WebGLProgram::WebGLProgram(WebGLContext* webgl) + : WebGLContextBoundObject(webgl), + mGLName(webgl->gl->fCreateProgram()), + mNumActiveTFOs(0), + mNextLink_TransformFeedbackBufferMode(LOCAL_GL_INTERLEAVED_ATTRIBS) {} + +WebGLProgram::~WebGLProgram() { + mVertShader = nullptr; + mFragShader = nullptr; + + mMostRecentLinkInfo = nullptr; + + if (!mContext) return; + mContext->gl->fDeleteProgram(mGLName); +} + +//////////////////////////////////////////////////////////////////////////////// +// GL funcs + +void WebGLProgram::AttachShader(WebGLShader& shader) { + RefPtr<WebGLShader>* shaderSlot = nullptr; + switch (shader.mType) { + case LOCAL_GL_VERTEX_SHADER: + shaderSlot = &mVertShader; + break; + case LOCAL_GL_FRAGMENT_SHADER: + shaderSlot = &mFragShader; + break; + } + MOZ_ASSERT(shaderSlot); + + *shaderSlot = &shader; + + mContext->gl->fAttachShader(mGLName, shader.mGLName); +} + +void WebGLProgram::BindAttribLocation(GLuint loc, const std::string& name) { + const auto err = CheckGLSLVariableName(mContext->IsWebGL2(), name); + if (err) { + mContext->GenerateError(err->type, "%s", err->info.c_str()); + return; + } + + if (loc >= mContext->MaxVertexAttribs()) { + mContext->ErrorInvalidValue( + "`location` must be less than" + " MAX_VERTEX_ATTRIBS."); + return; + } + + if (name.find("gl_") == 0) { + mContext->ErrorInvalidOperation( + "Can't set the location of a" + " name that starts with 'gl_'."); + return; + } + + auto res = mNextLink_BoundAttribLocs.insert({name, loc}); + + const auto& wasInserted = res.second; + if (!wasInserted) { + const auto& itr = res.first; + itr->second = loc; + } +} + +void WebGLProgram::DetachShader(const WebGLShader& shader) { + RefPtr<WebGLShader>* shaderSlot = nullptr; + switch (shader.mType) { + case LOCAL_GL_VERTEX_SHADER: + shaderSlot = &mVertShader; + break; + case LOCAL_GL_FRAGMENT_SHADER: + shaderSlot = &mFragShader; + break; + } + MOZ_ASSERT(shaderSlot); + + if (*shaderSlot != &shader) return; + + *shaderSlot = nullptr; + + mContext->gl->fDetachShader(mGLName, shader.mGLName); +} + +void WebGLProgram::UniformBlockBinding(GLuint uniformBlockIndex, + GLuint uniformBlockBinding) const { + if (!IsLinked()) { + mContext->ErrorInvalidOperation("`program` must be linked."); + return; + } + + auto& uniformBlocks = LinkInfo()->uniformBlocks; + if (uniformBlockIndex >= uniformBlocks.size()) { + mContext->ErrorInvalidValue("Index %u invalid.", uniformBlockIndex); + return; + } + auto& uniformBlock = uniformBlocks[uniformBlockIndex]; + + const auto& indexedBindings = mContext->mIndexedUniformBufferBindings; + if (uniformBlockBinding >= indexedBindings.size()) { + mContext->ErrorInvalidValue("Binding %u invalid.", uniformBlockBinding); + return; + } + const auto& indexedBinding = indexedBindings[uniformBlockBinding]; + + //// + + gl::GLContext* gl = mContext->GL(); + gl->fUniformBlockBinding(mGLName, uniformBlockIndex, uniformBlockBinding); + + //// + + uniformBlock.binding = &indexedBinding; +} + +bool WebGLProgram::ValidateForLink() { + const auto AppendCompileLog = [&](const WebGLShader* const shader) { + if (!shader) { + mLinkLog += " Missing shader."; + return; + } + mLinkLog += "\nSHADER_INFO_LOG:\n"; + mLinkLog += shader->CompileLog(); + }; + + if (!mVertShader || !mVertShader->IsCompiled()) { + mLinkLog = "Must have a compiled vertex shader attached:"; + AppendCompileLog(mVertShader); + return false; + } + const auto& vertInfo = *mVertShader->CompileResults(); + + if (!mFragShader || !mFragShader->IsCompiled()) { + mLinkLog = "Must have a compiled fragment shader attached:"; + AppendCompileLog(mFragShader); + return false; + } + const auto& fragInfo = *mFragShader->CompileResults(); + + nsCString errInfo; + if (!fragInfo.CanLinkTo(vertInfo, &errInfo)) { + mLinkLog = errInfo.BeginReading(); + return false; + } + + const auto& gl = mContext->gl; + + if (gl->WorkAroundDriverBugs() && mContext->mIsMesa) { + // Bug 1203135: Mesa crashes internally if we exceed the reported maximum + // attribute count. + if (mVertShader->NumAttributes() > mContext->MaxVertexAttribs()) { + mLinkLog = + "Number of attributes exceeds Mesa's reported max" + " attribute count."; + return false; + } + } + + return true; +} + +void WebGLProgram::LinkProgram() { + if (mNumActiveTFOs) { + mContext->ErrorInvalidOperation( + "Program is in-use by one or more active" + " transform feedback objects."); + return; + } + + // as some of the validation changes program state + + mLinkLog = {}; + mMostRecentLinkInfo = nullptr; + + if (!ValidateForLink()) { + mContext->GenerateWarning("%s", mLinkLog.c_str()); + return; + } + + // Bind the attrib locations. + // This can't be done trivially, because we have to deal with mapped attrib + // names. + for (const auto& pair : mNextLink_BoundAttribLocs) { + const auto& name = pair.first; + const auto& index = pair.second; + + mVertShader->BindAttribLocation(mGLName, name, index); + } + + // Storage for transform feedback varyings before link. + // (Work around for bug seen on nVidia drivers.) + std::vector<std::string> scopedMappedTFVaryings; + + if (mContext->IsWebGL2()) { + mVertShader->MapTransformFeedbackVaryings( + mNextLink_TransformFeedbackVaryings, &scopedMappedTFVaryings); + + std::vector<const char*> driverVaryings; + driverVaryings.reserve(scopedMappedTFVaryings.size()); + for (const auto& cur : scopedMappedTFVaryings) { + driverVaryings.push_back(cur.c_str()); + } + + mContext->gl->fTransformFeedbackVaryings( + mGLName, driverVaryings.size(), driverVaryings.data(), + mNextLink_TransformFeedbackBufferMode); + } + + LinkAndUpdate(); + + if (mMostRecentLinkInfo) { + std::string postLinkLog; + if (ValidateAfterTentativeLink(&postLinkLog)) return; + + mMostRecentLinkInfo = nullptr; + mLinkLog = std::move(postLinkLog); + } + + // Failed link. + if (mContext->ShouldGenerateWarnings()) { + // report shader/program infoLogs as warnings. + // note that shader compilation errors can be deferred to linkProgram, + // which is why we can't do anything in compileShader. In practice we could + // report in compileShader the translation errors generated by ANGLE, + // but it seems saner to keep a single way of obtaining shader infologs. + if (!mLinkLog.empty()) { + mContext->GenerateWarning( + "Failed to link, leaving the following" + " log:\n%s\n", + mLinkLog.c_str()); + } + } +} + +static uint8_t NumUsedLocationsByElemType(GLenum elemType) { + // GLES 3.0.4 p55 + + switch (elemType) { + case LOCAL_GL_FLOAT_MAT2: + case LOCAL_GL_FLOAT_MAT2x3: + case LOCAL_GL_FLOAT_MAT2x4: + return 2; + + case LOCAL_GL_FLOAT_MAT3x2: + case LOCAL_GL_FLOAT_MAT3: + case LOCAL_GL_FLOAT_MAT3x4: + return 3; + + case LOCAL_GL_FLOAT_MAT4x2: + case LOCAL_GL_FLOAT_MAT4x3: + case LOCAL_GL_FLOAT_MAT4: + return 4; + + default: + return 1; + } +} + +uint8_t ElemTypeComponents(const GLenum elemType) { + switch (elemType) { + case LOCAL_GL_BOOL: + case LOCAL_GL_FLOAT: + case LOCAL_GL_INT: + case LOCAL_GL_UNSIGNED_INT: + case LOCAL_GL_SAMPLER_2D: + case LOCAL_GL_SAMPLER_3D: + case LOCAL_GL_SAMPLER_CUBE: + case LOCAL_GL_SAMPLER_2D_SHADOW: + case LOCAL_GL_SAMPLER_2D_ARRAY: + case LOCAL_GL_SAMPLER_2D_ARRAY_SHADOW: + case LOCAL_GL_SAMPLER_CUBE_SHADOW: + case LOCAL_GL_INT_SAMPLER_2D: + case LOCAL_GL_INT_SAMPLER_3D: + case LOCAL_GL_INT_SAMPLER_CUBE: + case LOCAL_GL_INT_SAMPLER_2D_ARRAY: + case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D: + case LOCAL_GL_UNSIGNED_INT_SAMPLER_3D: + case LOCAL_GL_UNSIGNED_INT_SAMPLER_CUBE: + case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D_ARRAY: + return 1; + + case LOCAL_GL_BOOL_VEC2: + case LOCAL_GL_FLOAT_VEC2: + case LOCAL_GL_INT_VEC2: + case LOCAL_GL_UNSIGNED_INT_VEC2: + return 2; + + case LOCAL_GL_BOOL_VEC3: + case LOCAL_GL_FLOAT_VEC3: + case LOCAL_GL_INT_VEC3: + case LOCAL_GL_UNSIGNED_INT_VEC3: + return 3; + + case LOCAL_GL_BOOL_VEC4: + case LOCAL_GL_FLOAT_VEC4: + case LOCAL_GL_INT_VEC4: + case LOCAL_GL_UNSIGNED_INT_VEC4: + case LOCAL_GL_FLOAT_MAT2: + return 4; + + case LOCAL_GL_FLOAT_MAT2x3: + case LOCAL_GL_FLOAT_MAT3x2: + return 2 * 3; + + case LOCAL_GL_FLOAT_MAT2x4: + case LOCAL_GL_FLOAT_MAT4x2: + return 2 * 4; + + case LOCAL_GL_FLOAT_MAT3: + return 3 * 3; + + case LOCAL_GL_FLOAT_MAT3x4: + case LOCAL_GL_FLOAT_MAT4x3: + return 3 * 4; + + case LOCAL_GL_FLOAT_MAT4: + return 4 * 4; + + default: + return 0; + } +} + +bool WebGLProgram::ValidateAfterTentativeLink( + std::string* const out_linkLog) const { + const auto& linkInfo = mMostRecentLinkInfo; + const auto& gl = mContext->gl; + + // Check for overlapping attrib locations. + { + std::unordered_map<uint32_t, const std::string&> nameByLoc; + for (const auto& attrib : linkInfo->active.activeAttribs) { + if (attrib.location == -1) continue; + + const auto& elemType = attrib.elemType; + const auto numUsedLocs = NumUsedLocationsByElemType(elemType); + for (uint32_t i = 0; i < numUsedLocs; i++) { + const uint32_t usedLoc = attrib.location + i; + + const auto res = nameByLoc.insert({usedLoc, attrib.name}); + const bool& didInsert = res.second; + if (!didInsert) { + const auto& aliasingName = attrib.name; + const auto& itrExisting = res.first; + const auto& existingName = itrExisting->second; + *out_linkLog = nsPrintfCString( + "Attrib \"%s\" aliases locations used by" + " attrib \"%s\".", + aliasingName.c_str(), existingName.c_str()) + .BeginReading(); + return false; + } + } + } + } + + // Forbid too many components for specified buffer mode + const auto& activeTfVaryings = linkInfo->active.activeTfVaryings; + MOZ_ASSERT(mNextLink_TransformFeedbackVaryings.size() == + activeTfVaryings.size()); + if (!activeTfVaryings.empty()) { + GLuint maxComponentsPerIndex = 0; + switch (linkInfo->transformFeedbackBufferMode) { + case LOCAL_GL_INTERLEAVED_ATTRIBS: + gl->GetUIntegerv(LOCAL_GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS, + &maxComponentsPerIndex); + break; + + case LOCAL_GL_SEPARATE_ATTRIBS: + gl->GetUIntegerv(LOCAL_GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS, + &maxComponentsPerIndex); + break; + + default: + MOZ_CRASH("`bufferMode`"); + } + + std::vector<size_t> componentsPerVert; + for (const auto& cur : activeTfVaryings) { + if (componentsPerVert.empty() || + linkInfo->transformFeedbackBufferMode == LOCAL_GL_SEPARATE_ATTRIBS) { + componentsPerVert.push_back(0); + } + + size_t varyingComponents = ElemTypeComponents(cur.elemType); + MOZ_ASSERT(varyingComponents); + varyingComponents *= cur.elemCount; + + auto& totalComponentsForIndex = *(componentsPerVert.rbegin()); + totalComponentsForIndex += varyingComponents; + + if (totalComponentsForIndex > maxComponentsPerIndex) { + *out_linkLog = nsPrintfCString( + "Transform feedback varying \"%s\"" + " pushed `componentsForIndex` over the" + " limit of %u.", + cur.name.c_str(), maxComponentsPerIndex) + .BeginReading(); + return false; + } + } + + linkInfo->componentsPerTFVert = std::move(componentsPerVert); + } + + return true; +} + +bool WebGLProgram::UseProgram() const { + if (!mMostRecentLinkInfo) { + mContext->ErrorInvalidOperation( + "Program has not been successfully linked."); + return false; + } + + if (mContext->mBoundTransformFeedback && + mContext->mBoundTransformFeedback->mIsActive && + !mContext->mBoundTransformFeedback->mIsPaused) { + mContext->ErrorInvalidOperation( + "Transform feedback active and not paused."); + return false; + } + + mContext->gl->fUseProgram(mGLName); + return true; +} + +bool WebGLProgram::ValidateProgram() const { + gl::GLContext* gl = mContext->gl; + +#ifdef XP_MACOSX + // See bug 593867 for NVIDIA and bug 657201 for ATI. The latter is confirmed + // with Mac OS 10.6.7. + if (gl->WorkAroundDriverBugs()) { + mContext->GenerateWarning( + "Implemented as a no-op on" + " Mac to work around crashes."); + return true; + } +#endif + + gl->fValidateProgram(mGLName); + GLint ok = 0; + gl->fGetProgramiv(mGLName, LOCAL_GL_VALIDATE_STATUS, &ok); + return bool(ok); +} + +//////////////////////////////////////////////////////////////////////////////// + +void WebGLProgram::LinkAndUpdate() { + mMostRecentLinkInfo = nullptr; + + gl::GLContext* gl = mContext->gl; + gl->fLinkProgram(mGLName); + + // Grab the program log. + { + GLuint logLenWithNull = 0; + gl->fGetProgramiv(mGLName, LOCAL_GL_INFO_LOG_LENGTH, + (GLint*)&logLenWithNull); + if (logLenWithNull > 1) { + std::vector<char> buffer(logLenWithNull); + gl->fGetProgramInfoLog(mGLName, buffer.size(), nullptr, buffer.data()); + mLinkLog = buffer.data(); + } else { + mLinkLog.clear(); + } + } + + GLint ok = 0; + gl->fGetProgramiv(mGLName, LOCAL_GL_LINK_STATUS, &ok); + if (!ok) return; + + mMostRecentLinkInfo = + QueryProgramInfo(this, gl); // Fallible after context loss. +} + +void WebGLProgram::TransformFeedbackVaryings( + const std::vector<std::string>& varyings, GLenum bufferMode) { + const auto& gl = mContext->gl; + + switch (bufferMode) { + case LOCAL_GL_INTERLEAVED_ATTRIBS: + break; + + case LOCAL_GL_SEPARATE_ATTRIBS: { + GLuint maxAttribs = 0; + gl->GetUIntegerv(LOCAL_GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, + &maxAttribs); + if (varyings.size() > maxAttribs) { + mContext->ErrorInvalidValue("Length of `varyings` exceeds %s.", + "TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS"); + return; + } + } break; + + default: + mContext->ErrorInvalidEnumInfo("bufferMode", bufferMode); + return; + } + + //// + + mNextLink_TransformFeedbackVaryings = varyings; + mNextLink_TransformFeedbackBufferMode = bufferMode; +} + +} // namespace mozilla |