зеркало из https://github.com/mozilla/gecko-dev.git
600 строки
18 KiB
C++
600 строки
18 KiB
C++
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "WebGLContextUtils.h"
|
|
#include "WebGLContext.h"
|
|
#include "HostWebGLContext.h"
|
|
#include "GLContext.h"
|
|
#include "jsapi.h"
|
|
#include "js/Warnings.h" // JS::WarnASCII
|
|
#include "mozilla/dom/ScriptSettings.h"
|
|
#include "mozilla/gfx/Logging.h"
|
|
#include "mozilla/Preferences.h"
|
|
#include "mozilla/Sprintf.h"
|
|
#include "nsPrintfCString.h"
|
|
#include "nsServiceManagerUtils.h"
|
|
#include <stdarg.h>
|
|
#include "WebGLBuffer.h"
|
|
#include "WebGLExtensions.h"
|
|
#include "WebGLFramebuffer.h"
|
|
#include "WebGLProgram.h"
|
|
#include "WebGLTexture.h"
|
|
#include "WebGLVertexArray.h"
|
|
|
|
namespace mozilla {
|
|
|
|
TexTarget TexImageTargetToTexTarget(TexImageTarget texImageTarget) {
|
|
switch (texImageTarget.get()) {
|
|
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:
|
|
return LOCAL_GL_TEXTURE_CUBE_MAP;
|
|
|
|
default:
|
|
return texImageTarget.get();
|
|
}
|
|
}
|
|
|
|
/*static*/ const char* WebGLContext::ErrorName(GLenum error) {
|
|
switch (error) {
|
|
case LOCAL_GL_INVALID_ENUM:
|
|
return "INVALID_ENUM";
|
|
case LOCAL_GL_INVALID_OPERATION:
|
|
return "INVALID_OPERATION";
|
|
case LOCAL_GL_INVALID_VALUE:
|
|
return "INVALID_VALUE";
|
|
case LOCAL_GL_OUT_OF_MEMORY:
|
|
return "OUT_OF_MEMORY";
|
|
case LOCAL_GL_INVALID_FRAMEBUFFER_OPERATION:
|
|
return "INVALID_FRAMEBUFFER_OPERATION";
|
|
case LOCAL_GL_NO_ERROR:
|
|
return "NO_ERROR";
|
|
default:
|
|
MOZ_ASSERT(false);
|
|
return "[unknown WebGL error]";
|
|
}
|
|
}
|
|
|
|
// This version is fallible and will return nullptr if unrecognized.
|
|
const char* GetEnumName(const GLenum val, const char* const defaultRet) {
|
|
switch (val) {
|
|
case 0:
|
|
return "0";
|
|
#define XX(x) \
|
|
case LOCAL_GL_##x: \
|
|
return #x;
|
|
// XX(NONE)
|
|
XX(ALPHA)
|
|
XX(COMPRESSED_RGBA_PVRTC_2BPPV1)
|
|
XX(COMPRESSED_RGBA_PVRTC_4BPPV1)
|
|
XX(COMPRESSED_RGBA_S3TC_DXT1_EXT)
|
|
XX(COMPRESSED_RGBA_S3TC_DXT3_EXT)
|
|
XX(COMPRESSED_RGBA_S3TC_DXT5_EXT)
|
|
XX(COMPRESSED_RGB_PVRTC_2BPPV1)
|
|
XX(COMPRESSED_RGB_PVRTC_4BPPV1)
|
|
XX(COMPRESSED_RGB_S3TC_DXT1_EXT)
|
|
XX(DEPTH_ATTACHMENT)
|
|
XX(DEPTH_COMPONENT)
|
|
XX(DEPTH_COMPONENT16)
|
|
XX(DEPTH_COMPONENT32)
|
|
XX(DEPTH_STENCIL)
|
|
XX(DEPTH24_STENCIL8)
|
|
XX(DRAW_FRAMEBUFFER)
|
|
XX(ETC1_RGB8_OES)
|
|
XX(FLOAT)
|
|
XX(INT)
|
|
XX(FRAMEBUFFER)
|
|
XX(HALF_FLOAT)
|
|
XX(LUMINANCE)
|
|
XX(LUMINANCE_ALPHA)
|
|
XX(READ_FRAMEBUFFER)
|
|
XX(RGB)
|
|
XX(RGB16F)
|
|
XX(RGB32F)
|
|
XX(RGBA)
|
|
XX(RGBA16F)
|
|
XX(RGBA32F)
|
|
XX(SRGB)
|
|
XX(SRGB_ALPHA)
|
|
XX(TEXTURE_2D)
|
|
XX(TEXTURE_3D)
|
|
XX(TEXTURE_CUBE_MAP)
|
|
XX(TEXTURE_CUBE_MAP_NEGATIVE_X)
|
|
XX(TEXTURE_CUBE_MAP_NEGATIVE_Y)
|
|
XX(TEXTURE_CUBE_MAP_NEGATIVE_Z)
|
|
XX(TEXTURE_CUBE_MAP_POSITIVE_X)
|
|
XX(TEXTURE_CUBE_MAP_POSITIVE_Y)
|
|
XX(TEXTURE_CUBE_MAP_POSITIVE_Z)
|
|
XX(UNSIGNED_BYTE)
|
|
XX(UNSIGNED_INT)
|
|
XX(UNSIGNED_INT_24_8)
|
|
XX(UNSIGNED_SHORT)
|
|
XX(UNSIGNED_SHORT_4_4_4_4)
|
|
XX(UNSIGNED_SHORT_5_5_5_1)
|
|
XX(UNSIGNED_SHORT_5_6_5)
|
|
XX(READ_BUFFER)
|
|
XX(UNPACK_ROW_LENGTH)
|
|
XX(UNPACK_SKIP_ROWS)
|
|
XX(UNPACK_SKIP_PIXELS)
|
|
XX(PACK_ROW_LENGTH)
|
|
XX(PACK_SKIP_ROWS)
|
|
XX(PACK_SKIP_PIXELS)
|
|
XX(COLOR)
|
|
XX(DEPTH)
|
|
XX(STENCIL)
|
|
XX(RED)
|
|
XX(RGB8)
|
|
XX(RGBA8)
|
|
XX(RGB10_A2)
|
|
XX(TEXTURE_BINDING_3D)
|
|
XX(UNPACK_SKIP_IMAGES)
|
|
XX(UNPACK_IMAGE_HEIGHT)
|
|
XX(TEXTURE_WRAP_R)
|
|
XX(MAX_3D_TEXTURE_SIZE)
|
|
XX(UNSIGNED_INT_2_10_10_10_REV)
|
|
XX(MAX_ELEMENTS_VERTICES)
|
|
XX(MAX_ELEMENTS_INDICES)
|
|
XX(TEXTURE_MIN_LOD)
|
|
XX(TEXTURE_MAX_LOD)
|
|
XX(TEXTURE_BASE_LEVEL)
|
|
XX(TEXTURE_MAX_LEVEL)
|
|
XX(MIN)
|
|
XX(MAX)
|
|
XX(DEPTH_COMPONENT24)
|
|
XX(MAX_TEXTURE_LOD_BIAS)
|
|
XX(TEXTURE_COMPARE_MODE)
|
|
XX(TEXTURE_COMPARE_FUNC)
|
|
XX(CURRENT_QUERY)
|
|
XX(QUERY_RESULT)
|
|
XX(QUERY_RESULT_AVAILABLE)
|
|
XX(STREAM_READ)
|
|
XX(STREAM_COPY)
|
|
XX(STATIC_READ)
|
|
XX(STATIC_COPY)
|
|
XX(DYNAMIC_READ)
|
|
XX(DYNAMIC_COPY)
|
|
XX(MAX_DRAW_BUFFERS)
|
|
XX(DRAW_BUFFER0)
|
|
XX(DRAW_BUFFER1)
|
|
XX(DRAW_BUFFER2)
|
|
XX(DRAW_BUFFER3)
|
|
XX(DRAW_BUFFER4)
|
|
XX(DRAW_BUFFER5)
|
|
XX(DRAW_BUFFER6)
|
|
XX(DRAW_BUFFER7)
|
|
XX(DRAW_BUFFER8)
|
|
XX(DRAW_BUFFER9)
|
|
XX(DRAW_BUFFER10)
|
|
XX(DRAW_BUFFER11)
|
|
XX(DRAW_BUFFER12)
|
|
XX(DRAW_BUFFER13)
|
|
XX(DRAW_BUFFER14)
|
|
XX(DRAW_BUFFER15)
|
|
XX(MAX_FRAGMENT_UNIFORM_COMPONENTS)
|
|
XX(MAX_VERTEX_UNIFORM_COMPONENTS)
|
|
XX(SAMPLER_3D)
|
|
XX(SAMPLER_2D_SHADOW)
|
|
XX(FRAGMENT_SHADER_DERIVATIVE_HINT)
|
|
XX(PIXEL_PACK_BUFFER)
|
|
XX(PIXEL_UNPACK_BUFFER)
|
|
XX(PIXEL_PACK_BUFFER_BINDING)
|
|
XX(PIXEL_UNPACK_BUFFER_BINDING)
|
|
XX(FLOAT_MAT2x3)
|
|
XX(FLOAT_MAT2x4)
|
|
XX(FLOAT_MAT3x2)
|
|
XX(FLOAT_MAT3x4)
|
|
XX(FLOAT_MAT4x2)
|
|
XX(FLOAT_MAT4x3)
|
|
XX(SRGB8)
|
|
XX(SRGB8_ALPHA8)
|
|
XX(COMPARE_REF_TO_TEXTURE)
|
|
XX(VERTEX_ATTRIB_ARRAY_INTEGER)
|
|
XX(MAX_ARRAY_TEXTURE_LAYERS)
|
|
XX(MIN_PROGRAM_TEXEL_OFFSET)
|
|
XX(MAX_PROGRAM_TEXEL_OFFSET)
|
|
XX(MAX_VARYING_COMPONENTS)
|
|
XX(TEXTURE_2D_ARRAY)
|
|
XX(TEXTURE_BINDING_2D_ARRAY)
|
|
XX(R11F_G11F_B10F)
|
|
XX(UNSIGNED_INT_10F_11F_11F_REV)
|
|
XX(RGB9_E5)
|
|
XX(UNSIGNED_INT_5_9_9_9_REV)
|
|
XX(TRANSFORM_FEEDBACK_BUFFER_MODE)
|
|
XX(MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS)
|
|
XX(TRANSFORM_FEEDBACK_VARYINGS)
|
|
XX(TRANSFORM_FEEDBACK_BUFFER_START)
|
|
XX(TRANSFORM_FEEDBACK_BUFFER_SIZE)
|
|
XX(TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN)
|
|
XX(RASTERIZER_DISCARD)
|
|
XX(MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS)
|
|
XX(MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS)
|
|
XX(INTERLEAVED_ATTRIBS)
|
|
XX(SEPARATE_ATTRIBS)
|
|
XX(TRANSFORM_FEEDBACK_BUFFER)
|
|
XX(TRANSFORM_FEEDBACK_BUFFER_BINDING)
|
|
XX(RGBA32UI)
|
|
XX(RGB32UI)
|
|
XX(RGBA16UI)
|
|
XX(RGB16UI)
|
|
XX(RGBA8UI)
|
|
XX(RGB8UI)
|
|
XX(RGBA32I)
|
|
XX(RGB32I)
|
|
XX(RGBA16I)
|
|
XX(RGB16I)
|
|
XX(RGBA8I)
|
|
XX(RGB8I)
|
|
XX(RED_INTEGER)
|
|
XX(RGB_INTEGER)
|
|
XX(RGBA_INTEGER)
|
|
XX(SAMPLER_2D_ARRAY)
|
|
XX(SAMPLER_2D_ARRAY_SHADOW)
|
|
XX(SAMPLER_CUBE_SHADOW)
|
|
XX(UNSIGNED_INT_VEC2)
|
|
XX(UNSIGNED_INT_VEC3)
|
|
XX(UNSIGNED_INT_VEC4)
|
|
XX(INT_SAMPLER_2D)
|
|
XX(INT_SAMPLER_3D)
|
|
XX(INT_SAMPLER_CUBE)
|
|
XX(INT_SAMPLER_2D_ARRAY)
|
|
XX(UNSIGNED_INT_SAMPLER_2D)
|
|
XX(UNSIGNED_INT_SAMPLER_3D)
|
|
XX(UNSIGNED_INT_SAMPLER_CUBE)
|
|
XX(UNSIGNED_INT_SAMPLER_2D_ARRAY)
|
|
XX(DEPTH_COMPONENT32F)
|
|
XX(DEPTH32F_STENCIL8)
|
|
XX(FLOAT_32_UNSIGNED_INT_24_8_REV)
|
|
XX(FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)
|
|
XX(FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE)
|
|
XX(FRAMEBUFFER_ATTACHMENT_RED_SIZE)
|
|
XX(FRAMEBUFFER_ATTACHMENT_GREEN_SIZE)
|
|
XX(FRAMEBUFFER_ATTACHMENT_BLUE_SIZE)
|
|
XX(FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE)
|
|
XX(FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE)
|
|
XX(FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE)
|
|
XX(FRAMEBUFFER_DEFAULT)
|
|
XX(DEPTH_STENCIL_ATTACHMENT)
|
|
XX(UNSIGNED_NORMALIZED)
|
|
XX(DRAW_FRAMEBUFFER_BINDING)
|
|
XX(READ_FRAMEBUFFER_BINDING)
|
|
XX(RENDERBUFFER_SAMPLES)
|
|
XX(FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER)
|
|
XX(MAX_COLOR_ATTACHMENTS)
|
|
XX(COLOR_ATTACHMENT0)
|
|
XX(COLOR_ATTACHMENT1)
|
|
XX(COLOR_ATTACHMENT2)
|
|
XX(COLOR_ATTACHMENT3)
|
|
XX(COLOR_ATTACHMENT4)
|
|
XX(COLOR_ATTACHMENT5)
|
|
XX(COLOR_ATTACHMENT6)
|
|
XX(COLOR_ATTACHMENT7)
|
|
XX(COLOR_ATTACHMENT8)
|
|
XX(COLOR_ATTACHMENT9)
|
|
XX(COLOR_ATTACHMENT10)
|
|
XX(COLOR_ATTACHMENT11)
|
|
XX(COLOR_ATTACHMENT12)
|
|
XX(COLOR_ATTACHMENT13)
|
|
XX(COLOR_ATTACHMENT14)
|
|
XX(COLOR_ATTACHMENT15)
|
|
XX(FRAMEBUFFER_INCOMPLETE_MULTISAMPLE)
|
|
XX(MAX_SAMPLES)
|
|
XX(RG)
|
|
XX(RG_INTEGER)
|
|
XX(R8)
|
|
XX(RG8)
|
|
XX(R16F)
|
|
XX(R32F)
|
|
XX(RG16F)
|
|
XX(RG32F)
|
|
XX(R8I)
|
|
XX(R8UI)
|
|
XX(R16I)
|
|
XX(R16UI)
|
|
XX(R32I)
|
|
XX(R32UI)
|
|
XX(RG8I)
|
|
XX(RG8UI)
|
|
XX(RG16I)
|
|
XX(RG16UI)
|
|
XX(RG32I)
|
|
XX(RG32UI)
|
|
XX(VERTEX_ARRAY_BINDING)
|
|
XX(R8_SNORM)
|
|
XX(RG8_SNORM)
|
|
XX(RGB8_SNORM)
|
|
XX(RGBA8_SNORM)
|
|
XX(SIGNED_NORMALIZED)
|
|
XX(PRIMITIVE_RESTART_FIXED_INDEX)
|
|
XX(COPY_READ_BUFFER)
|
|
XX(COPY_WRITE_BUFFER)
|
|
XX(UNIFORM_BUFFER)
|
|
XX(UNIFORM_BUFFER_BINDING)
|
|
XX(UNIFORM_BUFFER_START)
|
|
XX(UNIFORM_BUFFER_SIZE)
|
|
XX(MAX_VERTEX_UNIFORM_BLOCKS)
|
|
XX(MAX_FRAGMENT_UNIFORM_BLOCKS)
|
|
XX(MAX_COMBINED_UNIFORM_BLOCKS)
|
|
XX(MAX_UNIFORM_BUFFER_BINDINGS)
|
|
XX(MAX_UNIFORM_BLOCK_SIZE)
|
|
XX(MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS)
|
|
XX(MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS)
|
|
XX(UNIFORM_BUFFER_OFFSET_ALIGNMENT)
|
|
XX(ACTIVE_UNIFORM_BLOCKS)
|
|
XX(UNIFORM_TYPE)
|
|
XX(UNIFORM_SIZE)
|
|
XX(UNIFORM_BLOCK_INDEX)
|
|
XX(UNIFORM_OFFSET)
|
|
XX(UNIFORM_ARRAY_STRIDE)
|
|
XX(UNIFORM_MATRIX_STRIDE)
|
|
XX(UNIFORM_IS_ROW_MAJOR)
|
|
XX(UNIFORM_BLOCK_BINDING)
|
|
XX(UNIFORM_BLOCK_DATA_SIZE)
|
|
XX(UNIFORM_BLOCK_ACTIVE_UNIFORMS)
|
|
XX(UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES)
|
|
XX(UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER)
|
|
XX(UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER)
|
|
XX(MAX_VERTEX_OUTPUT_COMPONENTS)
|
|
XX(MAX_FRAGMENT_INPUT_COMPONENTS)
|
|
XX(MAX_SERVER_WAIT_TIMEOUT)
|
|
XX(OBJECT_TYPE)
|
|
XX(SYNC_CONDITION)
|
|
XX(SYNC_STATUS)
|
|
XX(SYNC_FLAGS)
|
|
XX(SYNC_FENCE)
|
|
XX(SYNC_GPU_COMMANDS_COMPLETE)
|
|
XX(UNSIGNALED)
|
|
XX(SIGNALED)
|
|
XX(ALREADY_SIGNALED)
|
|
XX(TIMEOUT_EXPIRED)
|
|
XX(CONDITION_SATISFIED)
|
|
XX(WAIT_FAILED)
|
|
XX(VERTEX_ATTRIB_ARRAY_DIVISOR)
|
|
XX(ANY_SAMPLES_PASSED)
|
|
XX(ANY_SAMPLES_PASSED_CONSERVATIVE)
|
|
XX(SAMPLER_BINDING)
|
|
XX(RGB10_A2UI)
|
|
XX(TEXTURE_SWIZZLE_R)
|
|
XX(TEXTURE_SWIZZLE_G)
|
|
XX(TEXTURE_SWIZZLE_B)
|
|
XX(TEXTURE_SWIZZLE_A)
|
|
XX(GREEN)
|
|
XX(BLUE)
|
|
XX(INT_2_10_10_10_REV)
|
|
XX(TRANSFORM_FEEDBACK)
|
|
XX(TRANSFORM_FEEDBACK_PAUSED)
|
|
XX(TRANSFORM_FEEDBACK_ACTIVE)
|
|
XX(TRANSFORM_FEEDBACK_BINDING)
|
|
XX(COMPRESSED_R11_EAC)
|
|
XX(COMPRESSED_SIGNED_R11_EAC)
|
|
XX(COMPRESSED_RG11_EAC)
|
|
XX(COMPRESSED_SIGNED_RG11_EAC)
|
|
XX(COMPRESSED_RGB8_ETC2)
|
|
XX(COMPRESSED_SRGB8_ETC2)
|
|
XX(COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2)
|
|
XX(COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2)
|
|
XX(COMPRESSED_RGBA8_ETC2_EAC)
|
|
XX(COMPRESSED_SRGB8_ALPHA8_ETC2_EAC)
|
|
XX(TEXTURE_IMMUTABLE_FORMAT)
|
|
XX(MAX_ELEMENT_INDEX)
|
|
XX(NUM_SAMPLE_COUNTS)
|
|
XX(TEXTURE_IMMUTABLE_LEVELS)
|
|
#undef XX
|
|
}
|
|
|
|
return defaultRet;
|
|
}
|
|
|
|
/*static*/
|
|
void WebGLContext::EnumName(GLenum val, nsCString* out_name) {
|
|
const char* name = GetEnumName(val, nullptr);
|
|
if (name) {
|
|
*out_name = name;
|
|
return;
|
|
}
|
|
|
|
*out_name = nsPrintfCString("<enum 0x%04x>", val);
|
|
}
|
|
|
|
std::string EnumString(const GLenum val) {
|
|
const char* name = GetEnumName(val, nullptr);
|
|
if (name) {
|
|
return name;
|
|
}
|
|
|
|
const nsPrintfCString hex("<enum 0x%04x>", val);
|
|
return hex.BeginReading();
|
|
}
|
|
|
|
void WebGLContext::ErrorInvalidEnumArg(const char* const argName,
|
|
const GLenum val) const {
|
|
const auto info = nsPrintfCString("Bad `%s`", argName);
|
|
ErrorInvalidEnumInfo(info.BeginReading(), val);
|
|
}
|
|
|
|
void WebGLContext::ErrorInvalidEnumInfo(const char* const info,
|
|
const GLenum enumValue) const {
|
|
nsCString name;
|
|
EnumName(enumValue, &name);
|
|
|
|
const char* hint = "";
|
|
if (!enumValue) {
|
|
hint = " (Did you typo `gl.SOMETHINGG` and pass `undefined`?)";
|
|
}
|
|
|
|
ErrorInvalidEnum("%s: Invalid enum value %s%s", info, name.BeginReading(),
|
|
hint);
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
// For NaNs, etc.
|
|
static bool IsCacheCorrect(float cached, float actual) {
|
|
if (IsNaN(cached)) {
|
|
// GL is allowed to do anything it wants for NaNs, so if we're shadowing
|
|
// a NaN, then whatever `actual` is might be correct.
|
|
return true;
|
|
}
|
|
|
|
return cached == actual;
|
|
}
|
|
|
|
void AssertUintParamCorrect(gl::GLContext* gl, GLenum pname, GLuint shadow) {
|
|
GLuint val = 0;
|
|
gl->GetUIntegerv(pname, &val);
|
|
if (val != shadow) {
|
|
printf_stderr("Failed 0x%04x shadow: Cached 0x%x/%u, should be 0x%x/%u.\n",
|
|
pname, shadow, shadow, val, val);
|
|
MOZ_ASSERT(false, "Bad cached value.");
|
|
}
|
|
}
|
|
|
|
void AssertMaskedUintParamCorrect(gl::GLContext* gl, GLenum pname, GLuint mask,
|
|
GLuint shadow) {
|
|
GLuint val = 0;
|
|
gl->GetUIntegerv(pname, &val);
|
|
|
|
const GLuint valMasked = val & mask;
|
|
const GLuint shadowMasked = shadow & mask;
|
|
|
|
if (valMasked != shadowMasked) {
|
|
printf_stderr("Failed 0x%04x shadow: Cached 0x%x/%u, should be 0x%x/%u.\n",
|
|
pname, shadowMasked, shadowMasked, valMasked, valMasked);
|
|
MOZ_ASSERT(false, "Bad cached value.");
|
|
}
|
|
}
|
|
#else
|
|
void AssertUintParamCorrect(gl::GLContext*, GLenum, GLuint) {}
|
|
#endif
|
|
|
|
void WebGLContext::AssertCachedBindings() const {
|
|
#ifdef DEBUG
|
|
gl::GLContext::LocalErrorScope errorScope(*gl);
|
|
|
|
GLint stencilBits = 0;
|
|
if (GetStencilBits(&stencilBits)) { // Depends on current draw framebuffer.
|
|
const GLuint stencilRefMask = (1 << stencilBits) - 1;
|
|
|
|
AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_REF, stencilRefMask,
|
|
mStencilRefFront);
|
|
AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_BACK_REF, stencilRefMask,
|
|
mStencilRefBack);
|
|
}
|
|
|
|
// Program
|
|
GLuint bound = mCurrentProgram ? mCurrentProgram->mGLName : 0;
|
|
AssertUintParamCorrect(gl, LOCAL_GL_CURRENT_PROGRAM, bound);
|
|
|
|
// Buffers
|
|
bound = mBoundArrayBuffer ? mBoundArrayBuffer->mGLName : 0;
|
|
AssertUintParamCorrect(gl, LOCAL_GL_ARRAY_BUFFER_BINDING, bound);
|
|
|
|
MOZ_ASSERT(mBoundVertexArray);
|
|
WebGLBuffer* curBuff = mBoundVertexArray->mElementArrayBuffer;
|
|
bound = curBuff ? curBuff->mGLName : 0;
|
|
AssertUintParamCorrect(gl, LOCAL_GL_ELEMENT_ARRAY_BUFFER_BINDING, bound);
|
|
|
|
MOZ_ASSERT(!gl::GLContext::IsBadCallError(errorScope.GetError()));
|
|
#endif
|
|
|
|
// We do not check the renderbuffer binding, because we never rely on it
|
|
// matching.
|
|
}
|
|
|
|
void WebGLContext::AssertCachedGlobalState() const {
|
|
#ifdef DEBUG
|
|
gl::GLContext::LocalErrorScope errorScope(*gl);
|
|
|
|
////////////////
|
|
|
|
// Draw state
|
|
MOZ_ASSERT(gl->fIsEnabled(LOCAL_GL_DITHER) == mDitherEnabled);
|
|
MOZ_ASSERT_IF(IsWebGL2(), gl->fIsEnabled(LOCAL_GL_RASTERIZER_DISCARD) ==
|
|
mRasterizerDiscardEnabled);
|
|
MOZ_ASSERT(gl->fIsEnabled(LOCAL_GL_SCISSOR_TEST) == mScissorTestEnabled);
|
|
|
|
// Cannot trivially check COLOR_CLEAR_VALUE, since in old GL versions glGet
|
|
// may clamp based on whether the current framebuffer is floating-point or
|
|
// not. This also means COLOR_CLEAR_VALUE save+restore is dangerous!
|
|
|
|
realGLboolean depthWriteMask = 0;
|
|
gl->fGetBooleanv(LOCAL_GL_DEPTH_WRITEMASK, &depthWriteMask);
|
|
MOZ_ASSERT(depthWriteMask == mDepthWriteMask);
|
|
|
|
GLfloat depthClearValue = 0.0f;
|
|
gl->fGetFloatv(LOCAL_GL_DEPTH_CLEAR_VALUE, &depthClearValue);
|
|
MOZ_ASSERT(IsCacheCorrect(mDepthClearValue, depthClearValue));
|
|
|
|
const int maxStencilBits = 8;
|
|
const GLuint maxStencilBitsMask = (1 << maxStencilBits) - 1;
|
|
AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_CLEAR_VALUE,
|
|
maxStencilBitsMask, mStencilClearValue);
|
|
|
|
// GLES 3.0.4, $4.1.4, p177:
|
|
// [...] the front and back stencil mask are both set to the value `2^s -
|
|
// 1`, where `s` is greater than or equal to the number of bits in the
|
|
// deepest stencil buffer supported by the GL implementation.
|
|
AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_VALUE_MASK,
|
|
maxStencilBitsMask, mStencilValueMaskFront);
|
|
AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_BACK_VALUE_MASK,
|
|
maxStencilBitsMask, mStencilValueMaskBack);
|
|
|
|
AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_WRITEMASK,
|
|
maxStencilBitsMask, mStencilWriteMaskFront);
|
|
AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_BACK_WRITEMASK,
|
|
maxStencilBitsMask, mStencilWriteMaskBack);
|
|
|
|
// Viewport
|
|
GLint int4[4] = {0, 0, 0, 0};
|
|
gl->fGetIntegerv(LOCAL_GL_VIEWPORT, int4);
|
|
MOZ_ASSERT(int4[0] == mViewportX && int4[1] == mViewportY &&
|
|
int4[2] == mViewportWidth && int4[3] == mViewportHeight);
|
|
|
|
MOZ_ASSERT(!gl::GLContext::IsBadCallError(errorScope.GetError()));
|
|
#endif
|
|
}
|
|
|
|
const char* InfoFrom(WebGLTexImageFunc func, WebGLTexDimensions dims) {
|
|
switch (dims) {
|
|
case WebGLTexDimensions::Tex2D:
|
|
switch (func) {
|
|
case WebGLTexImageFunc::TexImage:
|
|
return "texImage2D";
|
|
case WebGLTexImageFunc::TexSubImage:
|
|
return "texSubImage2D";
|
|
case WebGLTexImageFunc::CopyTexImage:
|
|
return "copyTexImage2D";
|
|
case WebGLTexImageFunc::CopyTexSubImage:
|
|
return "copyTexSubImage2D";
|
|
case WebGLTexImageFunc::CompTexImage:
|
|
return "compressedTexImage2D";
|
|
case WebGLTexImageFunc::CompTexSubImage:
|
|
return "compressedTexSubImage2D";
|
|
default:
|
|
MOZ_CRASH("GFX: invalid 2D TexDimensions");
|
|
}
|
|
case WebGLTexDimensions::Tex3D:
|
|
switch (func) {
|
|
case WebGLTexImageFunc::TexImage:
|
|
return "texImage3D";
|
|
case WebGLTexImageFunc::TexSubImage:
|
|
return "texSubImage3D";
|
|
case WebGLTexImageFunc::CopyTexSubImage:
|
|
return "copyTexSubImage3D";
|
|
case WebGLTexImageFunc::CompTexSubImage:
|
|
return "compressedTexSubImage3D";
|
|
default:
|
|
MOZ_CRASH("GFX: invalid 3D TexDimensions");
|
|
}
|
|
default:
|
|
MOZ_CRASH("GFX: invalid TexDimensions");
|
|
}
|
|
}
|
|
|
|
////
|
|
|
|
} // namespace mozilla
|