summaryrefslogtreecommitdiffstats
path: root/dom/canvas/WebGLContextGL.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/canvas/WebGLContextGL.cpp')
-rw-r--r--dom/canvas/WebGLContextGL.cpp2367
1 files changed, 2367 insertions, 0 deletions
diff --git a/dom/canvas/WebGLContextGL.cpp b/dom/canvas/WebGLContextGL.cpp
new file mode 100644
index 000000000..e58fcd0d8
--- /dev/null
+++ b/dom/canvas/WebGLContextGL.cpp
@@ -0,0 +1,2367 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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 "WebGLActiveInfo.h"
+#include "WebGLContextUtils.h"
+#include "WebGLBuffer.h"
+#include "WebGLVertexAttribData.h"
+#include "WebGLShader.h"
+#include "WebGLProgram.h"
+#include "WebGLUniformLocation.h"
+#include "WebGLFormats.h"
+#include "WebGLFramebuffer.h"
+#include "WebGLRenderbuffer.h"
+#include "WebGLShaderPrecisionFormat.h"
+#include "WebGLTexture.h"
+#include "WebGLExtensions.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 "jsfriendapi.h"
+
+#include "WebGLTexelConversions.h"
+#include "WebGLValidateStrings.h"
+#include <algorithm>
+
+// needed to check if current OS is lower than 10.7
+#if defined(MOZ_WIDGET_COCOA)
+#include "nsCocoaFeatures.h"
+#endif
+
+#include "mozilla/DebugOnly.h"
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/ImageData.h"
+#include "mozilla/dom/ToJSValue.h"
+#include "mozilla/EndianUtils.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/UniquePtrExtensions.h"
+
+namespace mozilla {
+
+bool
+WebGLContext::ValidateObject(const char* funcName, const WebGLProgram& object)
+{
+ return ValidateObject(funcName, object, true);
+}
+
+bool
+WebGLContext::ValidateObject(const char* funcName, const WebGLShader& object)
+{
+ return ValidateObject(funcName, object, true);
+}
+
+using namespace mozilla::dom;
+using namespace mozilla::gfx;
+using namespace mozilla::gl;
+
+//
+// WebGL API
+//
+
+void
+WebGLContext::ActiveTexture(GLenum texture)
+{
+ if (IsContextLost())
+ return;
+
+ if (texture < LOCAL_GL_TEXTURE0 ||
+ texture >= LOCAL_GL_TEXTURE0 + uint32_t(mGLMaxTextureUnits))
+ {
+ return ErrorInvalidEnum(
+ "ActiveTexture: texture unit %d out of range. "
+ "Accepted values range from TEXTURE0 to TEXTURE0 + %d. "
+ "Notice that TEXTURE0 != 0.",
+ texture, mGLMaxTextureUnits);
+ }
+
+ MakeContextCurrent();
+ mActiveTexture = texture - LOCAL_GL_TEXTURE0;
+ gl->fActiveTexture(texture);
+}
+
+void
+WebGLContext::AttachShader(WebGLProgram& program, WebGLShader& shader)
+{
+ if (IsContextLost())
+ return;
+
+ if (!ValidateObject("attachShader: program", program) ||
+ !ValidateObject("attachShader: shader", shader))
+ {
+ return;
+ }
+
+ program.AttachShader(&shader);
+}
+
+void
+WebGLContext::BindAttribLocation(WebGLProgram& prog, GLuint location,
+ const nsAString& name)
+{
+ if (IsContextLost())
+ return;
+
+ if (!ValidateObject("bindAttribLocation: program", prog))
+ return;
+
+ prog.BindAttribLocation(location, name);
+}
+
+void
+WebGLContext::BindFramebuffer(GLenum target, WebGLFramebuffer* wfb)
+{
+ if (IsContextLost())
+ return;
+
+ if (!ValidateFramebufferTarget(target, "bindFramebuffer"))
+ return;
+
+ if (wfb && !ValidateObject("bindFramebuffer", *wfb))
+ return;
+
+ MakeContextCurrent();
+
+ if (!wfb) {
+ gl->fBindFramebuffer(target, 0);
+ } else {
+ GLuint framebuffername = wfb->mGLName;
+ gl->fBindFramebuffer(target, framebuffername);
+#ifdef ANDROID
+ wfb->mIsFB = true;
+#endif
+ }
+
+ 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:
+ break;
+ }
+}
+
+void
+WebGLContext::BindRenderbuffer(GLenum target, WebGLRenderbuffer* wrb)
+{
+ if (IsContextLost())
+ return;
+
+ if (target != LOCAL_GL_RENDERBUFFER)
+ return ErrorInvalidEnumInfo("bindRenderbuffer: target", target);
+
+ if (wrb && !ValidateObject("bindRenderbuffer", *wrb))
+ return;
+
+ // Usually, we would now call into glBindRenderbuffer. However, since we have to
+ // potentially emulate packed-depth-stencil, there's not a specific renderbuffer that
+ // we know we should bind here.
+ // Instead, we do all renderbuffer binding lazily.
+
+ if (wrb) {
+ wrb->mHasBeenBound = true;
+ }
+
+ mBoundRenderbuffer = wrb;
+}
+
+void WebGLContext::BlendEquation(GLenum mode)
+{
+ if (IsContextLost())
+ return;
+
+ if (!ValidateBlendEquationEnum(mode, "blendEquation: mode"))
+ return;
+
+ MakeContextCurrent();
+ gl->fBlendEquation(mode);
+}
+
+void WebGLContext::BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
+{
+ if (IsContextLost())
+ return;
+
+ if (!ValidateBlendEquationEnum(modeRGB, "blendEquationSeparate: modeRGB") ||
+ !ValidateBlendEquationEnum(modeAlpha, "blendEquationSeparate: modeAlpha"))
+ return;
+
+ MakeContextCurrent();
+ gl->fBlendEquationSeparate(modeRGB, modeAlpha);
+}
+
+void WebGLContext::BlendFunc(GLenum sfactor, GLenum dfactor)
+{
+ if (IsContextLost())
+ return;
+
+ if (!ValidateBlendFuncSrcEnum(sfactor, "blendFunc: sfactor") ||
+ !ValidateBlendFuncDstEnum(dfactor, "blendFunc: dfactor"))
+ return;
+
+ if (!ValidateBlendFuncEnumsCompatibility(sfactor, dfactor, "blendFuncSeparate: srcRGB and dstRGB"))
+ return;
+
+ MakeContextCurrent();
+ gl->fBlendFunc(sfactor, dfactor);
+}
+
+void
+WebGLContext::BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB,
+ GLenum srcAlpha, GLenum dstAlpha)
+{
+ if (IsContextLost())
+ return;
+
+ if (!ValidateBlendFuncSrcEnum(srcRGB, "blendFuncSeparate: srcRGB") ||
+ !ValidateBlendFuncSrcEnum(srcAlpha, "blendFuncSeparate: srcAlpha") ||
+ !ValidateBlendFuncDstEnum(dstRGB, "blendFuncSeparate: dstRGB") ||
+ !ValidateBlendFuncDstEnum(dstAlpha, "blendFuncSeparate: 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, "blendFuncSeparate: srcRGB and dstRGB"))
+ return;
+
+ MakeContextCurrent();
+ gl->fBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
+}
+
+GLenum
+WebGLContext::CheckFramebufferStatus(GLenum target)
+{
+ const char funcName[] = "checkFramebufferStatus";
+ if (IsContextLost())
+ return LOCAL_GL_FRAMEBUFFER_UNSUPPORTED;
+
+ if (!ValidateFramebufferTarget(target, funcName))
+ 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(funcName).get();
+}
+
+already_AddRefed<WebGLProgram>
+WebGLContext::CreateProgram()
+{
+ if (IsContextLost())
+ return nullptr;
+ RefPtr<WebGLProgram> globj = new WebGLProgram(this);
+ return globj.forget();
+}
+
+already_AddRefed<WebGLShader>
+WebGLContext::CreateShader(GLenum type)
+{
+ if (IsContextLost())
+ return nullptr;
+
+ if (type != LOCAL_GL_VERTEX_SHADER &&
+ type != LOCAL_GL_FRAGMENT_SHADER)
+ {
+ ErrorInvalidEnumInfo("createShader: type", type);
+ return nullptr;
+ }
+
+ RefPtr<WebGLShader> shader = new WebGLShader(this, type);
+ return shader.forget();
+}
+
+void
+WebGLContext::CullFace(GLenum face)
+{
+ if (IsContextLost())
+ return;
+
+ if (!ValidateFaceEnum(face, "cullFace"))
+ return;
+
+ MakeContextCurrent();
+ gl->fCullFace(face);
+}
+
+void
+WebGLContext::DeleteFramebuffer(WebGLFramebuffer* fbuf)
+{
+ if (!ValidateDeleteObject("deleteFramebuffer", fbuf))
+ return;
+
+ fbuf->RequestDelete();
+
+ if (mBoundReadFramebuffer == mBoundDrawFramebuffer) {
+ if (mBoundDrawFramebuffer == fbuf) {
+ BindFramebuffer(LOCAL_GL_FRAMEBUFFER,
+ static_cast<WebGLFramebuffer*>(nullptr));
+ }
+ } else if (mBoundDrawFramebuffer == fbuf) {
+ BindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER,
+ static_cast<WebGLFramebuffer*>(nullptr));
+ } else if (mBoundReadFramebuffer == fbuf) {
+ BindFramebuffer(LOCAL_GL_READ_FRAMEBUFFER,
+ static_cast<WebGLFramebuffer*>(nullptr));
+ }
+}
+
+void
+WebGLContext::DeleteRenderbuffer(WebGLRenderbuffer* rbuf)
+{
+ if (!ValidateDeleteObject("deleteRenderbuffer", rbuf))
+ return;
+
+ if (mBoundDrawFramebuffer)
+ mBoundDrawFramebuffer->DetachRenderbuffer(rbuf);
+
+ if (mBoundReadFramebuffer)
+ mBoundReadFramebuffer->DetachRenderbuffer(rbuf);
+
+ rbuf->InvalidateStatusOfAttachedFBs();
+
+ if (mBoundRenderbuffer == rbuf)
+ BindRenderbuffer(LOCAL_GL_RENDERBUFFER, nullptr);
+
+ rbuf->RequestDelete();
+}
+
+void
+WebGLContext::DeleteTexture(WebGLTexture* tex)
+{
+ if (!ValidateDeleteObject("deleteTexture", tex))
+ return;
+
+ if (mBoundDrawFramebuffer)
+ mBoundDrawFramebuffer->DetachTexture(tex);
+
+ if (mBoundReadFramebuffer)
+ mBoundReadFramebuffer->DetachTexture(tex);
+
+ GLuint activeTexture = mActiveTexture;
+ for (int32_t i = 0; i < mGLMaxTextureUnits; i++) {
+ if (mBound2DTextures[i] == tex ||
+ mBoundCubeMapTextures[i] == tex ||
+ mBound3DTextures[i] == tex ||
+ mBound2DArrayTextures[i] == tex)
+ {
+ ActiveTexture(LOCAL_GL_TEXTURE0 + i);
+ BindTexture(tex->Target().get(), nullptr);
+ }
+ }
+ ActiveTexture(LOCAL_GL_TEXTURE0 + activeTexture);
+
+ tex->RequestDelete();
+}
+
+void
+WebGLContext::DeleteProgram(WebGLProgram* prog)
+{
+ if (!ValidateDeleteObject("deleteProgram", prog))
+ return;
+
+ prog->RequestDelete();
+}
+
+void
+WebGLContext::DeleteShader(WebGLShader* shader)
+{
+ if (!ValidateDeleteObject("deleteShader", shader))
+ return;
+
+ shader->RequestDelete();
+}
+
+void
+WebGLContext::DetachShader(WebGLProgram& program, const WebGLShader& shader)
+{
+ if (IsContextLost())
+ return;
+
+ // It's valid to attempt to detach a deleted shader, since it's still a
+ // shader.
+ if (!ValidateObject("detachShader: program", program) ||
+ !ValidateObjectAllowDeleted("detachShader: shader", shader))
+ {
+ return;
+ }
+
+ program.DetachShader(&shader);
+}
+
+void
+WebGLContext::DepthFunc(GLenum func)
+{
+ if (IsContextLost())
+ return;
+
+ if (!ValidateComparisonEnum(func, "depthFunc"))
+ return;
+
+ MakeContextCurrent();
+ gl->fDepthFunc(func);
+}
+
+void
+WebGLContext::DepthRange(GLfloat zNear, GLfloat zFar)
+{
+ if (IsContextLost())
+ return;
+
+ if (zNear > zFar)
+ return ErrorInvalidOperation("depthRange: the near value is greater than the far value!");
+
+ MakeContextCurrent();
+ gl->fDepthRange(zNear, zFar);
+}
+
+void
+WebGLContext::FramebufferRenderbuffer(GLenum target, GLenum attachment,
+ GLenum rbtarget, WebGLRenderbuffer* wrb)
+{
+ const char funcName[] = "framebufferRenderbuffer";
+ if (IsContextLost())
+ return;
+
+ if (!ValidateFramebufferTarget(target, funcName))
+ return;
+
+ 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 ErrorInvalidOperation("%s: Cannot modify framebuffer 0.", funcName);
+
+ fb->FramebufferRenderbuffer(funcName, attachment, rbtarget, wrb);
+}
+
+void
+WebGLContext::FramebufferTexture2D(GLenum target,
+ GLenum attachment,
+ GLenum textarget,
+ WebGLTexture* tobj,
+ GLint level)
+{
+ const char funcName[] = "framebufferTexture2D";
+ if (IsContextLost())
+ return;
+
+ if (!ValidateFramebufferTarget(target, funcName))
+ return;
+
+ 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 ErrorInvalidOperation("%s: Cannot modify framebuffer 0.", funcName);
+
+ fb->FramebufferTexture2D(funcName, attachment, textarget, tobj, level);
+}
+
+void
+WebGLContext::FrontFace(GLenum mode)
+{
+ if (IsContextLost())
+ return;
+
+ switch (mode) {
+ case LOCAL_GL_CW:
+ case LOCAL_GL_CCW:
+ break;
+ default:
+ return ErrorInvalidEnumInfo("frontFace: mode", mode);
+ }
+
+ MakeContextCurrent();
+ gl->fFrontFace(mode);
+}
+
+already_AddRefed<WebGLActiveInfo>
+WebGLContext::GetActiveAttrib(const WebGLProgram& prog, GLuint index)
+{
+ if (IsContextLost())
+ return nullptr;
+
+ if (!ValidateObject("getActiveAttrib: program", prog))
+ return nullptr;
+
+ return prog.GetActiveAttrib(index);
+}
+
+already_AddRefed<WebGLActiveInfo>
+WebGLContext::GetActiveUniform(const WebGLProgram& prog, GLuint index)
+{
+ if (IsContextLost())
+ return nullptr;
+
+ if (!ValidateObject("getActiveUniform: program", prog))
+ return nullptr;
+
+ return prog.GetActiveUniform(index);
+}
+
+void
+WebGLContext::GetAttachedShaders(const WebGLProgram& prog,
+ dom::Nullable<nsTArray<RefPtr<WebGLShader>>>& retval)
+{
+ retval.SetNull();
+ if (IsContextLost())
+ return;
+
+ if (!ValidateObject("getAttachedShaders", prog))
+ return;
+
+ prog.GetAttachedShaders(&retval.SetValue());
+}
+
+GLint
+WebGLContext::GetAttribLocation(const WebGLProgram& prog, const nsAString& name)
+{
+ if (IsContextLost())
+ return -1;
+
+ if (!ValidateObject("getAttribLocation: program", prog))
+ return -1;
+
+ return prog.GetAttribLocation(name);
+}
+
+JS::Value
+WebGLContext::GetBufferParameter(GLenum target, GLenum pname)
+{
+ const char funcName[] = "getBufferParameter";
+ if (IsContextLost())
+ return JS::NullValue();
+
+ const auto& slot = ValidateBufferSlot(funcName, target);
+ if (!slot)
+ return JS::NullValue();
+ const auto& buffer = *slot;
+
+ if (!buffer) {
+ ErrorInvalidOperation("%s: Buffer for `target` is null.", funcName);
+ return JS::NullValue();
+ }
+
+ switch (pname) {
+ case LOCAL_GL_BUFFER_SIZE:
+ return JS::NumberValue(buffer->ByteLength());
+
+ case LOCAL_GL_BUFFER_USAGE:
+ return JS::NumberValue(buffer->Usage());
+
+ default:
+ ErrorInvalidEnumInfo("getBufferParameter: parameter", pname);
+ return JS::NullValue();
+ }
+}
+
+JS::Value
+WebGLContext::GetFramebufferAttachmentParameter(JSContext* cx,
+ GLenum target,
+ GLenum attachment,
+ GLenum pname,
+ ErrorResult& rv)
+{
+ const char funcName[] = "getFramebufferAttachmentParameter";
+
+ if (IsContextLost())
+ return JS::NullValue();
+
+ if (!ValidateFramebufferTarget(target, funcName))
+ return JS::NullValue();
+
+ 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.");
+ }
+
+ MakeContextCurrent();
+
+ if (fb)
+ return fb->GetAttachmentParameter(funcName, cx, target, attachment, pname, &rv);
+
+ ////////////////////////////////////
+
+ if (!IsWebGL2()) {
+ ErrorInvalidOperation("%s: Querying against the default framebuffer is not"
+ " allowed in WebGL 1.",
+ funcName);
+ return JS::NullValue();
+ }
+
+ switch (attachment) {
+ case LOCAL_GL_BACK:
+ case LOCAL_GL_DEPTH:
+ case LOCAL_GL_STENCIL:
+ break;
+
+ default:
+ ErrorInvalidEnum("%s: For the default framebuffer, can only query COLOR, DEPTH,"
+ " or STENCIL.",
+ funcName);
+ return JS::NullValue();
+ }
+
+ switch (pname) {
+ case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
+ switch (attachment) {
+ case LOCAL_GL_BACK:
+ break;
+ case LOCAL_GL_DEPTH:
+ if (!mOptions.depth) {
+ return JS::Int32Value(LOCAL_GL_NONE);
+ }
+ break;
+ case LOCAL_GL_STENCIL:
+ if (!mOptions.stencil) {
+ return JS::Int32Value(LOCAL_GL_NONE);
+ }
+ break;
+ default:
+ ErrorInvalidEnum("%s: With the default framebuffer, can only query COLOR, DEPTH,"
+ " or STENCIL for GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE",
+ funcName);
+ return JS::NullValue();
+ }
+ return JS::Int32Value(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 JS::NumberValue(8);
+ return JS::NumberValue(0);
+
+ case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
+ if (attachment == LOCAL_GL_BACK) {
+ if (mOptions.alpha) {
+ return JS::NumberValue(8);
+ }
+ ErrorInvalidOperation("The default framebuffer doesn't contain an alpha buffer");
+ return JS::NullValue();
+ }
+ return JS::NumberValue(0);
+
+ case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
+ if (attachment == LOCAL_GL_DEPTH) {
+ if (mOptions.depth) {
+ return JS::NumberValue(24);
+ }
+ ErrorInvalidOperation("The default framebuffer doesn't contain an depth buffer");
+ return JS::NullValue();
+ }
+ return JS::NumberValue(0);
+
+ case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
+ if (attachment == LOCAL_GL_STENCIL) {
+ if (mOptions.stencil) {
+ return JS::NumberValue(8);
+ }
+ ErrorInvalidOperation("The default framebuffer doesn't contain an stencil buffer");
+ return JS::NullValue();
+ }
+ return JS::NumberValue(0);
+
+ case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
+ if (attachment == LOCAL_GL_STENCIL) {
+ if (mOptions.stencil) {
+ return JS::NumberValue(LOCAL_GL_UNSIGNED_INT);
+ }
+ ErrorInvalidOperation("The default framebuffer doesn't contain an stencil buffer");
+ } else if (attachment == LOCAL_GL_DEPTH) {
+ if (mOptions.depth) {
+ return JS::NumberValue(LOCAL_GL_UNSIGNED_NORMALIZED);
+ }
+ ErrorInvalidOperation("The default framebuffer doesn't contain an depth buffer");
+ } else { // LOCAL_GL_BACK
+ return JS::NumberValue(LOCAL_GL_UNSIGNED_NORMALIZED);
+ }
+ return JS::NullValue();
+
+ 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 JS::NullValue();
+ }
+ } else if (attachment == LOCAL_GL_DEPTH) {
+ if (!mOptions.depth) {
+ ErrorInvalidOperation("The default framebuffer doesn't contain an depth buffer");
+ return JS::NullValue();
+ }
+ }
+ return JS::NumberValue(LOCAL_GL_LINEAR);
+ }
+
+ ErrorInvalidEnum("%s: Invalid pname: 0x%04x", funcName, pname);
+ return JS::NullValue();
+}
+
+JS::Value
+WebGLContext::GetRenderbufferParameter(GLenum target, GLenum pname)
+{
+ if (IsContextLost())
+ return JS::NullValue();
+
+ if (target != LOCAL_GL_RENDERBUFFER) {
+ ErrorInvalidEnumInfo("getRenderbufferParameter: target", target);
+ return JS::NullValue();
+ }
+
+ if (!mBoundRenderbuffer) {
+ ErrorInvalidOperation("getRenderbufferParameter: no render buffer is bound");
+ return JS::NullValue();
+ }
+
+ MakeContextCurrent();
+
+ switch (pname) {
+ case LOCAL_GL_RENDERBUFFER_SAMPLES:
+ if (!IsWebGL2())
+ break;
+ MOZ_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 = mBoundRenderbuffer->GetRenderbufferParameter(target, pname);
+ return JS::Int32Value(i);
+ }
+
+ default:
+ break;
+ }
+
+ ErrorInvalidEnumInfo("getRenderbufferParameter: parameter", pname);
+ return JS::NullValue();
+}
+
+already_AddRefed<WebGLTexture>
+WebGLContext::CreateTexture()
+{
+ if (IsContextLost())
+ return nullptr;
+
+ GLuint tex = 0;
+ MakeContextCurrent();
+ gl->fGenTextures(1, &tex);
+
+ RefPtr<WebGLTexture> globj = new WebGLTexture(this, tex);
+ return globj.forget();
+}
+
+static GLenum
+GetAndClearError(GLenum* errorVar)
+{
+ MOZ_ASSERT(errorVar);
+ GLenum ret = *errorVar;
+ *errorVar = LOCAL_GL_NO_ERROR;
+ return ret;
+}
+
+GLenum
+WebGLContext::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.
+ */
+
+ if (IsContextLost()) {
+ if (mEmitContextLostErrorOnce) {
+ mEmitContextLostErrorOnce = false;
+ return LOCAL_GL_CONTEXT_LOST;
+ }
+ // Don't return yet, since WEBGL_lose_contexts contradicts the
+ // original spec, and allows error generation while lost.
+ }
+
+ GLenum err = GetAndClearError(&mWebGLError);
+ if (err != LOCAL_GL_NO_ERROR)
+ return err;
+
+ if (IsContextLost())
+ return LOCAL_GL_NO_ERROR;
+
+ // Either no WebGL-side error, or it's already been cleared.
+ // UnderlyingGL-side errors, now.
+
+ MakeContextCurrent();
+ GetAndFlushUnderlyingGLErrors();
+
+ err = GetAndClearError(&mUnderlyingGLError);
+ return err;
+}
+
+JS::Value
+WebGLContext::GetProgramParameter(const WebGLProgram& prog, GLenum pname)
+{
+ if (IsContextLost())
+ return JS::NullValue();
+
+ if (!ValidateObjectAllowDeleted("getProgramParameter: program", prog))
+ return JS::NullValue();
+
+ return prog.GetProgramParameter(pname);
+}
+
+void
+WebGLContext::GetProgramInfoLog(const WebGLProgram& prog, nsAString& retval)
+{
+ retval.SetIsVoid(true);
+
+ if (IsContextLost())
+ return;
+
+ if (!ValidateObject("getProgramInfoLog: program", prog))
+ return;
+
+ prog.GetProgramInfoLog(&retval);
+}
+
+JS::Value
+WebGLContext::GetUniform(JSContext* js, const WebGLProgram& prog,
+ const WebGLUniformLocation& loc)
+{
+ if (IsContextLost())
+ return JS::NullValue();
+
+ if (!ValidateObject("getUniform: `program`", prog))
+ return JS::NullValue();
+
+ if (!ValidateObjectAllowDeleted("getUniform: `location`", loc))
+ return JS::NullValue();
+
+ if (!loc.ValidateForProgram(&prog, "getUniform"))
+ return JS::NullValue();
+
+ return loc.GetUniform(js);
+}
+
+already_AddRefed<WebGLUniformLocation>
+WebGLContext::GetUniformLocation(const WebGLProgram& prog, const nsAString& name)
+{
+ if (IsContextLost())
+ return nullptr;
+
+ if (!ValidateObject("getUniformLocation: program", prog))
+ return nullptr;
+
+ return prog.GetUniformLocation(name);
+}
+
+void
+WebGLContext::Hint(GLenum target, GLenum mode)
+{
+ if (IsContextLost())
+ return;
+
+ bool isValid = false;
+
+ switch (target) {
+ case LOCAL_GL_GENERATE_MIPMAP_HINT:
+ mGenerateMipmapHint = mode;
+
+ // Deprecated and removed in desktop GL Core profiles.
+ if (gl->IsCoreProfile())
+ return;
+
+ isValid = true;
+ break;
+
+ case LOCAL_GL_FRAGMENT_SHADER_DERIVATIVE_HINT:
+ if (IsWebGL2() ||
+ IsExtensionEnabled(WebGLExtensionID::OES_standard_derivatives))
+ {
+ isValid = true;
+ }
+ break;
+ }
+
+ if (!isValid)
+ return ErrorInvalidEnum("hint: invalid hint");
+
+ MakeContextCurrent();
+ gl->fHint(target, mode);
+}
+
+bool
+WebGLContext::IsFramebuffer(const WebGLFramebuffer* fb)
+{
+ if (!ValidateIsObject("isFramebuffer", fb))
+ return false;
+
+#ifdef ANDROID
+ if (gl->WorkAroundDriverBugs() &&
+ gl->Renderer() == GLRenderer::AndroidEmulator)
+ {
+ return fb->mIsFB;
+ }
+#endif
+
+ MakeContextCurrent();
+ return gl->fIsFramebuffer(fb->mGLName);
+}
+
+bool
+WebGLContext::IsProgram(const WebGLProgram* prog)
+{
+ if (!ValidateIsObject("isProgram", prog))
+ return false;
+
+ return true;
+}
+
+bool
+WebGLContext::IsRenderbuffer(const WebGLRenderbuffer* rb)
+{
+ if (!ValidateIsObject("isRenderbuffer", rb))
+ return false;
+
+ return rb->mHasBeenBound;
+}
+
+bool
+WebGLContext::IsShader(const WebGLShader* shader)
+{
+ if (!ValidateIsObject("isShader", shader))
+ return false;
+
+ return true;
+}
+
+void
+WebGLContext::LinkProgram(WebGLProgram& prog)
+{
+ if (IsContextLost())
+ return;
+
+ if (!ValidateObject("linkProgram", prog))
+ return;
+
+ prog.LinkProgram();
+
+ if (!prog.IsLinked()) {
+ // If we failed to link, but `prog == mCurrentProgram`, we are *not* supposed to
+ // null out mActiveProgramLinkInfo.
+ return;
+ }
+
+ if (&prog == mCurrentProgram) {
+ mActiveProgramLinkInfo = prog.LinkInfo();
+
+ if (gl->WorkAroundDriverBugs() &&
+ gl->Vendor() == gl::GLVendor::NVIDIA)
+ {
+ gl->fUseProgram(prog.mGLName);
+ }
+ }
+}
+
+void
+WebGLContext::PixelStorei(GLenum pname, GLint param)
+{
+ if (IsContextLost())
+ return;
+
+ if (IsWebGL2()) {
+ uint32_t* pValueSlot = nullptr;
+ switch (pname) {
+ case LOCAL_GL_UNPACK_IMAGE_HEIGHT:
+ pValueSlot = &mPixelStore_UnpackImageHeight;
+ break;
+
+ case LOCAL_GL_UNPACK_SKIP_IMAGES:
+ pValueSlot = &mPixelStore_UnpackSkipImages;
+ break;
+
+ case LOCAL_GL_UNPACK_ROW_LENGTH:
+ pValueSlot = &mPixelStore_UnpackRowLength;
+ break;
+
+ case LOCAL_GL_UNPACK_SKIP_ROWS:
+ pValueSlot = &mPixelStore_UnpackSkipRows;
+ break;
+
+ case LOCAL_GL_UNPACK_SKIP_PIXELS:
+ pValueSlot = &mPixelStore_UnpackSkipPixels;
+ break;
+
+ case LOCAL_GL_PACK_ROW_LENGTH:
+ pValueSlot = &mPixelStore_PackRowLength;
+ break;
+
+ case LOCAL_GL_PACK_SKIP_ROWS:
+ pValueSlot = &mPixelStore_PackSkipRows;
+ break;
+
+ case LOCAL_GL_PACK_SKIP_PIXELS:
+ pValueSlot = &mPixelStore_PackSkipPixels;
+ break;
+ }
+
+ if (pValueSlot) {
+ if (param < 0) {
+ ErrorInvalidValue("pixelStorei: param must be >= 0.");
+ return;
+ }
+
+ MakeContextCurrent();
+ gl->fPixelStorei(pname, param);
+ *pValueSlot = param;
+ return;
+ }
+ }
+
+ switch (pname) {
+ case UNPACK_FLIP_Y_WEBGL:
+ mPixelStore_FlipY = bool(param);
+ return;
+
+ case UNPACK_PREMULTIPLY_ALPHA_WEBGL:
+ mPixelStore_PremultiplyAlpha = bool(param);
+ return;
+
+ case UNPACK_COLORSPACE_CONVERSION_WEBGL:
+ switch (param) {
+ case LOCAL_GL_NONE:
+ case BROWSER_DEFAULT_WEBGL:
+ mPixelStore_ColorspaceConversion = param;
+ return;
+
+ default:
+ ErrorInvalidEnumInfo("pixelStorei: colorspace conversion parameter",
+ param);
+ return;
+ }
+
+ case LOCAL_GL_PACK_ALIGNMENT:
+ case LOCAL_GL_UNPACK_ALIGNMENT:
+ switch (param) {
+ case 1:
+ case 2:
+ case 4:
+ case 8:
+ if (pname == LOCAL_GL_PACK_ALIGNMENT)
+ mPixelStore_PackAlignment = param;
+ else if (pname == LOCAL_GL_UNPACK_ALIGNMENT)
+ mPixelStore_UnpackAlignment = param;
+
+ MakeContextCurrent();
+ gl->fPixelStorei(pname, param);
+ return;
+
+ default:
+ ErrorInvalidValue("pixelStorei: invalid pack/unpack alignment value");
+ return;
+ }
+
+
+
+ default:
+ break;
+ }
+
+ ErrorInvalidEnumInfo("pixelStorei: parameter", pname);
+}
+
+bool
+WebGLContext::DoReadPixelsAndConvert(const webgl::FormatInfo* srcFormat, GLint x, GLint y,
+ GLsizei width, GLsizei height, GLenum format,
+ GLenum destType, void* dest, uint32_t destSize,
+ uint32_t rowStride)
+{
+ // 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 = CheckedUint32(rowStride) * height;
+ const bool isDangerCloseToEdge = (!naiveBytesNeeded.isValid() ||
+ naiveBytesNeeded.value() > destSize);
+ const bool useParanoidHandling = (gl->WorkAroundDriverBugs() &&
+ isDangerCloseToEdge &&
+ mBoundPixelPackBuffer);
+ if (!useParanoidHandling) {
+ gl->fReadPixels(x, y, width, height, format, destType, dest);
+ return true;
+ }
+
+ // Read everything but the last row.
+ const auto bodyHeight = height - 1;
+ if (bodyHeight) {
+ gl->fReadPixels(x, y, width, bodyHeight, format, destType, 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 = (char*)dest + rowStride * bodyHeight;
+ gl->fReadPixels(x, y+bodyHeight, width, 1, format, destType, tailRowOffset);
+
+ gl->fPixelStorei(LOCAL_GL_PACK_ALIGNMENT, mPixelStore_PackAlignment);
+ gl->fPixelStorei(LOCAL_GL_PACK_ROW_LENGTH, mPixelStore_PackRowLength);
+ gl->fPixelStorei(LOCAL_GL_PACK_SKIP_ROWS, mPixelStore_PackSkipRows);
+ return true;
+}
+
+static bool
+GetJSScalarFromGLType(GLenum type, js::Scalar::Type* const out_scalarType)
+{
+ switch (type) {
+ case LOCAL_GL_BYTE:
+ *out_scalarType = js::Scalar::Int8;
+ return true;
+
+ case LOCAL_GL_UNSIGNED_BYTE:
+ *out_scalarType = js::Scalar::Uint8;
+ return true;
+
+ case LOCAL_GL_SHORT:
+ *out_scalarType = js::Scalar::Int16;
+ return true;
+
+ case LOCAL_GL_HALF_FLOAT:
+ case LOCAL_GL_HALF_FLOAT_OES:
+ case LOCAL_GL_UNSIGNED_SHORT:
+ case LOCAL_GL_UNSIGNED_SHORT_4_4_4_4:
+ case LOCAL_GL_UNSIGNED_SHORT_5_5_5_1:
+ case LOCAL_GL_UNSIGNED_SHORT_5_6_5:
+ *out_scalarType = js::Scalar::Uint16;
+ return true;
+
+ case LOCAL_GL_UNSIGNED_INT:
+ case LOCAL_GL_UNSIGNED_INT_2_10_10_10_REV:
+ case LOCAL_GL_UNSIGNED_INT_5_9_9_9_REV:
+ case LOCAL_GL_UNSIGNED_INT_10F_11F_11F_REV:
+ case LOCAL_GL_UNSIGNED_INT_24_8:
+ *out_scalarType = js::Scalar::Uint32;
+ return true;
+ case LOCAL_GL_INT:
+ *out_scalarType = js::Scalar::Int32;
+ return true;
+
+ case LOCAL_GL_FLOAT:
+ *out_scalarType = js::Scalar::Float32;
+ return true;
+
+ default:
+ return false;
+ }
+}
+
+bool
+WebGLContext::ReadPixels_SharedPrecheck(ErrorResult* const out_error)
+{
+ if (IsContextLost())
+ return false;
+
+ if (mCanvasElement &&
+ mCanvasElement->IsWriteOnly() &&
+ !nsContentUtils::IsCallerChrome())
+ {
+ GenerateWarning("readPixels: Not allowed");
+ out_error->Throw(NS_ERROR_DOM_SECURITY_ERR);
+ return false;
+ }
+
+ return true;
+}
+
+bool
+WebGLContext::ValidatePackSize(const char* funcName, uint32_t width, uint32_t height,
+ uint8_t bytesPerPixel, uint32_t* const out_rowStride,
+ uint32_t* const out_endOffset)
+{
+ if (!width || !height) {
+ *out_rowStride = 0;
+ *out_endOffset = 0;
+ return true;
+ }
+
+ // GLES 3.0.4, p116 (PACK_ functions like UNPACK_)
+
+ const auto rowLength = (mPixelStore_PackRowLength ? mPixelStore_PackRowLength
+ : width);
+ const auto skipPixels = mPixelStore_PackSkipPixels;
+ const auto skipRows = mPixelStore_PackSkipRows;
+ const auto alignment = mPixelStore_PackAlignment;
+
+ const auto usedPixelsPerRow = CheckedUint32(skipPixels) + width;
+ const auto usedRowsPerImage = CheckedUint32(skipRows) + height;
+
+ if (!usedPixelsPerRow.isValid() || usedPixelsPerRow.value() > rowLength) {
+ ErrorInvalidOperation("%s: SKIP_PIXELS + width > ROW_LENGTH.", funcName);
+ return false;
+ }
+
+ const auto rowLengthBytes = CheckedUint32(rowLength) * bytesPerPixel;
+ const auto rowStride = RoundUpToMultipleOf(rowLengthBytes, alignment);
+
+ const auto usedBytesPerRow = usedPixelsPerRow * bytesPerPixel;
+ const auto usedBytesPerImage = (usedRowsPerImage - 1) * rowStride + usedBytesPerRow;
+
+ if (!rowStride.isValid() || !usedBytesPerImage.isValid()) {
+ ErrorInvalidOperation("%s: Invalid UNPACK_ params.", funcName);
+ return false;
+ }
+
+ *out_rowStride = rowStride.value();
+ *out_endOffset = usedBytesPerImage.value();
+ return true;
+}
+
+void
+WebGLContext::ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format,
+ GLenum type, const dom::ArrayBufferView& dstView,
+ GLuint dstElemOffset, ErrorResult& out_error)
+{
+ const char funcName[] = "readPixels";
+ if (!ReadPixels_SharedPrecheck(&out_error))
+ return;
+
+ if (mBoundPixelPackBuffer) {
+ ErrorInvalidOperation("%s: PIXEL_PACK_BUFFER must be null.", funcName);
+ return;
+ }
+
+ ////
+
+ js::Scalar::Type reqScalarType;
+ if (!GetJSScalarFromGLType(type, &reqScalarType)) {
+ ErrorInvalidEnum("%s: Bad `type`.", funcName);
+ return;
+ }
+
+ const auto& viewElemType = dstView.Type();
+ if (viewElemType != reqScalarType) {
+ ErrorInvalidOperation("%s: `pixels` type does not match `type`.", funcName);
+ return;
+ }
+
+ ////
+
+ uint8_t* bytes;
+ size_t byteLen;
+ if (!ValidateArrayBufferView(funcName, dstView, dstElemOffset, 0, &bytes, &byteLen))
+ return;
+
+ ////
+
+ ReadPixelsImpl(x, y, width, height, format, type, bytes, byteLen);
+}
+
+void
+WebGLContext::ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format,
+ GLenum type, WebGLsizeiptr offset, ErrorResult& out_error)
+{
+ const char funcName[] = "readPixels";
+ if (!ReadPixels_SharedPrecheck(&out_error))
+ return;
+
+ const auto& buffer = ValidateBufferSelection(funcName, LOCAL_GL_PIXEL_PACK_BUFFER);
+ if (!buffer)
+ return;
+
+ //////
+
+ if (!ValidateNonNegative(funcName, "offset", offset))
+ return;
+
+ {
+ const auto bytesPerType = webgl::BytesPerPixel({LOCAL_GL_RED, type});
+
+ if (offset % bytesPerType != 0) {
+ ErrorInvalidOperation("%s: `offset` must be divisible by the size of `type`"
+ " in bytes.",
+ funcName);
+ return;
+ }
+ }
+
+ //////
+
+ const auto bytesAvailable = buffer->ByteLength();
+ const auto checkedBytesAfterOffset = CheckedUint32(bytesAvailable) - offset;
+
+ uint32_t bytesAfterOffset = 0;
+ if (checkedBytesAfterOffset.isValid()) {
+ bytesAfterOffset = checkedBytesAfterOffset.value();
+ }
+
+ gl->MakeCurrent();
+ const ScopedLazyBind lazyBind(gl, LOCAL_GL_PIXEL_PACK_BUFFER, buffer);
+
+ ReadPixelsImpl(x, y, width, height, format, type, (void*)offset, bytesAfterOffset);
+}
+
+static webgl::PackingInfo
+DefaultReadPixelPI(const webgl::FormatUsageInfo* usage)
+{
+ MOZ_ASSERT(usage->IsRenderable());
+
+ switch (usage->format->componentType) {
+ case webgl::ComponentType::NormUInt:
+ 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()...
+
+ // So yeah, we are actually checking that these are valid as /unpack/ formats, instead
+ // of /pack/ formats here, but it should cover the INVALID_ENUM cases.
+ if (!webgl->mFormatUsage->AreUnpackEnumsValid(pi.format, pi.type))
+ return false;
+
+ // 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;
+
+ 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)
+{
+ const char funcName[] = "readPixels";
+
+ if (!ArePossiblePackEnums(webgl, pi)) {
+ webgl->ErrorInvalidEnum("%s: Unexpected format or type.", funcName);
+ 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;
+ }
+
+ ////
+
+ MOZ_ASSERT(gl->IsCurrent());
+ const auto implPI = webgl->ValidImplementationColorReadPI(srcUsage);
+ if (pi == implPI)
+ return true;
+
+ ////
+
+ webgl->ErrorInvalidOperation("%s: Incompatible format or type.", funcName);
+ return false;
+}
+
+void
+WebGLContext::ReadPixelsImpl(GLint x, GLint y, GLsizei rawWidth, GLsizei rawHeight,
+ GLenum packFormat, GLenum packType, void* dest,
+ uint32_t dataLen)
+{
+ if (rawWidth < 0 || rawHeight < 0) {
+ ErrorInvalidValue("readPixels: negative size passed");
+ return;
+ }
+
+ const uint32_t width(rawWidth);
+ const uint32_t height(rawHeight);
+
+ //////
+
+ MakeContextCurrent();
+
+ const webgl::FormatUsageInfo* srcFormat;
+ uint32_t srcWidth;
+ uint32_t srcHeight;
+ if (!ValidateCurFBForRead("readPixels", &srcFormat, &srcWidth, &srcHeight))
+ return;
+
+ //////
+
+ const webgl::PackingInfo pi = {packFormat, packType};
+ if (!ValidateReadPixelsFormatAndType(srcFormat, pi, gl, this))
+ return;
+
+ uint8_t bytesPerPixel;
+ if (!webgl::GetBytesPerPixel(pi, &bytesPerPixel)) {
+ ErrorInvalidOperation("readPixels: Unsupported format and type.");
+ return;
+ }
+
+ //////
+
+ uint32_t rowStride;
+ uint32_t bytesNeeded;
+ if (!ValidatePackSize("readPixels", width, height, bytesPerPixel, &rowStride,
+ &bytesNeeded))
+ {
+ return;
+ }
+
+ if (bytesNeeded > dataLen) {
+ ErrorInvalidOperation("readPixels: buffer too small");
+ return;
+ }
+
+ ////
+
+ int32_t readX, readY;
+ int32_t writeX, writeY;
+ int32_t rwWidth, rwHeight;
+ if (!Intersect(srcWidth, x, width, &readX, &writeX, &rwWidth) ||
+ !Intersect(srcHeight, y, height, &readY, &writeY, &rwHeight))
+ {
+ ErrorOutOfMemory("readPixels: Bad subrect selection.");
+ return;
+ }
+
+ ////////////////
+ // Now that the errors are out of the way, on to actually reading!
+
+ OnBeforeReadCall();
+
+ if (!rwWidth || !rwHeight) {
+ // Disjoint rects, so we're done already.
+ DummyReadFramebufferOperation("readPixels");
+ return;
+ }
+
+ if (uint32_t(rwWidth) == width &&
+ uint32_t(rwHeight) == height)
+ {
+ DoReadPixelsAndConvert(srcFormat->format, x, y, width, height, packFormat,
+ packType, dest, dataLen, rowStride);
+ return;
+ }
+
+ // 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("readPixels: Out-of-bounds reads with readPixels are deprecated, and"
+ " may be slow.");
+
+ ////////////////////////////////////
+ // Read only the in-bounds pixels.
+
+ if (IsWebGL2()) {
+ if (!mPixelStore_PackRowLength) {
+ gl->fPixelStorei(LOCAL_GL_PACK_ROW_LENGTH,
+ mPixelStore_PackSkipPixels + width);
+ }
+ gl->fPixelStorei(LOCAL_GL_PACK_SKIP_PIXELS, mPixelStore_PackSkipPixels + writeX);
+ gl->fPixelStorei(LOCAL_GL_PACK_SKIP_ROWS, mPixelStore_PackSkipRows + writeY);
+
+ DoReadPixelsAndConvert(srcFormat->format, readX, readY, rwWidth, rwHeight,
+ packFormat, packType, dest, dataLen, rowStride);
+
+ gl->fPixelStorei(LOCAL_GL_PACK_ROW_LENGTH, mPixelStore_PackRowLength);
+ gl->fPixelStorei(LOCAL_GL_PACK_SKIP_PIXELS, mPixelStore_PackSkipPixels);
+ gl->fPixelStorei(LOCAL_GL_PACK_SKIP_ROWS, mPixelStore_PackSkipRows);
+ } else {
+ // I *did* say "hilariously slow".
+
+ uint8_t* row = (uint8_t*)dest + writeX * bytesPerPixel;
+ row += writeY * rowStride;
+ for (uint32_t j = 0; j < uint32_t(rwHeight); j++) {
+ DoReadPixelsAndConvert(srcFormat->format, readX, readY+j, rwWidth, 1,
+ packFormat, packType, row, dataLen, rowStride);
+ row += rowStride;
+ }
+ }
+}
+
+void
+WebGLContext::RenderbufferStorage_base(const char* funcName, GLenum target,
+ GLsizei samples, GLenum internalFormat,
+ GLsizei width, GLsizei height)
+{
+ if (IsContextLost())
+ return;
+
+ if (target != LOCAL_GL_RENDERBUFFER) {
+ ErrorInvalidEnumInfo("`target`", funcName, target);
+ return;
+ }
+
+ if (!mBoundRenderbuffer) {
+ ErrorInvalidOperation("%s: Called on renderbuffer 0.", funcName);
+ return;
+ }
+
+ if (samples < 0) {
+ ErrorInvalidValue("%s: `samples` must be >= 0.", funcName);
+ return;
+ }
+
+ if (width < 0 || height < 0) {
+ ErrorInvalidValue("%s: `width` and `height` must be >= 0.", funcName);
+ return;
+ }
+
+ mBoundRenderbuffer->RenderbufferStorage(funcName, uint32_t(samples), internalFormat,
+ uint32_t(width), uint32_t(height));
+}
+
+void
+WebGLContext::RenderbufferStorage(GLenum target, GLenum internalFormat, GLsizei width, GLsizei height)
+{
+ RenderbufferStorage_base("renderbufferStorage", target, 0, internalFormat, width,
+ height);
+}
+
+void
+WebGLContext::Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+ if (IsContextLost())
+ return;
+
+ if (width < 0 || height < 0)
+ return ErrorInvalidValue("scissor: negative size");
+
+ MakeContextCurrent();
+ gl->fScissor(x, y, width, height);
+}
+
+void
+WebGLContext::StencilFunc(GLenum func, GLint ref, GLuint mask)
+{
+ if (IsContextLost())
+ return;
+
+ if (!ValidateComparisonEnum(func, "stencilFunc: func"))
+ return;
+
+ mStencilRefFront = ref;
+ mStencilRefBack = ref;
+ mStencilValueMaskFront = mask;
+ mStencilValueMaskBack = mask;
+
+ MakeContextCurrent();
+ gl->fStencilFunc(func, ref, mask);
+}
+
+void
+WebGLContext::StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
+{
+ if (IsContextLost())
+ return;
+
+ if (!ValidateFaceEnum(face, "stencilFuncSeparate: face") ||
+ !ValidateComparisonEnum(func, "stencilFuncSeparate: 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;
+ }
+
+ MakeContextCurrent();
+ gl->fStencilFuncSeparate(face, func, ref, mask);
+}
+
+void
+WebGLContext::StencilOp(GLenum sfail, GLenum dpfail, GLenum dppass)
+{
+ if (IsContextLost())
+ return;
+
+ if (!ValidateStencilOpEnum(sfail, "stencilOp: sfail") ||
+ !ValidateStencilOpEnum(dpfail, "stencilOp: dpfail") ||
+ !ValidateStencilOpEnum(dppass, "stencilOp: dppass"))
+ return;
+
+ MakeContextCurrent();
+ gl->fStencilOp(sfail, dpfail, dppass);
+}
+
+void
+WebGLContext::StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
+{
+ if (IsContextLost())
+ return;
+
+ if (!ValidateFaceEnum(face, "stencilOpSeparate: face") ||
+ !ValidateStencilOpEnum(sfail, "stencilOpSeparate: sfail") ||
+ !ValidateStencilOpEnum(dpfail, "stencilOpSeparate: dpfail") ||
+ !ValidateStencilOpEnum(dppass, "stencilOpSeparate: dppass"))
+ return;
+
+ MakeContextCurrent();
+ gl->fStencilOpSeparate(face, sfail, dpfail, dppass);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Uniform setters.
+
+class ValidateIfSampler
+{
+ const WebGLUniformLocation* const mLoc;
+ const size_t mDataCount;
+ const GLint* const mData;
+ bool mIsValidatedSampler;
+
+public:
+ ValidateIfSampler(WebGLContext* webgl, const char* funcName,
+ WebGLUniformLocation* loc, size_t dataCount, const GLint* data,
+ bool* const out_error)
+ : mLoc(loc)
+ , mDataCount(dataCount)
+ , mData(data)
+ , mIsValidatedSampler(false)
+ {
+ if (!mLoc->mInfo->mSamplerTexList) {
+ *out_error = false;
+ return;
+ }
+
+ for (size_t i = 0; i < mDataCount; i++) {
+ const auto& val = mData[i];
+ if (val < 0 || uint32_t(val) >= webgl->GLMaxTextureUnits()) {
+ webgl->ErrorInvalidValue("%s: This uniform location is a sampler, but %d"
+ " is not a valid texture unit.",
+ funcName, val);
+ *out_error = true;
+ return;
+ }
+ }
+
+ mIsValidatedSampler = true;
+ *out_error = false;
+ }
+
+ ~ValidateIfSampler() {
+ if (!mIsValidatedSampler)
+ return;
+
+ auto& samplerValues = mLoc->mInfo->mSamplerValues;
+
+ for (size_t i = 0; i < mDataCount; i++) {
+ const size_t curIndex = mLoc->mArrayIndex + i;
+ if (curIndex >= samplerValues.size())
+ break;
+
+ samplerValues[curIndex] = mData[i];
+ }
+ }
+};
+
+////////////////////
+
+void
+WebGLContext::Uniform1i(WebGLUniformLocation* loc, GLint a1)
+{
+ const char funcName[] = "uniform1i";
+ if (!ValidateUniformSetter(loc, 1, LOCAL_GL_INT, funcName))
+ return;
+
+ bool error;
+ const ValidateIfSampler validate(this, funcName, loc, 1, &a1, &error);
+ if (error)
+ return;
+
+ MakeContextCurrent();
+ gl->fUniform1i(loc->mLoc, a1);
+}
+
+void
+WebGLContext::Uniform2i(WebGLUniformLocation* loc, GLint a1, GLint a2)
+{
+ const char funcName[] = "uniform2i";
+ if (!ValidateUniformSetter(loc, 2, LOCAL_GL_INT, funcName))
+ return;
+
+ MakeContextCurrent();
+ gl->fUniform2i(loc->mLoc, a1, a2);
+}
+
+void
+WebGLContext::Uniform3i(WebGLUniformLocation* loc, GLint a1, GLint a2, GLint a3)
+{
+ const char funcName[] = "uniform3i";
+ if (!ValidateUniformSetter(loc, 3, LOCAL_GL_INT, funcName))
+ return;
+
+ MakeContextCurrent();
+ gl->fUniform3i(loc->mLoc, a1, a2, a3);
+}
+
+void
+WebGLContext::Uniform4i(WebGLUniformLocation* loc, GLint a1, GLint a2, GLint a3,
+ GLint a4)
+{
+ const char funcName[] = "uniform4i";
+ if (!ValidateUniformSetter(loc, 4, LOCAL_GL_INT, funcName))
+ return;
+
+ MakeContextCurrent();
+ gl->fUniform4i(loc->mLoc, a1, a2, a3, a4);
+}
+
+//////////
+
+void
+WebGLContext::Uniform1f(WebGLUniformLocation* loc, GLfloat a1)
+{
+ const char funcName[] = "uniform1f";
+ if (!ValidateUniformSetter(loc, 1, LOCAL_GL_FLOAT, funcName))
+ return;
+
+ MakeContextCurrent();
+ gl->fUniform1f(loc->mLoc, a1);
+}
+
+void
+WebGLContext::Uniform2f(WebGLUniformLocation* loc, GLfloat a1, GLfloat a2)
+{
+ const char funcName[] = "uniform2f";
+ if (!ValidateUniformSetter(loc, 2, LOCAL_GL_FLOAT, funcName))
+ return;
+
+ MakeContextCurrent();
+ gl->fUniform2f(loc->mLoc, a1, a2);
+}
+
+void
+WebGLContext::Uniform3f(WebGLUniformLocation* loc, GLfloat a1, GLfloat a2,
+ GLfloat a3)
+{
+ const char funcName[] = "uniform3f";
+ if (!ValidateUniformSetter(loc, 3, LOCAL_GL_FLOAT, funcName))
+ return;
+
+ MakeContextCurrent();
+ gl->fUniform3f(loc->mLoc, a1, a2, a3);
+}
+
+void
+WebGLContext::Uniform4f(WebGLUniformLocation* loc, GLfloat a1, GLfloat a2,
+ GLfloat a3, GLfloat a4)
+{
+ const char funcName[] = "uniform4f";
+ if (!ValidateUniformSetter(loc, 4, LOCAL_GL_FLOAT, funcName))
+ return;
+
+ MakeContextCurrent();
+ gl->fUniform4f(loc->mLoc, a1, a2, a3, a4);
+}
+
+////////////////////////////////////////
+// Array
+
+static bool
+ValidateArrOffsetAndCount(WebGLContext* webgl, const char* funcName, size_t elemsAvail,
+ GLuint elemOffset, GLuint elemCountOverride,
+ size_t* const out_elemCount)
+{
+ if (elemOffset > elemsAvail) {
+ webgl->ErrorInvalidValue("%s: Bad offset into list.", funcName);
+ return false;
+ }
+ elemsAvail -= elemOffset;
+
+ if (elemCountOverride) {
+ if (elemCountOverride > elemsAvail) {
+ webgl->ErrorInvalidValue("%s: Bad count override for sub-list.", funcName);
+ return false;
+ }
+ elemsAvail = elemCountOverride;
+ }
+
+ *out_elemCount = elemsAvail;
+ return true;
+}
+
+void
+WebGLContext::UniformNiv(const char* funcName, uint8_t N, WebGLUniformLocation* loc,
+ const Int32Arr& arr, GLuint elemOffset, GLuint elemCountOverride)
+{
+ size_t elemCount;
+ if (!ValidateArrOffsetAndCount(this, funcName, arr.elemCount, elemOffset,
+ elemCountOverride, &elemCount))
+ {
+ return;
+ }
+ const auto elemBytes = arr.elemBytes + elemOffset;
+
+ uint32_t numElementsToUpload;
+ if (!ValidateUniformArraySetter(loc, N, LOCAL_GL_INT, elemCount, funcName,
+ &numElementsToUpload))
+ {
+ return;
+ }
+
+ bool error;
+ const ValidateIfSampler samplerValidator(this, funcName, loc, numElementsToUpload,
+ elemBytes, &error);
+ if (error)
+ return;
+
+ static const decltype(&gl::GLContext::fUniform1iv) kFuncList[] = {
+ &gl::GLContext::fUniform1iv,
+ &gl::GLContext::fUniform2iv,
+ &gl::GLContext::fUniform3iv,
+ &gl::GLContext::fUniform4iv
+ };
+ const auto func = kFuncList[N-1];
+
+ MakeContextCurrent();
+ (gl->*func)(loc->mLoc, numElementsToUpload, elemBytes);
+}
+
+void
+WebGLContext::UniformNuiv(const char* funcName, uint8_t N, WebGLUniformLocation* loc,
+ const Uint32Arr& arr, GLuint elemOffset,
+ GLuint elemCountOverride)
+{
+ size_t elemCount;
+ if (!ValidateArrOffsetAndCount(this, funcName, arr.elemCount, elemOffset,
+ elemCountOverride, &elemCount))
+ {
+ return;
+ }
+ const auto elemBytes = arr.elemBytes + elemOffset;
+
+ uint32_t numElementsToUpload;
+ if (!ValidateUniformArraySetter(loc, N, LOCAL_GL_UNSIGNED_INT, elemCount, funcName,
+ &numElementsToUpload))
+ {
+ return;
+ }
+ MOZ_ASSERT(!loc->mInfo->mSamplerTexList, "Should not be a sampler.");
+
+ static const decltype(&gl::GLContext::fUniform1uiv) kFuncList[] = {
+ &gl::GLContext::fUniform1uiv,
+ &gl::GLContext::fUniform2uiv,
+ &gl::GLContext::fUniform3uiv,
+ &gl::GLContext::fUniform4uiv
+ };
+ const auto func = kFuncList[N-1];
+
+ MakeContextCurrent();
+ (gl->*func)(loc->mLoc, numElementsToUpload, elemBytes);
+}
+
+void
+WebGLContext::UniformNfv(const char* funcName, uint8_t N, WebGLUniformLocation* loc,
+ const Float32Arr& arr, GLuint elemOffset,
+ GLuint elemCountOverride)
+{
+ size_t elemCount;
+ if (!ValidateArrOffsetAndCount(this, funcName, arr.elemCount, elemOffset,
+ elemCountOverride, &elemCount))
+ {
+ return;
+ }
+ const auto elemBytes = arr.elemBytes + elemOffset;
+
+ uint32_t numElementsToUpload;
+ if (!ValidateUniformArraySetter(loc, N, LOCAL_GL_FLOAT, elemCount, funcName,
+ &numElementsToUpload))
+ {
+ return;
+ }
+ MOZ_ASSERT(!loc->mInfo->mSamplerTexList, "Should not be a sampler.");
+
+ static const decltype(&gl::GLContext::fUniform1fv) kFuncList[] = {
+ &gl::GLContext::fUniform1fv,
+ &gl::GLContext::fUniform2fv,
+ &gl::GLContext::fUniform3fv,
+ &gl::GLContext::fUniform4fv
+ };
+ const auto func = kFuncList[N-1];
+
+ MakeContextCurrent();
+ (gl->*func)(loc->mLoc, numElementsToUpload, elemBytes);
+}
+
+void
+WebGLContext::UniformMatrixAxBfv(const char* funcName, uint8_t A, uint8_t B,
+ WebGLUniformLocation* loc, bool transpose,
+ const Float32Arr& arr, GLuint elemOffset,
+ GLuint elemCountOverride)
+{
+ size_t elemCount;
+ if (!ValidateArrOffsetAndCount(this, funcName, arr.elemCount, elemOffset,
+ elemCountOverride, &elemCount))
+ {
+ return;
+ }
+ const auto elemBytes = arr.elemBytes + elemOffset;
+
+ uint32_t numElementsToUpload;
+ if (!ValidateUniformMatrixArraySetter(loc, A, B, LOCAL_GL_FLOAT, elemCount,
+ transpose, funcName, &numElementsToUpload))
+ {
+ return;
+ }
+ MOZ_ASSERT(!loc->mInfo->mSamplerTexList, "Should not be a sampler.");
+
+ static const decltype(&gl::GLContext::fUniformMatrix2fv) kFuncList[] = {
+ &gl::GLContext::fUniformMatrix2fv,
+ &gl::GLContext::fUniformMatrix2x3fv,
+ &gl::GLContext::fUniformMatrix2x4fv,
+
+ &gl::GLContext::fUniformMatrix3x2fv,
+ &gl::GLContext::fUniformMatrix3fv,
+ &gl::GLContext::fUniformMatrix3x4fv,
+
+ &gl::GLContext::fUniformMatrix4x2fv,
+ &gl::GLContext::fUniformMatrix4x3fv,
+ &gl::GLContext::fUniformMatrix4fv
+ };
+ const auto func = kFuncList[3*(A-2) + (B-2)];
+
+ MakeContextCurrent();
+ (gl->*func)(loc->mLoc, numElementsToUpload, transpose, elemBytes);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void
+WebGLContext::UseProgram(WebGLProgram* prog)
+{
+ if (IsContextLost())
+ return;
+
+ if (!prog) {
+ mCurrentProgram = nullptr;
+ mActiveProgramLinkInfo = nullptr;
+ return;
+ }
+
+ if (!ValidateObject("useProgram", *prog))
+ return;
+
+ if (prog->UseProgram()) {
+ mCurrentProgram = prog;
+ mActiveProgramLinkInfo = mCurrentProgram->LinkInfo();
+ }
+}
+
+void
+WebGLContext::ValidateProgram(const WebGLProgram& prog)
+{
+ if (IsContextLost())
+ return;
+
+ if (!ValidateObject("validateProgram", prog))
+ return;
+
+ prog.ValidateProgram();
+}
+
+already_AddRefed<WebGLFramebuffer>
+WebGLContext::CreateFramebuffer()
+{
+ if (IsContextLost())
+ return nullptr;
+
+ GLuint fbo = 0;
+ MakeContextCurrent();
+ gl->fGenFramebuffers(1, &fbo);
+
+ RefPtr<WebGLFramebuffer> globj = new WebGLFramebuffer(this, fbo);
+ return globj.forget();
+}
+
+already_AddRefed<WebGLRenderbuffer>
+WebGLContext::CreateRenderbuffer()
+{
+ if (IsContextLost())
+ return nullptr;
+
+ MakeContextCurrent();
+ RefPtr<WebGLRenderbuffer> globj = new WebGLRenderbuffer(this);
+ return globj.forget();
+}
+
+void
+WebGLContext::Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+ if (IsContextLost())
+ return;
+
+ if (width < 0 || height < 0)
+ return ErrorInvalidValue("viewport: negative size");
+
+ width = std::min(width, (GLsizei)mImplMaxViewportDims[0]);
+ height = std::min(height, (GLsizei)mImplMaxViewportDims[1]);
+
+ MakeContextCurrent();
+ gl->fViewport(x, y, width, height);
+
+ mViewportX = x;
+ mViewportY = y;
+ mViewportWidth = width;
+ mViewportHeight = height;
+}
+
+void
+WebGLContext::CompileShader(WebGLShader& shader)
+{
+ if (IsContextLost())
+ return;
+
+ if (!ValidateObject("compileShader", shader))
+ return;
+
+ shader.CompileShader();
+}
+
+JS::Value
+WebGLContext::GetShaderParameter(const WebGLShader& shader, GLenum pname)
+{
+ if (IsContextLost())
+ return JS::NullValue();
+
+ if (!ValidateObjectAllowDeleted("getShaderParameter: shader", shader))
+ return JS::NullValue();
+
+ return shader.GetShaderParameter(pname);
+}
+
+void
+WebGLContext::GetShaderInfoLog(const WebGLShader& shader, nsAString& retval)
+{
+ retval.SetIsVoid(true);
+
+ if (IsContextLost())
+ return;
+
+ if (!ValidateObject("getShaderInfoLog: shader", shader))
+ return;
+
+ shader.GetShaderInfoLog(&retval);
+}
+
+already_AddRefed<WebGLShaderPrecisionFormat>
+WebGLContext::GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype)
+{
+ if (IsContextLost())
+ return nullptr;
+
+ switch (shadertype) {
+ case LOCAL_GL_FRAGMENT_SHADER:
+ case LOCAL_GL_VERTEX_SHADER:
+ break;
+ default:
+ ErrorInvalidEnumInfo("getShaderPrecisionFormat: shadertype", shadertype);
+ return nullptr;
+ }
+
+ 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("getShaderPrecisionFormat: precisiontype", precisiontype);
+ return nullptr;
+ }
+
+ MakeContextCurrent();
+ 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);
+ }
+
+ RefPtr<WebGLShaderPrecisionFormat> retShaderPrecisionFormat
+ = new WebGLShaderPrecisionFormat(this, range[0], range[1], precision);
+ return retShaderPrecisionFormat.forget();
+}
+
+void
+WebGLContext::GetShaderSource(const WebGLShader& shader, nsAString& retval)
+{
+ retval.SetIsVoid(true);
+
+ if (IsContextLost())
+ return;
+
+ if (!ValidateObject("getShaderSource: shader", shader))
+ return;
+
+ shader.GetShaderSource(&retval);
+}
+
+void
+WebGLContext::ShaderSource(WebGLShader& shader, const nsAString& source)
+{
+ if (IsContextLost())
+ return;
+
+ if (!ValidateObject("shaderSource: shader", shader))
+ return;
+
+ shader.ShaderSource(source);
+}
+
+void
+WebGLContext::LoseContext()
+{
+ if (IsContextLost())
+ return ErrorInvalidOperation("loseContext: Context is already lost.");
+
+ ForceLoseContext(true);
+}
+
+void
+WebGLContext::RestoreContext()
+{
+ if (!IsContextLost())
+ return ErrorInvalidOperation("restoreContext: Context is not lost.");
+
+ if (!mLastLossWasSimulated) {
+ return ErrorInvalidOperation("restoreContext: Context loss was not simulated."
+ " Cannot simulate restore.");
+ }
+ // If we're currently lost, and the last loss was simulated, then
+ // we're currently only simulated-lost, allowing us to call
+ // restoreContext().
+
+ if (!mAllowContextRestore)
+ return ErrorInvalidOperation("restoreContext: Context cannot be restored.");
+
+ ForceRestoreContext();
+}
+
+void
+WebGLContext::BlendColor(GLfloat r, GLfloat g, GLfloat b, GLfloat a) {
+ if (IsContextLost())
+ return;
+ MakeContextCurrent();
+ gl->fBlendColor(r, g, b, a);
+}
+
+void
+WebGLContext::Flush() {
+ if (IsContextLost())
+ return;
+ MakeContextCurrent();
+ gl->fFlush();
+}
+
+void
+WebGLContext::Finish() {
+ if (IsContextLost())
+ return;
+ MakeContextCurrent();
+ gl->fFinish();
+}
+
+void
+WebGLContext::LineWidth(GLfloat width)
+{
+ if (IsContextLost())
+ return;
+
+ // Doing it this way instead of `if (width <= 0.0)` handles NaNs.
+ const bool isValid = width > 0.0;
+ if (!isValid) {
+ ErrorInvalidValue("lineWidth: `width` must be positive and non-zero.");
+ return;
+ }
+
+ mLineWidth = width;
+
+ if (gl->IsCoreProfile() && width > 1.0) {
+ width = 1.0;
+ }
+
+ MakeContextCurrent();
+ gl->fLineWidth(width);
+}
+
+void
+WebGLContext::PolygonOffset(GLfloat factor, GLfloat units) {
+ if (IsContextLost())
+ return;
+ MakeContextCurrent();
+ gl->fPolygonOffset(factor, units);
+}
+
+void
+WebGLContext::SampleCoverage(GLclampf value, WebGLboolean invert) {
+ if (IsContextLost())
+ return;
+ MakeContextCurrent();
+ gl->fSampleCoverage(value, invert);
+}
+
+} // namespace mozilla