wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity
fc99c53ae5
gecko/dom/canvas/WebGLContextGL.cpp

4144 lines
135 KiB
C++
Raw Blame History

/* -*- 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 "WebGLContextUtils.h"
#include "WebGLBuffer.h"
#include "WebGLVertexAttribData.h"
#include "WebGLShader.h"
#include "WebGLProgram.h"
#include "WebGLUniformLocation.h"
#include "WebGLFramebuffer.h"
#include "WebGLRenderbuffer.h"
#include "WebGLShaderPrecisionFormat.h"
#include "WebGLTexture.h"
#include "WebGLExtensions.h"
#include "WebGLVertexArray.h"
#include "nsString.h"
#include "nsDebug.h"
#include "nsReadableUtils.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/Endian.h"
using namespace mozilla;
using namespace mozilla::dom;
using namespace mozilla::gl;
using namespace mozilla::gfx;
static bool BaseTypeAndSizeFromUniformType(GLenum uType, GLenum *baseType, GLint *unitSize);
const WebGLRectangleObject*
WebGLContext::CurValidFBRectObject() const
{
const WebGLRectangleObject* rect = nullptr;
if (mBoundFramebuffer) {
// We don't really need to ask the driver.
// Use 'precheck' to just check that our internal state looks good.
GLenum precheckStatus = mBoundFramebuffer->PrecheckFramebufferStatus();
if (precheckStatus == LOCAL_GL_FRAMEBUFFER_COMPLETE)
rect = &mBoundFramebuffer->RectangleObject();
} else {
rect = static_cast<const WebGLRectangleObject*>(this);
}
return rect;
}
//
// 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;
// Per GLSL ES 2.0, we can only have one of each type of shader
// attached. This renders the next test somewhat moot, but we'll
// leave it for when we support more than one shader of each type.
if (program->HasAttachedShaderOfType(shader->ShaderType()))
return ErrorInvalidOperation("attachShader: only one of each type of shader may be attached to a program");
if (!program->AttachShader(shader))
return ErrorInvalidOperation("attachShader: shader is already attached");
}
void
WebGLContext::BindAttribLocation(WebGLProgram *prog, GLuint location,
const nsAString& name)
{
if (IsContextLost())
return;
if (!ValidateObject("bindAttribLocation: program", prog))
return;
GLuint progname = prog->GLName();
if (!ValidateGLSLVariableName(name, "bindAttribLocation"))
return;
if (!ValidateAttribIndex(location, "bindAttribLocation"))
return;
if (StringBeginsWith(name, NS_LITERAL_STRING("gl_")))
return ErrorInvalidOperation("bindAttribLocation: can't set the location of a name that starts with 'gl_'");
NS_LossyConvertUTF16toASCII cname(name);
nsCString mappedName;
if (mShaderValidation) {
WebGLProgram::HashMapIdentifier(cname, &mappedName);
} else {
mappedName.Assign(cname);
}
MakeContextCurrent();
gl->fBindAttribLocation(progname, location, mappedName.get());
}
void
WebGLContext::BindFramebuffer(GLenum target, WebGLFramebuffer *wfb)
{
if (IsContextLost())
return;
if (target != LOCAL_GL_FRAMEBUFFER)
return ErrorInvalidEnum("bindFramebuffer: target must be GL_FRAMEBUFFER");
if (!ValidateObjectAllowDeletedOrNull("bindFramebuffer", wfb))
return;
// silently ignore a deleted frame buffer
if (wfb && wfb->IsDeleted())
return;
MakeContextCurrent();
if (!wfb) {
gl->fBindFramebuffer(target, 0);
} else {
wfb->BindTo(target);
GLuint framebuffername = wfb->GLName();
gl->fBindFramebuffer(target, framebuffername);
}
mBoundFramebuffer = wfb;
}
void
WebGLContext::BindRenderbuffer(GLenum target, WebGLRenderbuffer *wrb)
{
if (IsContextLost())
return;
if (target != LOCAL_GL_RENDERBUFFER)
return ErrorInvalidEnumInfo("bindRenderbuffer: target", target);
if (!ValidateObjectAllowDeletedOrNull("bindRenderbuffer", wrb))
return;
// silently ignore a deleted buffer
if (wrb && wrb->IsDeleted())
return;
if (wrb)
wrb->BindTo(target);
MakeContextCurrent();
// Sometimes we emulate renderbuffers (depth-stencil emu), so there's not
// always a 1-1 mapping from `wrb` to GL name. Just have `wrb` handle it.
if (wrb) {
wrb->BindRenderbuffer();
} else {
gl->fBindRenderbuffer(target, 0);
}
mBoundRenderbuffer = wrb;
}
void
WebGLContext::BindTexture(GLenum target, WebGLTexture *newTex)
{
if (IsContextLost())
return;
if (!ValidateObjectAllowDeletedOrNull("bindTexture", newTex))
return;
// silently ignore a deleted texture
if (newTex && newTex->IsDeleted())
return;
WebGLRefPtr<WebGLTexture>* currentTexPtr = nullptr;
if (target == LOCAL_GL_TEXTURE_2D) {
currentTexPtr = &mBound2DTextures[mActiveTexture];
} else if (target == LOCAL_GL_TEXTURE_CUBE_MAP) {
currentTexPtr = &mBoundCubeMapTextures[mActiveTexture];
} else {
return ErrorInvalidEnumInfo("bindTexture: target", target);
}
WebGLTextureFakeBlackStatus currentTexFakeBlackStatus = WebGLTextureFakeBlackStatus::NotNeeded;
if (*currentTexPtr) {
currentTexFakeBlackStatus = (*currentTexPtr)->ResolvedFakeBlackStatus();
}
WebGLTextureFakeBlackStatus newTexFakeBlackStatus = WebGLTextureFakeBlackStatus::NotNeeded;
if (newTex) {
newTexFakeBlackStatus = newTex->ResolvedFakeBlackStatus();
}
*currentTexPtr = newTex;
if (currentTexFakeBlackStatus != newTexFakeBlackStatus) {
SetFakeBlackStatus(WebGLContextFakeBlackStatus::Unknown);
}
MakeContextCurrent();
if (newTex)
newTex->Bind(target);
else
gl->fBindTexture(target, 0 /* == texturename */);
}
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)
{
if (IsContextLost())
return LOCAL_GL_FRAMEBUFFER_UNSUPPORTED;
if (target != LOCAL_GL_FRAMEBUFFER) {
ErrorInvalidEnum("checkFramebufferStatus: target must be FRAMEBUFFER");
return 0;
}
if (!mBoundFramebuffer)
return LOCAL_GL_FRAMEBUFFER_COMPLETE;
return mBoundFramebuffer->CheckFramebufferStatus();
}
void
WebGLContext::CopyTexSubImage2D_base(GLenum target,
GLint level,
GLenum internalformat,
GLint xoffset,
GLint yoffset,
GLint x,
GLint y,
GLsizei width,
GLsizei height,
bool sub)
{
const WebGLRectangleObject* framebufferRect = CurValidFBRectObject();
GLsizei framebufferWidth = framebufferRect ? framebufferRect->Width() : 0;
GLsizei framebufferHeight = framebufferRect ? framebufferRect->Height() : 0;
const char* info = sub ? "copyTexSubImage2D" : "copyTexImage2D";
WebGLTexImageFunc func = sub ? WebGLTexImageFunc::CopyTexSubImage : WebGLTexImageFunc::CopyTexImage;
// TODO: This changes with color_buffer_float. Reassess when the
// patch lands.
if (!ValidateTexImage(2, target, level, internalformat,
xoffset, yoffset, 0,
width, height, 0,
0, internalformat, LOCAL_GL_UNSIGNED_BYTE,
func))
{
return;
}
if (!ValidateCopyTexImage(internalformat, func))
return;
if (!mBoundFramebuffer)
ClearBackbufferIfNeeded();
MakeContextCurrent();
WebGLTexture *tex = activeBoundTextureForTarget(target);
if (!tex)
return ErrorInvalidOperation("%s: no texture is bound to this target");
if (CanvasUtils::CheckSaneSubrectSize(x, y, width, height, framebufferWidth, framebufferHeight)) {
if (sub)
gl->fCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
else
gl->fCopyTexImage2D(target, level, internalformat, x, y, width, height, 0);
} else {
// the rect doesn't fit in the framebuffer
/*** first, we initialize the texture as black ***/
// first, compute the size of the buffer we should allocate to initialize the texture as black
if (!ValidateTexInputData(LOCAL_GL_UNSIGNED_BYTE, -1, func))
return;
uint32_t texelSize = GetBitsPerTexel(internalformat, LOCAL_GL_UNSIGNED_BYTE) / 8;
CheckedUint32 checked_neededByteLength =
GetImageSize(height, width, texelSize, mPixelStoreUnpackAlignment);
if (!checked_neededByteLength.isValid())
return ErrorInvalidOperation("%s: integer overflow computing the needed buffer size", info);
uint32_t bytesNeeded = checked_neededByteLength.value();
// now that the size is known, create the buffer
// We need some zero pages, because GL doesn't guarantee the
// contents of a texture allocated with nullptr data.
// Hopefully calloc will just mmap zero pages here.
void* tempZeroData = calloc(1, bytesNeeded);
if (!tempZeroData)
return ErrorOutOfMemory("%s: could not allocate %d bytes (for zero fill)", info, bytesNeeded);
// now initialize the texture as black
if (sub)
gl->fTexSubImage2D(target, level, 0, 0, width, height,
internalformat, LOCAL_GL_UNSIGNED_BYTE, tempZeroData);
else
gl->fTexImage2D(target, level, internalformat, width, height,
0, internalformat, LOCAL_GL_UNSIGNED_BYTE, tempZeroData);
free(tempZeroData);
// if we are completely outside of the framebuffer, we can exit now with our black texture
if ( x >= framebufferWidth
|| x+width <= 0
|| y >= framebufferHeight
|| y+height <= 0)
{
// we are completely outside of range, can exit now with buffer filled with zeros
return DummyFramebufferOperation(info);
}
GLint actual_x = clamped(x, 0, framebufferWidth);
GLint actual_x_plus_width = clamped(x + width, 0, framebufferWidth);
GLsizei actual_width = actual_x_plus_width - actual_x;
GLint actual_xoffset = xoffset + actual_x - x;
GLint actual_y = clamped(y, 0, framebufferHeight);
GLint actual_y_plus_height = clamped(y + height, 0, framebufferHeight);
GLsizei actual_height = actual_y_plus_height - actual_y;
GLint actual_yoffset = yoffset + actual_y - y;
gl->fCopyTexSubImage2D(target, level, actual_xoffset, actual_yoffset, actual_x, actual_y, actual_width, actual_height);
}
}
void
WebGLContext::CopyTexImage2D(GLenum target,
GLint level,
GLenum internalformat,
GLint x,
GLint y,
GLsizei width,
GLsizei height,
GLint border)
{
if (IsContextLost())
return;
// copyTexImage2D only generates textures with type = UNSIGNED_BYTE
const WebGLTexImageFunc func = WebGLTexImageFunc::CopyTexImage;
const GLenum format = internalformat; // WebGL/ES Format
const GLenum type = LOCAL_GL_UNSIGNED_BYTE; // WebGL/ES Format
if (!ValidateTexImage(2, target, level, format,
0, 0, 0,
width, height, 0,
border, format, type,
func))
{
return;
}
if (!ValidateCopyTexImage(format, func))
return;
if (!mBoundFramebuffer)
ClearBackbufferIfNeeded();
// check if the memory size of this texture may change with this call
bool sizeMayChange = true;
WebGLTexture* tex = activeBoundTextureForTarget(target);
if (tex->HasImageInfoAt(target, level)) {
const WebGLTexture::ImageInfo& imageInfo = tex->ImageInfoAt(target, level);
sizeMayChange = width != imageInfo.Width() ||
height != imageInfo.Height() ||
format != imageInfo.WebGLFormat() ||
type != imageInfo.WebGLType();
}
if (sizeMayChange)
GetAndFlushUnderlyingGLErrors();
CopyTexSubImage2D_base(target, level, format, 0, 0, x, y, width, height, false);
if (sizeMayChange) {
GLenum error = GetAndFlushUnderlyingGLErrors();
if (error) {
GenerateWarning("copyTexImage2D generated error %s", ErrorName(error));
return;
}
}
tex->SetImageInfo(target, level, width, height, format, type,
WebGLImageDataStatus::InitializedImageData);
}
void
WebGLContext::CopyTexSubImage2D(GLenum target,
GLint level,
GLint xoffset,
GLint yoffset,
GLint x,
GLint y,
GLsizei width,
GLsizei height)
{
if (IsContextLost())
return;
switch (target) {
case LOCAL_GL_TEXTURE_2D:
case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_X:
case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
break;
default:
return ErrorInvalidEnumInfo("copyTexSubImage2D: target", target);
}
if (level < 0)
return ErrorInvalidValue("copyTexSubImage2D: level may not be negative");
GLsizei maxTextureSize = MaxTextureSizeForTarget(target);
if (!(maxTextureSize >> level))
return ErrorInvalidValue("copyTexSubImage2D: 2^level exceeds maximum texture size");
if (width < 0 || height < 0)
return ErrorInvalidValue("copyTexSubImage2D: width and height may not be negative");
if (xoffset < 0 || yoffset < 0)
return ErrorInvalidValue("copyTexSubImage2D: xoffset and yoffset may not be negative");
WebGLTexture *tex = activeBoundTextureForTarget(target);
if (!tex)
return ErrorInvalidOperation("copyTexSubImage2D: no texture bound to this target");
if (!tex->HasImageInfoAt(target, level))
return ErrorInvalidOperation("copyTexSubImage2D: no texture image previously defined for this level and face");
const WebGLTexture::ImageInfo &imageInfo = tex->ImageInfoAt(target, level);
GLsizei texWidth = imageInfo.Width();
GLsizei texHeight = imageInfo.Height();
if (xoffset + width > texWidth || xoffset + width < 0)
return ErrorInvalidValue("copyTexSubImage2D: xoffset+width is too large");
if (yoffset + height > texHeight || yoffset + height < 0)
return ErrorInvalidValue("copyTexSubImage2D: yoffset+height is too large");
if (!mBoundFramebuffer)
ClearBackbufferIfNeeded();
if (imageInfo.HasUninitializedImageData()) {
tex->DoDeferredImageInitialization(target, level);
}
return CopyTexSubImage2D_base(target, level, imageInfo.WebGLFormat(), xoffset, yoffset, x, y, width, height, true);
}
already_AddRefed<WebGLProgram>
WebGLContext::CreateProgram()
{
if (IsContextLost())
return nullptr;
nsRefPtr<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;
}
nsRefPtr<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 (IsContextLost())
return;
if (!ValidateObjectAllowDeletedOrNull("deleteFramebuffer", fbuf))
return;
if (!fbuf || fbuf->IsDeleted())
return;
fbuf->RequestDelete();
if (mBoundFramebuffer == fbuf)
BindFramebuffer(LOCAL_GL_FRAMEBUFFER,
static_cast<WebGLFramebuffer*>(nullptr));
}
void
WebGLContext::DeleteRenderbuffer(WebGLRenderbuffer *rbuf)
{
if (IsContextLost())
return;
if (!ValidateObjectAllowDeletedOrNull("deleteRenderbuffer", rbuf))
return;
if (!rbuf || rbuf->IsDeleted())
return;
if (mBoundFramebuffer)
mBoundFramebuffer->DetachRenderbuffer(rbuf);
// Invalidate framebuffer status cache
rbuf->NotifyFBsStatusChanged();
if (mBoundRenderbuffer == rbuf)
BindRenderbuffer(LOCAL_GL_RENDERBUFFER,
static_cast<WebGLRenderbuffer*>(nullptr));
rbuf->RequestDelete();
}
void
WebGLContext::DeleteTexture(WebGLTexture *tex)
{
if (IsContextLost())
return;
if (!ValidateObjectAllowDeletedOrNull("deleteTexture", tex))
return;
if (!tex || tex->IsDeleted())
return;
if (mBoundFramebuffer)
mBoundFramebuffer->DetachTexture(tex);
// Invalidate framebuffer status cache
tex->NotifyFBsStatusChanged();
GLuint activeTexture = mActiveTexture;
for (int32_t i = 0; i < mGLMaxTextureUnits; i++) {
if ((tex->Target() == LOCAL_GL_TEXTURE_2D && mBound2DTextures[i] == tex) ||
(tex->Target() == LOCAL_GL_TEXTURE_CUBE_MAP && mBoundCubeMapTextures[i] == tex))
{
ActiveTexture(LOCAL_GL_TEXTURE0 + i);
BindTexture(tex->Target(), static_cast<WebGLTexture*>(nullptr));
}
}
ActiveTexture(LOCAL_GL_TEXTURE0 + activeTexture);
tex->RequestDelete();
}
void
WebGLContext::DeleteProgram(WebGLProgram *prog)
{
if (IsContextLost())
return;
if (!ValidateObjectAllowDeletedOrNull("deleteProgram", prog))
return;
if (!prog || prog->IsDeleted())
return;
prog->RequestDelete();
}
void
WebGLContext::DeleteShader(WebGLShader *shader)
{
if (IsContextLost())
return;
if (!ValidateObjectAllowDeletedOrNull("deleteShader", shader))
return;
if (!shader || shader->IsDeleted())
return;
shader->RequestDelete();
}
void
WebGLContext::DetachShader(WebGLProgram *program, WebGLShader *shader)
{
if (IsContextLost())
return;
if (!ValidateObject("detachShader: program", program) ||
// it's valid to attempt to detach a deleted shader, since it's
// still a shader
!ValidateObjectAllowDeleted("detashShader: shader", shader))
return;
if (!program->DetachShader(shader))
return ErrorInvalidOperation("detachShader: shader is not attached");
}
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)
{
if (IsContextLost())
return;
if (!mBoundFramebuffer)
return ErrorInvalidOperation("framebufferRenderbuffer: cannot modify framebuffer 0");
return mBoundFramebuffer->FramebufferRenderbuffer(target, attachment, rbtarget, wrb);
}
void
WebGLContext::FramebufferTexture2D(GLenum target,
GLenum attachment,
GLenum textarget,
WebGLTexture *tobj,
GLint level)
{
if (IsContextLost())
return;
if (!mBoundFramebuffer)
return ErrorInvalidOperation("framebufferRenderbuffer: cannot modify framebuffer 0");
return mBoundFramebuffer->FramebufferTexture2D(target, 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(WebGLProgram *prog, uint32_t index)
{
if (IsContextLost())
return nullptr;
if (!ValidateObject("getActiveAttrib: program", prog))
return nullptr;
MakeContextCurrent();
GLint len = 0;
GLuint progname = prog->GLName();;
gl->fGetProgramiv(progname, LOCAL_GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &len);
if (len == 0)
return nullptr;
nsAutoArrayPtr<char> name(new char[len]);
GLint attrsize = 0;
GLuint attrtype = 0;
gl->fGetActiveAttrib(progname, index, len, &len, &attrsize, &attrtype, name);
if (attrsize == 0 || attrtype == 0) {
return nullptr;
}
nsCString reverseMappedName;
prog->ReverseMapIdentifier(nsDependentCString(name), &reverseMappedName);
nsRefPtr<WebGLActiveInfo> retActiveInfo =
new WebGLActiveInfo(attrsize, attrtype, reverseMappedName);
return retActiveInfo.forget();
}
void
WebGLContext::GenerateMipmap(GLenum target)
{
if (IsContextLost())
return;
if (!ValidateTextureTargetEnum(target, "generateMipmap"))
return;
WebGLTexture *tex = activeBoundTextureForTarget(target);
if (!tex)
return ErrorInvalidOperation("generateMipmap: No texture is bound to this target.");
GLenum imageTarget = (target == LOCAL_GL_TEXTURE_2D) ? LOCAL_GL_TEXTURE_2D
: LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_X;
if (!tex->HasImageInfoAt(imageTarget, 0))
{
return ErrorInvalidOperation("generateMipmap: Level zero of texture is not defined.");
}
if (!tex->IsFirstImagePowerOfTwo())
return ErrorInvalidOperation("generateMipmap: Level zero of texture does not have power-of-two width and height.");
GLenum webGLFormat = tex->ImageInfoAt(imageTarget, 0).WebGLFormat();
if (IsTextureFormatCompressed(webGLFormat))
return ErrorInvalidOperation("generateMipmap: Texture data at level zero is compressed.");
if (IsExtensionEnabled(WebGLExtensionID::WEBGL_depth_texture) &&
(IsGLDepthFormat(webGLFormat) || IsGLDepthStencilFormat(webGLFormat)))
{
return ErrorInvalidOperation("generateMipmap: "
"A texture that has a base internal format of "
"DEPTH_COMPONENT or DEPTH_STENCIL isn't supported");
}
if (!tex->AreAllLevel0ImageInfosEqual())
return ErrorInvalidOperation("generateMipmap: The six faces of this cube map have different dimensions, format, or type.");
tex->SetGeneratedMipmap();
MakeContextCurrent();
if (gl->WorkAroundDriverBugs()) {
// bug 696495 - to work around failures in the texture-mips.html test on various drivers, we
// set the minification filter before calling glGenerateMipmap. This should not carry a significant performance
// overhead so we do it unconditionally.
//
// note that the choice of GL_NEAREST_MIPMAP_NEAREST really matters. See Chromium bug 101105.
gl->fTexParameteri(target, LOCAL_GL_TEXTURE_MIN_FILTER, LOCAL_GL_NEAREST_MIPMAP_NEAREST);
gl->fGenerateMipmap(target);
gl->fTexParameteri(target, LOCAL_GL_TEXTURE_MIN_FILTER, tex->MinFilter());
} else {
gl->fGenerateMipmap(target);
}
}
already_AddRefed<WebGLActiveInfo>
WebGLContext::GetActiveUniform(WebGLProgram *prog, uint32_t index)
{
if (IsContextLost())
return nullptr;
if (!ValidateObject("getActiveUniform: program", prog))
return nullptr;
MakeContextCurrent();
GLint len = 0;
GLuint progname = prog->GLName();
gl->fGetProgramiv(progname, LOCAL_GL_ACTIVE_UNIFORM_MAX_LENGTH, &len);
if (len == 0)
return nullptr;
nsAutoArrayPtr<char> name(new char[len]);
GLint usize = 0;
GLuint utype = 0;
gl->fGetActiveUniform(progname, index, len, &len, &usize, &utype, name);
if (len == 0 || usize == 0 || utype == 0) {
return nullptr;
}
nsCString reverseMappedName;
prog->ReverseMapIdentifier(nsDependentCString(name), &reverseMappedName);
// OpenGL ES 2.0 specifies that if foo is a uniform array, GetActiveUniform returns its name as "foo[0]".
// See section 2.10 page 35 in the OpenGL ES 2.0.24 specification:
//
// > If the active uniform is an array, the uniform name returned in name will always
// > be the name of the uniform array appended with "[0]".
//
// There is no such requirement in the OpenGL (non-ES) spec and indeed we have OpenGL implementations returning
// "foo" instead of "foo[0]". So, when implementing WebGL on top of desktop OpenGL, we must check if the
// returned name ends in [0], and if it doesn't, append that.
//
// In principle we don't need to do that on OpenGL ES, but this is such a tricky difference between the ES and non-ES
// specs that it seems probable that some ES implementers will overlook it. Since the work-around is quite cheap,
// we do it unconditionally.
if (usize > 1 && reverseMappedName.CharAt(reverseMappedName.Length()-1) != ']')
reverseMappedName.AppendLiteral("[0]");
nsRefPtr<WebGLActiveInfo> retActiveInfo =
new WebGLActiveInfo(usize, utype, reverseMappedName);
return retActiveInfo.forget();
}
void
WebGLContext::GetAttachedShaders(WebGLProgram *prog,
Nullable< nsTArray<WebGLShader*> > &retval)
{
retval.SetNull();
if (IsContextLost())
return;
if (!ValidateObjectAllowNull("getAttachedShaders", prog))
return;
MakeContextCurrent();
if (!prog) {
retval.SetNull();
ErrorInvalidValue("getAttachedShaders: invalid program");
} else if (prog->AttachedShaders().Length() == 0) {
retval.SetValue().TruncateLength(0);
} else {
retval.SetValue().AppendElements(prog->AttachedShaders());
}
}
GLint
WebGLContext::GetAttribLocation(WebGLProgram *prog, const nsAString& name)
{
if (IsContextLost())
return -1;
if (!ValidateObject("getAttribLocation: program", prog))
return -1;
if (!ValidateGLSLVariableName(name, "getAttribLocation"))
return -1;
NS_LossyConvertUTF16toASCII cname(name);
nsCString mappedName;
prog->MapIdentifier(cname, &mappedName);
GLuint progname = prog->GLName();
MakeContextCurrent();
return gl->fGetAttribLocation(progname, mappedName.get());
}
JS::Value
WebGLContext::GetBufferParameter(GLenum target, GLenum pname)
{
if (IsContextLost())
return JS::NullValue();
if (target != LOCAL_GL_ARRAY_BUFFER && target != LOCAL_GL_ELEMENT_ARRAY_BUFFER) {
ErrorInvalidEnumInfo("getBufferParameter: target", target);
return JS::NullValue();
}
MakeContextCurrent();
switch (pname) {
case LOCAL_GL_BUFFER_SIZE:
case LOCAL_GL_BUFFER_USAGE:
{
GLint i = 0;
gl->fGetBufferParameteriv(target, pname, &i);
if (pname == LOCAL_GL_BUFFER_SIZE) {
return JS::Int32Value(i);
}
MOZ_ASSERT(pname == LOCAL_GL_BUFFER_USAGE);
return JS::NumberValue(uint32_t(i));
}
break;
default:
ErrorInvalidEnumInfo("getBufferParameter: parameter", pname);
}
return JS::NullValue();
}
JS::Value
WebGLContext::GetFramebufferAttachmentParameter(JSContext* cx,
GLenum target,
GLenum attachment,
GLenum pname,
ErrorResult& rv)
{
if (IsContextLost())
return JS::NullValue();
if (target != LOCAL_GL_FRAMEBUFFER) {
ErrorInvalidEnumInfo("getFramebufferAttachmentParameter: target", target);
return JS::NullValue();
}
if (!mBoundFramebuffer) {
ErrorInvalidOperation("getFramebufferAttachmentParameter: cannot query framebuffer 0");
return JS::NullValue();
}
if (attachment != LOCAL_GL_DEPTH_ATTACHMENT &&
attachment != LOCAL_GL_STENCIL_ATTACHMENT &&
attachment != LOCAL_GL_DEPTH_STENCIL_ATTACHMENT)
{
if (IsExtensionEnabled(WebGLExtensionID::WEBGL_draw_buffers))
{
if (attachment < LOCAL_GL_COLOR_ATTACHMENT0 ||
attachment >= GLenum(LOCAL_GL_COLOR_ATTACHMENT0 + mGLMaxColorAttachments))
{
ErrorInvalidEnumInfo("getFramebufferAttachmentParameter: attachment", attachment);
return JS::NullValue();
}
mBoundFramebuffer->EnsureColorAttachments(attachment - LOCAL_GL_COLOR_ATTACHMENT0);
}
else if (attachment != LOCAL_GL_COLOR_ATTACHMENT0)
{
ErrorInvalidEnumInfo("getFramebufferAttachmentParameter: attachment", attachment);
return JS::NullValue();
}
}
MakeContextCurrent();
const WebGLFramebuffer::Attachment& fba = mBoundFramebuffer->GetAttachment(attachment);
if (fba.Renderbuffer()) {
switch (pname) {
case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT:
if (IsExtensionEnabled(WebGLExtensionID::EXT_sRGB)) {
const GLenum internalFormat = fba.Renderbuffer()->InternalFormat();
return (internalFormat == LOCAL_GL_SRGB_EXT ||
internalFormat == LOCAL_GL_SRGB_ALPHA_EXT ||
internalFormat == LOCAL_GL_SRGB8_ALPHA8_EXT) ?
JS::NumberValue(uint32_t(LOCAL_GL_SRGB_EXT)) :
JS::NumberValue(uint32_t(LOCAL_GL_LINEAR));
}
break;
case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
return JS::NumberValue(uint32_t(LOCAL_GL_RENDERBUFFER));
case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
return WebGLObjectAsJSValue(cx, fba.Renderbuffer(), rv);
case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: {
if (!IsExtensionEnabled(WebGLExtensionID::EXT_color_buffer_half_float) &&
!IsExtensionEnabled(WebGLExtensionID::WEBGL_color_buffer_float))
{
break;
}
if (attachment == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
ErrorInvalidOperation("getFramebufferAttachmentParameter: Cannot get component"
" type of a depth-stencil attachment.");
return JS::NullValue();
}
if (!fba.IsComplete())
return JS::NumberValue(uint32_t(LOCAL_GL_NONE));
uint32_t ret = LOCAL_GL_NONE;
switch (fba.Renderbuffer()->InternalFormat()) {
case LOCAL_GL_RGBA4:
case LOCAL_GL_RGB5_A1:
case LOCAL_GL_RGB565:
case LOCAL_GL_SRGB8_ALPHA8:
ret = LOCAL_GL_UNSIGNED_NORMALIZED;
break;
case LOCAL_GL_RGB16F:
case LOCAL_GL_RGBA16F:
case LOCAL_GL_RGB32F:
case LOCAL_GL_RGBA32F:
ret = LOCAL_GL_FLOAT;
break;
case LOCAL_GL_DEPTH_COMPONENT16:
case LOCAL_GL_STENCIL_INDEX8:
ret = LOCAL_GL_UNSIGNED_INT;
break;
default:
MOZ_ASSERT(false, "Unhandled RB component type.");
break;
}
return JS::NumberValue(uint32_t(ret));
}
}
ErrorInvalidEnumInfo("getFramebufferAttachmentParameter: pname", pname);
return JS::NullValue();
} else if (fba.Texture()) {
switch (pname) {
case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT:
if (IsExtensionEnabled(WebGLExtensionID::EXT_sRGB)) {
const GLenum webGLFormat =
fba.Texture()->ImageInfoBase().WebGLFormat();
return (webGLFormat == LOCAL_GL_SRGB ||
webGLFormat == LOCAL_GL_SRGB_ALPHA) ?
JS::NumberValue(uint32_t(LOCAL_GL_SRGB)) :
JS::NumberValue(uint32_t(LOCAL_GL_LINEAR));
}
break;
case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
return JS::NumberValue(uint32_t(LOCAL_GL_TEXTURE));
case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
return WebGLObjectAsJSValue(cx, fba.Texture(), rv);
case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
return JS::Int32Value(fba.TexImageLevel());
case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: {
GLenum face = fba.TexImageTarget();
if (face == LOCAL_GL_TEXTURE_2D)
face = 0;
return JS::Int32Value(face);
}
case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: {
if (!IsExtensionEnabled(WebGLExtensionID::EXT_color_buffer_half_float) &&
!IsExtensionEnabled(WebGLExtensionID::WEBGL_color_buffer_float))
{
break;
}
if (attachment == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
ErrorInvalidOperation("getFramebufferAttachmentParameter: cannot component"
" type of depth-stencil attachments.");
return JS::NullValue();
}
if (!fba.IsComplete())
return JS::NumberValue(uint32_t(LOCAL_GL_NONE));
uint32_t ret = LOCAL_GL_NONE;
GLenum type = fba.Texture()->ImageInfoAt(fba.TexImageTarget(),
fba.TexImageLevel()).WebGLType();
switch (type) {
case LOCAL_GL_UNSIGNED_BYTE:
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:
ret = LOCAL_GL_UNSIGNED_NORMALIZED;
break;
case LOCAL_GL_FLOAT:
case LOCAL_GL_HALF_FLOAT_OES:
ret = LOCAL_GL_FLOAT;
break;
case LOCAL_GL_UNSIGNED_SHORT:
case LOCAL_GL_UNSIGNED_INT:
ret = LOCAL_GL_UNSIGNED_INT;
break;
default:
MOZ_ASSERT(false, "Unhandled RB component type.");
break;
}
return JS::NumberValue(uint32_t(ret));
}
}
ErrorInvalidEnumInfo("getFramebufferAttachmentParameter: pname", pname);
return JS::NullValue();
} else {
switch (pname) {
case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
return JS::NumberValue(uint32_t(LOCAL_GL_NONE));
default:
ErrorInvalidEnumInfo("getFramebufferAttachmentParameter: pname", pname);
return JS::NullValue();
}
}
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_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:
{
// RB emulation means we have to ask the RB itself.
GLint i = mBoundRenderbuffer->GetRenderbufferParameter(target, pname);
return JS::Int32Value(i);
}
case LOCAL_GL_RENDERBUFFER_INTERNAL_FORMAT:
{
return JS::NumberValue(mBoundRenderbuffer->InternalFormat());
}
default:
ErrorInvalidEnumInfo("getRenderbufferParameter: parameter", pname);
}
return JS::NullValue();
}
already_AddRefed<WebGLTexture>
WebGLContext::CreateTexture()
{
if (IsContextLost())
return nullptr;
nsRefPtr<WebGLTexture> globj = new WebGLTexture(this);
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(WebGLProgram *prog, GLenum pname)
{
if (IsContextLost())
return JS::NullValue();
if (!ValidateObjectAllowDeleted("getProgramParameter: program", prog))
return JS::NullValue();
GLuint progname = prog->GLName();
MakeContextCurrent();
switch (pname) {
case LOCAL_GL_ATTACHED_SHADERS:
case LOCAL_GL_ACTIVE_UNIFORMS:
case LOCAL_GL_ACTIVE_ATTRIBUTES:
{
GLint i = 0;
gl->fGetProgramiv(progname, pname, &i);
return JS::Int32Value(i);
}
case LOCAL_GL_DELETE_STATUS:
return JS::BooleanValue(prog->IsDeleteRequested());
case LOCAL_GL_LINK_STATUS:
{
return JS::BooleanValue(prog->LinkStatus());
}
case LOCAL_GL_VALIDATE_STATUS:
{
GLint i = 0;
#ifdef XP_MACOSX
// See comment in ValidateProgram below.
if (gl->WorkAroundDriverBugs())
i = 1;
else
gl->fGetProgramiv(progname, pname, &i);
#else
gl->fGetProgramiv(progname, pname, &i);
#endif
return JS::BooleanValue(bool(i));
}
break;
default:
ErrorInvalidEnumInfo("getProgramParameter: parameter", pname);
}
return JS::NullValue();
}
void
WebGLContext::GetProgramInfoLog(WebGLProgram *prog, nsAString& retval)
{
nsAutoCString s;
GetProgramInfoLog(prog, s);
if (s.IsVoid())
retval.SetIsVoid(true);
else
CopyASCIItoUTF16(s, retval);
}
void
WebGLContext::GetProgramInfoLog(WebGLProgram *prog, nsACString& retval)
{
if (IsContextLost())
{
retval.SetIsVoid(true);
return;
}
if (!ValidateObject("getProgramInfoLog: program", prog)) {
retval.Truncate();
return;
}
GLuint progname = prog->GLName();
MakeContextCurrent();
GLint k = -1;
gl->fGetProgramiv(progname, LOCAL_GL_INFO_LOG_LENGTH, &k);
if (k == -1) {
// If GetProgramiv doesn't modify |k|,
// it's because there was a GL error.
// GetProgramInfoLog should return null on error. (Bug 746740)
retval.SetIsVoid(true);
return;
}
if (k == 0) {
retval.Truncate();
return;
}
retval.SetCapacity(k);
gl->fGetProgramInfoLog(progname, k, &k, (char*) retval.BeginWriting());
retval.SetLength(k);
}
// here we have to support all pnames with both int and float params.
// See this discussion:
// https://www.khronos.org/webgl/public-mailing-list/archives/1008/msg00014.html
void WebGLContext::TexParameter_base(GLenum target, GLenum pname,
GLint *intParamPtr,
GLfloat *floatParamPtr)
{
MOZ_ASSERT(intParamPtr || floatParamPtr);
if (IsContextLost())
return;
GLint intParam = intParamPtr ? *intParamPtr : GLint(*floatParamPtr);
GLfloat floatParam = floatParamPtr ? *floatParamPtr : GLfloat(*intParamPtr);
if (!ValidateTextureTargetEnum(target, "texParameter: target"))
return;
WebGLTexture *tex = activeBoundTextureForTarget(target);
if (!tex)
return ErrorInvalidOperation("texParameter: no texture is bound to this target");
bool pnameAndParamAreIncompatible = false;
bool paramValueInvalid = false;
switch (pname) {
case LOCAL_GL_TEXTURE_MIN_FILTER:
switch (intParam) {
case LOCAL_GL_NEAREST:
case LOCAL_GL_LINEAR:
case LOCAL_GL_NEAREST_MIPMAP_NEAREST:
case LOCAL_GL_LINEAR_MIPMAP_NEAREST:
case LOCAL_GL_NEAREST_MIPMAP_LINEAR:
case LOCAL_GL_LINEAR_MIPMAP_LINEAR:
tex->SetMinFilter(intParam);
break;
default:
pnameAndParamAreIncompatible = true;
}
break;
case LOCAL_GL_TEXTURE_MAG_FILTER:
switch (intParam) {
case LOCAL_GL_NEAREST:
case LOCAL_GL_LINEAR:
tex->SetMagFilter(intParam);
break;
default:
pnameAndParamAreIncompatible = true;
}
break;
case LOCAL_GL_TEXTURE_WRAP_S:
switch (intParam) {
case LOCAL_GL_CLAMP_TO_EDGE:
case LOCAL_GL_MIRRORED_REPEAT:
case LOCAL_GL_REPEAT:
tex->SetWrapS(intParam);
break;
default:
pnameAndParamAreIncompatible = true;
}
break;
case LOCAL_GL_TEXTURE_WRAP_T:
switch (intParam) {
case LOCAL_GL_CLAMP_TO_EDGE:
case LOCAL_GL_MIRRORED_REPEAT:
case LOCAL_GL_REPEAT:
tex->SetWrapT(intParam);
break;
default:
pnameAndParamAreIncompatible = true;
}
break;
case LOCAL_GL_TEXTURE_MAX_ANISOTROPY_EXT:
if (IsExtensionEnabled(WebGLExtensionID::EXT_texture_filter_anisotropic)) {
if (floatParamPtr && floatParam < 1.f)
paramValueInvalid = true;
else if (intParamPtr && intParam < 1)
paramValueInvalid = true;
}
else
pnameAndParamAreIncompatible = true;
break;
default:
return ErrorInvalidEnumInfo("texParameter: pname", pname);
}
if (pnameAndParamAreIncompatible) {
if (intParamPtr)
return ErrorInvalidEnum("texParameteri: pname %x and param %x (decimal %d) are mutually incompatible",
pname, intParam, intParam);
else
return ErrorInvalidEnum("texParameterf: pname %x and param %g are mutually incompatible",
pname, floatParam);
} else if (paramValueInvalid) {
if (intParamPtr)
return ErrorInvalidValue("texParameteri: pname %x and param %x (decimal %d) is invalid",
pname, intParam, intParam);
else
return ErrorInvalidValue("texParameterf: pname %x and param %g is invalid",
pname, floatParam);
}
MakeContextCurrent();
if (intParamPtr)
gl->fTexParameteri(target, pname, intParam);
else
gl->fTexParameterf(target, pname, floatParam);
}
JS::Value
WebGLContext::GetTexParameter(GLenum target, GLenum pname)
{
if (IsContextLost())
return JS::NullValue();
MakeContextCurrent();
if (!ValidateTextureTargetEnum(target, "getTexParameter: target"))
return JS::NullValue();
if (!activeBoundTextureForTarget(target)) {
ErrorInvalidOperation("getTexParameter: no texture bound");
return JS::NullValue();
}
switch (pname) {
case LOCAL_GL_TEXTURE_MIN_FILTER:
case LOCAL_GL_TEXTURE_MAG_FILTER:
case LOCAL_GL_TEXTURE_WRAP_S:
case LOCAL_GL_TEXTURE_WRAP_T:
{
GLint i = 0;
gl->fGetTexParameteriv(target, pname, &i);
return JS::NumberValue(uint32_t(i));
}
case LOCAL_GL_TEXTURE_MAX_ANISOTROPY_EXT:
if (IsExtensionEnabled(WebGLExtensionID::EXT_texture_filter_anisotropic)) {
GLfloat f = 0.f;
gl->fGetTexParameterfv(target, pname, &f);
return JS::DoubleValue(f);
}
ErrorInvalidEnumInfo("getTexParameter: parameter", pname);
break;
default:
ErrorInvalidEnumInfo("getTexParameter: parameter", pname);
}
return JS::NullValue();
}
JS::Value
WebGLContext::GetUniform(JSContext* cx, WebGLProgram *prog,
WebGLUniformLocation *location)
{
if (IsContextLost())
return JS::NullValue();
if (!ValidateObject("getUniform: program", prog))
return JS::NullValue();
if (!ValidateObject("getUniform: location", location))
return JS::NullValue();
if (location->Program() != prog) {
ErrorInvalidValue("getUniform: this uniform location corresponds to another program");
return JS::NullValue();
}
if (location->ProgramGeneration() != prog->Generation()) {
ErrorInvalidOperation("getUniform: this uniform location is obsolete since the program has been relinked");
return JS::NullValue();
}
GLuint progname = prog->GLName();
MakeContextCurrent();
GLint uniforms = 0;
GLint uniformNameMaxLength = 0;
gl->fGetProgramiv(progname, LOCAL_GL_ACTIVE_UNIFORMS, &uniforms);
gl->fGetProgramiv(progname, LOCAL_GL_ACTIVE_UNIFORM_MAX_LENGTH, &uniformNameMaxLength);
// we now need the type info to switch between fGetUniformfv and fGetUniformiv
// the only way to get that is to iterate through all active uniforms by index until
// one matches the given uniform location.
GLenum uniformType = 0;
nsAutoArrayPtr<GLchar> uniformName(new GLchar[uniformNameMaxLength]);
// this buffer has 16 more bytes to be able to store [index] at the end.
nsAutoArrayPtr<GLchar> uniformNameBracketIndex(new GLchar[uniformNameMaxLength + 16]);
GLint index;
for (index = 0; index < uniforms; ++index) {
GLsizei length;
GLint size;
gl->fGetActiveUniform(progname, index, uniformNameMaxLength, &length,
&size, &uniformType, uniformName);
if (gl->fGetUniformLocation(progname, uniformName) == location->Location())
break;
// now we handle the case of array uniforms. In that case, fGetActiveUniform returned as 'size'
// the biggest index used plus one, so we need to loop over that. The 0 index has already been handled above,
// so we can start at one. For each index, we construct the string uniformName + "[" + index + "]".
if (size > 1) {
bool found_it = false;
if (uniformName[length - 1] == ']') { // if uniformName ends in [0]
// remove the [0] at the end
length -= 3;
uniformName[length] = 0;
}
for (GLint arrayIndex = 1; arrayIndex < size; arrayIndex++) {
sprintf(uniformNameBracketIndex.get(), "%s[%d]", uniformName.get(), arrayIndex);
if (gl->fGetUniformLocation(progname, uniformNameBracketIndex) == location->Location()) {
found_it = true;
break;
}
}
if (found_it) break;
}
}
if (index == uniforms) {
GenerateWarning("getUniform: internal error: hit an OpenGL driver bug");
return JS::NullValue();
}
GLenum baseType;
GLint unitSize;
if (!BaseTypeAndSizeFromUniformType(uniformType, &baseType, &unitSize)) {
GenerateWarning("getUniform: internal error: unknown uniform type 0x%x", uniformType);
return JS::NullValue();
}
// this should never happen
if (unitSize > 16) {
GenerateWarning("getUniform: internal error: unexpected uniform unit size %d", unitSize);
return JS::NullValue();
}
if (baseType == LOCAL_GL_FLOAT) {
GLfloat fv[16] = { GLfloat(0) };
gl->fGetUniformfv(progname, location->Location(), fv);
if (unitSize == 1) {
return JS::DoubleValue(fv[0]);
} else {
JSObject* obj = Float32Array::Create(cx, this, unitSize, fv);
if (!obj) {
ErrorOutOfMemory("getUniform: out of memory");
return JS::NullValue();
}
return JS::ObjectOrNullValue(obj);
}
} else if (baseType == LOCAL_GL_INT) {
GLint iv[16] = { 0 };
gl->fGetUniformiv(progname, location->Location(), iv);
if (unitSize == 1) {
return JS::Int32Value(iv[0]);
} else {
JSObject* obj = Int32Array::Create(cx, this, unitSize, iv);
if (!obj) {
ErrorOutOfMemory("getUniform: out of memory");
return JS::NullValue();
}
return JS::ObjectOrNullValue(obj);
}
} else if (baseType == LOCAL_GL_BOOL) {
GLint iv[16] = { 0 };
gl->fGetUniformiv(progname, location->Location(), iv);
if (unitSize == 1) {
return JS::BooleanValue(iv[0] ? true : false);
} else {
bool uv[16];
for (int k = 0; k < unitSize; k++)
uv[k] = iv[k];
JS::Rooted<JS::Value> val(cx);
// Be careful: we don't want to convert all of |uv|!
if (!ToJSValue(cx, uv, unitSize, &val)) {
ErrorOutOfMemory("getUniform: out of memory");
return JS::NullValue();
}
return val;
}
}
// Else preserving behavior, but I'm not sure this is correct per spec
return JS::UndefinedValue();
}
already_AddRefed<WebGLUniformLocation>
WebGLContext::GetUniformLocation(WebGLProgram *prog, const nsAString& name)
{
if (IsContextLost())
return nullptr;
if (!ValidateObject("getUniformLocation: program", prog))
return nullptr;
if (!ValidateGLSLVariableName(name, "getUniformLocation"))
return nullptr;
NS_LossyConvertUTF16toASCII cname(name);
nsCString mappedName;
prog->MapIdentifier(cname, &mappedName);
GLuint progname = prog->GLName();
MakeContextCurrent();
GLint intlocation = gl->fGetUniformLocation(progname, mappedName.get());
nsRefPtr<WebGLUniformLocation> loc;
if (intlocation >= 0) {
WebGLUniformInfo info = prog->GetUniformInfoForMappedIdentifier(mappedName);
loc = new WebGLUniformLocation(this,
prog,
intlocation,
info);
}
return loc.forget();
}
void
WebGLContext::Hint(GLenum target, GLenum mode)
{
if (IsContextLost())
return;
bool isValid = false;
switch (target) {
case LOCAL_GL_GENERATE_MIPMAP_HINT:
isValid = true;
break;
case LOCAL_GL_FRAGMENT_SHADER_DERIVATIVE_HINT:
if (IsExtensionEnabled(WebGLExtensionID::OES_standard_derivatives))
isValid = true;
break;
}
if (!isValid)
return ErrorInvalidEnum("hint: invalid hint");
MakeContextCurrent();
gl->fHint(target, mode);
}
bool
WebGLContext::IsFramebuffer(WebGLFramebuffer *fb)
{
if (IsContextLost())
return false;
return ValidateObjectAllowDeleted("isFramebuffer", fb) &&
!fb->IsDeleted() &&
fb->HasEverBeenBound();
}
bool
WebGLContext::IsProgram(WebGLProgram *prog)
{
if (IsContextLost())
return false;
return ValidateObjectAllowDeleted("isProgram", prog) && !prog->IsDeleted();
}
bool
WebGLContext::IsRenderbuffer(WebGLRenderbuffer *rb)
{
if (IsContextLost())
return false;
return ValidateObjectAllowDeleted("isRenderBuffer", rb) &&
!rb->IsDeleted() &&
rb->HasEverBeenBound();
}
bool
WebGLContext::IsShader(WebGLShader *shader)
{
if (IsContextLost())
return false;
return ValidateObjectAllowDeleted("isShader", shader) &&
!shader->IsDeleted();
}
bool
WebGLContext::IsTexture(WebGLTexture *tex)
{
if (IsContextLost())
return false;
return ValidateObjectAllowDeleted("isTexture", tex) &&
!tex->IsDeleted() &&
tex->HasEverBeenBound();
}
// Try to bind an attribute that is an array to location 0:
bool WebGLContext::BindArrayAttribToLocation0(WebGLProgram *program)
{
if (mBoundVertexArray->IsAttribArrayEnabled(0)) {
return false;
}
GLint leastArrayLocation = -1;
std::map<GLint, nsCString>::iterator itr;
for (itr = program->mActiveAttribMap.begin();
itr != program->mActiveAttribMap.end();
itr++) {
int32_t index = itr->first;
if (mBoundVertexArray->IsAttribArrayEnabled(index) &&
index < leastArrayLocation)
{
leastArrayLocation = index;
}
}
if (leastArrayLocation > 0) {
nsCString& attrName = program->mActiveAttribMap.find(leastArrayLocation)->second;
const char* attrNameCStr = attrName.get();
gl->fBindAttribLocation(program->GLName(), 0, attrNameCStr);
return true;
}
return false;
}
void
WebGLContext::LinkProgram(WebGLProgram *program)
{
if (IsContextLost())
return;
if (!ValidateObject("linkProgram", program))
return;
InvalidateBufferFetching(); // we do it early in this function
// as some of the validation below changes program state
GLuint progname = program->GLName();
if (!program->NextGeneration()) {
// XXX throw?
return;
}
if (!program->HasBothShaderTypesAttached()) {
GenerateWarning("linkProgram: this program doesn't have both a vertex shader"
" and a fragment shader");
program->SetLinkStatus(false);
return;
}
// bug 777028
// Mesa can't handle more than 16 samplers per program, counting each array entry.
if (gl->WorkAroundDriverBugs() &&
mIsMesa &&
program->UpperBoundNumSamplerUniforms() > 16)
{
GenerateWarning("Programs with more than 16 samplers are disallowed on Mesa drivers " "to avoid a Mesa crasher.");
program->SetLinkStatus(false);
return;
}
bool updateInfoSucceeded = false;
GLint ok = 0;
if (gl->WorkAroundDriverBugs() &&
program->HasBadShaderAttached())
{
// it's a common driver bug, caught by program-test.html, that linkProgram doesn't
// correctly preserve the state of an in-use program that has been attached a bad shader
// see bug 777883
ok = false;
} else {
MakeContextCurrent();
gl->fLinkProgram(progname);
gl->fGetProgramiv(progname, LOCAL_GL_LINK_STATUS, &ok);
if (ok) {
updateInfoSucceeded = program->UpdateInfo();
program->SetLinkStatus(updateInfoSucceeded);
if (BindArrayAttribToLocation0(program)) {
GenerateWarning("linkProgram: relinking program to make attrib0 an "
"array.");
gl->fLinkProgram(progname);
gl->fGetProgramiv(progname, LOCAL_GL_LINK_STATUS, &ok);
if (ok) {
updateInfoSucceeded = program->UpdateInfo();
program->SetLinkStatus(updateInfoSucceeded);
}
}
}
}
if (ok) {
// Bug 750527
if (gl->WorkAroundDriverBugs() &&
updateInfoSucceeded &&
gl->Vendor() == gl::GLVendor::NVIDIA)
{
if (program == mCurrentProgram)
gl->fUseProgram(progname);
}
} else {
program->SetLinkStatus(false);
if (ShouldGenerateWarnings()) {
// report shader/program infoLogs as warnings.
// note that shader compilation errors can be deferred to linkProgram,
// which is why we can't do anything in compileShader. In practice we could
// report in compileShader the translation errors generated by ANGLE,
// but it seems saner to keep a single way of obtaining shader infologs.
nsAutoCString log;
bool alreadyReportedShaderInfoLog = false;
for (size_t i = 0; i < program->AttachedShaders().Length(); i++) {
WebGLShader* shader = program->AttachedShaders()[i];
if (shader->CompileStatus())
continue;
const char *shaderTypeName = nullptr;
if (shader->ShaderType() == LOCAL_GL_VERTEX_SHADER) {
shaderTypeName = "vertex";
} else if (shader->ShaderType() == LOCAL_GL_FRAGMENT_SHADER) {
shaderTypeName = "fragment";
} else {
// should have been validated earlier
MOZ_ASSERT(false);
shaderTypeName = "<unknown>";
}
GetShaderInfoLog(shader, log);
GenerateWarning("linkProgram: a %s shader used in this program failed to "
"compile, with this log:\n%s\n",
shaderTypeName,
log.get());
alreadyReportedShaderInfoLog = true;
}
if (!alreadyReportedShaderInfoLog) {
GetProgramInfoLog(program, log);
if (!log.IsEmpty()) {
GenerateWarning("linkProgram failed, with this log:\n%s\n",
log.get());
}
}
}
}
}
void
WebGLContext::PixelStorei(GLenum pname, GLint param)
{
if (IsContextLost())
return;
switch (pname) {
case UNPACK_FLIP_Y_WEBGL:
mPixelStoreFlipY = (param != 0);
break;
case UNPACK_PREMULTIPLY_ALPHA_WEBGL:
mPixelStorePremultiplyAlpha = (param != 0);
break;
case UNPACK_COLORSPACE_CONVERSION_WEBGL:
if (param == LOCAL_GL_NONE || param == BROWSER_DEFAULT_WEBGL)
mPixelStoreColorspaceConversion = param;
else
return ErrorInvalidEnumInfo("pixelStorei: colorspace conversion parameter", param);
break;
case LOCAL_GL_PACK_ALIGNMENT:
case LOCAL_GL_UNPACK_ALIGNMENT:
if (param != 1 &&
param != 2 &&
param != 4 &&
param != 8)
return ErrorInvalidValue("pixelStorei: invalid pack/unpack alignment value");
if (pname == LOCAL_GL_PACK_ALIGNMENT)
mPixelStorePackAlignment = param;
else if (pname == LOCAL_GL_UNPACK_ALIGNMENT)
mPixelStoreUnpackAlignment = param;
MakeContextCurrent();
gl->fPixelStorei(pname, param);
break;
default:
return ErrorInvalidEnumInfo("pixelStorei: parameter", pname);
}
}
void
WebGLContext::ReadPixels(GLint x, GLint y, GLsizei width,
GLsizei height, GLenum format,
GLenum type, const Nullable<ArrayBufferView> &pixels,
ErrorResult& rv)
{
if (IsContextLost())
return;
if (mCanvasElement->IsWriteOnly() && !nsContentUtils::IsCallerChrome()) {
GenerateWarning("readPixels: Not allowed");
return rv.Throw(NS_ERROR_DOM_SECURITY_ERR);
}
if (width < 0 || height < 0)
return ErrorInvalidValue("readPixels: negative size passed");
if (pixels.IsNull())
return ErrorInvalidValue("readPixels: null destination buffer");
const WebGLRectangleObject* framebufferRect = CurValidFBRectObject();
GLsizei framebufferWidth = framebufferRect ? framebufferRect->Width() : 0;
GLsizei framebufferHeight = framebufferRect ? framebufferRect->Height() : 0;
uint32_t channels = 0;
// Check the format param
switch (format) {
case LOCAL_GL_ALPHA:
channels = 1;
break;
case LOCAL_GL_RGB:
channels = 3;
break;
case LOCAL_GL_RGBA:
channels = 4;
break;
default:
return ErrorInvalidEnum("readPixels: Bad format");
}
uint32_t bytesPerPixel = 0;
int requiredDataType = 0;
// Check the type param
bool isReadTypeValid = false;
bool isReadTypeFloat = false;
switch (type) {
case LOCAL_GL_UNSIGNED_BYTE:
isReadTypeValid = true;
bytesPerPixel = 1*channels;
requiredDataType = js::Scalar::Uint8;
break;
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:
isReadTypeValid = true;
bytesPerPixel = 2;
requiredDataType = js::Scalar::Uint16;
break;
case LOCAL_GL_FLOAT:
if (IsExtensionEnabled(WebGLExtensionID::WEBGL_color_buffer_float) ||
IsExtensionEnabled(WebGLExtensionID::EXT_color_buffer_half_float))
{
isReadTypeValid = true;
isReadTypeFloat = true;
bytesPerPixel = 4*channels;
requiredDataType = js::Scalar::Float32;
}
break;
}
if (!isReadTypeValid)
return ErrorInvalidEnum("readPixels: Bad type", type);
const ArrayBufferView& pixbuf = pixels.Value();
int dataType = JS_GetArrayBufferViewType(pixbuf.Obj());
// Check the pixels param type
if (dataType != requiredDataType)
return ErrorInvalidOperation("readPixels: Mismatched type/pixels types");
// Check the pixels param size
CheckedUint32 checked_neededByteLength =
GetImageSize(height, width, bytesPerPixel, mPixelStorePackAlignment);
CheckedUint32 checked_plainRowSize = CheckedUint32(width) * bytesPerPixel;
CheckedUint32 checked_alignedRowSize =
RoundedToNextMultipleOf(checked_plainRowSize, mPixelStorePackAlignment);
if (!checked_neededByteLength.isValid())
return ErrorInvalidOperation("readPixels: integer overflow computing the needed buffer size");
// Compute length and data. Don't reenter after this point, lest the
// precomputed go out of sync with the instant length/data.
pixbuf.ComputeLengthAndData();
uint32_t dataByteLen = pixbuf.Length();
if (checked_neededByteLength.value() > dataByteLen)
return ErrorInvalidOperation("readPixels: buffer too small");
void* data = pixbuf.Data();
if (!data) {
ErrorOutOfMemory("readPixels: buffer storage is null. Did we run out of memory?");
return rv.Throw(NS_ERROR_OUT_OF_MEMORY);
}
bool isSourceTypeFloat = false;
if (mBoundFramebuffer &&
mBoundFramebuffer->ColorAttachmentCount() &&
mBoundFramebuffer->ColorAttachment(0).IsDefined())
{
isSourceTypeFloat = mBoundFramebuffer->ColorAttachment(0).IsReadableFloat();
}
if (isReadTypeFloat != isSourceTypeFloat)
return ErrorInvalidOperation("readPixels: Invalid type floatness");
// Check the format and type params to assure they are an acceptable pair (as per spec)
MakeContextCurrent();
if (mBoundFramebuffer) {
// prevent readback of arbitrary video memory through uninitialized renderbuffers!
if (!mBoundFramebuffer->CheckAndInitializeAttachments())
return ErrorInvalidFramebufferOperation("readPixels: incomplete framebuffer");
GLenum readPlaneBits = LOCAL_GL_COLOR_BUFFER_BIT;
if (!mBoundFramebuffer->HasCompletePlanes(readPlaneBits)) {
return ErrorInvalidOperation("readPixels: Read source attachment doesn't have the"
" correct color/depth/stencil type.");
}
} else {
ClearBackbufferIfNeeded();
}
bool isFormatAndTypeValid = false;
// OpenGL ES 2.0 $4.3.1 - IMPLEMENTATION_COLOR_READ_{TYPE/FORMAT} is a valid
// combination for glReadPixels().
if (gl->IsSupported(gl::GLFeature::ES2_compatibility)) {
GLenum implType = 0;
GLenum implFormat = 0;
gl->fGetIntegerv(LOCAL_GL_IMPLEMENTATION_COLOR_READ_TYPE,
reinterpret_cast<GLint*>(&implType));
gl->fGetIntegerv(LOCAL_GL_IMPLEMENTATION_COLOR_READ_FORMAT,
reinterpret_cast<GLint*>(&implFormat));
if (type == implType && format == implFormat) {
isFormatAndTypeValid = true;
}
}
switch (format) {
case LOCAL_GL_RGBA: {
switch (type) {
case LOCAL_GL_UNSIGNED_BYTE:
case LOCAL_GL_FLOAT:
isFormatAndTypeValid = true;
break;
}
break;
}
}
if (!isFormatAndTypeValid) {
return ErrorInvalidOperation("readPixels: Invalid format/type pair");
}
// Now that the errors are out of the way, on to actually reading
// If we won't be reading any pixels anyways, just skip the actual reading
if (width == 0 || height == 0)
return DummyFramebufferOperation("readPixels");
if (CanvasUtils::CheckSaneSubrectSize(x, y, width, height, framebufferWidth, framebufferHeight)) {
// the easy case: we're not reading out-of-range pixels
gl->fReadPixels(x, y, width, height, format, type, data);
} else {
// the rectangle doesn't fit entirely in the bound buffer. We then have to set to zero the part
// of the buffer that correspond to out-of-range pixels. We don't want to rely on system OpenGL
// to do that for us, because passing out of range parameters to a buggy OpenGL implementation
// could conceivably allow to read memory we shouldn't be allowed to read. So we manually initialize
// the buffer to zero and compute the parameters to pass to OpenGL. We have to use an intermediate buffer
// to accomodate the potentially different strides (widths).
// Zero the whole pixel dest area in the destination buffer.
memset(data, 0, checked_neededByteLength.value());
if ( x >= framebufferWidth
|| x+width <= 0
|| y >= framebufferHeight
|| y+height <= 0)
{
// we are completely outside of range, can exit now with buffer filled with zeros
return DummyFramebufferOperation("readPixels");
}
// compute the parameters of the subrect we're actually going to call glReadPixels on
GLint subrect_x = std::max(x, 0);
GLint subrect_end_x = std::min(x+width, framebufferWidth);
GLsizei subrect_width = subrect_end_x - subrect_x;
GLint subrect_y = std::max(y, 0);
GLint subrect_end_y = std::min(y+height, framebufferHeight);
GLsizei subrect_height = subrect_end_y - subrect_y;
if (subrect_width < 0 || subrect_height < 0 ||
subrect_width > width || subrect_height > height)
return ErrorInvalidOperation("readPixels: integer overflow computing clipped rect size");
// now we know that subrect_width is in the [0..width] interval, and same for heights.
// now, same computation as above to find the size of the intermediate buffer to allocate for the subrect
// no need to check again for integer overflow here, since we already know the sizes aren't greater than before
uint32_t subrect_plainRowSize = subrect_width * bytesPerPixel;
// There are checks above to ensure that this doesn't overflow.
uint32_t subrect_alignedRowSize =
RoundedToNextMultipleOf(subrect_plainRowSize, mPixelStorePackAlignment).value();
uint32_t subrect_byteLength = (subrect_height-1)*subrect_alignedRowSize + subrect_plainRowSize;
// create subrect buffer, call glReadPixels, copy pixels into destination buffer, delete subrect buffer
GLubyte *subrect_data = new GLubyte[subrect_byteLength];
gl->fReadPixels(subrect_x, subrect_y, subrect_width, subrect_height, format, type, subrect_data);
// notice that this for loop terminates because we already checked that subrect_height is at most height
for (GLint y_inside_subrect = 0; y_inside_subrect < subrect_height; ++y_inside_subrect) {
GLint subrect_x_in_dest_buffer = subrect_x - x;
GLint subrect_y_in_dest_buffer = subrect_y - y;
memcpy(static_cast<GLubyte*>(data)
+ checked_alignedRowSize.value() * (subrect_y_in_dest_buffer + y_inside_subrect)
+ bytesPerPixel * subrect_x_in_dest_buffer, // destination
subrect_data + subrect_alignedRowSize * y_inside_subrect, // source
subrect_plainRowSize); // size
}
delete [] subrect_data;
}
// if we're reading alpha, we may need to do fixup. Note that we don't allow
// GL_ALPHA to readpixels currently, but we had the code written for it already.
if (format == LOCAL_GL_ALPHA ||
format == LOCAL_GL_RGBA)
{
bool needAlphaFixup;
if (mBoundFramebuffer) {
needAlphaFixup = !mBoundFramebuffer->ColorAttachment(0).HasAlpha();
} else {
needAlphaFixup = gl->GetPixelFormat().alpha == 0;
}
if (needAlphaFixup) {
if (format == LOCAL_GL_ALPHA && type == LOCAL_GL_UNSIGNED_BYTE) {
// this is easy; it's an 0xff memset per row
uint8_t *row = static_cast<uint8_t*>(data);
for (GLint j = 0; j < height; ++j) {
memset(row, 0xff, checked_plainRowSize.value());
row += checked_alignedRowSize.value();
}
} else if (format == LOCAL_GL_RGBA && type == LOCAL_GL_UNSIGNED_BYTE) {
// this is harder, we need to just set the alpha byte here
uint8_t *row = static_cast<uint8_t*>(data);
for (GLint j = 0; j < height; ++j) {
uint8_t *rowp = row;
#if MOZ_LITTLE_ENDIAN
// offset to get the alpha byte; we're always going to
// move by 4 bytes
rowp += 3;
#endif
uint8_t *endrowp = rowp + 4 * width;
while (rowp != endrowp) {
*rowp = 0xff;
rowp += 4;
}
row += checked_alignedRowSize.value();
}
} else if (format == LOCAL_GL_RGBA && type == LOCAL_GL_FLOAT) {
float* row = static_cast<float*>(data);
for (GLint j = 0; j < height; ++j) {
float* pAlpha = row + 3;
float* pAlphaEnd = pAlpha + 4*width;
while (pAlpha != pAlphaEnd) {
*pAlpha = 1.0f;
pAlpha += 4;
}
row += checked_alignedRowSize.value();
}
} else {
NS_WARNING("Unhandled case, how'd we get here?");
return rv.Throw(NS_ERROR_FAILURE);
}
}
}
}
void
WebGLContext::RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
{
if (IsContextLost())
return;
if (!mBoundRenderbuffer)
return ErrorInvalidOperation("renderbufferStorage called on renderbuffer 0");
if (target != LOCAL_GL_RENDERBUFFER)
return ErrorInvalidEnumInfo("renderbufferStorage: target", target);
if (width < 0 || height < 0)
return ErrorInvalidValue("renderbufferStorage: width and height must be >= 0");
if (width > mGLMaxRenderbufferSize || height > mGLMaxRenderbufferSize)
return ErrorInvalidValue("renderbufferStorage: width or height exceeds maximum renderbuffer size");
// certain OpenGL ES renderbuffer formats may not exist on desktop OpenGL
GLenum internalformatForGL = internalformat;
switch (internalformat) {
case LOCAL_GL_RGBA4:
case LOCAL_GL_RGB5_A1:
// 16-bit RGBA formats are not supported on desktop GL
if (!gl->IsGLES()) internalformatForGL = LOCAL_GL_RGBA8;
break;
case LOCAL_GL_RGB565:
// the RGB565 format is not supported on desktop GL
if (!gl->IsGLES()) internalformatForGL = LOCAL_GL_RGB8;
break;
case LOCAL_GL_DEPTH_COMPONENT16:
if (!gl->IsGLES() || gl->IsExtensionSupported(gl::GLContext::OES_depth24))
internalformatForGL = LOCAL_GL_DEPTH_COMPONENT24;
else if (gl->IsExtensionSupported(gl::GLContext::OES_packed_depth_stencil))
internalformatForGL = LOCAL_GL_DEPTH24_STENCIL8;
break;
case LOCAL_GL_STENCIL_INDEX8:
break;
case LOCAL_GL_DEPTH_STENCIL:
// We emulate this in WebGLRenderbuffer if we don't have the requisite extension.
internalformatForGL = LOCAL_GL_DEPTH24_STENCIL8;
break;
case LOCAL_GL_SRGB8_ALPHA8_EXT:
break;
case LOCAL_GL_RGB16F:
case LOCAL_GL_RGBA16F: {
bool hasExtensions = IsExtensionEnabled(WebGLExtensionID::OES_texture_half_float) &&
IsExtensionEnabled(WebGLExtensionID::EXT_color_buffer_half_float);
if (!hasExtensions)
return ErrorInvalidEnumInfo("renderbufferStorage: internalformat", target);
break;
}
case LOCAL_GL_RGB32F:
case LOCAL_GL_RGBA32F: {
bool hasExtensions = IsExtensionEnabled(WebGLExtensionID::OES_texture_float) &&
IsExtensionEnabled(WebGLExtensionID::WEBGL_color_buffer_float);
if (!hasExtensions)
return ErrorInvalidEnumInfo("renderbufferStorage: internalformat", target);
break;
}
default:
return ErrorInvalidEnumInfo("renderbufferStorage: internalformat", internalformat);
}
MakeContextCurrent();
bool sizeChanges = width != mBoundRenderbuffer->Width() ||
height != mBoundRenderbuffer->Height() ||
internalformat != mBoundRenderbuffer->InternalFormat();
if (sizeChanges) {
// Invalidate framebuffer status cache
mBoundRenderbuffer->NotifyFBsStatusChanged();
GetAndFlushUnderlyingGLErrors();
mBoundRenderbuffer->RenderbufferStorage(internalformatForGL, width, height);
GLenum error = GetAndFlushUnderlyingGLErrors();
if (error) {
GenerateWarning("renderbufferStorage generated error %s", ErrorName(error));
return;
}
} else {
mBoundRenderbuffer->RenderbufferStorage(internalformatForGL, width, height);
}
mBoundRenderbuffer->SetInternalFormat(internalformat);
mBoundRenderbuffer->SetInternalFormatForGL(internalformatForGL);
mBoundRenderbuffer->setDimensions(width, height);
mBoundRenderbuffer->SetImageDataStatus(WebGLImageDataStatus::UninitializedImageData);
}
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);
}
nsresult
WebGLContext::SurfaceFromElementResultToImageSurface(nsLayoutUtils::SurfaceFromElementResult& res,
RefPtr<DataSourceSurface>& imageOut, WebGLTexelFormat *format)
{
*format = WebGLTexelFormat::None;
if (!res.mSourceSurface)
return NS_OK;
RefPtr<DataSourceSurface> data = res.mSourceSurface->GetDataSurface();
if (!data) {
// SurfaceFromElement lied!
return NS_OK;
}
if (!mPixelStorePremultiplyAlpha && res.mIsPremultiplied) {
switch (data->GetFormat()) {
case SurfaceFormat::B8G8R8X8:
// No alpha, so de-facto premult'd.
break;
case SurfaceFormat::B8G8R8A8:
data = gfxUtils::CreateUnpremultipliedDataSurface(data);
break;
default:
MOZ_ASSERT(false, "Format unsupported.");
break;
}
}
// We disallow loading cross-domain images and videos that have not been validated
// with CORS as WebGL textures. The reason for doing that is that timing
// attacks on WebGL shaders are able to retrieve approximations of the
// pixel values in WebGL textures; see bug 655987.
//
// To prevent a loophole where a Canvas2D would be used as a proxy to load
// cross-domain textures, we also disallow loading textures from write-only
// Canvas2D's.
// part 1: check that the DOM element is same-origin, or has otherwise been
// validated for cross-domain use.
if (!res.mCORSUsed) {
bool subsumes;
nsresult rv = mCanvasElement->NodePrincipal()->Subsumes(res.mPrincipal, &subsumes);
if (NS_FAILED(rv) || !subsumes) {
GenerateWarning("It is forbidden to load a WebGL texture from a cross-domain element that has not been validated with CORS. "
"See https://developer.mozilla.org/en/WebGL/Cross-Domain_Textures");
return NS_ERROR_DOM_SECURITY_ERR;
}
}
// part 2: if the DOM element is write-only, it might contain
// cross-domain image data.
if (res.mIsWriteOnly) {
GenerateWarning("The canvas used as source for texImage2D here is tainted (write-only). It is forbidden "
"to load a WebGL texture from a tainted canvas. A Canvas becomes tainted for example "
"when a cross-domain image is drawn on it. "
"See https://developer.mozilla.org/en/WebGL/Cross-Domain_Textures");
return NS_ERROR_DOM_SECURITY_ERR;
}
// End of security checks, now we should be safe regarding cross-domain images
// Notice that there is never a need to mark the WebGL canvas as write-only, since we reject write-only/cross-domain
// texture sources in the first place.
switch (data->GetFormat()) {
case SurfaceFormat::B8G8R8A8:
*format = WebGLTexelFormat::BGRA8; // careful, our ARGB means BGRA
break;
case SurfaceFormat::B8G8R8X8:
*format = WebGLTexelFormat::BGRX8; // careful, our RGB24 is not tightly packed. Whence BGRX8.
break;
case SurfaceFormat::A8:
*format = WebGLTexelFormat::A8;
break;
case SurfaceFormat::R5G6B5:
*format = WebGLTexelFormat::RGB565;
break;
default:
NS_ASSERTION(false, "Unsupported image format. Unimplemented.");
return NS_ERROR_NOT_IMPLEMENTED;
}
imageOut = data;
return NS_OK;
}
void
WebGLContext::Uniform1i(WebGLUniformLocation *location_object, GLint a1)
{
GLint location;
if (!ValidateUniformSetter("Uniform1i", location_object, location))
return;
// Only uniform1i can take sampler settings.
if (!ValidateSamplerUniformSetter("Uniform1i", location_object, a1))
return;
MakeContextCurrent();
gl->fUniform1i(location, a1);
}
void
WebGLContext::Uniform2i(WebGLUniformLocation *location_object, GLint a1,
GLint a2)
{
GLint location;
if (!ValidateUniformSetter("Uniform2i", location_object, location))
return;
MakeContextCurrent();
gl->fUniform2i(location, a1, a2);
}
void
WebGLContext::Uniform3i(WebGLUniformLocation *location_object, GLint a1,
GLint a2, GLint a3)
{
GLint location;
if (!ValidateUniformSetter("Uniform3i", location_object, location))
return;
MakeContextCurrent();
gl->fUniform3i(location, a1, a2, a3);
}
void
WebGLContext::Uniform4i(WebGLUniformLocation *location_object, GLint a1,
GLint a2, GLint a3, GLint a4)
{
GLint location;
if (!ValidateUniformSetter("Uniform4i", location_object, location))
return;
MakeContextCurrent();
gl->fUniform4i(location, a1, a2, a3, a4);
}
void
WebGLContext::Uniform1f(WebGLUniformLocation *location_object, GLfloat a1)
{
GLint location;
if (!ValidateUniformSetter("Uniform1f", location_object, location))
return;
MakeContextCurrent();
gl->fUniform1f(location, a1);
}
void
WebGLContext::Uniform2f(WebGLUniformLocation *location_object, GLfloat a1,
GLfloat a2)
{
GLint location;
if (!ValidateUniformSetter("Uniform2f", location_object, location))
return;
MakeContextCurrent();
gl->fUniform2f(location, a1, a2);
}
void
WebGLContext::Uniform3f(WebGLUniformLocation *location_object, GLfloat a1,
GLfloat a2, GLfloat a3)
{
GLint location;
if (!ValidateUniformSetter("Uniform3f", location_object, location))
return;
MakeContextCurrent();
gl->fUniform3f(location, a1, a2, a3);
}
void
WebGLContext::Uniform4f(WebGLUniformLocation *location_object, GLfloat a1,
GLfloat a2, GLfloat a3, GLfloat a4)
{
GLint location;
if (!ValidateUniformSetter("Uniform4f", location_object, location))
return;
MakeContextCurrent();
gl->fUniform4f(location, a1, a2, a3, a4);
}
void
WebGLContext::Uniform1iv_base(WebGLUniformLocation *location_object,
uint32_t arrayLength, const GLint* data)
{
uint32_t numElementsToUpload;
GLint location;
if (!ValidateUniformArraySetter("Uniform1iv", 1, location_object, location,
numElementsToUpload, arrayLength)) {
return;
}
if (!ValidateSamplerUniformSetter("Uniform1iv", location_object, data[0]))
return;
MakeContextCurrent();
gl->fUniform1iv(location, numElementsToUpload, data);
}
void
WebGLContext::Uniform2iv_base(WebGLUniformLocation *location_object,
uint32_t arrayLength, const GLint* data)
{
uint32_t numElementsToUpload;
GLint location;
if (!ValidateUniformArraySetter("Uniform2iv", 2, location_object, location,
numElementsToUpload, arrayLength)) {
return;
}
if (!ValidateSamplerUniformSetter("Uniform2iv", location_object, data[0]) ||
!ValidateSamplerUniformSetter("Uniform2iv", location_object, data[1]))
{
return;
}
MakeContextCurrent();
gl->fUniform2iv(location, numElementsToUpload, data);
}
void
WebGLContext::Uniform3iv_base(WebGLUniformLocation *location_object,
uint32_t arrayLength, const GLint* data)
{
uint32_t numElementsToUpload;
GLint location;
if (!ValidateUniformArraySetter("Uniform3iv", 3, location_object, location,
numElementsToUpload, arrayLength)) {
return;
}
if (!ValidateSamplerUniformSetter("Uniform3iv", location_object, data[0]) ||
!ValidateSamplerUniformSetter("Uniform3iv", location_object, data[1]) ||
!ValidateSamplerUniformSetter("Uniform3iv", location_object, data[2]))
{
return;
}
MakeContextCurrent();
gl->fUniform3iv(location, numElementsToUpload, data);
}
void
WebGLContext::Uniform4iv_base(WebGLUniformLocation *location_object,
uint32_t arrayLength, const GLint* data)
{
uint32_t numElementsToUpload;
GLint location;
if (!ValidateUniformArraySetter("Uniform4iv", 4, location_object, location,
numElementsToUpload, arrayLength)) {
return;
}
if (!ValidateSamplerUniformSetter("Uniform4iv", location_object, data[0]) ||
!ValidateSamplerUniformSetter("Uniform4iv", location_object, data[1]) ||
!ValidateSamplerUniformSetter("Uniform4iv", location_object, data[2]) ||
!ValidateSamplerUniformSetter("Uniform4iv", location_object, data[3]))
{
return;
}
MakeContextCurrent();
gl->fUniform4iv(location, numElementsToUpload, data);
}
void
WebGLContext::Uniform1fv_base(WebGLUniformLocation *location_object,
uint32_t arrayLength, const GLfloat* data)
{
uint32_t numElementsToUpload;
GLint location;
if (!ValidateUniformArraySetter("Uniform1fv", 1, location_object, location,
numElementsToUpload, arrayLength)) {
return;
}
MakeContextCurrent();
gl->fUniform1fv(location, numElementsToUpload, data);
}
void
WebGLContext::Uniform2fv_base(WebGLUniformLocation *location_object,
uint32_t arrayLength, const GLfloat* data)
{
uint32_t numElementsToUpload;
GLint location;
if (!ValidateUniformArraySetter("Uniform2fv", 2, location_object, location,
numElementsToUpload, arrayLength)) {
return;
}
MakeContextCurrent();
gl->fUniform2fv(location, numElementsToUpload, data);
}
void
WebGLContext::Uniform3fv_base(WebGLUniformLocation *location_object,
uint32_t arrayLength, const GLfloat* data)
{
uint32_t numElementsToUpload;
GLint location;
if (!ValidateUniformArraySetter("Uniform3fv", 3, location_object, location,
numElementsToUpload, arrayLength)) {
return;
}
MakeContextCurrent();
gl->fUniform3fv(location, numElementsToUpload, data);
}
void
WebGLContext::Uniform4fv_base(WebGLUniformLocation *location_object,
uint32_t arrayLength, const GLfloat* data)
{
uint32_t numElementsToUpload;
GLint location;
if (!ValidateUniformArraySetter("Uniform4fv", 4, location_object, location,
numElementsToUpload, arrayLength)) {
return;
}
MakeContextCurrent();
gl->fUniform4fv(location, numElementsToUpload, data);
}
void
WebGLContext::UniformMatrix2fv_base(WebGLUniformLocation* location_object,
WebGLboolean aTranspose, uint32_t arrayLength,
const float* data)
{
uint32_t numElementsToUpload;
GLint location;
if (!ValidateUniformMatrixArraySetter("UniformMatrix2fv", 2, location_object, location,
numElementsToUpload, arrayLength, aTranspose)) {
return;
}
MakeContextCurrent();
gl->fUniformMatrix2fv(location, numElementsToUpload, false, data);
}
void
WebGLContext::UniformMatrix3fv_base(WebGLUniformLocation* location_object,
WebGLboolean aTranspose, uint32_t arrayLength,
const float* data)
{
uint32_t numElementsToUpload;
GLint location;
if (!ValidateUniformMatrixArraySetter("UniformMatrix3fv", 3, location_object, location,
numElementsToUpload, arrayLength, aTranspose)) {
return;
}
MakeContextCurrent();
gl->fUniformMatrix3fv(location, numElementsToUpload, false, data);
}
void
WebGLContext::UniformMatrix4fv_base(WebGLUniformLocation* location_object,
WebGLboolean aTranspose, uint32_t arrayLength,
const float* data)
{
uint32_t numElementsToUpload;
GLint location;
if (!ValidateUniformMatrixArraySetter("UniformMatrix4fv", 4, location_object, location,
numElementsToUpload, arrayLength, aTranspose)) {
return;
}
MakeContextCurrent();
gl->fUniformMatrix4fv(location, numElementsToUpload, false, data);
}
void
WebGLContext::UseProgram(WebGLProgram *prog)
{
if (IsContextLost())
return;
if (!ValidateObjectAllowNull("useProgram", prog))
return;
MakeContextCurrent();
InvalidateBufferFetching();
GLuint progname = prog ? prog->GLName() : 0;
if (prog && !prog->LinkStatus())
return ErrorInvalidOperation("useProgram: program was not linked successfully");
gl->fUseProgram(progname);
mCurrentProgram = prog;
}
void
WebGLContext::ValidateProgram(WebGLProgram *prog)
{
if (IsContextLost())
return;
if (!ValidateObject("validateProgram", prog))
return;
MakeContextCurrent();
#ifdef XP_MACOSX
// see bug 593867 for NVIDIA and bug 657201 for ATI. The latter is confirmed with Mac OS 10.6.7
if (gl->WorkAroundDriverBugs()) {
GenerateWarning("validateProgram: implemented as a no-operation on Mac to work around crashes");
return;
}
#endif
GLuint progname = prog->GLName();
gl->fValidateProgram(progname);
}
already_AddRefed<WebGLFramebuffer>
WebGLContext::CreateFramebuffer()
{
if (IsContextLost())
return nullptr;
nsRefPtr<WebGLFramebuffer> globj = new WebGLFramebuffer(this);
return globj.forget();
}
already_AddRefed<WebGLRenderbuffer>
WebGLContext::CreateRenderbuffer()
{
if (IsContextLost())
return nullptr;
nsRefPtr<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");
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;
GLuint shadername = shader->GLName();
shader->SetCompileStatus(false);
// nothing to do if the validator is disabled
if (!mShaderValidation)
return;
// nothing to do if translation was already done
if (!shader->NeedsTranslation())
return;
MakeContextCurrent();
ShShaderOutput targetShaderSourceLanguage = gl->IsGLES() ? SH_ESSL_OUTPUT : SH_GLSL_OUTPUT;
ShHandle compiler = 0;
ShBuiltInResources resources;
memset(&resources, 0, sizeof(ShBuiltInResources));
ShInitBuiltInResources(&resources);
resources.MaxVertexAttribs = mGLMaxVertexAttribs;
resources.MaxVertexUniformVectors = mGLMaxVertexUniformVectors;
resources.MaxVaryingVectors = mGLMaxVaryingVectors;
resources.MaxVertexTextureImageUnits = mGLMaxVertexTextureImageUnits;
resources.MaxCombinedTextureImageUnits = mGLMaxTextureUnits;
resources.MaxTextureImageUnits = mGLMaxTextureImageUnits;
resources.MaxFragmentUniformVectors = mGLMaxFragmentUniformVectors;
resources.MaxDrawBuffers = mGLMaxDrawBuffers;
if (IsExtensionEnabled(WebGLExtensionID::EXT_frag_depth))
resources.EXT_frag_depth = 1;
if (IsExtensionEnabled(WebGLExtensionID::OES_standard_derivatives))
resources.OES_standard_derivatives = 1;
if (IsExtensionEnabled(WebGLExtensionID::WEBGL_draw_buffers))
resources.EXT_draw_buffers = 1;
if (IsExtensionEnabled(WebGLExtensionID::EXT_shader_texture_lod))
resources.EXT_shader_texture_lod = 1;
// Tell ANGLE to allow highp in frag shaders. (unless disabled)
// If underlying GLES doesn't have highp in frag shaders, it should complain anyways.
resources.FragmentPrecisionHigh = mDisableFragHighP ? 0 : 1;
resources.HashFunction = WebGLProgram::IdentifierHashFunction;
if (gl->WorkAroundDriverBugs()) {
#ifdef XP_MACOSX
if (gl->Vendor() == gl::GLVendor::NVIDIA) {
// Work around bug 890432
resources.MaxExpressionComplexity = 1000;
}
#endif
}
// We're storing an actual instance of StripComments because, if we don't, the
// cleanSource nsAString instance will be destroyed before the reference is
// actually used.
StripComments stripComments(shader->Source());
const nsAString& cleanSource = Substring(stripComments.result().Elements(), stripComments.length());
if (!ValidateGLSLString(cleanSource, "compileShader"))
return;
// shaderSource() already checks that the source stripped of comments is in the
// 7-bit ASCII range, so we can skip the NS_IsAscii() check.
NS_LossyConvertUTF16toASCII sourceCString(cleanSource);
if (gl->WorkAroundDriverBugs()) {
const uint32_t maxSourceLength = 0x3ffff;
if (sourceCString.Length() > maxSourceLength)
return ErrorInvalidValue("compileShader: source has more than %d characters",
maxSourceLength);
}
const char *s = sourceCString.get();
#define WEBGL2_BYPASS_ANGLE
#ifdef WEBGL2_BYPASS_ANGLE
/*
* The bypass don't bring a full support for GLSL ES 3.0, but the main purpose
* is to natively bring gl_InstanceID (to do instanced rendering) and gl_FragData
*
* To remove the bypass code, just comment #define WEBGL2_BYPASS_ANGLE above
*
* To bypass angle, the context must be a WebGL 2 and the shader must have the
* following line at the very top :
* #version proto-200
*
* In this case, byPassANGLE == true and here is what we do :
* We create two shader source code:
* - one for the driver, that enable GL_EXT_gpu_shader4
* - one for the angle compilor, to get informations about vertex attributes
* and uniforms
*/
static const char *bypassPrefixSearch = "#version proto-200";
static const char *bypassANGLEPrefix[2] = {"precision mediump float;\n"
"#define gl_VertexID 0\n"
"#define gl_InstanceID 0\n",
"precision mediump float;\n"
"#extension GL_EXT_draw_buffers : enable\n"
"#define gl_PrimitiveID 0\n"};
const bool bypassANGLE = IsWebGL2() && (strstr(s, bypassPrefixSearch) != 0);
const char *angleShaderCode = s;
nsTArray<char> bypassANGLEShaderCode;
nsTArray<char> bypassDriverShaderCode;
if (bypassANGLE) {
const int bypassStage = (shader->ShaderType() == LOCAL_GL_FRAGMENT_SHADER) ? 1 : 0;
const char *originalShader = strstr(s, bypassPrefixSearch) + strlen(bypassPrefixSearch);
int originalShaderSize = strlen(s) - (originalShader - s);
int bypassShaderCodeSize = originalShaderSize + 4096 + 1;
bypassANGLEShaderCode.SetLength(bypassShaderCodeSize);
strcpy(bypassANGLEShaderCode.Elements(), bypassANGLEPrefix[bypassStage]);
strcat(bypassANGLEShaderCode.Elements(), originalShader);
bypassDriverShaderCode.SetLength(bypassShaderCodeSize);
strcpy(bypassDriverShaderCode.Elements(), "#extension GL_EXT_gpu_shader4 : enable\n");
strcat(bypassDriverShaderCode.Elements(), originalShader);
angleShaderCode = bypassANGLEShaderCode.Elements();
}
#endif
compiler = ShConstructCompiler((ShShaderType) shader->ShaderType(),
SH_WEBGL_SPEC,
targetShaderSourceLanguage,
&resources);
int compileOptions = SH_VARIABLES |
SH_ENFORCE_PACKING_RESTRICTIONS |
SH_INIT_VARYINGS_WITHOUT_STATIC_USE |
SH_OBJECT_CODE;
if (resources.MaxExpressionComplexity > 0) {
compileOptions |= SH_LIMIT_EXPRESSION_COMPLEXITY;
}
#ifndef XP_MACOSX
// We want to do this everywhere, but to do this on Mac, we need
// to do it only on Mac OSX > 10.6 as this causes the shader
// compiler in 10.6 to crash
compileOptions |= SH_CLAMP_INDIRECT_ARRAY_BOUNDS;
#endif
#ifdef XP_MACOSX
if (gl->WorkAroundDriverBugs()) {
// Work around bug 665578 and bug 769810
if (gl->Vendor() == gl::GLVendor::ATI) {
compileOptions |= SH_EMULATE_BUILT_IN_FUNCTIONS;
}
// Work around bug 735560
if (gl->Vendor() == gl::GLVendor::Intel) {
compileOptions |= SH_EMULATE_BUILT_IN_FUNCTIONS;
}
// Work around bug 636926
if (gl->Vendor() == gl::GLVendor::NVIDIA) {
compileOptions |= SH_UNROLL_FOR_LOOP_WITH_SAMPLER_ARRAY_INDEX;
}
// Work around https://bugs.webkit.org/show_bug.cgi?id=124684,
// https://chromium.googlesource.com/angle/angle/+/5e70cf9d0b1bb
compileOptions |= SH_UNFOLD_SHORT_CIRCUIT;
}
#endif
#ifdef WEBGL2_BYPASS_ANGLE
if (!ShCompile(compiler, &angleShaderCode, 1, compileOptions)) {
#else
if (!ShCompile(compiler, &s, 1, compileOptions)) {
#endif
size_t lenWithNull = 0;
ShGetInfo(compiler, SH_INFO_LOG_LENGTH, &lenWithNull);
if (!lenWithNull) {
// Error in ShGetInfo.
shader->SetTranslationFailure(NS_LITERAL_CSTRING("Internal error: failed to get shader info log"));
} else {
size_t len = lenWithNull - 1;
nsAutoCString info;
info.SetLength(len); // Allocates len+1, for the null-term.
ShGetInfoLog(compiler, info.BeginWriting());
shader->SetTranslationFailure(info);
}
ShDestruct(compiler);
shader->SetCompileStatus(false);
return;
}
size_t num_attributes = 0;
ShGetInfo(compiler, SH_ACTIVE_ATTRIBUTES, &num_attributes);
size_t num_uniforms = 0;
ShGetInfo(compiler, SH_ACTIVE_UNIFORMS, &num_uniforms);
size_t attrib_max_length = 0;
ShGetInfo(compiler, SH_ACTIVE_ATTRIBUTE_MAX_LENGTH, &attrib_max_length);
size_t uniform_max_length = 0;
ShGetInfo(compiler, SH_ACTIVE_UNIFORM_MAX_LENGTH, &uniform_max_length);
size_t mapped_max_length = 0;
ShGetInfo(compiler, SH_MAPPED_NAME_MAX_LENGTH, &mapped_max_length);
shader->mAttribMaxNameLength = attrib_max_length;
shader->mAttributes.Clear();
shader->mUniforms.Clear();
shader->mUniformInfos.Clear();
nsAutoArrayPtr<char> attribute_name(new char[attrib_max_length+1]);
nsAutoArrayPtr<char> uniform_name(new char[uniform_max_length+1]);
nsAutoArrayPtr<char> mapped_name(new char[mapped_max_length+1]);
for (size_t i = 0; i < num_uniforms; i++) {
size_t length;
int size;
ShDataType type;
ShPrecisionType precision;
int staticUse;
ShGetVariableInfo(compiler, SH_ACTIVE_UNIFORMS, (int)i,
&length, &size, &type,
&precision, &staticUse,
uniform_name,
mapped_name);
shader->mUniforms.AppendElement(WebGLMappedIdentifier(
nsDependentCString(uniform_name),
nsDependentCString(mapped_name)));
// we need uniform info to validate uniform setter calls
char mappedNameLength = strlen(mapped_name);
char mappedNameLastChar = mappedNameLength > 1
? mapped_name[mappedNameLength - 1]
: 0;
shader->mUniformInfos.AppendElement(WebGLUniformInfo(
size,
mappedNameLastChar == ']',
type));
}
for (size_t i = 0; i < num_attributes; i++) {
size_t length;
int size;
ShDataType type;
ShPrecisionType precision;
int staticUse;
ShGetVariableInfo(compiler, SH_ACTIVE_ATTRIBUTES, (int)i,
&length, &size, &type,
&precision, &staticUse,
attribute_name,
mapped_name);
shader->mAttributes.AppendElement(WebGLMappedIdentifier(
nsDependentCString(attribute_name),
nsDependentCString(mapped_name)));
}
size_t lenWithNull = 0;
ShGetInfo(compiler, SH_OBJECT_CODE_LENGTH, &lenWithNull);
MOZ_ASSERT(lenWithNull >= 1);
size_t len = lenWithNull - 1;
nsAutoCString translatedSrc;
translatedSrc.SetLength(len); // Allocates len+1, for the null-term.
ShGetObjectCode(compiler, translatedSrc.BeginWriting());
CopyASCIItoUTF16(translatedSrc, shader->mTranslatedSource);
const char *ts = translatedSrc.get();
#ifdef WEBGL2_BYPASS_ANGLE
if (bypassANGLE) {
const char* driverShaderCode = bypassDriverShaderCode.Elements();
gl->fShaderSource(shadername, 1, (const GLchar**) &driverShaderCode, nullptr);
} else {
gl->fShaderSource(shadername, 1, &ts, nullptr);
}
#else
gl->fShaderSource(shadername, 1, &ts, nullptr);
#endif
shader->SetTranslationSuccess();
ShDestruct(compiler);
gl->fCompileShader(shadername);
GLint ok;
gl->fGetShaderiv(shadername, LOCAL_GL_COMPILE_STATUS, &ok);
shader->SetCompileStatus(ok);
}
void
WebGLContext::CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat,
GLsizei width, GLsizei height, GLint border,
const ArrayBufferView& view)
{
if (IsContextLost())
return;
const WebGLTexImageFunc func = WebGLTexImageFunc::CompTexImage;
if (!ValidateTexImage(2, target, level, internalformat,
0, 0, 0, width, height, 0,
border, internalformat, LOCAL_GL_UNSIGNED_BYTE,
func))
{
return;
}
view.ComputeLengthAndData();
uint32_t byteLength = view.Length();
if (!ValidateCompTexImageDataSize(target, internalformat, width, height, byteLength, func)) {
return;
}
if (!ValidateCompTexImageSize(target, level, internalformat, 0, 0,
width, height, width, height, func))
{
return;
}
MakeContextCurrent();
gl->fCompressedTexImage2D(target, level, internalformat, width, height, border, byteLength, view.Data());
WebGLTexture* tex = activeBoundTextureForTarget(target);
MOZ_ASSERT(tex);
tex->SetImageInfo(target, level, width, height, internalformat, LOCAL_GL_UNSIGNED_BYTE,
WebGLImageDataStatus::InitializedImageData);
}
void
WebGLContext::CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset,
GLint yoffset, GLsizei width, GLsizei height,
GLenum format, const ArrayBufferView& view)
{
if (IsContextLost())
return;
const WebGLTexImageFunc func = WebGLTexImageFunc::CompTexSubImage;
if (!ValidateTexImage(2, target,
level, format,
xoffset, yoffset, 0,
width, height, 0,
0, format, LOCAL_GL_UNSIGNED_BYTE,
func))
{
return;
}
WebGLTexture *tex = activeBoundTextureForTarget(target);
MOZ_ASSERT(tex);
WebGLTexture::ImageInfo& levelInfo = tex->ImageInfoAt(target, level);
view.ComputeLengthAndData();
uint32_t byteLength = view.Length();
if (!ValidateCompTexImageDataSize(target, format, width, height, byteLength, func))
return;
if (!ValidateCompTexImageSize(target, level, format,
xoffset, yoffset,
width, height,
levelInfo.Width(), levelInfo.Height(),
func))
{
return;
}
if (levelInfo.HasUninitializedImageData())
tex->DoDeferredImageInitialization(target, level);
MakeContextCurrent();
gl->fCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, byteLength, view.Data());
}
JS::Value
WebGLContext::GetShaderParameter(WebGLShader *shader, GLenum pname)
{
if (IsContextLost())
return JS::NullValue();
if (!ValidateObject("getShaderParameter: shader", shader))
return JS::NullValue();
GLuint shadername = shader->GLName();
MakeContextCurrent();
switch (pname) {
case LOCAL_GL_SHADER_TYPE:
{
GLint i = 0;
gl->fGetShaderiv(shadername, pname, &i);
return JS::NumberValue(uint32_t(i));
}
break;
case LOCAL_GL_DELETE_STATUS:
return JS::BooleanValue(shader->IsDeleteRequested());
break;
case LOCAL_GL_COMPILE_STATUS:
{
GLint i = 0;
gl->fGetShaderiv(shadername, pname, &i);
return JS::BooleanValue(bool(i));
}
break;
default:
ErrorInvalidEnumInfo("getShaderParameter: parameter", pname);
}
return JS::NullValue();
}
void
WebGLContext::GetShaderInfoLog(WebGLShader *shader, nsAString& retval)
{
nsAutoCString s;
GetShaderInfoLog(shader, s);
if (s.IsVoid())
retval.SetIsVoid(true);
else
CopyASCIItoUTF16(s, retval);
}
void
WebGLContext::GetShaderInfoLog(WebGLShader *shader, nsACString& retval)
{
if (IsContextLost())
{
retval.SetIsVoid(true);
return;
}
if (!ValidateObject("getShaderInfoLog: shader", shader))
return;
retval = shader->TranslationLog();
if (!retval.IsVoid()) {
return;
}
MakeContextCurrent();
GLuint shadername = shader->GLName();
GLint k = -1;
gl->fGetShaderiv(shadername, LOCAL_GL_INFO_LOG_LENGTH, &k);
if (k == -1) {
// XXX GL Error? should never happen.
return;
}
if (k == 0) {
retval.Truncate();
return;
}
retval.SetCapacity(k);
gl->fGetShaderInfoLog(shadername, k, &k, (char*) retval.BeginWriting());
retval.SetLength(k);
}
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);
}
nsRefPtr<WebGLShaderPrecisionFormat> retShaderPrecisionFormat
= new WebGLShaderPrecisionFormat(this, range[0], range[1], precision);
return retShaderPrecisionFormat.forget();
}
void
WebGLContext::GetShaderSource(WebGLShader *shader, nsAString& retval)
{
if (IsContextLost()) {
retval.SetIsVoid(true);
return;
}
if (!ValidateObject("getShaderSource: shader", shader))
return;
retval.Assign(shader->Source());
}
void
WebGLContext::ShaderSource(WebGLShader *shader, const nsAString& source)
{
if (IsContextLost())
return;
if (!ValidateObject("shaderSource: shader", shader))
return;
// We're storing an actual instance of StripComments because, if we don't, the
// cleanSource nsAString instance will be destroyed before the reference is
// actually used.
StripComments stripComments(source);
const nsAString& cleanSource = Substring(stripComments.result().Elements(), stripComments.length());
if (!ValidateGLSLString(cleanSource, "compileShader"))
return;
shader->SetSource(source);
shader->SetNeedsTranslation();
}
void
WebGLContext::GetShaderTranslatedSource(WebGLShader *shader, nsAString& retval)
{
if (IsContextLost()) {
retval.SetIsVoid(true);
return;
}
if (!ValidateObject("getShaderTranslatedSource: shader", shader))
return;
retval.Assign(shader->TranslatedSource());
}
GLenum WebGLContext::CheckedTexImage2D(GLenum target,
GLint level,
GLenum internalFormat,
GLsizei width,
GLsizei height,
GLint border,
GLenum format,
GLenum type,
const GLvoid *data)
{
MOZ_ASSERT(internalFormat == format);
WebGLTexture *tex = activeBoundTextureForTarget(target);
MOZ_ASSERT(tex != nullptr, "no texture bound");
bool sizeMayChange = true;
if (tex->HasImageInfoAt(target, level)) {
const WebGLTexture::ImageInfo& imageInfo = tex->ImageInfoAt(target, level);
sizeMayChange = width != imageInfo.Width() ||
height != imageInfo.Height() ||
format != imageInfo.WebGLFormat() ||
type != imageInfo.WebGLType();
}
// Convert to format and type required by OpenGL 'driver'.
GLenum driverType = DriverTypeFromType(gl, type);
GLenum driverInternalFormat = LOCAL_GL_NONE;
GLenum driverFormat = LOCAL_GL_NONE;
DriverFormatsFromFormatAndType(gl, format, type, &driverInternalFormat, &driverFormat);
if (sizeMayChange) {
GetAndFlushUnderlyingGLErrors();
}
gl->fTexImage2D(target, level, driverInternalFormat, width, height, border, driverFormat, driverType, data);
GLenum error = LOCAL_GL_NO_ERROR;
if (sizeMayChange) {
error = GetAndFlushUnderlyingGLErrors();
}
return error;
}
void
WebGLContext::TexImage2D_base(GLenum target, GLint level, GLenum internalformat,
GLsizei width, GLsizei height, GLsizei srcStrideOrZero,
GLint border,
GLenum format, GLenum type,
void* data, uint32_t byteLength,
int jsArrayType, // a TypedArray format enum, or -1 if not relevant
WebGLTexelFormat srcFormat, bool srcPremultiplied)
{
const WebGLTexImageFunc func = WebGLTexImageFunc::TexImage;
if (!ValidateTexImage(2, target, level, internalformat,
0, 0, 0,
width, height, 0,
border, format, type, func))
{
return;
}
const bool isDepthTexture = format == LOCAL_GL_DEPTH_COMPONENT ||
format == LOCAL_GL_DEPTH_STENCIL;
if (isDepthTexture) {
if (data != nullptr || level != 0)
return ErrorInvalidOperation("texImage2D: "
"with format of DEPTH_COMPONENT or DEPTH_STENCIL, "
"data must be nullptr, "
"level must be zero");
}
if (!ValidateTexInputData(type, jsArrayType, func))
return;
WebGLTexelFormat dstFormat = GetWebGLTexelFormat(format, type);
WebGLTexelFormat actualSrcFormat = srcFormat == WebGLTexelFormat::Auto ? dstFormat : srcFormat;
uint32_t srcTexelSize = WebGLTexelConversions::TexelBytesForFormat(actualSrcFormat);
CheckedUint32 checked_neededByteLength =
GetImageSize(height, width, srcTexelSize, mPixelStoreUnpackAlignment);
CheckedUint32 checked_plainRowSize = CheckedUint32(width) * srcTexelSize;
CheckedUint32 checked_alignedRowSize =
RoundedToNextMultipleOf(checked_plainRowSize.value(), mPixelStoreUnpackAlignment);
if (!checked_neededByteLength.isValid())
return ErrorInvalidOperation("texImage2D: integer overflow computing the needed buffer size");
uint32_t bytesNeeded = checked_neededByteLength.value();
if (byteLength && byteLength < bytesNeeded)
return ErrorInvalidOperation("texImage2D: not enough data for operation (need %d, have %d)",
bytesNeeded, byteLength);
WebGLTexture *tex = activeBoundTextureForTarget(target);
if (!tex)
return ErrorInvalidOperation("texImage2D: no texture is bound to this target");
MakeContextCurrent();
nsAutoArrayPtr<uint8_t> convertedData;
void* pixels = nullptr;
WebGLImageDataStatus imageInfoStatusIfSuccess = WebGLImageDataStatus::UninitializedImageData;
if (byteLength) {
size_t srcStride = srcStrideOrZero ? srcStrideOrZero : checked_alignedRowSize.value();
uint32_t dstTexelSize = GetBitsPerTexel(format, type) / 8;
size_t dstPlainRowSize = dstTexelSize * width;
size_t unpackAlignment = mPixelStoreUnpackAlignment;
size_t dstStride = ((dstPlainRowSize + unpackAlignment-1) / unpackAlignment) * unpackAlignment;
if (actualSrcFormat == dstFormat &&
srcPremultiplied == mPixelStorePremultiplyAlpha &&
srcStride == dstStride &&
!mPixelStoreFlipY)
{
// no conversion, no flipping, so we avoid copying anything and just pass the source pointer
pixels = data;
}
else
{
size_t convertedDataSize = height * dstStride;
convertedData = new uint8_t[convertedDataSize];
ConvertImage(width, height, srcStride, dstStride,
static_cast<uint8_t*>(data), convertedData,
actualSrcFormat, srcPremultiplied,
dstFormat, mPixelStorePremultiplyAlpha, dstTexelSize);
pixels = reinterpret_cast<void*>(convertedData.get());
}
imageInfoStatusIfSuccess = WebGLImageDataStatus::InitializedImageData;
}
GLenum error = CheckedTexImage2D(target, level, internalformat, width,
height, border, format, type, pixels);
if (error) {
GenerateWarning("texImage2D generated error %s", ErrorName(error));
return;
}
// in all of the code paths above, we should have either initialized data,
// or allocated data and left it uninitialized, but in any case we shouldn't
// have NoImageData at this point.
MOZ_ASSERT(imageInfoStatusIfSuccess != WebGLImageDataStatus::NoImageData);
tex->SetImageInfo(target, level, width, height, format, type, imageInfoStatusIfSuccess);
}
void
WebGLContext::TexImage2D(GLenum target, GLint level,
GLenum internalformat, GLsizei width,
GLsizei height, GLint border, GLenum format,
GLenum type, const Nullable<ArrayBufferView> &pixels, ErrorResult& rv)
{
if (IsContextLost())
return;
void* data;
uint32_t length;
int jsArrayType;
if (pixels.IsNull()) {
data = nullptr;
length = 0;
jsArrayType = -1;
} else {
const ArrayBufferView& view = pixels.Value();
view.ComputeLengthAndData();
data = view.Data();
length = view.Length();
jsArrayType = int(JS_GetArrayBufferViewType(view.Obj()));
}
return TexImage2D_base(target, level, internalformat, width, height, 0, border, format, type,
data, length, jsArrayType,
WebGLTexelFormat::Auto, false);
}
void
WebGLContext::TexImage2D(GLenum target, GLint level,
GLenum internalformat, GLenum format,
GLenum type, ImageData* pixels, ErrorResult& rv)
{
if (IsContextLost())
return;
if (!pixels) {
// Spec says to generate an INVALID_VALUE error
return ErrorInvalidValue("texImage2D: null ImageData");
}
Uint8ClampedArray arr;
DebugOnly<bool> inited = arr.Init(pixels->GetDataObject());
MOZ_ASSERT(inited);
arr.ComputeLengthAndData();
return TexImage2D_base(target, level, internalformat, pixels->Width(),
pixels->Height(), 4*pixels->Width(), 0,
format, type, arr.Data(), arr.Length(), -1,
WebGLTexelFormat::RGBA8, false);
}
void
WebGLContext::TexSubImage2D_base(GLenum target, GLint level,
GLint xoffset, GLint yoffset,
GLsizei width, GLsizei height, GLsizei srcStrideOrZero,
GLenum format, GLenum type,
void* data, uint32_t byteLength,
int jsArrayType,
WebGLTexelFormat srcFormat, bool srcPremultiplied)
{
const WebGLTexImageFunc func = WebGLTexImageFunc::TexSubImage;
if (!ValidateTexImage(2, target, level, format,
xoffset, yoffset, 0,
width, height, 0,
0, format, type, func))
{
return;
}
if (!ValidateTexInputData(type, jsArrayType, func))
return;
WebGLTexelFormat dstFormat = GetWebGLTexelFormat(format, type);
WebGLTexelFormat actualSrcFormat = srcFormat == WebGLTexelFormat::Auto ? dstFormat : srcFormat;
uint32_t srcTexelSize = WebGLTexelConversions::TexelBytesForFormat(actualSrcFormat);
if (width == 0 || height == 0)
return; // ES 2.0 says it has no effect, we better return right now
CheckedUint32 checked_neededByteLength =
GetImageSize(height, width, srcTexelSize, mPixelStoreUnpackAlignment);
CheckedUint32 checked_plainRowSize = CheckedUint32(width) * srcTexelSize;
CheckedUint32 checked_alignedRowSize =
RoundedToNextMultipleOf(checked_plainRowSize.value(), mPixelStoreUnpackAlignment);
if (!checked_neededByteLength.isValid())
return ErrorInvalidOperation("texSubImage2D: integer overflow computing the needed buffer size");
uint32_t bytesNeeded = checked_neededByteLength.value();
if (byteLength < bytesNeeded)
return ErrorInvalidOperation("texSubImage2D: not enough data for operation (need %d, have %d)", bytesNeeded, byteLength);
WebGLTexture *tex = activeBoundTextureForTarget(target);
const WebGLTexture::ImageInfo &imageInfo = tex->ImageInfoAt(target, level);
if (imageInfo.HasUninitializedImageData())
tex->DoDeferredImageInitialization(target, level);
MakeContextCurrent();
size_t srcStride = srcStrideOrZero ? srcStrideOrZero : checked_alignedRowSize.value();
uint32_t dstTexelSize = GetBitsPerTexel(format, type) / 8;
size_t dstPlainRowSize = dstTexelSize * width;
// There are checks above to ensure that this won't overflow.
size_t dstStride = RoundedToNextMultipleOf(dstPlainRowSize, mPixelStoreUnpackAlignment).value();
void* pixels = data;
nsAutoArrayPtr<uint8_t> convertedData;
// no conversion, no flipping, so we avoid copying anything and just pass the source pointer
bool noConversion = (actualSrcFormat == dstFormat &&
srcPremultiplied == mPixelStorePremultiplyAlpha &&
srcStride == dstStride &&
!mPixelStoreFlipY);
if (!noConversion) {
size_t convertedDataSize = height * dstStride;
convertedData = new uint8_t[convertedDataSize];
ConvertImage(width, height, srcStride, dstStride,
static_cast<const uint8_t*>(data), convertedData,
actualSrcFormat, srcPremultiplied,
dstFormat, mPixelStorePremultiplyAlpha, dstTexelSize);
pixels = reinterpret_cast<void*>(convertedData.get());
}
GLenum driverType = DriverTypeFromType(gl, type);
GLenum driverInternalFormat = LOCAL_GL_NONE;
GLenum driverFormat = LOCAL_GL_NONE;
DriverFormatsFromFormatAndType(gl, format, type, &driverInternalFormat, &driverFormat);
gl->fTexSubImage2D(target, level, xoffset, yoffset, width, height, driverFormat, driverType, pixels);
}
void
WebGLContext::TexSubImage2D(GLenum target, GLint level,
GLint xoffset, GLint yoffset,
GLsizei width, GLsizei height,
GLenum format, GLenum type,
const Nullable<ArrayBufferView> &pixels,
ErrorResult& rv)
{
if (IsContextLost())
return;
if (pixels.IsNull())
return ErrorInvalidValue("texSubImage2D: pixels must not be null!");
const ArrayBufferView& view = pixels.Value();
view.ComputeLengthAndData();
return TexSubImage2D_base(target, level, xoffset, yoffset,
width, height, 0, format, type,
view.Data(), view.Length(),
JS_GetArrayBufferViewType(view.Obj()),
WebGLTexelFormat::Auto, false);
}
void
WebGLContext::TexSubImage2D(GLenum target, GLint level,
GLint xoffset, GLint yoffset,
GLenum format, GLenum type, ImageData* pixels,
ErrorResult& rv)
{
if (IsContextLost())
return;
if (!pixels)
return ErrorInvalidValue("texSubImage2D: pixels must not be null!");
Uint8ClampedArray arr;
DebugOnly<bool> inited = arr.Init(pixels->GetDataObject());
MOZ_ASSERT(inited);
arr.ComputeLengthAndData();
return TexSubImage2D_base(target, level, xoffset, yoffset,
pixels->Width(), pixels->Height(),
4*pixels->Width(), format, type,
arr.Data(), arr.Length(),
-1,
WebGLTexelFormat::RGBA8, false);
}
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();
}
bool
BaseTypeAndSizeFromUniformType(GLenum uType, GLenum *baseType, GLint *unitSize)
{
switch (uType) {
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_CUBE:
*baseType = LOCAL_GL_INT;
break;
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:
*baseType = LOCAL_GL_FLOAT;
break;
case LOCAL_GL_BOOL:
case LOCAL_GL_BOOL_VEC2:
case LOCAL_GL_BOOL_VEC3:
case LOCAL_GL_BOOL_VEC4:
*baseType = LOCAL_GL_BOOL; // pretend these are int
break;
default:
return false;
}
switch (uType) {
case LOCAL_GL_INT:
case LOCAL_GL_FLOAT:
case LOCAL_GL_BOOL:
case LOCAL_GL_SAMPLER_2D:
case LOCAL_GL_SAMPLER_CUBE:
*unitSize = 1;
break;
case LOCAL_GL_INT_VEC2:
case LOCAL_GL_FLOAT_VEC2:
case LOCAL_GL_BOOL_VEC2:
*unitSize = 2;
break;
case LOCAL_GL_INT_VEC3:
case LOCAL_GL_FLOAT_VEC3:
case LOCAL_GL_BOOL_VEC3:
*unitSize = 3;
break;
case LOCAL_GL_INT_VEC4:
case LOCAL_GL_FLOAT_VEC4:
case LOCAL_GL_BOOL_VEC4:
*unitSize = 4;
break;
case LOCAL_GL_FLOAT_MAT2:
*unitSize = 4;
break;
case LOCAL_GL_FLOAT_MAT3:
*unitSize = 9;
break;
case LOCAL_GL_FLOAT_MAT4:
*unitSize = 16;
break;
default:
return false;
}
return true;
}
WebGLTexelFormat mozilla::GetWebGLTexelFormat(GLenum internalformat, GLenum type)
{
//
// WEBGL_depth_texture
if (internalformat == LOCAL_GL_DEPTH_COMPONENT) {
switch (type) {
case LOCAL_GL_UNSIGNED_SHORT:
return WebGLTexelFormat::D16;
case LOCAL_GL_UNSIGNED_INT:
return WebGLTexelFormat::D32;
}
MOZ_CRASH("Invalid WebGL texture format/type?");
}
if (internalformat == LOCAL_GL_DEPTH_STENCIL) {
switch (type) {
case LOCAL_GL_UNSIGNED_INT_24_8_EXT:
return WebGLTexelFormat::D24S8;
}
MOZ_CRASH("Invalid WebGL texture format/type?");
}
if (internalformat == LOCAL_GL_DEPTH_COMPONENT16) {
return WebGLTexelFormat::D16;
}
if (internalformat == LOCAL_GL_DEPTH_COMPONENT32) {
return WebGLTexelFormat::D32;
}
if (internalformat == LOCAL_GL_DEPTH24_STENCIL8) {
return WebGLTexelFormat::D24S8;
}
if (type == LOCAL_GL_UNSIGNED_BYTE) {
switch (internalformat) {
case LOCAL_GL_RGBA:
case LOCAL_GL_SRGB_ALPHA_EXT:
return WebGLTexelFormat::RGBA8;
case LOCAL_GL_RGB:
case LOCAL_GL_SRGB_EXT:
return WebGLTexelFormat::RGB8;
case LOCAL_GL_ALPHA:
return WebGLTexelFormat::A8;
case LOCAL_GL_LUMINANCE:
return WebGLTexelFormat::R8;
case LOCAL_GL_LUMINANCE_ALPHA:
return WebGLTexelFormat::RA8;
}
MOZ_CRASH("Invalid WebGL texture format/type?");
}
if (type == LOCAL_GL_FLOAT) {
// OES_texture_float
switch (internalformat) {
case LOCAL_GL_RGBA:
case LOCAL_GL_RGBA32F:
return WebGLTexelFormat::RGBA32F;
case LOCAL_GL_RGB:
case LOCAL_GL_RGB32F:
return WebGLTexelFormat::RGB32F;
case LOCAL_GL_ALPHA:
case LOCAL_GL_ALPHA32F_ARB:
return WebGLTexelFormat::A32F;
case LOCAL_GL_LUMINANCE:
case LOCAL_GL_LUMINANCE32F_ARB:
return WebGLTexelFormat::R32F;
case LOCAL_GL_LUMINANCE_ALPHA:
case LOCAL_GL_LUMINANCE_ALPHA32F_ARB:
return WebGLTexelFormat::RA32F;
}
MOZ_CRASH("Invalid WebGL texture format/type?");
} else if (type == LOCAL_GL_HALF_FLOAT_OES) {
// OES_texture_half_float
switch (internalformat) {
case LOCAL_GL_RGBA:
case LOCAL_GL_RGBA16F:
return WebGLTexelFormat::RGBA16F;
case LOCAL_GL_RGB:
case LOCAL_GL_RGB16F:
return WebGLTexelFormat::RGB16F;
case LOCAL_GL_ALPHA:
case LOCAL_GL_ALPHA16F_ARB:
return WebGLTexelFormat::A16F;
case LOCAL_GL_LUMINANCE:
case LOCAL_GL_LUMINANCE16F_ARB:
return WebGLTexelFormat::R16F;
case LOCAL_GL_LUMINANCE_ALPHA:
case LOCAL_GL_LUMINANCE_ALPHA16F_ARB:
return WebGLTexelFormat::RA16F;
default:
MOZ_ASSERT(false, "Coding mistake?! Should never reach this point.");
return WebGLTexelFormat::BadFormat;
}
}
switch (type) {
case LOCAL_GL_UNSIGNED_SHORT_4_4_4_4:
return WebGLTexelFormat::RGBA4444;
case LOCAL_GL_UNSIGNED_SHORT_5_5_5_1:
return WebGLTexelFormat::RGBA5551;
case LOCAL_GL_UNSIGNED_SHORT_5_6_5:
return WebGLTexelFormat::RGB565;
default:
MOZ_ASSERT(false, "Coding mistake?! Should never reach this point.");
return WebGLTexelFormat::BadFormat;
}
MOZ_CRASH("Invalid WebGL texture format/type?");
}
void
WebGLContext::BlendColor(GLclampf r, GLclampf g, GLclampf b, GLclampf 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;
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);
}
Reference in New Issue View Git Blame Copy Permalink