dom/canvas/WebGLContextUtils.cpp

   1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "WebGLContextUtils.h"
   7 #include "WebGLContext.h"
   8 #include "HostWebGLContext.h"
   9 #include "GLContext.h"
  10 #include "jsapi.h"
  11 #include "js/Warnings.h"  // JS::WarnASCII
  12 #include "mozilla/dom/ScriptSettings.h"
  13 #include "mozilla/gfx/Logging.h"
  14 #include "mozilla/Preferences.h"
  15 #include "mozilla/Sprintf.h"
  16 #include "nsPrintfCString.h"
  17 #include "nsServiceManagerUtils.h"
  18 #include <stdarg.h>
  19 #include "WebGLBuffer.h"
  20 #include "WebGLExtensions.h"
  21 #include "WebGLFramebuffer.h"
  22 #include "WebGLProgram.h"
  23 #include "WebGLTexture.h"
  24 #include "WebGLVertexArray.h"
  25
  26 namespace mozilla {
  27
  28 TexTarget TexImageTargetToTexTarget(TexImageTarget texImageTarget) {
  29   switch (texImageTarget.get()) {
  30     case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_X:
  31     case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
  32     case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
  33     case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
  34     case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
  35     case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
  36       return LOCAL_GL_TEXTURE_CUBE_MAP;
  37
  38     default:
  39       return texImageTarget.get();
  40   }
  41 }
  42
  43 /*static*/ const char* WebGLContext::ErrorName(GLenum error) {
  44   switch (error) {
  45     case LOCAL_GL_INVALID_ENUM:
  46       return "INVALID_ENUM";
  47     case LOCAL_GL_INVALID_OPERATION:
  48       return "INVALID_OPERATION";
  49     case LOCAL_GL_INVALID_VALUE:
  50       return "INVALID_VALUE";
  51     case LOCAL_GL_OUT_OF_MEMORY:
  52       return "OUT_OF_MEMORY";
  53     case LOCAL_GL_INVALID_FRAMEBUFFER_OPERATION:
  54       return "INVALID_FRAMEBUFFER_OPERATION";
  55     case LOCAL_GL_NO_ERROR:
  56       return "NO_ERROR";
  57     default:
  58       MOZ_ASSERT(false);
  59       return "[unknown WebGL error]";
  60   }
  61 }
  62
  63 // This version is fallible and will return nullptr if unrecognized.
  64 const char* GetEnumName(const GLenum val, const char* const defaultRet) {
  65   switch (val) {
  66 #define XX(x)        \
  67   case LOCAL_GL_##x: \
  68     return #x
  69     XX(NONE);
  70     XX(ALPHA);
  71     XX(COMPRESSED_RGBA_PVRTC_2BPPV1);
  72     XX(COMPRESSED_RGBA_PVRTC_4BPPV1);
  73     XX(COMPRESSED_RGBA_S3TC_DXT1_EXT);
  74     XX(COMPRESSED_RGBA_S3TC_DXT3_EXT);
  75     XX(COMPRESSED_RGBA_S3TC_DXT5_EXT);
  76     XX(COMPRESSED_RGB_PVRTC_2BPPV1);
  77     XX(COMPRESSED_RGB_PVRTC_4BPPV1);
  78     XX(COMPRESSED_RGB_S3TC_DXT1_EXT);
  79     XX(DEPTH_ATTACHMENT);
  80     XX(DEPTH_COMPONENT);
  81     XX(DEPTH_COMPONENT16);
  82     XX(DEPTH_COMPONENT32);
  83     XX(DEPTH_STENCIL);
  84     XX(DEPTH24_STENCIL8);
  85     XX(DRAW_FRAMEBUFFER);
  86     XX(ETC1_RGB8_OES);
  87     XX(FLOAT);
  88     XX(INT);
  89     XX(FRAMEBUFFER);
  90     XX(HALF_FLOAT);
  91     XX(LUMINANCE);
  92     XX(LUMINANCE_ALPHA);
  93     XX(READ_FRAMEBUFFER);
  94     XX(RGB);
  95     XX(RGB16F);
  96     XX(RGB32F);
  97     XX(RGBA);
  98     XX(RGBA16F);
  99     XX(RGBA32F);
 100     XX(SRGB);
 101     XX(SRGB_ALPHA);
 102     XX(TEXTURE_2D);
 103     XX(TEXTURE_3D);
 104     XX(TEXTURE_CUBE_MAP);
 105     XX(TEXTURE_CUBE_MAP_NEGATIVE_X);
 106     XX(TEXTURE_CUBE_MAP_NEGATIVE_Y);
 107     XX(TEXTURE_CUBE_MAP_NEGATIVE_Z);
 108     XX(TEXTURE_CUBE_MAP_POSITIVE_X);
 109     XX(TEXTURE_CUBE_MAP_POSITIVE_Y);
 110     XX(TEXTURE_CUBE_MAP_POSITIVE_Z);
 111     XX(UNSIGNED_BYTE);
 112     XX(UNSIGNED_INT);
 113     XX(UNSIGNED_INT_24_8);
 114     XX(UNSIGNED_SHORT);
 115     XX(UNSIGNED_SHORT_4_4_4_4);
 116     XX(UNSIGNED_SHORT_5_5_5_1);
 117     XX(UNSIGNED_SHORT_5_6_5);
 118     XX(READ_BUFFER);
 119     XX(UNPACK_ROW_LENGTH);
 120     XX(UNPACK_SKIP_ROWS);
 121     XX(UNPACK_SKIP_PIXELS);
 122     XX(PACK_ROW_LENGTH);
 123     XX(PACK_SKIP_ROWS);
 124     XX(PACK_SKIP_PIXELS);
 125     XX(COLOR);
 126     XX(DEPTH);
 127     XX(STENCIL);
 128     XX(RED);
 129     XX(RGB8);
 130     XX(RGBA8);
 131     XX(RGB10_A2);
 132     XX(TEXTURE_BINDING_3D);
 133     XX(UNPACK_SKIP_IMAGES);
 134     XX(UNPACK_IMAGE_HEIGHT);
 135     XX(TEXTURE_WRAP_R);
 136     XX(MAX_3D_TEXTURE_SIZE);
 137     XX(UNSIGNED_INT_2_10_10_10_REV);
 138     XX(MAX_ELEMENTS_VERTICES);
 139     XX(MAX_ELEMENTS_INDICES);
 140     XX(TEXTURE_MIN_LOD);
 141     XX(TEXTURE_MAX_LOD);
 142     XX(TEXTURE_BASE_LEVEL);
 143     XX(TEXTURE_MAX_LEVEL);
 144     XX(MIN);
 145     XX(MAX);
 146     XX(DEPTH_COMPONENT24);
 147     XX(MAX_TEXTURE_LOD_BIAS);
 148     XX(TEXTURE_COMPARE_MODE);
 149     XX(TEXTURE_COMPARE_FUNC);
 150     XX(CURRENT_QUERY);
 151     XX(QUERY_RESULT);
 152     XX(QUERY_RESULT_AVAILABLE);
 153     XX(STREAM_READ);
 154     XX(STREAM_COPY);
 155     XX(STATIC_READ);
 156     XX(STATIC_COPY);
 157     XX(DYNAMIC_READ);
 158     XX(DYNAMIC_COPY);
 159     XX(MAX_DRAW_BUFFERS);
 160     XX(DRAW_BUFFER0);
 161     XX(DRAW_BUFFER1);
 162     XX(DRAW_BUFFER2);
 163     XX(DRAW_BUFFER3);
 164     XX(DRAW_BUFFER4);
 165     XX(DRAW_BUFFER5);
 166     XX(DRAW_BUFFER6);
 167     XX(DRAW_BUFFER7);
 168     XX(DRAW_BUFFER8);
 169     XX(DRAW_BUFFER9);
 170     XX(DRAW_BUFFER10);
 171     XX(DRAW_BUFFER11);
 172     XX(DRAW_BUFFER12);
 173     XX(DRAW_BUFFER13);
 174     XX(DRAW_BUFFER14);
 175     XX(DRAW_BUFFER15);
 176     XX(MAX_FRAGMENT_UNIFORM_COMPONENTS);
 177     XX(MAX_VERTEX_UNIFORM_COMPONENTS);
 178     XX(SAMPLER_3D);
 179     XX(SAMPLER_2D_SHADOW);
 180     XX(FRAGMENT_SHADER_DERIVATIVE_HINT);
 181     XX(PIXEL_PACK_BUFFER);
 182     XX(PIXEL_UNPACK_BUFFER);
 183     XX(PIXEL_PACK_BUFFER_BINDING);
 184     XX(PIXEL_UNPACK_BUFFER_BINDING);
 185     XX(FLOAT_MAT2x3);
 186     XX(FLOAT_MAT2x4);
 187     XX(FLOAT_MAT3x2);
 188     XX(FLOAT_MAT3x4);
 189     XX(FLOAT_MAT4x2);
 190     XX(FLOAT_MAT4x3);
 191     XX(SRGB8);
 192     XX(SRGB8_ALPHA8);
 193     XX(COMPARE_REF_TO_TEXTURE);
 194     XX(VERTEX_ATTRIB_ARRAY_INTEGER);
 195     XX(MAX_ARRAY_TEXTURE_LAYERS);
 196     XX(MIN_PROGRAM_TEXEL_OFFSET);
 197     XX(MAX_PROGRAM_TEXEL_OFFSET);
 198     XX(MAX_VARYING_COMPONENTS);
 199     XX(TEXTURE_2D_ARRAY);
 200     XX(TEXTURE_BINDING_2D_ARRAY);
 201     XX(R11F_G11F_B10F);
 202     XX(UNSIGNED_INT_10F_11F_11F_REV);
 203     XX(RGB9_E5);
 204     XX(UNSIGNED_INT_5_9_9_9_REV);
 205     XX(TRANSFORM_FEEDBACK_BUFFER_MODE);
 206     XX(MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS);
 207     XX(TRANSFORM_FEEDBACK_VARYINGS);
 208     XX(TRANSFORM_FEEDBACK_BUFFER_START);
 209     XX(TRANSFORM_FEEDBACK_BUFFER_SIZE);
 210     XX(TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
 211     XX(RASTERIZER_DISCARD);
 212     XX(MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS);
 213     XX(MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS);
 214     XX(INTERLEAVED_ATTRIBS);
 215     XX(SEPARATE_ATTRIBS);
 216     XX(TRANSFORM_FEEDBACK_BUFFER);
 217     XX(TRANSFORM_FEEDBACK_BUFFER_BINDING);
 218     XX(RGBA32UI);
 219     XX(RGB32UI);
 220     XX(RGBA16UI);
 221     XX(RGB16UI);
 222     XX(RGBA8UI);
 223     XX(RGB8UI);
 224     XX(RGBA32I);
 225     XX(RGB32I);
 226     XX(RGBA16I);
 227     XX(RGB16I);
 228     XX(RGBA8I);
 229     XX(RGB8I);
 230     XX(RED_INTEGER);
 231     XX(RGB_INTEGER);
 232     XX(RGBA_INTEGER);
 233     XX(SAMPLER_2D_ARRAY);
 234     XX(SAMPLER_2D_ARRAY_SHADOW);
 235     XX(SAMPLER_CUBE_SHADOW);
 236     XX(UNSIGNED_INT_VEC2);
 237     XX(UNSIGNED_INT_VEC3);
 238     XX(UNSIGNED_INT_VEC4);
 239     XX(INT_SAMPLER_2D);
 240     XX(INT_SAMPLER_3D);
 241     XX(INT_SAMPLER_CUBE);
 242     XX(INT_SAMPLER_2D_ARRAY);
 243     XX(UNSIGNED_INT_SAMPLER_2D);
 244     XX(UNSIGNED_INT_SAMPLER_3D);
 245     XX(UNSIGNED_INT_SAMPLER_CUBE);
 246     XX(UNSIGNED_INT_SAMPLER_2D_ARRAY);
 247     XX(DEPTH_COMPONENT32F);
 248     XX(DEPTH32F_STENCIL8);
 249     XX(FLOAT_32_UNSIGNED_INT_24_8_REV);
 250     XX(FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING);
 251     XX(FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE);
 252     XX(FRAMEBUFFER_ATTACHMENT_RED_SIZE);
 253     XX(FRAMEBUFFER_ATTACHMENT_GREEN_SIZE);
 254     XX(FRAMEBUFFER_ATTACHMENT_BLUE_SIZE);
 255     XX(FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE);
 256     XX(FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE);
 257     XX(FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE);
 258     XX(FRAMEBUFFER_DEFAULT);
 259     XX(DEPTH_STENCIL_ATTACHMENT);
 260     XX(UNSIGNED_NORMALIZED);
 261     XX(DRAW_FRAMEBUFFER_BINDING);
 262     XX(READ_FRAMEBUFFER_BINDING);
 263     XX(RENDERBUFFER_SAMPLES);
 264     XX(FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER);
 265     XX(MAX_COLOR_ATTACHMENTS);
 266     XX(COLOR_ATTACHMENT0);
 267     XX(COLOR_ATTACHMENT1);
 268     XX(COLOR_ATTACHMENT2);
 269     XX(COLOR_ATTACHMENT3);
 270     XX(COLOR_ATTACHMENT4);
 271     XX(COLOR_ATTACHMENT5);
 272     XX(COLOR_ATTACHMENT6);
 273     XX(COLOR_ATTACHMENT7);
 274     XX(COLOR_ATTACHMENT8);
 275     XX(COLOR_ATTACHMENT9);
 276     XX(COLOR_ATTACHMENT10);
 277     XX(COLOR_ATTACHMENT11);
 278     XX(COLOR_ATTACHMENT12);
 279     XX(COLOR_ATTACHMENT13);
 280     XX(COLOR_ATTACHMENT14);
 281     XX(COLOR_ATTACHMENT15);
 282     XX(FRAMEBUFFER_INCOMPLETE_MULTISAMPLE);
 283     XX(MAX_SAMPLES);
 284     XX(RG);
 285     XX(RG_INTEGER);
 286     XX(R8);
 287     XX(RG8);
 288     XX(R16F);
 289     XX(R32F);
 290     XX(RG16F);
 291     XX(RG32F);
 292     XX(R8I);
 293     XX(R8UI);
 294     XX(R16I);
 295     XX(R16UI);
 296     XX(R32I);
 297     XX(R32UI);
 298     XX(RG8I);
 299     XX(RG8UI);
 300     XX(RG16I);
 301     XX(RG16UI);
 302     XX(RG32I);
 303     XX(RG32UI);
 304     XX(VERTEX_ARRAY_BINDING);
 305     XX(R8_SNORM);
 306     XX(RG8_SNORM);
 307     XX(RGB8_SNORM);
 308     XX(RGBA8_SNORM);
 309     XX(SIGNED_NORMALIZED);
 310     XX(PRIMITIVE_RESTART_FIXED_INDEX);
 311     XX(COPY_READ_BUFFER);
 312     XX(COPY_WRITE_BUFFER);
 313     XX(UNIFORM_BUFFER);
 314     XX(UNIFORM_BUFFER_BINDING);
 315     XX(UNIFORM_BUFFER_START);
 316     XX(UNIFORM_BUFFER_SIZE);
 317     XX(MAX_VERTEX_UNIFORM_BLOCKS);
 318     XX(MAX_FRAGMENT_UNIFORM_BLOCKS);
 319     XX(MAX_COMBINED_UNIFORM_BLOCKS);
 320     XX(MAX_UNIFORM_BUFFER_BINDINGS);
 321     XX(MAX_UNIFORM_BLOCK_SIZE);
 322     XX(MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS);
 323     XX(MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS);
 324     XX(UNIFORM_BUFFER_OFFSET_ALIGNMENT);
 325     XX(ACTIVE_UNIFORM_BLOCKS);
 326     XX(UNIFORM_TYPE);
 327     XX(UNIFORM_SIZE);
 328     XX(UNIFORM_BLOCK_INDEX);
 329     XX(UNIFORM_OFFSET);
 330     XX(UNIFORM_ARRAY_STRIDE);
 331     XX(UNIFORM_MATRIX_STRIDE);
 332     XX(UNIFORM_IS_ROW_MAJOR);
 333     XX(UNIFORM_BLOCK_BINDING);
 334     XX(UNIFORM_BLOCK_DATA_SIZE);
 335     XX(UNIFORM_BLOCK_ACTIVE_UNIFORMS);
 336     XX(UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES);
 337     XX(UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER);
 338     XX(UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER);
 339     XX(MAX_VERTEX_OUTPUT_COMPONENTS);
 340     XX(MAX_FRAGMENT_INPUT_COMPONENTS);
 341     XX(MAX_SERVER_WAIT_TIMEOUT);
 342     XX(OBJECT_TYPE);
 343     XX(SYNC_CONDITION);
 344     XX(SYNC_STATUS);
 345     XX(SYNC_FLAGS);
 346     XX(SYNC_FENCE);
 347     XX(SYNC_GPU_COMMANDS_COMPLETE);
 348     XX(UNSIGNALED);
 349     XX(SIGNALED);
 350     XX(ALREADY_SIGNALED);
 351     XX(TIMEOUT_EXPIRED);
 352     XX(CONDITION_SATISFIED);
 353     XX(WAIT_FAILED);
 354     XX(VERTEX_ATTRIB_ARRAY_DIVISOR);
 355     XX(ANY_SAMPLES_PASSED);
 356     XX(ANY_SAMPLES_PASSED_CONSERVATIVE);
 357     XX(SAMPLER_BINDING);
 358     XX(RGB10_A2UI);
 359     XX(TEXTURE_SWIZZLE_R);
 360     XX(TEXTURE_SWIZZLE_G);
 361     XX(TEXTURE_SWIZZLE_B);
 362     XX(TEXTURE_SWIZZLE_A);
 363     XX(GREEN);
 364     XX(BLUE);
 365     XX(INT_2_10_10_10_REV);
 366     XX(TRANSFORM_FEEDBACK);
 367     XX(TRANSFORM_FEEDBACK_PAUSED);
 368     XX(TRANSFORM_FEEDBACK_ACTIVE);
 369     XX(TRANSFORM_FEEDBACK_BINDING);
 370     XX(COMPRESSED_R11_EAC);
 371     XX(COMPRESSED_SIGNED_R11_EAC);
 372     XX(COMPRESSED_RG11_EAC);
 373     XX(COMPRESSED_SIGNED_RG11_EAC);
 374     XX(COMPRESSED_RGB8_ETC2);
 375     XX(COMPRESSED_SRGB8_ETC2);
 376     XX(COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2);
 377     XX(COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2);
 378     XX(COMPRESSED_RGBA8_ETC2_EAC);
 379     XX(COMPRESSED_SRGB8_ALPHA8_ETC2_EAC);
 380     XX(TEXTURE_IMMUTABLE_FORMAT);
 381     XX(MAX_ELEMENT_INDEX);
 382     XX(NUM_SAMPLE_COUNTS);
 383     XX(TEXTURE_IMMUTABLE_LEVELS);
 384 #undef XX
 385   }
 386
 387   return defaultRet;
 388 }
 389
 390 /*static*/
 391 void WebGLContext::EnumName(GLenum val, nsCString* out_name) {
 392   const char* name = GetEnumName(val, nullptr);
 393   if (name) {
 394     *out_name = name;
 395     return;
 396   }
 397
 398   *out_name = nsPrintfCString("<enum 0x%04x>", val);
 399 }
 400
 401 std::string EnumString(const GLenum val) {
 402   const char* name = GetEnumName(val, nullptr);
 403   if (name) {
 404     return name;
 405   }
 406
 407   const nsPrintfCString hex("<enum 0x%04x>", val);
 408   return hex.BeginReading();
 409 }
 410
 411 void WebGLContext::ErrorInvalidEnumArg(const char* const argName,
 412                                        const GLenum val) const {
 413   nsCString enumName;
 414   EnumName(val, &enumName);
 415   ErrorInvalidEnum("Bad `%s`: %s", argName, enumName.BeginReading());
 416 }
 417
 418 void WebGLContext::ErrorInvalidEnumInfo(const char* const info,
 419                                         const GLenum enumValue) const {
 420   nsCString name;
 421   EnumName(enumValue, &name);
 422   return ErrorInvalidEnum("%s: Invalid enum value %s", info,
 423                           name.BeginReading());
 424 }
 425
 426 #ifdef DEBUG
 427 // For NaNs, etc.
 428 static bool IsCacheCorrect(float cached, float actual) {
 429   if (IsNaN(cached)) {
 430     // GL is allowed to do anything it wants for NaNs, so if we're shadowing
 431     // a NaN, then whatever `actual` is might be correct.
 432     return true;
 433   }
 434
 435   return cached == actual;
 436 }
 437
 438 void AssertUintParamCorrect(gl::GLContext* gl, GLenum pname, GLuint shadow) {
 439   GLuint val = 0;
 440   gl->GetUIntegerv(pname, &val);
 441   if (val != shadow) {
 442     printf_stderr("Failed 0x%04x shadow: Cached 0x%x/%u, should be 0x%x/%u.\n",
 443                   pname, shadow, shadow, val, val);
 444     MOZ_ASSERT(false, "Bad cached value.");
 445   }
 446 }
 447
 448 void AssertMaskedUintParamCorrect(gl::GLContext* gl, GLenum pname, GLuint mask,
 449                                   GLuint shadow) {
 450   GLuint val = 0;
 451   gl->GetUIntegerv(pname, &val);
 452
 453   const GLuint valMasked = val & mask;
 454   const GLuint shadowMasked = shadow & mask;
 455
 456   if (valMasked != shadowMasked) {
 457     printf_stderr("Failed 0x%04x shadow: Cached 0x%x/%u, should be 0x%x/%u.\n",
 458                   pname, shadowMasked, shadowMasked, valMasked, valMasked);
 459     MOZ_ASSERT(false, "Bad cached value.");
 460   }
 461 }
 462 #else
 463 void AssertUintParamCorrect(gl::GLContext*, GLenum, GLuint) {}
 464 #endif
 465
 466 void WebGLContext::AssertCachedBindings() const {
 467 #ifdef DEBUG
 468   gl::GLContext::LocalErrorScope errorScope(*gl);
 469
 470   GLint stencilBits = 0;
 471   if (GetStencilBits(&stencilBits)) {  // Depends on current draw framebuffer.
 472     const GLuint stencilRefMask = (1 << stencilBits) - 1;
 473
 474     AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_REF, stencilRefMask,
 475                                  mStencilRefFront);
 476     AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_BACK_REF, stencilRefMask,
 477                                  mStencilRefBack);
 478   }
 479
 480   // Program
 481   GLuint bound = mCurrentProgram ? mCurrentProgram->mGLName : 0;
 482   AssertUintParamCorrect(gl, LOCAL_GL_CURRENT_PROGRAM, bound);
 483
 484   // Buffers
 485   bound = mBoundArrayBuffer ? mBoundArrayBuffer->mGLName : 0;
 486   AssertUintParamCorrect(gl, LOCAL_GL_ARRAY_BUFFER_BINDING, bound);
 487
 488   MOZ_ASSERT(mBoundVertexArray);
 489   WebGLBuffer* curBuff = mBoundVertexArray->mElementArrayBuffer;
 490   bound = curBuff ? curBuff->mGLName : 0;
 491   AssertUintParamCorrect(gl, LOCAL_GL_ELEMENT_ARRAY_BUFFER_BINDING, bound);
 492
 493   MOZ_ASSERT(!gl::GLContext::IsBadCallError(errorScope.GetError()));
 494 #endif
 495
 496   // We do not check the renderbuffer binding, because we never rely on it
 497   // matching.
 498 }
 499
 500 void WebGLContext::AssertCachedGlobalState() const {
 501 #ifdef DEBUG
 502   gl::GLContext::LocalErrorScope errorScope(*gl);
 503
 504   ////////////////
 505
 506   // Draw state
 507   MOZ_ASSERT(gl->fIsEnabled(LOCAL_GL_DITHER) == mDitherEnabled);
 508   MOZ_ASSERT_IF(IsWebGL2(), gl->fIsEnabled(LOCAL_GL_RASTERIZER_DISCARD) ==
 509                                 mRasterizerDiscardEnabled);
 510   MOZ_ASSERT(gl->fIsEnabled(LOCAL_GL_SCISSOR_TEST) == mScissorTestEnabled);
 511
 512   // Cannot trivially check COLOR_CLEAR_VALUE, since in old GL versions glGet
 513   // may clamp based on whether the current framebuffer is floating-point or
 514   // not. This also means COLOR_CLEAR_VALUE save+restore is dangerous!
 515
 516   realGLboolean depthWriteMask = 0;
 517   gl->fGetBooleanv(LOCAL_GL_DEPTH_WRITEMASK, &depthWriteMask);
 518   MOZ_ASSERT(depthWriteMask == mDepthWriteMask);
 519
 520   GLfloat depthClearValue = 0.0f;
 521   gl->fGetFloatv(LOCAL_GL_DEPTH_CLEAR_VALUE, &depthClearValue);
 522   MOZ_ASSERT(IsCacheCorrect(mDepthClearValue, depthClearValue));
 523
 524   const int maxStencilBits = 8;
 525   const GLuint maxStencilBitsMask = (1 << maxStencilBits) - 1;
 526   AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_CLEAR_VALUE,
 527                                maxStencilBitsMask, mStencilClearValue);
 528
 529   // GLES 3.0.4, $4.1.4, p177:
 530   //   [...] the front and back stencil mask are both set to the value `2^s -
 531   //   1`, where `s` is greater than or equal to the number of bits in the
 532   //   deepest stencil buffer supported by the GL implementation.
 533   AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_VALUE_MASK,
 534                                maxStencilBitsMask, mStencilValueMaskFront);
 535   AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_BACK_VALUE_MASK,
 536                                maxStencilBitsMask, mStencilValueMaskBack);
 537
 538   AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_WRITEMASK,
 539                                maxStencilBitsMask, mStencilWriteMaskFront);
 540   AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_BACK_WRITEMASK,
 541                                maxStencilBitsMask, mStencilWriteMaskBack);
 542
 543   // Viewport
 544   GLint int4[4] = {0, 0, 0, 0};
 545   gl->fGetIntegerv(LOCAL_GL_VIEWPORT, int4);
 546   MOZ_ASSERT(int4[0] == mViewportX && int4[1] == mViewportY &&
 547              int4[2] == mViewportWidth && int4[3] == mViewportHeight);
 548
 549   MOZ_ASSERT(!gl::GLContext::IsBadCallError(errorScope.GetError()));
 550 #endif
 551 }
 552
 553 const char* InfoFrom(WebGLTexImageFunc func, WebGLTexDimensions dims) {
 554   switch (dims) {
 555     case WebGLTexDimensions::Tex2D:
 556       switch (func) {
 557         case WebGLTexImageFunc::TexImage:
 558           return "texImage2D";
 559         case WebGLTexImageFunc::TexSubImage:
 560           return "texSubImage2D";
 561         case WebGLTexImageFunc::CopyTexImage:
 562           return "copyTexImage2D";
 563         case WebGLTexImageFunc::CopyTexSubImage:
 564           return "copyTexSubImage2D";
 565         case WebGLTexImageFunc::CompTexImage:
 566           return "compressedTexImage2D";
 567         case WebGLTexImageFunc::CompTexSubImage:
 568           return "compressedTexSubImage2D";
 569         default:
 570           MOZ_CRASH("GFX: invalid 2D TexDimensions");
 571       }
 572     case WebGLTexDimensions::Tex3D:
 573       switch (func) {
 574         case WebGLTexImageFunc::TexImage:
 575           return "texImage3D";
 576         case WebGLTexImageFunc::TexSubImage:
 577           return "texSubImage3D";
 578         case WebGLTexImageFunc::CopyTexSubImage:
 579           return "copyTexSubImage3D";
 580         case WebGLTexImageFunc::CompTexSubImage:
 581           return "compressedTexSubImage3D";
 582         default:
 583           MOZ_CRASH("GFX: invalid 3D TexDimensions");
 584       }
 585     default:
 586       MOZ_CRASH("GFX: invalid TexDimensions");
 587   }
 588 }
 589
 590 ////
 591
 592 }  // namespace mozilla