diff options
Diffstat (limited to 'dom/canvas/WebGLContextGL.cpp')
| -rw-r--r-- | dom/canvas/WebGLContextGL.cpp | 1574 |
1 files changed, 1574 insertions, 0 deletions
diff --git a/dom/canvas/WebGLContextGL.cpp b/dom/canvas/WebGLContextGL.cpp new file mode 100644 index 0000000000..7411cec02f --- /dev/null +++ b/dom/canvas/WebGLContextGL.cpp @@ -0,0 +1,1574 @@ +/* -*- Mode: C++; tab-width: 4; 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 "WebGLContext.h" +#include "WebGL2Context.h" + +#include "WebGLContextUtils.h" +#include "WebGLBuffer.h" +#include "WebGLShader.h" +#include "WebGLProgram.h" +#include "WebGLFormats.h" +#include "WebGLFramebuffer.h" +#include "WebGLQuery.h" +#include "WebGLRenderbuffer.h" +#include "WebGLTexture.h" +#include "WebGLVertexArray.h" + +#include "nsDebug.h" +#include "nsReadableUtils.h" +#include "nsString.h" + +#include "gfxContext.h" +#include "gfxPlatform.h" +#include "GLContext.h" + +#include "nsContentUtils.h" +#include "nsError.h" +#include "nsLayoutUtils.h" + +#include "CanvasUtils.h" +#include "gfxUtils.h" +#include "MozFramebuffer.h" + +#include "jsfriendapi.h" + +#include "WebGLTexelConversions.h" +#include "WebGLValidateStrings.h" +#include <algorithm> + +#include "mozilla/DebugOnly.h" +#include "mozilla/dom/BindingUtils.h" +#include "mozilla/dom/ImageData.h" +#include "mozilla/dom/WebGLRenderingContextBinding.h" +#include "mozilla/EndianUtils.h" +#include "mozilla/RefPtr.h" +#include "mozilla/UniquePtrExtensions.h" +#include "mozilla/StaticPrefs_webgl.h" + +namespace mozilla { + +using namespace mozilla::dom; +using namespace mozilla::gfx; +using namespace mozilla::gl; + +// +// WebGL API +// + +void WebGLContext::ActiveTexture(uint32_t texUnit) { + FuncScope funcScope(*this, "activeTexture"); + if (IsContextLost()) return; + funcScope.mBindFailureGuard = true; + + if (texUnit >= Limits().maxTexUnits) { + return ErrorInvalidEnum("Texture unit %u out of range (%u).", texUnit, + Limits().maxTexUnits); + } + + mActiveTexture = texUnit; + gl->fActiveTexture(LOCAL_GL_TEXTURE0 + texUnit); + + funcScope.mBindFailureGuard = false; +} + +void WebGLContext::AttachShader(WebGLProgram& prog, WebGLShader& shader) { + FuncScope funcScope(*this, "attachShader"); + if (IsContextLost()) return; + funcScope.mBindFailureGuard = true; + + prog.AttachShader(shader); + + funcScope.mBindFailureGuard = false; +} + +void WebGLContext::BindAttribLocation(WebGLProgram& prog, GLuint location, + const std::string& name) const { + const FuncScope funcScope(*this, "bindAttribLocation"); + if (IsContextLost()) return; + + prog.BindAttribLocation(location, name); +} + +void WebGLContext::BindFramebuffer(GLenum target, WebGLFramebuffer* wfb) { + FuncScope funcScope(*this, "bindFramebuffer"); + if (IsContextLost()) return; + funcScope.mBindFailureGuard = true; + + if (!ValidateFramebufferTarget(target)) return; + + if (!wfb) { + gl->fBindFramebuffer(target, 0); + } else { + GLuint framebuffername = wfb->mGLName; + gl->fBindFramebuffer(target, framebuffername); + wfb->mHasBeenBound = true; + } + + switch (target) { + case LOCAL_GL_FRAMEBUFFER: + mBoundDrawFramebuffer = wfb; + mBoundReadFramebuffer = wfb; + break; + case LOCAL_GL_DRAW_FRAMEBUFFER: + mBoundDrawFramebuffer = wfb; + break; + case LOCAL_GL_READ_FRAMEBUFFER: + mBoundReadFramebuffer = wfb; + break; + default: + return; + } + funcScope.mBindFailureGuard = false; +} + +void WebGLContext::BlendEquationSeparate(Maybe<GLuint> i, GLenum modeRGB, + GLenum modeAlpha) { + const FuncScope funcScope(*this, "blendEquationSeparate"); + if (IsContextLost()) return; + + if (!ValidateBlendEquationEnum(modeRGB, "modeRGB") || + !ValidateBlendEquationEnum(modeAlpha, "modeAlpha")) { + return; + } + + if (i) { + MOZ_RELEASE_ASSERT( + IsExtensionEnabled(WebGLExtensionID::OES_draw_buffers_indexed)); + const auto limit = MaxValidDrawBuffers(); + if (*i >= limit) { + ErrorInvalidValue("`index` (%u) must be < %s (%u)", *i, + "MAX_DRAW_BUFFERS", limit); + return; + } + + gl->fBlendEquationSeparatei(*i, modeRGB, modeAlpha); + } else { + gl->fBlendEquationSeparate(modeRGB, modeAlpha); + } +} + +static bool ValidateBlendFuncEnum(WebGLContext* webgl, GLenum factor, + const char* varName) { + switch (factor) { + case LOCAL_GL_ZERO: + case LOCAL_GL_ONE: + case LOCAL_GL_SRC_COLOR: + case LOCAL_GL_ONE_MINUS_SRC_COLOR: + case LOCAL_GL_DST_COLOR: + case LOCAL_GL_ONE_MINUS_DST_COLOR: + case LOCAL_GL_SRC_ALPHA: + case LOCAL_GL_ONE_MINUS_SRC_ALPHA: + case LOCAL_GL_DST_ALPHA: + case LOCAL_GL_ONE_MINUS_DST_ALPHA: + case LOCAL_GL_CONSTANT_COLOR: + case LOCAL_GL_ONE_MINUS_CONSTANT_COLOR: + case LOCAL_GL_CONSTANT_ALPHA: + case LOCAL_GL_ONE_MINUS_CONSTANT_ALPHA: + case LOCAL_GL_SRC_ALPHA_SATURATE: + return true; + + default: + webgl->ErrorInvalidEnumInfo(varName, factor); + return false; + } +} + +static bool ValidateBlendFuncEnums(WebGLContext* webgl, GLenum srcRGB, + GLenum srcAlpha, GLenum dstRGB, + GLenum dstAlpha) { + if (!webgl->IsWebGL2()) { + if (dstRGB == LOCAL_GL_SRC_ALPHA_SATURATE || + dstAlpha == LOCAL_GL_SRC_ALPHA_SATURATE) { + webgl->ErrorInvalidEnum( + "LOCAL_GL_SRC_ALPHA_SATURATE as a destination" + " blend function is disallowed in WebGL 1 (dstRGB =" + " 0x%04x, dstAlpha = 0x%04x).", + dstRGB, dstAlpha); + return false; + } + } + + if (!ValidateBlendFuncEnum(webgl, srcRGB, "srcRGB") || + !ValidateBlendFuncEnum(webgl, srcAlpha, "srcAlpha") || + !ValidateBlendFuncEnum(webgl, dstRGB, "dstRGB") || + !ValidateBlendFuncEnum(webgl, dstAlpha, "dstAlpha")) { + return false; + } + + return true; +} + +void WebGLContext::BlendFuncSeparate(Maybe<GLuint> i, GLenum srcRGB, + GLenum dstRGB, GLenum srcAlpha, + GLenum dstAlpha) { + const FuncScope funcScope(*this, "blendFuncSeparate"); + if (IsContextLost()) return; + + if (!ValidateBlendFuncEnums(this, srcRGB, srcAlpha, dstRGB, dstAlpha)) return; + + // note that we only check compatibity for the RGB enums, no need to for the + // Alpha enums, see "Section 6.8 forgetting to mention alpha factors?" thread + // on the public_webgl mailing list + if (!ValidateBlendFuncEnumsCompatibility(srcRGB, dstRGB, "srcRGB and dstRGB")) + return; + + if (i) { + MOZ_RELEASE_ASSERT( + IsExtensionEnabled(WebGLExtensionID::OES_draw_buffers_indexed)); + const auto limit = MaxValidDrawBuffers(); + if (*i >= limit) { + ErrorInvalidValue("`index` (%u) must be < %s (%u)", *i, + "MAX_DRAW_BUFFERS", limit); + return; + } + + gl->fBlendFuncSeparatei(*i, srcRGB, dstRGB, srcAlpha, dstAlpha); + } else { + gl->fBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); + } +} + +GLenum WebGLContext::CheckFramebufferStatus(GLenum target) { + const FuncScope funcScope(*this, "checkFramebufferStatus"); + if (IsContextLost()) return LOCAL_GL_FRAMEBUFFER_UNSUPPORTED; + + if (!ValidateFramebufferTarget(target)) return 0; + + WebGLFramebuffer* fb; + switch (target) { + case LOCAL_GL_FRAMEBUFFER: + case LOCAL_GL_DRAW_FRAMEBUFFER: + fb = mBoundDrawFramebuffer; + break; + + case LOCAL_GL_READ_FRAMEBUFFER: + fb = mBoundReadFramebuffer; + break; + + default: + MOZ_CRASH("GFX: Bad target."); + } + + if (!fb) return LOCAL_GL_FRAMEBUFFER_COMPLETE; + + return fb->CheckFramebufferStatus().get(); +} + +RefPtr<WebGLProgram> WebGLContext::CreateProgram() { + const FuncScope funcScope(*this, "createProgram"); + if (IsContextLost()) return nullptr; + + return new WebGLProgram(this); +} + +RefPtr<WebGLShader> WebGLContext::CreateShader(GLenum type) { + const FuncScope funcScope(*this, "createShader"); + if (IsContextLost()) return nullptr; + + if (type != LOCAL_GL_VERTEX_SHADER && type != LOCAL_GL_FRAGMENT_SHADER) { + ErrorInvalidEnumInfo("type", type); + return nullptr; + } + + return new WebGLShader(this, type); +} + +void WebGLContext::CullFace(GLenum face) { + const FuncScope funcScope(*this, "cullFace"); + if (IsContextLost()) return; + + if (!ValidateFaceEnum(face)) return; + + gl->fCullFace(face); +} + +void WebGLContext::DetachShader(WebGLProgram& prog, const WebGLShader& shader) { + FuncScope funcScope(*this, "detachShader"); + if (IsContextLost()) return; + funcScope.mBindFailureGuard = true; + + prog.DetachShader(shader); + + funcScope.mBindFailureGuard = false; +} + +static bool ValidateComparisonEnum(WebGLContext& webgl, const GLenum func) { + switch (func) { + case LOCAL_GL_NEVER: + case LOCAL_GL_LESS: + case LOCAL_GL_LEQUAL: + case LOCAL_GL_GREATER: + case LOCAL_GL_GEQUAL: + case LOCAL_GL_EQUAL: + case LOCAL_GL_NOTEQUAL: + case LOCAL_GL_ALWAYS: + return true; + + default: + webgl.ErrorInvalidEnumInfo("func", func); + return false; + } +} + +void WebGLContext::DepthFunc(GLenum func) { + const FuncScope funcScope(*this, "depthFunc"); + if (IsContextLost()) return; + + if (!ValidateComparisonEnum(*this, func)) return; + + gl->fDepthFunc(func); +} + +void WebGLContext::DepthRange(GLfloat zNear, GLfloat zFar) { + const FuncScope funcScope(*this, "depthRange"); + if (IsContextLost()) return; + + if (zNear > zFar) + return ErrorInvalidOperation( + "the near value is greater than the far value!"); + + gl->fDepthRange(zNear, zFar); +} + +// - + +void WebGLContext::FramebufferAttach(const GLenum target, + const GLenum attachSlot, + const GLenum bindImageTarget, + const webgl::FbAttachInfo& toAttach) { + FuncScope funcScope(*this, "framebufferAttach"); + funcScope.mBindFailureGuard = true; + const auto& limits = *mLimits; + + if (!ValidateFramebufferTarget(target)) return; + + auto fb = mBoundDrawFramebuffer; + if (target == LOCAL_GL_READ_FRAMEBUFFER) { + fb = mBoundReadFramebuffer; + } + if (!fb) return; + + // `rb` needs no validation. + + // `tex` + const auto& tex = toAttach.tex; + if (tex) { + const auto err = CheckFramebufferAttach(bindImageTarget, tex->mTarget.get(), + toAttach.mipLevel, toAttach.zLayer, + toAttach.zLayerCount, limits); + if (err) return; + } + + auto safeToAttach = toAttach; + if (!toAttach.rb && !toAttach.tex) { + safeToAttach = {}; + } + if (!IsWebGL2() && + !IsExtensionEnabled(WebGLExtensionID::OES_fbo_render_mipmap)) { + safeToAttach.mipLevel = 0; + } + if (!IsExtensionEnabled(WebGLExtensionID::OVR_multiview2)) { + safeToAttach.isMultiview = false; + } + + if (!fb->FramebufferAttach(attachSlot, safeToAttach)) return; + + funcScope.mBindFailureGuard = false; +} + +// - + +void WebGLContext::FrontFace(GLenum mode) { + const FuncScope funcScope(*this, "frontFace"); + if (IsContextLost()) return; + + switch (mode) { + case LOCAL_GL_CW: + case LOCAL_GL_CCW: + break; + default: + return ErrorInvalidEnumInfo("mode", mode); + } + + gl->fFrontFace(mode); +} + +Maybe<double> WebGLContext::GetBufferParameter(GLenum target, GLenum pname) { + const FuncScope funcScope(*this, "getBufferParameter"); + if (IsContextLost()) return Nothing(); + + const auto& slot = ValidateBufferSlot(target); + if (!slot) return Nothing(); + const auto& buffer = *slot; + + if (!buffer) { + ErrorInvalidOperation("Buffer for `target` is null."); + return Nothing(); + } + + switch (pname) { + case LOCAL_GL_BUFFER_SIZE: + return Some(buffer->ByteLength()); + + case LOCAL_GL_BUFFER_USAGE: + return Some(buffer->Usage()); + + default: + ErrorInvalidEnumInfo("pname", pname); + return Nothing(); + } +} + +Maybe<double> WebGLContext::GetFramebufferAttachmentParameter( + WebGLFramebuffer* const fb, GLenum attachment, GLenum pname) const { + const FuncScope funcScope(*this, "getFramebufferAttachmentParameter"); + if (IsContextLost()) return Nothing(); + + if (fb) return fb->GetAttachmentParameter(attachment, pname); + + //////////////////////////////////// + + if (!IsWebGL2()) { + ErrorInvalidOperation( + "Querying against the default framebuffer is not" + " allowed in WebGL 1."); + return Nothing(); + } + + switch (attachment) { + case LOCAL_GL_BACK: + case LOCAL_GL_DEPTH: + case LOCAL_GL_STENCIL: + break; + + default: + ErrorInvalidEnum( + "For the default framebuffer, can only query COLOR, DEPTH," + " or STENCIL."); + return Nothing(); + } + + switch (pname) { + case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: + switch (attachment) { + case LOCAL_GL_BACK: + break; + case LOCAL_GL_DEPTH: + if (!mOptions.depth) { + return Some(LOCAL_GL_NONE); + } + break; + case LOCAL_GL_STENCIL: + if (!mOptions.stencil) { + return Some(LOCAL_GL_NONE); + } + break; + default: + ErrorInvalidEnum( + "With the default framebuffer, can only query COLOR, DEPTH," + " or STENCIL for GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE"); + return Nothing(); + } + return Some(LOCAL_GL_FRAMEBUFFER_DEFAULT); + + //////////////// + + case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE: + case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: + case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: + if (attachment == LOCAL_GL_BACK) return Some(8); + return Some(0); + + case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: + if (attachment == LOCAL_GL_BACK) { + if (mOptions.alpha) { + return Some(8); + } + ErrorInvalidOperation( + "The default framebuffer doesn't contain an alpha buffer"); + return Nothing(); + } + return Some(0); + + case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: + if (attachment == LOCAL_GL_DEPTH) { + if (mOptions.depth) { + return Some(24); + } + ErrorInvalidOperation( + "The default framebuffer doesn't contain an depth buffer"); + return Nothing(); + } + return Some(0); + + case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: + if (attachment == LOCAL_GL_STENCIL) { + if (mOptions.stencil) { + return Some(8); + } + ErrorInvalidOperation( + "The default framebuffer doesn't contain an stencil buffer"); + return Nothing(); + } + return Some(0); + + case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: + if (attachment == LOCAL_GL_STENCIL) { + if (mOptions.stencil) { + return Some(LOCAL_GL_UNSIGNED_INT); + } + ErrorInvalidOperation( + "The default framebuffer doesn't contain an stencil buffer"); + } else if (attachment == LOCAL_GL_DEPTH) { + if (mOptions.depth) { + return Some(LOCAL_GL_UNSIGNED_NORMALIZED); + } + ErrorInvalidOperation( + "The default framebuffer doesn't contain an depth buffer"); + } else { // LOCAL_GL_BACK + return Some(LOCAL_GL_UNSIGNED_NORMALIZED); + } + return Nothing(); + + case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: + if (attachment == LOCAL_GL_STENCIL) { + if (!mOptions.stencil) { + ErrorInvalidOperation( + "The default framebuffer doesn't contain an stencil buffer"); + return Nothing(); + } + } else if (attachment == LOCAL_GL_DEPTH) { + if (!mOptions.depth) { + ErrorInvalidOperation( + "The default framebuffer doesn't contain an depth buffer"); + return Nothing(); + } + } + return Some(LOCAL_GL_LINEAR); + } + + ErrorInvalidEnumInfo("pname", pname); + return Nothing(); +} + +Maybe<double> WebGLContext::GetRenderbufferParameter( + const WebGLRenderbuffer& rb, GLenum pname) const { + const FuncScope funcScope(*this, "getRenderbufferParameter"); + if (IsContextLost()) return Nothing(); + + switch (pname) { + case LOCAL_GL_RENDERBUFFER_SAMPLES: + if (!IsWebGL2()) break; + [[fallthrough]]; + + case LOCAL_GL_RENDERBUFFER_WIDTH: + case LOCAL_GL_RENDERBUFFER_HEIGHT: + case LOCAL_GL_RENDERBUFFER_RED_SIZE: + case LOCAL_GL_RENDERBUFFER_GREEN_SIZE: + case LOCAL_GL_RENDERBUFFER_BLUE_SIZE: + case LOCAL_GL_RENDERBUFFER_ALPHA_SIZE: + case LOCAL_GL_RENDERBUFFER_DEPTH_SIZE: + case LOCAL_GL_RENDERBUFFER_STENCIL_SIZE: + case LOCAL_GL_RENDERBUFFER_INTERNAL_FORMAT: { + // RB emulation means we have to ask the RB itself. + GLint i = rb.GetRenderbufferParameter(pname); + return Some(i); + } + + default: + break; + } + + ErrorInvalidEnumInfo("pname", pname); + return Nothing(); +} + +RefPtr<WebGLTexture> WebGLContext::CreateTexture() { + const FuncScope funcScope(*this, "createTexture"); + if (IsContextLost()) return nullptr; + + GLuint tex = 0; + gl->fGenTextures(1, &tex); + + return new WebGLTexture(this, tex); +} + +GLenum WebGLContext::GetError() { + const FuncScope funcScope(*this, "getError"); + + /* WebGL 1.0: Section 5.14.3: Setting and getting state: + * If the context's webgl context lost flag is set, returns + * CONTEXT_LOST_WEBGL the first time this method is called. + * Afterward, returns NO_ERROR until the context has been + * restored. + * + * WEBGL_lose_context: + * [When this extension is enabled: ] loseContext and + * restoreContext are allowed to generate INVALID_OPERATION errors + * even when the context is lost. + */ + + auto err = mWebGLError; + mWebGLError = 0; + if (IsContextLost() || err) // Must check IsContextLost in all flow paths. + return err; + + // Either no WebGL-side error, or it's already been cleared. + // UnderlyingGL-side errors, now. + err = gl->fGetError(); + if (gl->IsContextLost()) { + CheckForContextLoss(); + return GetError(); + } + MOZ_ASSERT(err != LOCAL_GL_CONTEXT_LOST); + + if (err) { + GenerateWarning("Driver error unexpected by WebGL: 0x%04x", err); + // This might be: + // - INVALID_OPERATION from ANGLE due to incomplete RBAB implementation for + // DrawElements + // with DYNAMIC_DRAW index buffer. + } + return err; +} + +webgl::GetUniformData WebGLContext::GetUniform(const WebGLProgram& prog, + const uint32_t loc) const { + const FuncScope funcScope(*this, "getUniform"); + webgl::GetUniformData ret; + [&]() { + if (IsContextLost()) return; + + const auto& info = prog.LinkInfo(); + if (!info) return; + + const auto locInfo = MaybeFind(info->locationMap, loc); + if (!locInfo) return; + + ret.type = locInfo->info.info.elemType; + switch (ret.type) { + 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_MAT3: + case LOCAL_GL_FLOAT_MAT4: + case LOCAL_GL_FLOAT_MAT2x3: + case LOCAL_GL_FLOAT_MAT2x4: + case LOCAL_GL_FLOAT_MAT3x2: + case LOCAL_GL_FLOAT_MAT3x4: + case LOCAL_GL_FLOAT_MAT4x2: + case LOCAL_GL_FLOAT_MAT4x3: + gl->fGetUniformfv(prog.mGLName, loc, + reinterpret_cast<float*>(ret.data)); + break; + + 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: + case LOCAL_GL_BOOL: + case LOCAL_GL_BOOL_VEC2: + case LOCAL_GL_BOOL_VEC3: + case LOCAL_GL_BOOL_VEC4: + gl->fGetUniformiv(prog.mGLName, loc, + reinterpret_cast<int32_t*>(ret.data)); + break; + + case LOCAL_GL_UNSIGNED_INT: + case LOCAL_GL_UNSIGNED_INT_VEC2: + case LOCAL_GL_UNSIGNED_INT_VEC3: + case LOCAL_GL_UNSIGNED_INT_VEC4: + gl->fGetUniformuiv(prog.mGLName, loc, + reinterpret_cast<uint32_t*>(ret.data)); + break; + + default: + MOZ_CRASH("GFX: Invalid elemType."); + } + }(); + return ret; +} + +void WebGLContext::Hint(GLenum target, GLenum mode) { + const FuncScope funcScope(*this, "hint"); + if (IsContextLost()) return; + + switch (mode) { + case LOCAL_GL_FASTEST: + case LOCAL_GL_NICEST: + case LOCAL_GL_DONT_CARE: + break; + default: + return ErrorInvalidEnumArg("mode", mode); + } + + // - + + bool isValid = false; + + switch (target) { + case LOCAL_GL_GENERATE_MIPMAP_HINT: + mGenerateMipmapHint = mode; + isValid = true; + + // Deprecated and removed in desktop GL Core profiles. + if (gl->IsCoreProfile()) return; + + break; + + case LOCAL_GL_FRAGMENT_SHADER_DERIVATIVE_HINT: + if (IsWebGL2() || + IsExtensionEnabled(WebGLExtensionID::OES_standard_derivatives)) { + isValid = true; + } + break; + } + if (!isValid) return ErrorInvalidEnumInfo("target", target); + + // - + + gl->fHint(target, mode); +} + +// - + +void WebGLContext::LinkProgram(WebGLProgram& prog) { + const FuncScope funcScope(*this, "linkProgram"); + if (IsContextLost()) return; + + prog.LinkProgram(); + + if (&prog == mCurrentProgram) { + if (!prog.IsLinked()) { + // We use to simply early-out here, and preserve the GL behavior that + // failed relink doesn't invalidate the current active program link info. + // The new behavior was changed for WebGL here: + // https://github.com/KhronosGroup/WebGL/pull/3371 + mActiveProgramLinkInfo = nullptr; + gl->fUseProgram(0); // Shouldn't be needed, but let's be safe. + return; + } + mActiveProgramLinkInfo = prog.LinkInfo(); + gl->fUseProgram(prog.mGLName); // Uncontionally re-use. + // Previously, we needed this re-use on nvidia as a driver workaround, + // but we might as well do it unconditionally. + } +} + +Maybe<webgl::ErrorInfo> SetPixelUnpack( + const bool isWebgl2, webgl::PixelUnpackStateWebgl* const unpacking, + const GLenum pname, const GLint param) { + if (isWebgl2) { + uint32_t* pValueSlot = nullptr; + switch (pname) { + case LOCAL_GL_UNPACK_IMAGE_HEIGHT: + pValueSlot = &unpacking->imageHeight; + break; + + case LOCAL_GL_UNPACK_SKIP_IMAGES: + pValueSlot = &unpacking->skipImages; + break; + + case LOCAL_GL_UNPACK_ROW_LENGTH: + pValueSlot = &unpacking->rowLength; + break; + + case LOCAL_GL_UNPACK_SKIP_ROWS: + pValueSlot = &unpacking->skipRows; + break; + + case LOCAL_GL_UNPACK_SKIP_PIXELS: + pValueSlot = &unpacking->skipPixels; + break; + } + + if (pValueSlot) { + *pValueSlot = static_cast<uint32_t>(param); + return {}; + } + } + + switch (pname) { + case dom::WebGLRenderingContext_Binding::UNPACK_FLIP_Y_WEBGL: + unpacking->flipY = bool(param); + return {}; + + case dom::WebGLRenderingContext_Binding::UNPACK_PREMULTIPLY_ALPHA_WEBGL: + unpacking->premultiplyAlpha = bool(param); + return {}; + + case dom::WebGLRenderingContext_Binding::UNPACK_COLORSPACE_CONVERSION_WEBGL: + switch (param) { + case LOCAL_GL_NONE: + case dom::WebGLRenderingContext_Binding::BROWSER_DEFAULT_WEBGL: + break; + + default: { + const nsPrintfCString text("Bad UNPACK_COLORSPACE_CONVERSION: %s", + EnumString(param).c_str()); + return Some(webgl::ErrorInfo{LOCAL_GL_INVALID_VALUE, ToString(text)}); + } + } + unpacking->colorspaceConversion = param; + return {}; + + case dom::MOZ_debug_Binding::UNPACK_REQUIRE_FASTPATH: + unpacking->requireFastPath = bool(param); + return {}; + + case LOCAL_GL_UNPACK_ALIGNMENT: + switch (param) { + case 1: + case 2: + case 4: + case 8: + break; + + default: { + const nsPrintfCString text( + "UNPACK_ALIGNMENT must be [1,2,4,8], was %i", param); + return Some(webgl::ErrorInfo{LOCAL_GL_INVALID_VALUE, ToString(text)}); + } + } + unpacking->alignmentInTypeElems = param; + return {}; + + default: + break; + } + const nsPrintfCString text("Bad `pname`: %s", EnumString(pname).c_str()); + return Some(webgl::ErrorInfo{LOCAL_GL_INVALID_ENUM, ToString(text)}); +} + +bool WebGLContext::DoReadPixelsAndConvert( + const webgl::FormatInfo* const srcFormat, const webgl::ReadPixelsDesc& desc, + const uintptr_t dest, const uint64_t destSize, const uint32_t rowStride) { + const auto& x = desc.srcOffset.x; + const auto& y = desc.srcOffset.y; + const auto size = *ivec2::From(desc.size); + const auto& pi = desc.pi; + + // On at least Win+NV, we'll get PBO errors if we don't have at least + // `rowStride * height` bytes available to read into. + const auto naiveBytesNeeded = CheckedInt<uint64_t>(rowStride) * size.y; + const bool isDangerCloseToEdge = + (!naiveBytesNeeded.isValid() || naiveBytesNeeded.value() > destSize); + const bool useParanoidHandling = + (gl->WorkAroundDriverBugs() && isDangerCloseToEdge && + mBoundPixelPackBuffer); + if (!useParanoidHandling) { + gl->fReadPixels(x, y, size.x, size.y, pi.format, pi.type, + reinterpret_cast<void*>(dest)); + return true; + } + + // Read everything but the last row. + const auto bodyHeight = size.y - 1; + if (bodyHeight) { + gl->fReadPixels(x, y, size.x, bodyHeight, pi.format, pi.type, + reinterpret_cast<void*>(dest)); + } + + // Now read the last row. + gl->fPixelStorei(LOCAL_GL_PACK_ALIGNMENT, 1); + gl->fPixelStorei(LOCAL_GL_PACK_ROW_LENGTH, 0); + gl->fPixelStorei(LOCAL_GL_PACK_SKIP_ROWS, 0); + + const auto tailRowOffset = + reinterpret_cast<uint8_t*>(dest) + rowStride * bodyHeight; + gl->fReadPixels(x, y + bodyHeight, size.x, 1, pi.format, pi.type, + tailRowOffset); + + return true; +} + +webgl::ReadPixelsResult WebGLContext::ReadPixelsInto( + const webgl::ReadPixelsDesc& desc, const Range<uint8_t>& dest) { + const FuncScope funcScope(*this, "readPixels"); + if (IsContextLost()) return {}; + + if (mBoundPixelPackBuffer) { + ErrorInvalidOperation("PIXEL_PACK_BUFFER must be null."); + return {}; + } + + return ReadPixelsImpl(desc, reinterpret_cast<uintptr_t>(dest.begin().get()), + dest.length()); +} + +void WebGLContext::ReadPixelsPbo(const webgl::ReadPixelsDesc& desc, + const uint64_t offset) { + const FuncScope funcScope(*this, "readPixels"); + if (IsContextLost()) return; + + const auto& buffer = ValidateBufferSelection(LOCAL_GL_PIXEL_PACK_BUFFER); + if (!buffer) return; + + ////// + + { + const auto pii = webgl::PackingInfoInfo::For(desc.pi); + if (!pii) { + GLenum err = LOCAL_GL_INVALID_OPERATION; + if (!desc.pi.format || !desc.pi.type) { + err = LOCAL_GL_INVALID_ENUM; + } + GenerateError(err, "`format` (%s) and/or `type` (%s) not acceptable.", + EnumString(desc.pi.format).c_str(), + EnumString(desc.pi.type).c_str()); + return; + } + + if (offset % pii->bytesPerElement != 0) { + ErrorInvalidOperation( + "`offset` must be divisible by the size of `type`" + " in bytes."); + return; + } + } + + ////// + + auto bytesAvailable = buffer->ByteLength(); + if (offset > bytesAvailable) { + ErrorInvalidOperation("`offset` too large for bound PIXEL_PACK_BUFFER."); + return; + } + bytesAvailable -= offset; + + // - + + const ScopedLazyBind lazyBind(gl, LOCAL_GL_PIXEL_PACK_BUFFER, buffer); + + ReadPixelsImpl(desc, offset, bytesAvailable); + + buffer->ResetLastUpdateFenceId(); +} + +static webgl::PackingInfo DefaultReadPixelPI( + const webgl::FormatUsageInfo* usage) { + MOZ_ASSERT(usage->IsRenderable()); + const auto& format = *usage->format; + switch (format.componentType) { + case webgl::ComponentType::NormUInt: + if (format.r == 16) { + return {LOCAL_GL_RGBA, LOCAL_GL_UNSIGNED_SHORT}; + } + return {LOCAL_GL_RGBA, LOCAL_GL_UNSIGNED_BYTE}; + + case webgl::ComponentType::Int: + return {LOCAL_GL_RGBA_INTEGER, LOCAL_GL_INT}; + + case webgl::ComponentType::UInt: + return {LOCAL_GL_RGBA_INTEGER, LOCAL_GL_UNSIGNED_INT}; + + case webgl::ComponentType::Float: + return {LOCAL_GL_RGBA, LOCAL_GL_FLOAT}; + + default: + MOZ_CRASH(); + } +} + +static bool ArePossiblePackEnums(const WebGLContext* webgl, + const webgl::PackingInfo& pi) { + // OpenGL ES 2.0 $4.3.1 - IMPLEMENTATION_COLOR_READ_{TYPE/FORMAT} is a valid + // combination for glReadPixels()... + + // Only valid when pulled from: + // * GLES 2.0.25 p105: + // "table 3.4, excluding formats LUMINANCE and LUMINANCE_ALPHA." + // * GLES 3.0.4 p193: + // "table 3.2, excluding formats DEPTH_COMPONENT and DEPTH_STENCIL." + switch (pi.format) { + case LOCAL_GL_LUMINANCE: + case LOCAL_GL_LUMINANCE_ALPHA: + case LOCAL_GL_DEPTH_COMPONENT: + case LOCAL_GL_DEPTH_STENCIL: + return false; + } + + if (pi.type == LOCAL_GL_UNSIGNED_INT_24_8) return false; + + const auto pii = webgl::PackingInfoInfo::For(pi); + if (!pii) return false; + + return true; +} + +webgl::PackingInfo WebGLContext::ValidImplementationColorReadPI( + const webgl::FormatUsageInfo* usage) const { + const auto defaultPI = DefaultReadPixelPI(usage); + + // ES2_compatibility always returns RGBA/UNSIGNED_BYTE, so branch on actual + // IsGLES(). Also OSX+NV generates an error here. + if (!gl->IsGLES()) return defaultPI; + + webgl::PackingInfo implPI; + gl->fGetIntegerv(LOCAL_GL_IMPLEMENTATION_COLOR_READ_FORMAT, + (GLint*)&implPI.format); + gl->fGetIntegerv(LOCAL_GL_IMPLEMENTATION_COLOR_READ_TYPE, + (GLint*)&implPI.type); + + if (!ArePossiblePackEnums(this, implPI)) return defaultPI; + + return implPI; +} + +static bool ValidateReadPixelsFormatAndType( + const webgl::FormatUsageInfo* srcUsage, const webgl::PackingInfo& pi, + gl::GLContext* gl, WebGLContext* webgl) { + if (!ArePossiblePackEnums(webgl, pi)) { + webgl->ErrorInvalidEnum("Unexpected format or type."); + return false; + } + + const auto defaultPI = DefaultReadPixelPI(srcUsage); + if (pi == defaultPI) return true; + + //// + + // OpenGL ES 3.0.4 p194 - When the internal format of the rendering surface is + // RGB10_A2, a third combination of format RGBA and type + // UNSIGNED_INT_2_10_10_10_REV is accepted. + + if (webgl->IsWebGL2() && + srcUsage->format->effectiveFormat == webgl::EffectiveFormat::RGB10_A2 && + pi.format == LOCAL_GL_RGBA && + pi.type == LOCAL_GL_UNSIGNED_INT_2_10_10_10_REV) { + return true; + } + + //// + + const auto implPI = webgl->ValidImplementationColorReadPI(srcUsage); + if (pi == implPI) return true; + + //// + + // clang-format off + webgl->ErrorInvalidOperation( + "Format and type %s/%s incompatible with this %s attachment." + " This framebuffer requires either %s/%s or" + " getParameter(IMPLEMENTATION_COLOR_READ_FORMAT/_TYPE) %s/%s.", + EnumString(pi.format).c_str(), EnumString(pi.type).c_str(), + srcUsage->format->name, + EnumString(defaultPI.format).c_str(), EnumString(defaultPI.type).c_str(), + EnumString(implPI.format).c_str(), EnumString(implPI.type).c_str()); + // clang-format on + + return false; +} + +webgl::ReadPixelsResult WebGLContext::ReadPixelsImpl( + const webgl::ReadPixelsDesc& desc, const uintptr_t dest, + const uint64_t availBytes) { + const webgl::FormatUsageInfo* srcFormat; + uint32_t srcWidth; + uint32_t srcHeight; + if (!BindCurFBForColorRead(&srcFormat, &srcWidth, &srcHeight)) return {}; + + ////// + + if (!ValidateReadPixelsFormatAndType(srcFormat, desc.pi, gl, this)) return {}; + + ////// + + const auto& srcOffset = desc.srcOffset; + const auto& size = desc.size; + + if (!ivec2::From(size)) { + ErrorInvalidValue("width and height must be non-negative."); + return {}; + } + + const auto& packing = desc.packState; + const auto explicitPackingRes = webgl::ExplicitPixelPackingState::ForUseWith( + packing, LOCAL_GL_TEXTURE_2D, {size.x, size.y, 1}, desc.pi, {}); + if (!explicitPackingRes.isOk()) { + ErrorInvalidOperation("%s", explicitPackingRes.inspectErr().c_str()); + return {}; + } + const auto& explicitPacking = explicitPackingRes.inspect(); + const auto& rowStride = explicitPacking.metrics.bytesPerRowStride; + const auto& bytesNeeded = explicitPacking.metrics.totalBytesUsed; + if (bytesNeeded > availBytes) { + ErrorInvalidOperation("buffer too small"); + return {}; + } + + //// + + int32_t readX, readY; + int32_t writeX, writeY; + int32_t rwWidth, rwHeight; + if (!Intersect(srcWidth, srcOffset.x, size.x, &readX, &writeX, &rwWidth) || + !Intersect(srcHeight, srcOffset.y, size.y, &readY, &writeY, &rwHeight)) { + ErrorOutOfMemory("Bad subrect selection."); + return {}; + } + + //////////////// + // Now that the errors are out of the way, on to actually reading! + + gl->fPixelStorei(LOCAL_GL_PACK_ALIGNMENT, packing.alignmentInTypeElems); + if (IsWebGL2()) { + gl->fPixelStorei(LOCAL_GL_PACK_ROW_LENGTH, packing.rowLength); + gl->fPixelStorei(LOCAL_GL_PACK_SKIP_PIXELS, packing.skipPixels); + gl->fPixelStorei(LOCAL_GL_PACK_SKIP_ROWS, packing.skipRows); + } + + if (!rwWidth || !rwHeight) { + // Disjoint rects, so we're done already. + DummyReadFramebufferOperation(); + return {}; + } + const auto rwSize = *uvec2::From(rwWidth, rwHeight); + + const auto res = webgl::ReadPixelsResult{ + {{writeX, writeY}, {rwSize.x, rwSize.y}}, rowStride}; + + if (rwSize == size) { + DoReadPixelsAndConvert(srcFormat->format, desc, dest, bytesNeeded, + rowStride); + return res; + } + + // Read request contains out-of-bounds pixels. Unfortunately: + // GLES 3.0.4 p194 "Obtaining Pixels from the Framebuffer": + // "If any of these pixels lies outside of the window allocated to the current + // GL context, or outside of the image attached to the currently bound + // framebuffer object, then the values obtained for those pixels are + // undefined." + + // This is a slow-path, so warn people away! + GenerateWarning( + "Out-of-bounds reads with readPixels are deprecated, and" + " may be slow."); + + //////////////////////////////////// + // Read only the in-bounds pixels. + + if (IsWebGL2()) { + if (!packing.rowLength) { + gl->fPixelStorei(LOCAL_GL_PACK_ROW_LENGTH, packing.skipPixels + size.x); + } + gl->fPixelStorei(LOCAL_GL_PACK_SKIP_PIXELS, packing.skipPixels + writeX); + gl->fPixelStorei(LOCAL_GL_PACK_SKIP_ROWS, packing.skipRows + writeY); + + auto desc2 = desc; + desc2.srcOffset = {readX, readY}; + desc2.size = rwSize; + + DoReadPixelsAndConvert(srcFormat->format, desc2, dest, bytesNeeded, + rowStride); + } else { + // I *did* say "hilariously slow". + + auto desc2 = desc; + desc2.srcOffset = {readX, readY}; + desc2.size = {rwSize.x, 1}; + + const auto skipBytes = writeX * explicitPacking.metrics.bytesPerPixel; + const auto usedRowBytes = rwSize.x * explicitPacking.metrics.bytesPerPixel; + for (const auto j : IntegerRange(rwSize.y)) { + desc2.srcOffset.y = readY + j; + const auto destWriteBegin = dest + skipBytes + (writeY + j) * rowStride; + MOZ_RELEASE_ASSERT(dest <= destWriteBegin); + MOZ_RELEASE_ASSERT(destWriteBegin <= dest + availBytes); + + const auto destWriteEnd = destWriteBegin + usedRowBytes; + MOZ_RELEASE_ASSERT(dest <= destWriteEnd); + MOZ_RELEASE_ASSERT(destWriteEnd <= dest + availBytes); + + DoReadPixelsAndConvert(srcFormat->format, desc2, destWriteBegin, + destWriteEnd - destWriteBegin, rowStride); + } + } + + return res; +} + +void WebGLContext::RenderbufferStorageMultisample(WebGLRenderbuffer& rb, + uint32_t samples, + GLenum internalFormat, + uint32_t width, + uint32_t height) const { + const FuncScope funcScope(*this, "renderbufferStorage(Multisample)?"); + if (IsContextLost()) return; + + rb.RenderbufferStorage(samples, internalFormat, width, height); +} + +void WebGLContext::Scissor(GLint x, GLint y, GLsizei width, GLsizei height) { + const FuncScope funcScope(*this, "scissor"); + if (IsContextLost()) return; + + if (!ValidateNonNegative("width", width) || + !ValidateNonNegative("height", height)) { + return; + } + + mScissorRect = {x, y, width, height}; + mScissorRect.Apply(*gl); +} + +void WebGLContext::StencilFuncSeparate(GLenum face, GLenum func, GLint ref, + GLuint mask) { + const FuncScope funcScope(*this, "stencilFuncSeparate"); + if (IsContextLost()) return; + + if (!ValidateFaceEnum(face) || !ValidateComparisonEnum(*this, func)) { + return; + } + + switch (face) { + case LOCAL_GL_FRONT_AND_BACK: + mStencilRefFront = ref; + mStencilRefBack = ref; + mStencilValueMaskFront = mask; + mStencilValueMaskBack = mask; + break; + case LOCAL_GL_FRONT: + mStencilRefFront = ref; + mStencilValueMaskFront = mask; + break; + case LOCAL_GL_BACK: + mStencilRefBack = ref; + mStencilValueMaskBack = mask; + break; + } + + gl->fStencilFuncSeparate(face, func, ref, mask); +} + +void WebGLContext::StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, + GLenum dppass) { + const FuncScope funcScope(*this, "stencilOpSeparate"); + if (IsContextLost()) return; + + if (!ValidateFaceEnum(face) || !ValidateStencilOpEnum(sfail, "sfail") || + !ValidateStencilOpEnum(dpfail, "dpfail") || + !ValidateStencilOpEnum(dppass, "dppass")) + return; + + gl->fStencilOpSeparate(face, sfail, dpfail, dppass); +} + +//////////////////////////////////////////////////////////////////////////////// +// Uniform setters. + +void WebGLContext::UniformData( + const uint32_t loc, const bool transpose, + const Range<const webgl::UniformDataVal>& data) const { + const FuncScope funcScope(*this, "uniform setter"); + + if (!IsWebGL2() && transpose) { + GenerateError(LOCAL_GL_INVALID_VALUE, "`transpose`:true requires WebGL 2."); + return; + } + + // - + + const auto& link = mActiveProgramLinkInfo; + if (!link) return; + + const auto locInfo = MaybeFind(link->locationMap, loc); + if (!locInfo) { + // Null WebGLUniformLocations become -1, which will end up here. + return; + } + + const auto& validationInfo = locInfo->info; + const auto& activeInfo = validationInfo.info; + const auto& channels = validationInfo.channelsPerElem; + const auto& pfn = validationInfo.pfn; + + // - + + const auto lengthInType = data.length(); + const auto elemCount = lengthInType / channels; + if (elemCount > 1 && !validationInfo.isArray) { + GenerateError( + LOCAL_GL_INVALID_OPERATION, + "(uniform %s) `values` length (%u) must exactly match size of %s.", + activeInfo.name.c_str(), lengthInType, + EnumString(activeInfo.elemType).c_str()); + return; + } + + // - + + const auto& samplerInfo = locInfo->samplerInfo; + if (samplerInfo) { + const auto idata = reinterpret_cast<const uint32_t*>(data.begin().get()); + const auto maxTexUnits = GLMaxTextureUnits(); + for (const auto& val : Range<const uint32_t>(idata, elemCount)) { + if (val >= maxTexUnits) { + ErrorInvalidValue( + "This uniform location is a sampler, but %d" + " is not a valid texture unit.", + val); + return; + } + } + } + + // - + + // This is a little galaxy-brain, sorry! + const auto ptr = static_cast<const void*>(data.begin().get()); + (*pfn)(*gl, static_cast<GLint>(loc), elemCount, transpose, ptr); + + // - + + if (samplerInfo) { + auto& texUnits = samplerInfo->texUnits; + + const auto srcBegin = reinterpret_cast<const uint32_t*>(data.begin().get()); + auto destIndex = locInfo->indexIntoUniform; + if (destIndex < texUnits.length()) { + // Only sample as many indexes as available tex units allow. + const auto destCount = std::min(elemCount, texUnits.length() - destIndex); + for (const auto& val : Range<const uint32_t>(srcBegin, destCount)) { + texUnits[destIndex] = AssertedCast<uint8_t>(val); + destIndex += 1; + } + } + } +} + +//////////////////////////////////////////////////////////////////////////////// + +void WebGLContext::UseProgram(WebGLProgram* prog) { + FuncScope funcScope(*this, "useProgram"); + if (IsContextLost()) return; + funcScope.mBindFailureGuard = true; + + if (!prog) { + mCurrentProgram = nullptr; + mActiveProgramLinkInfo = nullptr; + funcScope.mBindFailureGuard = false; + return; + } + + if (!ValidateObject("prog", *prog)) return; + + if (!prog->UseProgram()) return; + + mCurrentProgram = prog; + mActiveProgramLinkInfo = mCurrentProgram->LinkInfo(); + + funcScope.mBindFailureGuard = false; +} + +bool WebGLContext::ValidateProgram(const WebGLProgram& prog) const { + const FuncScope funcScope(*this, "validateProgram"); + if (IsContextLost()) return false; + + return prog.ValidateProgram(); +} + +RefPtr<WebGLFramebuffer> WebGLContext::CreateFramebuffer() { + const FuncScope funcScope(*this, "createFramebuffer"); + if (IsContextLost()) return nullptr; + + GLuint fbo = 0; + gl->fGenFramebuffers(1, &fbo); + + return new WebGLFramebuffer(this, fbo); +} + +RefPtr<WebGLFramebuffer> WebGLContext::CreateOpaqueFramebuffer( + const webgl::OpaqueFramebufferOptions& options) { + const FuncScope funcScope(*this, "createOpaqueFramebuffer"); + if (IsContextLost()) return nullptr; + + uint32_t samples = options.antialias ? StaticPrefs::webgl_msaa_samples() : 0; + samples = std::min(samples, gl->MaxSamples()); + const gfx::IntSize size = {options.width, options.height}; + + auto fbo = + gl::MozFramebuffer::Create(gl, size, samples, options.depthStencil); + if (!fbo) { + return nullptr; + } + + return new WebGLFramebuffer(this, std::move(fbo)); +} + +RefPtr<WebGLRenderbuffer> WebGLContext::CreateRenderbuffer() { + const FuncScope funcScope(*this, "createRenderbuffer"); + if (IsContextLost()) return nullptr; + + return new WebGLRenderbuffer(this); +} + +void WebGLContext::Viewport(GLint x, GLint y, GLsizei width, GLsizei height) { + const FuncScope funcScope(*this, "viewport"); + if (IsContextLost()) return; + + if (!ValidateNonNegative("width", width) || + !ValidateNonNegative("height", height)) { + return; + } + + const auto& limits = Limits(); + width = std::min(width, static_cast<GLsizei>(limits.maxViewportDim)); + height = std::min(height, static_cast<GLsizei>(limits.maxViewportDim)); + + gl->fViewport(x, y, width, height); + + mViewportX = x; + mViewportY = y; + mViewportWidth = width; + mViewportHeight = height; +} + +void WebGLContext::CompileShader(WebGLShader& shader) { + const FuncScope funcScope(*this, "compileShader"); + if (IsContextLost()) return; + + if (!ValidateObject("shader", shader)) return; + + shader.CompileShader(); +} + +Maybe<webgl::ShaderPrecisionFormat> WebGLContext::GetShaderPrecisionFormat( + GLenum shadertype, GLenum precisiontype) const { + const FuncScope funcScope(*this, "getShaderPrecisionFormat"); + if (IsContextLost()) return Nothing(); + + switch (shadertype) { + case LOCAL_GL_FRAGMENT_SHADER: + case LOCAL_GL_VERTEX_SHADER: + break; + default: + ErrorInvalidEnumInfo("shadertype", shadertype); + return Nothing(); + } + + switch (precisiontype) { + case LOCAL_GL_LOW_FLOAT: + case LOCAL_GL_MEDIUM_FLOAT: + case LOCAL_GL_HIGH_FLOAT: + case LOCAL_GL_LOW_INT: + case LOCAL_GL_MEDIUM_INT: + case LOCAL_GL_HIGH_INT: + break; + default: + ErrorInvalidEnumInfo("precisiontype", precisiontype); + return Nothing(); + } + + GLint range[2], precision; + + if (mDisableFragHighP && shadertype == LOCAL_GL_FRAGMENT_SHADER && + (precisiontype == LOCAL_GL_HIGH_FLOAT || + precisiontype == LOCAL_GL_HIGH_INT)) { + precision = 0; + range[0] = 0; + range[1] = 0; + } else { + gl->fGetShaderPrecisionFormat(shadertype, precisiontype, range, &precision); + } + + return Some(webgl::ShaderPrecisionFormat{range[0], range[1], precision}); +} + +void WebGLContext::ShaderSource(WebGLShader& shader, + const std::string& source) const { + const FuncScope funcScope(*this, "shaderSource"); + if (IsContextLost()) return; + + shader.ShaderSource(source); +} + +void WebGLContext::BlendColor(GLfloat r, GLfloat g, GLfloat b, GLfloat a) { + const FuncScope funcScope(*this, "blendColor"); + if (IsContextLost()) return; + + gl->fBlendColor(r, g, b, a); +} + +void WebGLContext::Flush() { + const FuncScope funcScope(*this, "flush"); + if (IsContextLost()) return; + + gl->fFlush(); +} + +void WebGLContext::Finish() { + const FuncScope funcScope(*this, "finish"); + if (IsContextLost()) return; + + gl->fFinish(); + + mCompletedFenceId = mNextFenceId; + mNextFenceId += 1; +} + +void WebGLContext::LineWidth(GLfloat width) { + const FuncScope funcScope(*this, "lineWidth"); + if (IsContextLost()) return; + + // Doing it this way instead of `if (width <= 0.0)` handles NaNs. + const bool isValid = width > 0.0; + if (!isValid) { + ErrorInvalidValue("`width` must be positive and non-zero."); + return; + } + + mLineWidth = width; + + if (gl->IsCoreProfile() && width > 1.0) { + width = 1.0; + } + + gl->fLineWidth(width); +} + +void WebGLContext::PolygonOffset(GLfloat factor, GLfloat units) { + const FuncScope funcScope(*this, "polygonOffset"); + if (IsContextLost()) return; + + gl->fPolygonOffset(factor, units); +} + +void WebGLContext::ProvokingVertex(const webgl::ProvokingVertex mode) const { + const FuncScope funcScope(*this, "provokingVertex"); + if (IsContextLost()) return; + MOZ_RELEASE_ASSERT( + IsExtensionEnabled(WebGLExtensionID::WEBGL_provoking_vertex)); + + gl->fProvokingVertex(UnderlyingValue(mode)); +} + +void WebGLContext::SampleCoverage(GLclampf value, WebGLboolean invert) { + const FuncScope funcScope(*this, "sampleCoverage"); + if (IsContextLost()) return; + + gl->fSampleCoverage(value, invert); +} + +} // namespace mozilla |