зеркало из https://github.com/mozilla/gecko-dev.git
1684 строки
51 KiB
C++
1684 строки
51 KiB
C++
/* -*- 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/RefPtr.h"
|
|
#include "nsPrintfCString.h"
|
|
#include "WebGLActiveInfo.h"
|
|
#include "WebGLBuffer.h"
|
|
#include "WebGLContext.h"
|
|
#include "WebGLShader.h"
|
|
#include "WebGLShaderValidator.h"
|
|
#include "WebGLTransformFeedback.h"
|
|
#include "WebGLUniformLocation.h"
|
|
#include "WebGLValidateStrings.h"
|
|
#include "WebGLVertexArray.h"
|
|
|
|
namespace mozilla {
|
|
|
|
/* If `name`: "foo[3]"
|
|
* Then returns true, with
|
|
* `out_baseName`: "foo"
|
|
* `out_isArray`: true
|
|
* `out_index`: 3
|
|
*
|
|
* If `name`: "foo"
|
|
* Then returns true, with
|
|
* `out_baseName`: "foo"
|
|
* `out_isArray`: false
|
|
* `out_index`: 0
|
|
*/
|
|
static bool ParseName(const nsCString& name, nsCString* const out_baseName,
|
|
bool* const out_isArray, size_t* const out_arrayIndex) {
|
|
int32_t indexEnd = name.RFind("]");
|
|
if (indexEnd == -1 || (uint32_t)indexEnd != name.Length() - 1) {
|
|
*out_baseName = name;
|
|
*out_isArray = false;
|
|
*out_arrayIndex = 0;
|
|
return true;
|
|
}
|
|
|
|
int32_t indexOpenBracket = name.RFind("[");
|
|
if (indexOpenBracket == -1) return false;
|
|
|
|
uint32_t indexStart = indexOpenBracket + 1;
|
|
uint32_t indexLen = indexEnd - indexStart;
|
|
if (indexLen == 0) return false;
|
|
|
|
const nsAutoCString indexStr(Substring(name, indexStart, indexLen));
|
|
|
|
nsresult errorcode;
|
|
int32_t indexNum = indexStr.ToInteger(&errorcode);
|
|
if (NS_FAILED(errorcode)) return false;
|
|
|
|
if (indexNum < 0) return false;
|
|
|
|
*out_baseName = StringHead(name, indexOpenBracket);
|
|
*out_isArray = true;
|
|
*out_arrayIndex = indexNum;
|
|
return true;
|
|
}
|
|
|
|
static void AssembleName(const nsCString& baseName, bool isArray,
|
|
size_t arrayIndex, nsCString* const out_name) {
|
|
*out_name = baseName;
|
|
if (isArray) {
|
|
out_name->Append('[');
|
|
out_name->AppendInt(uint64_t(arrayIndex));
|
|
out_name->Append(']');
|
|
}
|
|
}
|
|
|
|
////
|
|
|
|
/*static*/
|
|
const webgl::UniformInfo::TexListT* webgl::UniformInfo::GetTexList(
|
|
WebGLActiveInfo* activeInfo) {
|
|
const auto& webgl = activeInfo->mWebGL;
|
|
|
|
switch (activeInfo->mElemType) {
|
|
case LOCAL_GL_SAMPLER_2D:
|
|
case LOCAL_GL_SAMPLER_2D_SHADOW:
|
|
case LOCAL_GL_INT_SAMPLER_2D:
|
|
case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D:
|
|
return &webgl->mBound2DTextures;
|
|
|
|
case LOCAL_GL_SAMPLER_CUBE:
|
|
case LOCAL_GL_SAMPLER_CUBE_SHADOW:
|
|
case LOCAL_GL_INT_SAMPLER_CUBE:
|
|
case LOCAL_GL_UNSIGNED_INT_SAMPLER_CUBE:
|
|
return &webgl->mBoundCubeMapTextures;
|
|
|
|
case LOCAL_GL_SAMPLER_3D:
|
|
case LOCAL_GL_INT_SAMPLER_3D:
|
|
case LOCAL_GL_UNSIGNED_INT_SAMPLER_3D:
|
|
return &webgl->mBound3DTextures;
|
|
|
|
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:
|
|
return &webgl->mBound2DArrayTextures;
|
|
|
|
default:
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
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 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 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 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 webgl::TextureBaseType::UInt;
|
|
|
|
default:
|
|
return webgl::TextureBaseType::Float; // Will be ignored.
|
|
}
|
|
}
|
|
|
|
webgl::UniformInfo::UniformInfo(WebGLActiveInfo* activeInfo)
|
|
: mActiveInfo(activeInfo),
|
|
mSamplerTexList(GetTexList(activeInfo)),
|
|
mTexBaseType(SamplerBaseType(mActiveInfo->mElemType)),
|
|
mIsShadowSampler(IsShadowSampler(mActiveInfo->mElemType)) {
|
|
if (mSamplerTexList) {
|
|
mSamplerValues.assign(mActiveInfo->mElemCount, 0);
|
|
}
|
|
}
|
|
|
|
//////////
|
|
|
|
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;
|
|
}
|
|
|
|
// -
|
|
|
|
//#define DUMP_SHADERVAR_MAPPINGS
|
|
|
|
static RefPtr<const webgl::LinkedProgramInfo> QueryProgramInfo(
|
|
WebGLProgram* prog, gl::GLContext* gl) {
|
|
WebGLContext* const webgl = prog->mContext;
|
|
|
|
RefPtr<webgl::LinkedProgramInfo> info(new webgl::LinkedProgramInfo(prog));
|
|
|
|
GLuint maxAttribLenWithNull = 0;
|
|
gl->fGetProgramiv(prog->mGLName, LOCAL_GL_ACTIVE_ATTRIBUTE_MAX_LENGTH,
|
|
(GLint*)&maxAttribLenWithNull);
|
|
if (maxAttribLenWithNull < 1) maxAttribLenWithNull = 1;
|
|
|
|
GLuint maxUniformLenWithNull = 0;
|
|
gl->fGetProgramiv(prog->mGLName, LOCAL_GL_ACTIVE_UNIFORM_MAX_LENGTH,
|
|
(GLint*)&maxUniformLenWithNull);
|
|
if (maxUniformLenWithNull < 1) maxUniformLenWithNull = 1;
|
|
|
|
GLuint maxUniformBlockLenWithNull = 0;
|
|
if (gl->IsSupported(gl::GLFeature::uniform_buffer_object)) {
|
|
gl->fGetProgramiv(prog->mGLName,
|
|
LOCAL_GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH,
|
|
(GLint*)&maxUniformBlockLenWithNull);
|
|
if (maxUniformBlockLenWithNull < 1) maxUniformBlockLenWithNull = 1;
|
|
}
|
|
|
|
GLuint maxTransformFeedbackVaryingLenWithNull = 0;
|
|
if (gl->IsSupported(gl::GLFeature::transform_feedback2)) {
|
|
gl->fGetProgramiv(prog->mGLName,
|
|
LOCAL_GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH,
|
|
(GLint*)&maxTransformFeedbackVaryingLenWithNull);
|
|
if (maxTransformFeedbackVaryingLenWithNull < 1)
|
|
maxTransformFeedbackVaryingLenWithNull = 1;
|
|
}
|
|
|
|
// Attribs (can't be arrays)
|
|
|
|
GLuint numActiveAttribs = 0;
|
|
gl->fGetProgramiv(prog->mGLName, LOCAL_GL_ACTIVE_ATTRIBUTES,
|
|
(GLint*)&numActiveAttribs);
|
|
|
|
for (GLuint i = 0; i < numActiveAttribs; i++) {
|
|
nsAutoCString mappedName;
|
|
mappedName.SetLength(maxAttribLenWithNull - 1);
|
|
|
|
GLsizei lengthWithoutNull = 0;
|
|
GLint elemCount = 0; // `size`
|
|
GLenum elemType = 0; // `type`
|
|
gl->fGetActiveAttrib(prog->mGLName, i, mappedName.Length() + 1,
|
|
&lengthWithoutNull, &elemCount, &elemType,
|
|
mappedName.BeginWriting());
|
|
if (!elemType) {
|
|
const auto error = gl->fGetError();
|
|
if (error != LOCAL_GL_CONTEXT_LOST) {
|
|
gfxCriticalError() << "Failed to do glGetActiveAttrib: " << error;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
mappedName.SetLength(lengthWithoutNull);
|
|
|
|
////
|
|
|
|
nsCString userName;
|
|
if (!prog->FindAttribUserNameByMappedName(mappedName, &userName)) {
|
|
userName = mappedName;
|
|
}
|
|
|
|
///////
|
|
|
|
GLint loc =
|
|
gl->fGetAttribLocation(prog->mGLName, mappedName.BeginReading());
|
|
if (gl->WorkAroundDriverBugs() && mappedName.EqualsIgnoreCase("gl_", 3)) {
|
|
// Bug 1328559: Appears problematic on ANGLE and OSX, but not Linux or
|
|
// Win+GL.
|
|
loc = -1;
|
|
}
|
|
#ifdef DUMP_SHADERVAR_MAPPINGS
|
|
printf_stderr("[attrib %u/%u] @%i %s->%s\n", i, numActiveAttribs, loc,
|
|
userName.BeginReading(), mappedName.BeginReading());
|
|
#endif
|
|
MOZ_ASSERT_IF(mappedName.EqualsIgnoreCase("gl_", 3), loc == -1);
|
|
|
|
///////
|
|
|
|
const bool isArray = false;
|
|
const RefPtr<WebGLActiveInfo> activeInfo = new WebGLActiveInfo(
|
|
webgl, elemCount, elemType, isArray, userName, mappedName);
|
|
const webgl::AttribInfo attrib = {activeInfo, loc};
|
|
info->attribs.push_back(attrib);
|
|
|
|
if (loc == 0) {
|
|
info->attrib0Active = true;
|
|
}
|
|
}
|
|
|
|
// Uniforms (can be basically anything)
|
|
|
|
const bool needsCheckForArrays = gl->WorkAroundDriverBugs();
|
|
|
|
GLuint numActiveUniforms = 0;
|
|
gl->fGetProgramiv(prog->mGLName, LOCAL_GL_ACTIVE_UNIFORMS,
|
|
(GLint*)&numActiveUniforms);
|
|
|
|
for (GLuint i = 0; i < numActiveUniforms; i++) {
|
|
nsAutoCString mappedName;
|
|
mappedName.SetLength(maxUniformLenWithNull - 1);
|
|
|
|
GLsizei lengthWithoutNull = 0;
|
|
GLint elemCount = 0; // `size`
|
|
GLenum elemType = 0; // `type`
|
|
gl->fGetActiveUniform(prog->mGLName, i, mappedName.Length() + 1,
|
|
&lengthWithoutNull, &elemCount, &elemType,
|
|
mappedName.BeginWriting());
|
|
if (!elemType) {
|
|
const auto error = gl->fGetError();
|
|
if (error != LOCAL_GL_CONTEXT_LOST) {
|
|
gfxCriticalError() << "Failed to do glGetActiveAttrib: " << error;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
mappedName.SetLength(lengthWithoutNull);
|
|
|
|
///////
|
|
|
|
nsAutoCString baseMappedName;
|
|
bool isArray;
|
|
size_t arrayIndex;
|
|
if (!ParseName(mappedName, &baseMappedName, &isArray, &arrayIndex))
|
|
MOZ_CRASH("GFX: Failed to parse `mappedName` received from driver.");
|
|
|
|
// Note that for good drivers, `isArray` should already be correct.
|
|
// However, if FindUniform succeeds, it will be validator-guaranteed
|
|
// correct.
|
|
|
|
///////
|
|
|
|
nsAutoCString baseUserName;
|
|
if (!prog->FindUniformByMappedName(baseMappedName, &baseUserName,
|
|
&isArray)) {
|
|
// Validator likely missing.
|
|
baseUserName = baseMappedName;
|
|
|
|
if (needsCheckForArrays && !isArray) {
|
|
// By GLES 3, GetUniformLocation("foo[0]") should return -1 if `foo` is
|
|
// not an array. Our current linux Try slaves return the location of
|
|
// `foo` anyways, though.
|
|
std::string mappedNameStr = baseMappedName.BeginReading();
|
|
mappedNameStr += "[0]";
|
|
|
|
GLint loc =
|
|
gl->fGetUniformLocation(prog->mGLName, mappedNameStr.c_str());
|
|
if (loc != -1) isArray = true;
|
|
}
|
|
}
|
|
|
|
///////
|
|
|
|
#ifdef DUMP_SHADERVAR_MAPPINGS
|
|
printf_stderr("[uniform %u/%u] %s->%s\n", i, numActiveUniforms,
|
|
baseUserName.BeginReading(), mappedName.BeginReading());
|
|
#endif
|
|
|
|
///////
|
|
|
|
const RefPtr<WebGLActiveInfo> activeInfo = new WebGLActiveInfo(
|
|
webgl, elemCount, elemType, isArray, baseUserName, baseMappedName);
|
|
|
|
auto* uniform = new webgl::UniformInfo(activeInfo);
|
|
info->uniforms.push_back(uniform);
|
|
|
|
if (uniform->mSamplerTexList) {
|
|
info->uniformSamplers.push_back(uniform);
|
|
}
|
|
}
|
|
|
|
// Uniform Blocks (can be arrays, but can't contain sampler types)
|
|
|
|
if (gl->IsSupported(gl::GLFeature::uniform_buffer_object)) {
|
|
GLuint numActiveUniformBlocks = 0;
|
|
gl->fGetProgramiv(prog->mGLName, LOCAL_GL_ACTIVE_UNIFORM_BLOCKS,
|
|
(GLint*)&numActiveUniformBlocks);
|
|
|
|
for (GLuint i = 0; i < numActiveUniformBlocks; i++) {
|
|
nsAutoCString mappedName;
|
|
mappedName.SetLength(maxUniformBlockLenWithNull - 1);
|
|
|
|
GLint lengthWithoutNull;
|
|
gl->fGetActiveUniformBlockiv(prog->mGLName, i,
|
|
LOCAL_GL_UNIFORM_BLOCK_NAME_LENGTH,
|
|
&lengthWithoutNull);
|
|
gl->fGetActiveUniformBlockName(
|
|
prog->mGLName, i, maxUniformBlockLenWithNull, &lengthWithoutNull,
|
|
mappedName.BeginWriting());
|
|
mappedName.SetLength(lengthWithoutNull);
|
|
|
|
////
|
|
|
|
nsCString userName;
|
|
if (!prog->UnmapUniformBlockName(mappedName, &userName)) continue;
|
|
|
|
#ifdef DUMP_SHADERVAR_MAPPINGS
|
|
printf_stderr("[uniform block %u/%u] %s->%s\n", i, numActiveUniformBlocks,
|
|
userName.BeginReading(), mappedName.BeginReading());
|
|
#endif
|
|
|
|
////
|
|
|
|
GLuint dataSize = 0;
|
|
gl->fGetActiveUniformBlockiv(prog->mGLName, i,
|
|
LOCAL_GL_UNIFORM_BLOCK_DATA_SIZE,
|
|
(GLint*)&dataSize);
|
|
|
|
auto* block =
|
|
new webgl::UniformBlockInfo(webgl, userName, mappedName, dataSize);
|
|
info->uniformBlocks.push_back(block);
|
|
}
|
|
}
|
|
|
|
// Transform feedback varyings (can be arrays)
|
|
|
|
if (gl->IsSupported(gl::GLFeature::transform_feedback2)) {
|
|
GLuint numTransformFeedbackVaryings = 0;
|
|
gl->fGetProgramiv(prog->mGLName, LOCAL_GL_TRANSFORM_FEEDBACK_VARYINGS,
|
|
(GLint*)&numTransformFeedbackVaryings);
|
|
|
|
for (GLuint i = 0; i < numTransformFeedbackVaryings; i++) {
|
|
nsAutoCString mappedName;
|
|
mappedName.SetLength(maxTransformFeedbackVaryingLenWithNull - 1);
|
|
|
|
GLint lengthWithoutNull;
|
|
GLsizei elemCount;
|
|
GLenum elemType;
|
|
gl->fGetTransformFeedbackVarying(
|
|
prog->mGLName, i, maxTransformFeedbackVaryingLenWithNull,
|
|
&lengthWithoutNull, &elemCount, &elemType, mappedName.BeginWriting());
|
|
|
|
if (!elemType) {
|
|
const auto error = gl->fGetError();
|
|
if (error != LOCAL_GL_CONTEXT_LOST) {
|
|
gfxCriticalError() << "Failed to do glGetActiveAttrib: " << error;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
mappedName.SetLength(lengthWithoutNull);
|
|
|
|
////
|
|
|
|
nsAutoCString baseMappedName;
|
|
bool isArray;
|
|
size_t arrayIndex;
|
|
if (!ParseName(mappedName, &baseMappedName, &isArray, &arrayIndex))
|
|
MOZ_CRASH("GFX: Failed to parse `mappedName` received from driver.");
|
|
|
|
nsAutoCString baseUserName;
|
|
if (!prog->FindVaryingByMappedName(mappedName, &baseUserName, &isArray)) {
|
|
baseUserName = baseMappedName;
|
|
}
|
|
|
|
////
|
|
|
|
#ifdef DUMP_SHADERVAR_MAPPINGS
|
|
printf_stderr("[transform feedback varying %u/%u] %s->%s\n", i,
|
|
numTransformFeedbackVaryings, baseUserName.BeginReading(),
|
|
mappedName.BeginReading());
|
|
#endif
|
|
|
|
const RefPtr<WebGLActiveInfo> activeInfo = new WebGLActiveInfo(
|
|
webgl, elemCount, elemType, isArray, baseUserName, mappedName);
|
|
info->transformFeedbackVaryings.push_back(activeInfo);
|
|
}
|
|
}
|
|
|
|
// Frag outputs
|
|
|
|
{
|
|
const auto& fragShader = prog->FragShader();
|
|
MOZ_RELEASE_ASSERT(fragShader);
|
|
MOZ_RELEASE_ASSERT(fragShader->Validator());
|
|
const auto& handle = fragShader->Validator()->Handle();
|
|
const auto version = sh::GetShaderVersion(handle);
|
|
|
|
const auto fnAddInfo = [&](const webgl::FragOutputInfo& x) {
|
|
info->fragOutputs.insert({x.loc, x});
|
|
};
|
|
|
|
if (version == 300) {
|
|
const auto& fragOutputs = sh::GetOutputVariables(handle);
|
|
if (fragOutputs) {
|
|
for (const auto& cur : *fragOutputs) {
|
|
auto loc = cur.location;
|
|
if (loc == -1) loc = 0;
|
|
|
|
const auto info = webgl::FragOutputInfo{
|
|
uint8_t(loc), nsCString(cur.name.c_str()),
|
|
nsCString(cur.mappedName.c_str()), 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 = nsPrintfCString("[%u]", i);
|
|
|
|
auto userName = info.userName;
|
|
userName.Append(indexStr);
|
|
auto mappedName = info.mappedName;
|
|
mappedName.Append(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 = fragShader->TranslatedSource();
|
|
uint32_t drawBuffers = 1;
|
|
if (translatedSource.Find("(gl_FragData[1]") != -1 ||
|
|
translatedSource.Find("(webgl_FragData[1]") != -1) {
|
|
// 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();
|
|
}
|
|
|
|
for (uint32_t i = 0; i < drawBuffers; ++i) {
|
|
const auto& name = nsPrintfCString("gl_FragData[%u]", i);
|
|
const auto info = webgl::FragOutputInfo{uint8_t(i), name, name,
|
|
webgl::TextureBaseType::Float};
|
|
fnAddInfo(info);
|
|
}
|
|
}
|
|
}
|
|
|
|
return info;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
webgl::LinkedProgramInfo::LinkedProgramInfo(WebGLProgram* prog)
|
|
: prog(prog),
|
|
transformFeedbackBufferMode(prog->mNextLink_TransformFeedbackBufferMode),
|
|
attrib0Active(false) {}
|
|
|
|
webgl::LinkedProgramInfo::~LinkedProgramInfo() {
|
|
for (auto& cur : uniforms) {
|
|
delete cur;
|
|
}
|
|
for (auto& cur : uniformBlocks) {
|
|
delete cur;
|
|
}
|
|
}
|
|
|
|
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 webgl::CachedDrawFetchLimits*
|
|
webgl::LinkedProgramInfo::GetDrawFetchLimits() const {
|
|
const auto& webgl = prog->mContext;
|
|
const auto& vao = webgl->mBoundVertexArray;
|
|
|
|
const auto found = mDrawFetchCache.Find(vao);
|
|
if (found) return found;
|
|
|
|
std::vector<const CacheInvalidator*> cacheDeps;
|
|
cacheDeps.push_back(vao.get());
|
|
cacheDeps.push_back(&webgl->mGenericVertexAttribTypeInvalidator);
|
|
|
|
{
|
|
// We have to ensure that every enabled attrib array (not just the active
|
|
// ones) has a non-null buffer.
|
|
uint32_t i = 0;
|
|
for (const auto& cur : vao->mAttribs) {
|
|
if (cur.mEnabled && !cur.mBuf) {
|
|
webgl->ErrorInvalidOperation(
|
|
"Vertex attrib array %u is enabled but"
|
|
" has no buffer bound.",
|
|
i);
|
|
return nullptr;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
bool hasActiveAttrib = false;
|
|
bool hasActiveDivisor0 = false;
|
|
webgl::CachedDrawFetchLimits fetchLimits = {UINT64_MAX, UINT64_MAX};
|
|
|
|
for (const auto& progAttrib : this->attribs) {
|
|
const auto& loc = progAttrib.mLoc;
|
|
if (loc == -1) continue;
|
|
hasActiveAttrib |= true;
|
|
|
|
const auto& attribData = vao->mAttribs[loc];
|
|
hasActiveDivisor0 |= (attribData.mDivisor == 0);
|
|
|
|
webgl::AttribBaseType attribDataBaseType;
|
|
if (attribData.mEnabled) {
|
|
MOZ_ASSERT(attribData.mBuf);
|
|
if (attribData.mBuf->IsBoundForTF()) {
|
|
webgl->ErrorInvalidOperation(
|
|
"Vertex attrib %u's buffer is bound for"
|
|
" transform feedback.",
|
|
loc);
|
|
return nullptr;
|
|
}
|
|
cacheDeps.push_back(&attribData.mBuf->mFetchInvalidator);
|
|
|
|
attribDataBaseType = attribData.BaseType();
|
|
|
|
const size_t availBytes = attribData.mBuf->ByteLength();
|
|
const auto availElems =
|
|
AvailGroups(availBytes, attribData.ByteOffset(),
|
|
attribData.BytesPerVertex(), attribData.ExplicitStride());
|
|
if (attribData.mDivisor) {
|
|
const auto availInstances =
|
|
CheckedInt<uint64_t>(availElems) * attribData.mDivisor;
|
|
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.mActiveInfo->mBaseType;
|
|
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 (hasActiveAttrib && !hasActiveDivisor0) {
|
|
webgl->ErrorInvalidOperation(
|
|
"One active vertex attrib (if any are active)"
|
|
" must have a divisor of 0.");
|
|
return nullptr;
|
|
}
|
|
|
|
// --
|
|
|
|
auto entry = mDrawFetchCache.MakeEntry(vao.get(), std::move(fetchLimits));
|
|
entry->ResetInvalidators(std::move(cacheDeps));
|
|
return mDrawFetchCache.Insert(std::move(entry));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// WebGLProgram
|
|
|
|
WebGLProgram::WebGLProgram(WebGLContext* webgl)
|
|
: WebGLRefCountedObject(webgl),
|
|
mGLName(webgl->gl->fCreateProgram()),
|
|
mNumActiveTFOs(0),
|
|
mNextLink_TransformFeedbackBufferMode(LOCAL_GL_INTERLEAVED_ATTRIBS) {
|
|
mContext->mPrograms.insertBack(this);
|
|
}
|
|
|
|
WebGLProgram::~WebGLProgram() { DeleteOnce(); }
|
|
|
|
void WebGLProgram::Delete() {
|
|
gl::GLContext* gl = mContext->GL();
|
|
gl->fDeleteProgram(mGLName);
|
|
|
|
mVertShader = nullptr;
|
|
mFragShader = nullptr;
|
|
|
|
mMostRecentLinkInfo = nullptr;
|
|
|
|
LinkedListElement<WebGLProgram>::removeFrom(mContext->mPrograms);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// GL funcs
|
|
|
|
void WebGLProgram::AttachShader(WebGLShader* shader) {
|
|
WebGLRefPtr<WebGLShader>* shaderSlot;
|
|
switch (shader->mType) {
|
|
case LOCAL_GL_VERTEX_SHADER:
|
|
shaderSlot = &mVertShader;
|
|
break;
|
|
case LOCAL_GL_FRAGMENT_SHADER:
|
|
shaderSlot = &mFragShader;
|
|
break;
|
|
default:
|
|
mContext->ErrorInvalidOperation("attachShader: Bad type for shader.");
|
|
return;
|
|
}
|
|
|
|
if (*shaderSlot) {
|
|
if (shader == *shaderSlot) {
|
|
mContext->ErrorInvalidOperation(
|
|
"attachShader: `shader` is already attached.");
|
|
} else {
|
|
mContext->ErrorInvalidOperation(
|
|
"attachShader: Only one of each type of"
|
|
" shader may be attached to a program.");
|
|
}
|
|
return;
|
|
}
|
|
|
|
*shaderSlot = shader;
|
|
|
|
mContext->gl->fAttachShader(mGLName, shader->mGLName);
|
|
}
|
|
|
|
void WebGLProgram::BindAttribLocation(GLuint loc, const nsAString& name) {
|
|
if (!ValidateGLSLVariableName(name, mContext)) return;
|
|
|
|
if (loc >= mContext->MaxVertexAttribs()) {
|
|
mContext->ErrorInvalidValue(
|
|
"`location` must be less than"
|
|
" MAX_VERTEX_ATTRIBS.");
|
|
return;
|
|
}
|
|
|
|
if (StringBeginsWith(name, NS_LITERAL_STRING("gl_"))) {
|
|
mContext->ErrorInvalidOperation(
|
|
"Can't set the location of a"
|
|
" name that starts with 'gl_'.");
|
|
return;
|
|
}
|
|
|
|
NS_LossyConvertUTF16toASCII asciiName(name);
|
|
|
|
auto res = mNextLink_BoundAttribLocs.insert({asciiName, loc});
|
|
|
|
const bool wasInserted = res.second;
|
|
if (!wasInserted) {
|
|
auto itr = res.first;
|
|
itr->second = loc;
|
|
}
|
|
}
|
|
|
|
void WebGLProgram::DetachShader(const WebGLShader* shader) {
|
|
MOZ_ASSERT(shader);
|
|
|
|
WebGLRefPtr<WebGLShader>* shaderSlot;
|
|
switch (shader->mType) {
|
|
case LOCAL_GL_VERTEX_SHADER:
|
|
shaderSlot = &mVertShader;
|
|
break;
|
|
case LOCAL_GL_FRAGMENT_SHADER:
|
|
shaderSlot = &mFragShader;
|
|
break;
|
|
default:
|
|
mContext->ErrorInvalidOperation("attachShader: Bad type for shader.");
|
|
return;
|
|
}
|
|
|
|
if (*shaderSlot != shader) {
|
|
mContext->ErrorInvalidOperation("detachShader: `shader` is not attached.");
|
|
return;
|
|
}
|
|
|
|
*shaderSlot = nullptr;
|
|
|
|
mContext->gl->fDetachShader(mGLName, shader->mGLName);
|
|
}
|
|
|
|
already_AddRefed<WebGLActiveInfo> WebGLProgram::GetActiveAttrib(
|
|
GLuint index) const {
|
|
if (!mMostRecentLinkInfo) {
|
|
RefPtr<WebGLActiveInfo> ret = WebGLActiveInfo::CreateInvalid(mContext);
|
|
return ret.forget();
|
|
}
|
|
|
|
const auto& attribs = mMostRecentLinkInfo->attribs;
|
|
|
|
if (index >= attribs.size()) {
|
|
mContext->ErrorInvalidValue("`index` (%i) must be less than %s (%zu).",
|
|
index, "ACTIVE_ATTRIBS", attribs.size());
|
|
return nullptr;
|
|
}
|
|
|
|
RefPtr<WebGLActiveInfo> ret = attribs[index].mActiveInfo;
|
|
return ret.forget();
|
|
}
|
|
|
|
already_AddRefed<WebGLActiveInfo> WebGLProgram::GetActiveUniform(
|
|
GLuint index) const {
|
|
if (!mMostRecentLinkInfo) {
|
|
// According to the spec, this can return null.
|
|
RefPtr<WebGLActiveInfo> ret = WebGLActiveInfo::CreateInvalid(mContext);
|
|
return ret.forget();
|
|
}
|
|
|
|
const auto& uniforms = mMostRecentLinkInfo->uniforms;
|
|
|
|
if (index >= uniforms.size()) {
|
|
mContext->ErrorInvalidValue("`index` (%i) must be less than %s (%zu).",
|
|
index, "ACTIVE_UNIFORMS", uniforms.size());
|
|
return nullptr;
|
|
}
|
|
|
|
RefPtr<WebGLActiveInfo> ret = uniforms[index]->mActiveInfo;
|
|
return ret.forget();
|
|
}
|
|
|
|
void WebGLProgram::GetAttachedShaders(
|
|
nsTArray<RefPtr<WebGLShader>>* const out) const {
|
|
out->TruncateLength(0);
|
|
|
|
if (mVertShader) out->AppendElement(mVertShader);
|
|
|
|
if (mFragShader) out->AppendElement(mFragShader);
|
|
}
|
|
|
|
GLint WebGLProgram::GetAttribLocation(const nsAString& userName_wide) const {
|
|
if (!ValidateGLSLVariableName(userName_wide, mContext)) return -1;
|
|
|
|
if (!IsLinked()) {
|
|
mContext->ErrorInvalidOperation("`program` must be linked.");
|
|
return -1;
|
|
}
|
|
|
|
const NS_LossyConvertUTF16toASCII userName(userName_wide);
|
|
|
|
const webgl::AttribInfo* info;
|
|
if (!LinkInfo()->FindAttrib(userName, &info)) return -1;
|
|
|
|
return GLint(info->mLoc);
|
|
}
|
|
|
|
GLint WebGLProgram::GetFragDataLocation(const nsAString& userName_wide) const {
|
|
if (!ValidateGLSLVariableName(userName_wide, mContext)) return -1;
|
|
|
|
if (!IsLinked()) {
|
|
mContext->ErrorInvalidOperation("`program` must be linked.");
|
|
return -1;
|
|
}
|
|
|
|
const NS_LossyConvertUTF16toASCII userName(userName_wide);
|
|
auto userNameId0 = nsCString(userName);
|
|
userNameId0.AppendLiteral("[0]");
|
|
const auto& fragOutputs = LinkInfo()->fragOutputs;
|
|
for (const auto& pair : fragOutputs) {
|
|
const auto& info = pair.second;
|
|
if (info.userName == userName || info.userName == userNameId0) {
|
|
return info.loc;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void WebGLProgram::GetProgramInfoLog(nsAString* const out) const {
|
|
CopyASCIItoUTF16(mLinkLog, *out);
|
|
}
|
|
|
|
static GLint GetProgramiv(gl::GLContext* gl, GLuint program, GLenum pname) {
|
|
GLint ret = 0;
|
|
gl->fGetProgramiv(program, pname, &ret);
|
|
return ret;
|
|
}
|
|
|
|
JS::Value WebGLProgram::GetProgramParameter(GLenum pname) const {
|
|
gl::GLContext* gl = mContext->gl;
|
|
|
|
if (mContext->IsWebGL2()) {
|
|
switch (pname) {
|
|
case LOCAL_GL_ACTIVE_UNIFORM_BLOCKS:
|
|
if (!IsLinked()) return JS::NumberValue(0);
|
|
return JS::NumberValue(LinkInfo()->uniformBlocks.size());
|
|
|
|
case LOCAL_GL_TRANSFORM_FEEDBACK_VARYINGS:
|
|
if (!IsLinked()) return JS::NumberValue(0);
|
|
return JS::NumberValue(LinkInfo()->transformFeedbackVaryings.size());
|
|
|
|
case LOCAL_GL_TRANSFORM_FEEDBACK_BUFFER_MODE:
|
|
if (!IsLinked()) return JS::NumberValue(LOCAL_GL_INTERLEAVED_ATTRIBS);
|
|
return JS::NumberValue(LinkInfo()->transformFeedbackBufferMode);
|
|
}
|
|
}
|
|
|
|
switch (pname) {
|
|
case LOCAL_GL_ATTACHED_SHADERS:
|
|
return JS::NumberValue(int(bool(mVertShader.get())) +
|
|
int(bool(mFragShader)));
|
|
|
|
case LOCAL_GL_ACTIVE_UNIFORMS:
|
|
if (!IsLinked()) return JS::NumberValue(0);
|
|
return JS::NumberValue(LinkInfo()->uniforms.size());
|
|
|
|
case LOCAL_GL_ACTIVE_ATTRIBUTES:
|
|
if (!IsLinked()) return JS::NumberValue(0);
|
|
return JS::NumberValue(LinkInfo()->attribs.size());
|
|
|
|
case LOCAL_GL_DELETE_STATUS:
|
|
return JS::BooleanValue(IsDeleteRequested());
|
|
|
|
case LOCAL_GL_LINK_STATUS:
|
|
return JS::BooleanValue(IsLinked());
|
|
|
|
case LOCAL_GL_VALIDATE_STATUS:
|
|
#ifdef XP_MACOSX
|
|
// See comment in ValidateProgram.
|
|
if (gl->WorkAroundDriverBugs()) return JS::BooleanValue(true);
|
|
#endif
|
|
// Todo: Implement this in our code.
|
|
return JS::BooleanValue(bool(GetProgramiv(gl, mGLName, pname)));
|
|
|
|
default:
|
|
mContext->ErrorInvalidEnumInfo("pname", pname);
|
|
return JS::NullValue();
|
|
}
|
|
}
|
|
|
|
GLuint WebGLProgram::GetUniformBlockIndex(
|
|
const nsAString& userName_wide) const {
|
|
if (!ValidateGLSLVariableName(userName_wide, mContext))
|
|
return LOCAL_GL_INVALID_INDEX;
|
|
|
|
if (!IsLinked()) {
|
|
mContext->ErrorInvalidOperation("`program` must be linked.");
|
|
return LOCAL_GL_INVALID_INDEX;
|
|
}
|
|
|
|
const NS_LossyConvertUTF16toASCII userName(userName_wide);
|
|
|
|
const webgl::UniformBlockInfo* info = nullptr;
|
|
for (const auto& cur : LinkInfo()->uniformBlocks) {
|
|
if (cur->mUserName == userName) {
|
|
info = cur;
|
|
break;
|
|
}
|
|
}
|
|
if (!info) return LOCAL_GL_INVALID_INDEX;
|
|
|
|
const auto& mappedName = info->mMappedName;
|
|
|
|
gl::GLContext* gl = mContext->GL();
|
|
return gl->fGetUniformBlockIndex(mGLName, mappedName.BeginReading());
|
|
}
|
|
|
|
void WebGLProgram::GetActiveUniformBlockName(GLuint uniformBlockIndex,
|
|
nsAString& retval) const {
|
|
if (!IsLinked()) {
|
|
mContext->ErrorInvalidOperation("`program` must be linked.");
|
|
return;
|
|
}
|
|
|
|
const webgl::LinkedProgramInfo* linkInfo = LinkInfo();
|
|
GLuint uniformBlockCount = (GLuint)linkInfo->uniformBlocks.size();
|
|
if (uniformBlockIndex >= uniformBlockCount) {
|
|
mContext->ErrorInvalidValue("index %u invalid.", uniformBlockIndex);
|
|
return;
|
|
}
|
|
|
|
const auto& blockInfo = linkInfo->uniformBlocks[uniformBlockIndex];
|
|
retval.Assign(NS_ConvertASCIItoUTF16(blockInfo->mUserName));
|
|
}
|
|
|
|
JS::Value WebGLProgram::GetActiveUniformBlockParam(GLuint uniformBlockIndex,
|
|
GLenum pname) const {
|
|
if (!IsLinked()) {
|
|
mContext->ErrorInvalidOperation("`program` must be linked.");
|
|
return JS::NullValue();
|
|
}
|
|
|
|
const webgl::LinkedProgramInfo* linkInfo = LinkInfo();
|
|
GLuint uniformBlockCount = (GLuint)linkInfo->uniformBlocks.size();
|
|
if (uniformBlockIndex >= uniformBlockCount) {
|
|
mContext->ErrorInvalidValue("Index %u invalid.", uniformBlockIndex);
|
|
return JS::NullValue();
|
|
}
|
|
|
|
gl::GLContext* gl = mContext->GL();
|
|
GLint param = 0;
|
|
|
|
switch (pname) {
|
|
case LOCAL_GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
|
|
case LOCAL_GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
|
|
gl->fGetActiveUniformBlockiv(mGLName, uniformBlockIndex, pname, ¶m);
|
|
return JS::BooleanValue(bool(param));
|
|
|
|
case LOCAL_GL_UNIFORM_BLOCK_BINDING:
|
|
case LOCAL_GL_UNIFORM_BLOCK_DATA_SIZE:
|
|
case LOCAL_GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
|
|
gl->fGetActiveUniformBlockiv(mGLName, uniformBlockIndex, pname, ¶m);
|
|
return JS::NumberValue(param);
|
|
|
|
default:
|
|
MOZ_CRASH("bad `pname`.");
|
|
}
|
|
}
|
|
|
|
JS::Value WebGLProgram::GetActiveUniformBlockActiveUniforms(
|
|
JSContext* cx, GLuint uniformBlockIndex,
|
|
ErrorResult* const out_error) const {
|
|
if (!IsLinked()) {
|
|
mContext->ErrorInvalidOperation("`program` must be linked.");
|
|
return JS::NullValue();
|
|
}
|
|
|
|
const webgl::LinkedProgramInfo* linkInfo = LinkInfo();
|
|
GLuint uniformBlockCount = (GLuint)linkInfo->uniformBlocks.size();
|
|
if (uniformBlockIndex >= uniformBlockCount) {
|
|
mContext->ErrorInvalidValue("Index %u invalid.", uniformBlockIndex);
|
|
return JS::NullValue();
|
|
}
|
|
|
|
gl::GLContext* gl = mContext->GL();
|
|
GLint activeUniformCount = 0;
|
|
gl->fGetActiveUniformBlockiv(mGLName, uniformBlockIndex,
|
|
LOCAL_GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS,
|
|
&activeUniformCount);
|
|
JS::RootedObject obj(
|
|
cx, dom::Uint32Array::Create(cx, mContext, activeUniformCount, nullptr));
|
|
if (!obj) {
|
|
*out_error = NS_ERROR_OUT_OF_MEMORY;
|
|
return JS::NullValue();
|
|
}
|
|
|
|
dom::Uint32Array result;
|
|
DebugOnly<bool> inited = result.Init(obj);
|
|
MOZ_ASSERT(inited);
|
|
result.ComputeLengthAndData();
|
|
gl->fGetActiveUniformBlockiv(mGLName, uniformBlockIndex,
|
|
LOCAL_GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES,
|
|
(GLint*)result.Data());
|
|
|
|
return JS::ObjectValue(*obj);
|
|
}
|
|
|
|
already_AddRefed<WebGLUniformLocation> WebGLProgram::GetUniformLocation(
|
|
const nsAString& userName_wide) const {
|
|
if (!ValidateGLSLVariableName(userName_wide, mContext)) return nullptr;
|
|
|
|
if (!IsLinked()) {
|
|
mContext->ErrorInvalidOperation("`program` must be linked.");
|
|
return nullptr;
|
|
}
|
|
|
|
const NS_LossyConvertUTF16toASCII userName(userName_wide);
|
|
|
|
// GLES 2.0.25, Section 2.10, p35
|
|
// If the the uniform location is an array, then the location of the first
|
|
// element of that array can be retrieved by either using the name of the
|
|
// uniform array, or the name of the uniform array appended with "[0]".
|
|
nsCString mappedName;
|
|
size_t arrayIndex;
|
|
webgl::UniformInfo* info;
|
|
if (!LinkInfo()->FindUniform(userName, &mappedName, &arrayIndex, &info))
|
|
return nullptr;
|
|
|
|
gl::GLContext* gl = mContext->GL();
|
|
|
|
GLint loc = gl->fGetUniformLocation(mGLName, mappedName.BeginReading());
|
|
if (loc == -1) return nullptr;
|
|
|
|
RefPtr<WebGLUniformLocation> locObj =
|
|
new WebGLUniformLocation(mContext, LinkInfo(), info, loc, arrayIndex);
|
|
return locObj.forget();
|
|
}
|
|
|
|
void WebGLProgram::GetUniformIndices(
|
|
const dom::Sequence<nsString>& uniformNames,
|
|
dom::Nullable<nsTArray<GLuint>>& retval) const {
|
|
if (!IsLinked()) {
|
|
mContext->ErrorInvalidOperation("`program` must be linked.");
|
|
return;
|
|
}
|
|
|
|
size_t count = uniformNames.Length();
|
|
nsTArray<GLuint>& arr = retval.SetValue();
|
|
|
|
gl::GLContext* gl = mContext->GL();
|
|
|
|
for (size_t i = 0; i < count; i++) {
|
|
const NS_LossyConvertUTF16toASCII userName(uniformNames[i]);
|
|
|
|
nsCString mappedName;
|
|
size_t arrayIndex;
|
|
webgl::UniformInfo* info;
|
|
if (!LinkInfo()->FindUniform(userName, &mappedName, &arrayIndex, &info)) {
|
|
arr.AppendElement(LOCAL_GL_INVALID_INDEX);
|
|
continue;
|
|
}
|
|
|
|
const GLchar* const mappedNameBegin = mappedName.get();
|
|
|
|
GLuint index = LOCAL_GL_INVALID_INDEX;
|
|
gl->fGetUniformIndices(mGLName, 1, &mappedNameBegin, &index);
|
|
arr.AppendElement(index);
|
|
}
|
|
}
|
|
|
|
void WebGLProgram::UniformBlockBinding(GLuint uniformBlockIndex,
|
|
GLuint uniformBlockBinding) const {
|
|
if (!IsLinked()) {
|
|
mContext->ErrorInvalidOperation("`program` must be linked.");
|
|
return;
|
|
}
|
|
|
|
const auto& uniformBlocks = LinkInfo()->uniformBlocks;
|
|
if (uniformBlockIndex >= uniformBlocks.size()) {
|
|
mContext->ErrorInvalidValue("Index %u invalid.", uniformBlockIndex);
|
|
return;
|
|
}
|
|
const 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->mBinding = &indexedBinding;
|
|
}
|
|
|
|
bool WebGLProgram::ValidateForLink() {
|
|
if (!mVertShader || !mVertShader->IsCompiled()) {
|
|
mLinkLog.AssignLiteral("Must have a compiled vertex shader attached.");
|
|
return false;
|
|
}
|
|
|
|
if (!mFragShader || !mFragShader->IsCompiled()) {
|
|
mLinkLog.AssignLiteral("Must have an compiled fragment shader attached.");
|
|
return false;
|
|
}
|
|
|
|
if (!mFragShader->CanLinkTo(mVertShader, &mLinkLog)) return false;
|
|
|
|
const auto& gl = mContext->gl;
|
|
|
|
if (gl->WorkAroundDriverBugs() && mContext->mIsMesa) {
|
|
// Bug 777028: Mesa can't handle more than 16 samplers per program,
|
|
// counting each array entry.
|
|
size_t numSamplerUniforms_upperBound =
|
|
mVertShader->CalcNumSamplerUniforms() +
|
|
mFragShader->CalcNumSamplerUniforms();
|
|
if (numSamplerUniforms_upperBound > 16) {
|
|
mLinkLog.AssignLiteral(
|
|
"Programs with more than 16 samplers are disallowed on"
|
|
" Mesa drivers to avoid crashing.");
|
|
return false;
|
|
}
|
|
|
|
// Bug 1203135: Mesa crashes internally if we exceed the reported maximum
|
|
// attribute count.
|
|
if (mVertShader->NumAttributes() > mContext->MaxVertexAttribs()) {
|
|
mLinkLog.AssignLiteral(
|
|
"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.Truncate();
|
|
mMostRecentLinkInfo = nullptr;
|
|
|
|
if (!ValidateForLink()) {
|
|
mContext->GenerateWarning("%s", mLinkLog.BeginReading());
|
|
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) {
|
|
nsCString postLinkLog;
|
|
if (ValidateAfterTentativeLink(&postLinkLog)) return;
|
|
|
|
mMostRecentLinkInfo = nullptr;
|
|
mLinkLog = 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.IsEmpty()) {
|
|
mContext->GenerateWarning(
|
|
"Failed to link, leaving the following"
|
|
" log:\n%s\n",
|
|
mLinkLog.BeginReading());
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
static uint8_t NumComponents(GLenum elemType) {
|
|
switch (elemType) {
|
|
case LOCAL_GL_FLOAT:
|
|
case LOCAL_GL_INT:
|
|
case LOCAL_GL_UNSIGNED_INT:
|
|
case LOCAL_GL_BOOL:
|
|
return 1;
|
|
|
|
case LOCAL_GL_FLOAT_VEC2:
|
|
case LOCAL_GL_INT_VEC2:
|
|
case LOCAL_GL_UNSIGNED_INT_VEC2:
|
|
case LOCAL_GL_BOOL_VEC2:
|
|
return 2;
|
|
|
|
case LOCAL_GL_FLOAT_VEC3:
|
|
case LOCAL_GL_INT_VEC3:
|
|
case LOCAL_GL_UNSIGNED_INT_VEC3:
|
|
case LOCAL_GL_BOOL_VEC3:
|
|
return 3;
|
|
|
|
case LOCAL_GL_FLOAT_VEC4:
|
|
case LOCAL_GL_INT_VEC4:
|
|
case LOCAL_GL_UNSIGNED_INT_VEC4:
|
|
case LOCAL_GL_BOOL_VEC4:
|
|
case LOCAL_GL_FLOAT_MAT2:
|
|
return 4;
|
|
|
|
case LOCAL_GL_FLOAT_MAT2x3:
|
|
case LOCAL_GL_FLOAT_MAT3x2:
|
|
return 6;
|
|
|
|
case LOCAL_GL_FLOAT_MAT2x4:
|
|
case LOCAL_GL_FLOAT_MAT4x2:
|
|
return 8;
|
|
|
|
case LOCAL_GL_FLOAT_MAT3:
|
|
return 9;
|
|
|
|
case LOCAL_GL_FLOAT_MAT3x4:
|
|
case LOCAL_GL_FLOAT_MAT4x3:
|
|
return 12;
|
|
|
|
case LOCAL_GL_FLOAT_MAT4:
|
|
return 16;
|
|
|
|
default:
|
|
MOZ_CRASH("`elemType`");
|
|
}
|
|
}
|
|
|
|
bool WebGLProgram::ValidateAfterTentativeLink(
|
|
nsCString* const out_linkLog) const {
|
|
const auto& linkInfo = mMostRecentLinkInfo;
|
|
const auto& gl = mContext->gl;
|
|
|
|
// Check if the attrib name conflicting to uniform name
|
|
for (const auto& attrib : linkInfo->attribs) {
|
|
const auto& attribName = attrib.mActiveInfo->mBaseUserName;
|
|
|
|
for (const auto& uniform : linkInfo->uniforms) {
|
|
const auto& uniformName = uniform->mActiveInfo->mBaseUserName;
|
|
if (attribName == uniformName) {
|
|
*out_linkLog = nsPrintfCString(
|
|
"Attrib name conflicts with uniform name:"
|
|
" %s",
|
|
attribName.BeginReading());
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::map<uint32_t, const webgl::AttribInfo*> attribsByLoc;
|
|
for (const auto& attrib : linkInfo->attribs) {
|
|
if (attrib.mLoc == -1) continue;
|
|
|
|
const auto& elemType = attrib.mActiveInfo->mElemType;
|
|
const auto numUsedLocs = NumUsedLocationsByElemType(elemType);
|
|
for (uint32_t i = 0; i < numUsedLocs; i++) {
|
|
const uint32_t usedLoc = attrib.mLoc + i;
|
|
|
|
const auto res = attribsByLoc.insert({usedLoc, &attrib});
|
|
const bool& didInsert = res.second;
|
|
if (!didInsert) {
|
|
const auto& aliasingName = attrib.mActiveInfo->mBaseUserName;
|
|
const auto& itrExisting = res.first;
|
|
const auto& existingInfo = itrExisting->second;
|
|
const auto& existingName = existingInfo->mActiveInfo->mBaseUserName;
|
|
*out_linkLog = nsPrintfCString(
|
|
"Attrib \"%s\" aliases locations used by"
|
|
" attrib \"%s\".",
|
|
aliasingName.BeginReading(), existingName.BeginReading());
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Forbid:
|
|
// * Unrecognized varying name
|
|
// * Duplicate varying name
|
|
// * Too many components for specified buffer mode
|
|
if (!mNextLink_TransformFeedbackVaryings.empty()) {
|
|
GLuint maxComponentsPerIndex = 0;
|
|
switch (mNextLink_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;
|
|
std::set<const WebGLActiveInfo*> alreadyUsed;
|
|
for (const auto& wideUserName : mNextLink_TransformFeedbackVaryings) {
|
|
if (componentsPerVert.empty() ||
|
|
mNextLink_TransformFeedbackBufferMode == LOCAL_GL_SEPARATE_ATTRIBS) {
|
|
componentsPerVert.push_back(0);
|
|
}
|
|
|
|
////
|
|
|
|
const WebGLActiveInfo* curInfo = nullptr;
|
|
for (const auto& info : linkInfo->transformFeedbackVaryings) {
|
|
const NS_ConvertASCIItoUTF16 info_wideUserName(info->mBaseUserName);
|
|
if (info_wideUserName == wideUserName) {
|
|
curInfo = info.get();
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!curInfo) {
|
|
const NS_LossyConvertUTF16toASCII asciiUserName(wideUserName);
|
|
*out_linkLog = nsPrintfCString(
|
|
"Transform feedback varying \"%s\" not"
|
|
" found.",
|
|
asciiUserName.BeginReading());
|
|
return false;
|
|
}
|
|
|
|
const auto insertResPair = alreadyUsed.insert(curInfo);
|
|
const auto& didInsert = insertResPair.second;
|
|
if (!didInsert) {
|
|
const NS_LossyConvertUTF16toASCII asciiUserName(wideUserName);
|
|
*out_linkLog = nsPrintfCString(
|
|
"Transform feedback varying \"%s\""
|
|
" specified twice.",
|
|
asciiUserName.BeginReading());
|
|
return false;
|
|
}
|
|
|
|
////
|
|
|
|
size_t varyingComponents = NumComponents(curInfo->mElemType);
|
|
varyingComponents *= curInfo->mElemCount;
|
|
|
|
auto& totalComponentsForIndex = *(componentsPerVert.rbegin());
|
|
totalComponentsForIndex += varyingComponents;
|
|
|
|
if (totalComponentsForIndex > maxComponentsPerIndex) {
|
|
const NS_LossyConvertUTF16toASCII asciiUserName(wideUserName);
|
|
*out_linkLog = nsPrintfCString(
|
|
"Transform feedback varying \"%s\""
|
|
" pushed `componentsForIndex` over the"
|
|
" limit of %u.",
|
|
asciiUserName.BeginReading(), maxComponentsPerIndex);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
linkInfo->componentsPerTFVert.swap(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;
|
|
}
|
|
|
|
void 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;
|
|
}
|
|
#endif
|
|
|
|
gl->fValidateProgram(mGLName);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
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) {
|
|
mLinkLog.SetLength(logLenWithNull - 1);
|
|
gl->fGetProgramInfoLog(mGLName, logLenWithNull, nullptr,
|
|
mLinkLog.BeginWriting());
|
|
} else {
|
|
mLinkLog.SetLength(0);
|
|
}
|
|
|
|
GLint ok = 0;
|
|
gl->fGetProgramiv(mGLName, LOCAL_GL_LINK_STATUS, &ok);
|
|
if (!ok) return;
|
|
|
|
mMostRecentLinkInfo =
|
|
QueryProgramInfo(this, gl); // Fallible after context loss.
|
|
}
|
|
|
|
bool WebGLProgram::FindAttribUserNameByMappedName(
|
|
const nsACString& mappedName, nsCString* const out_userName) const {
|
|
if (mVertShader->FindAttribUserNameByMappedName(mappedName, out_userName))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool WebGLProgram::FindVaryingByMappedName(const nsACString& mappedName,
|
|
nsCString* const out_userName,
|
|
bool* const out_isArray) const {
|
|
if (mVertShader->FindVaryingByMappedName(mappedName, out_userName,
|
|
out_isArray))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool WebGLProgram::FindUniformByMappedName(const nsACString& mappedName,
|
|
nsCString* const out_userName,
|
|
bool* const out_isArray) const {
|
|
if (mVertShader->FindUniformByMappedName(mappedName, out_userName,
|
|
out_isArray))
|
|
return true;
|
|
|
|
if (mFragShader->FindUniformByMappedName(mappedName, out_userName,
|
|
out_isArray))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
void WebGLProgram::TransformFeedbackVaryings(
|
|
const dom::Sequence<nsString>& 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.Length() > maxAttribs) {
|
|
mContext->ErrorInvalidValue("Length of `varyings` exceeds %s.",
|
|
"TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS");
|
|
return;
|
|
}
|
|
} break;
|
|
|
|
default:
|
|
mContext->ErrorInvalidEnumInfo("bufferMode", bufferMode);
|
|
return;
|
|
}
|
|
|
|
////
|
|
|
|
mNextLink_TransformFeedbackVaryings.assign(
|
|
varyings.Elements(), varyings.Elements() + varyings.Length());
|
|
mNextLink_TransformFeedbackBufferMode = bufferMode;
|
|
}
|
|
|
|
already_AddRefed<WebGLActiveInfo> WebGLProgram::GetTransformFeedbackVarying(
|
|
GLuint index) const {
|
|
// No docs in the WebGL 2 spec for this function. Taking the language for
|
|
// getActiveAttrib, which states that the function returns null on any error.
|
|
if (!IsLinked()) {
|
|
mContext->ErrorInvalidOperation("`program` must be linked.");
|
|
return nullptr;
|
|
}
|
|
|
|
if (index >= LinkInfo()->transformFeedbackVaryings.size()) {
|
|
mContext->ErrorInvalidValue(
|
|
"`index` is greater or "
|
|
"equal to TRANSFORM_FEEDBACK_VARYINGS.");
|
|
return nullptr;
|
|
}
|
|
|
|
RefPtr<WebGLActiveInfo> ret = LinkInfo()->transformFeedbackVaryings[index];
|
|
return ret.forget();
|
|
}
|
|
|
|
bool WebGLProgram::UnmapUniformBlockName(const nsCString& mappedName,
|
|
nsCString* const out_userName) const {
|
|
nsCString baseMappedName;
|
|
bool isArray;
|
|
size_t arrayIndex;
|
|
if (!ParseName(mappedName, &baseMappedName, &isArray, &arrayIndex))
|
|
return false;
|
|
|
|
nsCString baseUserName;
|
|
if (!mVertShader->UnmapUniformBlockName(baseMappedName, &baseUserName) &&
|
|
!mFragShader->UnmapUniformBlockName(baseMappedName, &baseUserName)) {
|
|
return false;
|
|
}
|
|
|
|
AssembleName(baseUserName, isArray, arrayIndex, out_userName);
|
|
return true;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
bool IsBaseName(const nsCString& name) {
|
|
if (!name.Length()) return true;
|
|
|
|
return name[name.Length() - 1] != ']'; // Doesn't end in ']'.
|
|
}
|
|
|
|
bool webgl::LinkedProgramInfo::FindAttrib(
|
|
const nsCString& userName, const webgl::AttribInfo** const out) const {
|
|
// VS inputs cannot be arrays or structures.
|
|
// `userName` is thus always `baseUserName`.
|
|
for (const auto& attrib : attribs) {
|
|
if (attrib.mActiveInfo->mBaseUserName == userName) {
|
|
*out = &attrib;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool webgl::LinkedProgramInfo::FindUniform(
|
|
const nsCString& userName, nsCString* const out_mappedName,
|
|
size_t* const out_arrayIndex, webgl::UniformInfo** const out_info) const {
|
|
nsCString baseUserName;
|
|
bool isArray;
|
|
size_t arrayIndex;
|
|
if (!ParseName(userName, &baseUserName, &isArray, &arrayIndex)) return false;
|
|
|
|
webgl::UniformInfo* info = nullptr;
|
|
for (const auto& uniform : uniforms) {
|
|
if (uniform->mActiveInfo->mBaseUserName == baseUserName) {
|
|
info = uniform;
|
|
break;
|
|
}
|
|
}
|
|
if (!info) return false;
|
|
|
|
const auto& baseMappedName = info->mActiveInfo->mBaseMappedName;
|
|
AssembleName(baseMappedName, isArray, arrayIndex, out_mappedName);
|
|
|
|
*out_arrayIndex = arrayIndex;
|
|
*out_info = info;
|
|
return true;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
JSObject* WebGLProgram::WrapObject(JSContext* js,
|
|
JS::Handle<JSObject*> givenProto) {
|
|
return dom::WebGLProgram_Binding::Wrap(js, this, givenProto);
|
|
}
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(WebGLProgram, mVertShader, mFragShader)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(WebGLProgram, AddRef)
|
|
NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(WebGLProgram, Release)
|
|
|
|
} // namespace mozilla
|