1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/content/canvas/src/WebGLContextState.cpp Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,536 @@
1.4 +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
1.5 +/* This Source Code Form is subject to the terms of the Mozilla Public
1.6 + * License, v. 2.0. If a copy of the MPL was not distributed with this
1.7 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
1.8 +
1.9 +#include "WebGLContext.h"
1.10 +#include "WebGLContextUtils.h"
1.11 +#include "WebGLBuffer.h"
1.12 +#include "WebGLShader.h"
1.13 +#include "WebGLProgram.h"
1.14 +#include "WebGLFramebuffer.h"
1.15 +#include "WebGLRenderbuffer.h"
1.16 +#include "WebGLTexture.h"
1.17 +#include "WebGLVertexArray.h"
1.18 +#include "GLContext.h"
1.19 +#include "mozilla/dom/ToJSValue.h"
1.20 +
1.21 +using namespace mozilla;
1.22 +using namespace dom;
1.23 +
1.24 +void
1.25 +WebGLContext::Disable(GLenum cap)
1.26 +{
1.27 + if (IsContextLost())
1.28 + return;
1.29 +
1.30 + if (!ValidateCapabilityEnum(cap, "disable"))
1.31 + return;
1.32 +
1.33 + realGLboolean* trackingSlot = GetStateTrackingSlot(cap);
1.34 +
1.35 + if (trackingSlot)
1.36 + {
1.37 + *trackingSlot = 0;
1.38 + }
1.39 +
1.40 + MakeContextCurrent();
1.41 + gl->fDisable(cap);
1.42 +}
1.43 +
1.44 +void
1.45 +WebGLContext::Enable(GLenum cap)
1.46 +{
1.47 + if (IsContextLost())
1.48 + return;
1.49 +
1.50 + if (!ValidateCapabilityEnum(cap, "enable"))
1.51 + return;
1.52 +
1.53 + realGLboolean* trackingSlot = GetStateTrackingSlot(cap);
1.54 +
1.55 + if (trackingSlot)
1.56 + {
1.57 + *trackingSlot = 1;
1.58 + }
1.59 +
1.60 + MakeContextCurrent();
1.61 + gl->fEnable(cap);
1.62 +}
1.63 +
1.64 +static JS::Value
1.65 +StringValue(JSContext* cx, const char* chars, ErrorResult& rv)
1.66 +{
1.67 + JSString* str = JS_NewStringCopyZ(cx, chars);
1.68 + if (!str) {
1.69 + rv.Throw(NS_ERROR_OUT_OF_MEMORY);
1.70 + return JS::NullValue();
1.71 + }
1.72 +
1.73 + return JS::StringValue(str);
1.74 +}
1.75 +
1.76 +JS::Value
1.77 +WebGLContext::GetParameter(JSContext* cx, GLenum pname, ErrorResult& rv)
1.78 +{
1.79 + if (IsContextLost())
1.80 + return JS::NullValue();
1.81 +
1.82 + MakeContextCurrent();
1.83 +
1.84 + if (MinCapabilityMode()) {
1.85 + switch(pname) {
1.86 + ////////////////////////////
1.87 + // Single-value params
1.88 +
1.89 + // int
1.90 + case LOCAL_GL_MAX_VERTEX_ATTRIBS:
1.91 + return JS::Int32Value(MINVALUE_GL_MAX_VERTEX_ATTRIBS);
1.92 +
1.93 + case LOCAL_GL_MAX_FRAGMENT_UNIFORM_VECTORS:
1.94 + return JS::Int32Value(MINVALUE_GL_MAX_FRAGMENT_UNIFORM_VECTORS);
1.95 +
1.96 + case LOCAL_GL_MAX_VERTEX_UNIFORM_VECTORS:
1.97 + return JS::Int32Value(MINVALUE_GL_MAX_VERTEX_UNIFORM_VECTORS);
1.98 +
1.99 + case LOCAL_GL_MAX_VARYING_VECTORS:
1.100 + return JS::Int32Value(MINVALUE_GL_MAX_VARYING_VECTORS);
1.101 +
1.102 + case LOCAL_GL_MAX_TEXTURE_SIZE:
1.103 + return JS::Int32Value(MINVALUE_GL_MAX_TEXTURE_SIZE);
1.104 +
1.105 + case LOCAL_GL_MAX_CUBE_MAP_TEXTURE_SIZE:
1.106 + return JS::Int32Value(MINVALUE_GL_MAX_CUBE_MAP_TEXTURE_SIZE);
1.107 +
1.108 + case LOCAL_GL_MAX_TEXTURE_IMAGE_UNITS:
1.109 + return JS::Int32Value(MINVALUE_GL_MAX_TEXTURE_IMAGE_UNITS);
1.110 +
1.111 + case LOCAL_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
1.112 + return JS::Int32Value(MINVALUE_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS);
1.113 +
1.114 + case LOCAL_GL_MAX_RENDERBUFFER_SIZE:
1.115 + return JS::Int32Value(MINVALUE_GL_MAX_RENDERBUFFER_SIZE);
1.116 +
1.117 + default:
1.118 + // Return the real value; we're not overriding this one
1.119 + break;
1.120 + }
1.121 + }
1.122 +
1.123 + if (IsExtensionEnabled(WebGLExtensionID::WEBGL_draw_buffers)) {
1.124 + if (pname == LOCAL_GL_MAX_COLOR_ATTACHMENTS) {
1.125 + return JS::Int32Value(mGLMaxColorAttachments);
1.126 +
1.127 + } else if (pname == LOCAL_GL_MAX_DRAW_BUFFERS) {
1.128 + return JS::Int32Value(mGLMaxDrawBuffers);
1.129 +
1.130 + } else if (pname >= LOCAL_GL_DRAW_BUFFER0 &&
1.131 + pname < GLenum(LOCAL_GL_DRAW_BUFFER0 + mGLMaxDrawBuffers))
1.132 + {
1.133 + if (mBoundFramebuffer) {
1.134 + GLint iv = 0;
1.135 + gl->fGetIntegerv(pname, &iv);
1.136 + return JS::Int32Value(iv);
1.137 + }
1.138 +
1.139 + GLint iv = 0;
1.140 + gl->fGetIntegerv(pname, &iv);
1.141 +
1.142 + if (iv == GLint(LOCAL_GL_COLOR_ATTACHMENT0 + pname - LOCAL_GL_DRAW_BUFFER0)) {
1.143 + return JS::Int32Value(LOCAL_GL_BACK);
1.144 + }
1.145 +
1.146 + return JS::Int32Value(LOCAL_GL_NONE);
1.147 + }
1.148 + }
1.149 +
1.150 + if (IsExtensionEnabled(WebGLExtensionID::OES_vertex_array_object)) {
1.151 + if (pname == LOCAL_GL_VERTEX_ARRAY_BINDING) {
1.152 + if (mBoundVertexArray == mDefaultVertexArray){
1.153 + return WebGLObjectAsJSValue(cx, (WebGLVertexArray *) nullptr, rv);
1.154 + }
1.155 +
1.156 + return WebGLObjectAsJSValue(cx, mBoundVertexArray.get(), rv);
1.157 + }
1.158 + }
1.159 +
1.160 + switch (pname) {
1.161 + //
1.162 + // String params
1.163 + //
1.164 + case LOCAL_GL_VENDOR:
1.165 + return StringValue(cx, "Mozilla", rv);
1.166 + case LOCAL_GL_RENDERER:
1.167 + return StringValue(cx, "Mozilla", rv);
1.168 + case LOCAL_GL_VERSION: {
1.169 + const char* version = 0;
1.170 +
1.171 + if (IsWebGL2()) {
1.172 + version = "WebGL 2.0";
1.173 + } else {
1.174 + version = "WebGL 1.0";
1.175 + }
1.176 +
1.177 + MOZ_ASSERT(version != 0);
1.178 + return StringValue(cx, version, rv);
1.179 + }
1.180 + case LOCAL_GL_SHADING_LANGUAGE_VERSION:
1.181 + return StringValue(cx, "WebGL GLSL ES 1.0", rv);
1.182 +
1.183 + // Privileged string params exposed by WEBGL_debug_renderer_info:
1.184 + case UNMASKED_VENDOR_WEBGL:
1.185 + case UNMASKED_RENDERER_WEBGL: {
1.186 + // The privilege check is done in WebGLContext::IsExtensionSupported.
1.187 + // So here we just have to check that the extension is enabled.
1.188 + if (!IsExtensionEnabled(WebGLExtensionID::WEBGL_debug_renderer_info)) {
1.189 + break;
1.190 + }
1.191 + GLenum glstringname = LOCAL_GL_NONE;
1.192 + if (pname == UNMASKED_VENDOR_WEBGL) {
1.193 + glstringname = LOCAL_GL_VENDOR;
1.194 + } else if (pname == UNMASKED_RENDERER_WEBGL) {
1.195 + glstringname = LOCAL_GL_RENDERER;
1.196 + }
1.197 + const char* string = reinterpret_cast<const char*>(gl->fGetString(glstringname));
1.198 + return StringValue(cx, string, rv);
1.199 + }
1.200 +
1.201 + ////////////////////////////////
1.202 + // Single-value params
1.203 +
1.204 + // unsigned int
1.205 + case LOCAL_GL_CULL_FACE_MODE:
1.206 + case LOCAL_GL_FRONT_FACE:
1.207 + case LOCAL_GL_ACTIVE_TEXTURE:
1.208 + case LOCAL_GL_STENCIL_FUNC:
1.209 + case LOCAL_GL_STENCIL_FAIL:
1.210 + case LOCAL_GL_STENCIL_PASS_DEPTH_FAIL:
1.211 + case LOCAL_GL_STENCIL_PASS_DEPTH_PASS:
1.212 + case LOCAL_GL_STENCIL_BACK_FUNC:
1.213 + case LOCAL_GL_STENCIL_BACK_FAIL:
1.214 + case LOCAL_GL_STENCIL_BACK_PASS_DEPTH_FAIL:
1.215 + case LOCAL_GL_STENCIL_BACK_PASS_DEPTH_PASS:
1.216 + case LOCAL_GL_DEPTH_FUNC:
1.217 + case LOCAL_GL_BLEND_SRC_RGB:
1.218 + case LOCAL_GL_BLEND_SRC_ALPHA:
1.219 + case LOCAL_GL_BLEND_DST_RGB:
1.220 + case LOCAL_GL_BLEND_DST_ALPHA:
1.221 + case LOCAL_GL_BLEND_EQUATION_RGB:
1.222 + case LOCAL_GL_BLEND_EQUATION_ALPHA:
1.223 + case LOCAL_GL_GENERATE_MIPMAP_HINT: {
1.224 + GLint i = 0;
1.225 + gl->fGetIntegerv(pname, &i);
1.226 + return JS::NumberValue(uint32_t(i));
1.227 + }
1.228 + // int
1.229 + case LOCAL_GL_STENCIL_CLEAR_VALUE:
1.230 + case LOCAL_GL_STENCIL_REF:
1.231 + case LOCAL_GL_STENCIL_BACK_REF:
1.232 + case LOCAL_GL_UNPACK_ALIGNMENT:
1.233 + case LOCAL_GL_PACK_ALIGNMENT:
1.234 + case LOCAL_GL_SUBPIXEL_BITS:
1.235 + case LOCAL_GL_SAMPLE_BUFFERS:
1.236 + case LOCAL_GL_SAMPLES:
1.237 + case LOCAL_GL_MAX_VERTEX_ATTRIBS:
1.238 + case LOCAL_GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
1.239 + case LOCAL_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
1.240 + case LOCAL_GL_MAX_TEXTURE_IMAGE_UNITS:
1.241 + case LOCAL_GL_RED_BITS:
1.242 + case LOCAL_GL_GREEN_BITS:
1.243 + case LOCAL_GL_BLUE_BITS:
1.244 + case LOCAL_GL_ALPHA_BITS:
1.245 + case LOCAL_GL_DEPTH_BITS:
1.246 + case LOCAL_GL_STENCIL_BITS: {
1.247 + GLint i = 0;
1.248 + gl->fGetIntegerv(pname, &i);
1.249 + return JS::Int32Value(i);
1.250 + }
1.251 + case LOCAL_GL_FRAGMENT_SHADER_DERIVATIVE_HINT: {
1.252 + if (IsExtensionEnabled(WebGLExtensionID::OES_standard_derivatives)) {
1.253 + GLint i = 0;
1.254 + gl->fGetIntegerv(pname, &i);
1.255 + return JS::Int32Value(i);
1.256 + } else {
1.257 + break;
1.258 + }
1.259 + }
1.260 + case LOCAL_GL_MAX_TEXTURE_SIZE:
1.261 + return JS::Int32Value(mGLMaxTextureSize);
1.262 +
1.263 + case LOCAL_GL_MAX_CUBE_MAP_TEXTURE_SIZE:
1.264 + return JS::Int32Value(mGLMaxCubeMapTextureSize);
1.265 +
1.266 + case LOCAL_GL_MAX_RENDERBUFFER_SIZE:
1.267 + return JS::Int32Value(mGLMaxRenderbufferSize);
1.268 +
1.269 + case LOCAL_GL_MAX_VERTEX_UNIFORM_VECTORS:
1.270 + return JS::Int32Value(mGLMaxVertexUniformVectors);
1.271 +
1.272 + case LOCAL_GL_MAX_FRAGMENT_UNIFORM_VECTORS:
1.273 + return JS::Int32Value(mGLMaxFragmentUniformVectors);
1.274 +
1.275 + case LOCAL_GL_MAX_VARYING_VECTORS:
1.276 + return JS::Int32Value(mGLMaxVaryingVectors);
1.277 +
1.278 + case LOCAL_GL_NUM_COMPRESSED_TEXTURE_FORMATS:
1.279 + return JS::Int32Value(0);
1.280 + case LOCAL_GL_COMPRESSED_TEXTURE_FORMATS: {
1.281 + uint32_t length = mCompressedTextureFormats.Length();
1.282 + JSObject* obj = Uint32Array::Create(cx, this, length, mCompressedTextureFormats.Elements());
1.283 + if (!obj) {
1.284 + rv = NS_ERROR_OUT_OF_MEMORY;
1.285 + }
1.286 + return JS::ObjectOrNullValue(obj);
1.287 + }
1.288 + case LOCAL_GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: {
1.289 + if (!IsWebGL2()) {
1.290 + break;
1.291 + }
1.292 + return JS::Int32Value(mGLMaxTransformFeedbackSeparateAttribs);
1.293 + }
1.294 +
1.295 + // unsigned int. here we may have to return very large values like 2^32-1 that can't be represented as
1.296 + // javascript integer values. We just return them as doubles and javascript doesn't care.
1.297 + case LOCAL_GL_STENCIL_BACK_VALUE_MASK:
1.298 + case LOCAL_GL_STENCIL_BACK_WRITEMASK:
1.299 + case LOCAL_GL_STENCIL_VALUE_MASK:
1.300 + case LOCAL_GL_STENCIL_WRITEMASK: {
1.301 + GLint i = 0; // the GL api (glGetIntegerv) only does signed ints
1.302 + gl->fGetIntegerv(pname, &i);
1.303 + GLuint i_unsigned(i); // this is where -1 becomes 2^32-1
1.304 + double i_double(i_unsigned); // pass as FP value to allow large values such as 2^32-1.
1.305 + return JS::DoubleValue(i_double);
1.306 + }
1.307 +
1.308 + // float
1.309 + case LOCAL_GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: {
1.310 + if (IsExtensionEnabled(WebGLExtensionID::EXT_texture_filter_anisotropic)) {
1.311 + GLfloat f = 0.f;
1.312 + gl->fGetFloatv(pname, &f);
1.313 + return JS::DoubleValue(f);
1.314 + } else {
1.315 + break;
1.316 + }
1.317 + }
1.318 + case LOCAL_GL_DEPTH_CLEAR_VALUE:
1.319 + case LOCAL_GL_LINE_WIDTH:
1.320 + case LOCAL_GL_POLYGON_OFFSET_FACTOR:
1.321 + case LOCAL_GL_POLYGON_OFFSET_UNITS:
1.322 + case LOCAL_GL_SAMPLE_COVERAGE_VALUE: {
1.323 + GLfloat f = 0.f;
1.324 + gl->fGetFloatv(pname, &f);
1.325 + return JS::DoubleValue(f);
1.326 + }
1.327 +
1.328 + // bool
1.329 + case LOCAL_GL_BLEND:
1.330 + case LOCAL_GL_DEPTH_TEST:
1.331 + case LOCAL_GL_STENCIL_TEST:
1.332 + case LOCAL_GL_CULL_FACE:
1.333 + case LOCAL_GL_DITHER:
1.334 + case LOCAL_GL_POLYGON_OFFSET_FILL:
1.335 + case LOCAL_GL_SCISSOR_TEST:
1.336 + case LOCAL_GL_SAMPLE_COVERAGE_INVERT:
1.337 + case LOCAL_GL_DEPTH_WRITEMASK: {
1.338 + realGLboolean b = 0;
1.339 + gl->fGetBooleanv(pname, &b);
1.340 + return JS::BooleanValue(bool(b));
1.341 + }
1.342 +
1.343 + // bool, WebGL-specific
1.344 + case UNPACK_FLIP_Y_WEBGL:
1.345 + return JS::BooleanValue(mPixelStoreFlipY);
1.346 + case UNPACK_PREMULTIPLY_ALPHA_WEBGL:
1.347 + return JS::BooleanValue(mPixelStorePremultiplyAlpha);
1.348 +
1.349 + // uint, WebGL-specific
1.350 + case UNPACK_COLORSPACE_CONVERSION_WEBGL:
1.351 + return JS::NumberValue(uint32_t(mPixelStoreColorspaceConversion));
1.352 +
1.353 + ////////////////////////////////
1.354 + // Complex values
1.355 +
1.356 + // 2 floats
1.357 + case LOCAL_GL_DEPTH_RANGE:
1.358 + case LOCAL_GL_ALIASED_POINT_SIZE_RANGE:
1.359 + case LOCAL_GL_ALIASED_LINE_WIDTH_RANGE: {
1.360 + GLfloat fv[2] = { 0 };
1.361 + gl->fGetFloatv(pname, fv);
1.362 + JSObject* obj = Float32Array::Create(cx, this, 2, fv);
1.363 + if (!obj) {
1.364 + rv = NS_ERROR_OUT_OF_MEMORY;
1.365 + }
1.366 + return JS::ObjectOrNullValue(obj);
1.367 + }
1.368 +
1.369 + // 4 floats
1.370 + case LOCAL_GL_COLOR_CLEAR_VALUE:
1.371 + case LOCAL_GL_BLEND_COLOR: {
1.372 + GLfloat fv[4] = { 0 };
1.373 + gl->fGetFloatv(pname, fv);
1.374 + JSObject* obj = Float32Array::Create(cx, this, 4, fv);
1.375 + if (!obj) {
1.376 + rv = NS_ERROR_OUT_OF_MEMORY;
1.377 + }
1.378 + return JS::ObjectOrNullValue(obj);
1.379 + }
1.380 +
1.381 + // 2 ints
1.382 + case LOCAL_GL_MAX_VIEWPORT_DIMS: {
1.383 + GLint iv[2] = { 0 };
1.384 + gl->fGetIntegerv(pname, iv);
1.385 + JSObject* obj = Int32Array::Create(cx, this, 2, iv);
1.386 + if (!obj) {
1.387 + rv = NS_ERROR_OUT_OF_MEMORY;
1.388 + }
1.389 + return JS::ObjectOrNullValue(obj);
1.390 + }
1.391 +
1.392 + // 4 ints
1.393 + case LOCAL_GL_SCISSOR_BOX:
1.394 + case LOCAL_GL_VIEWPORT: {
1.395 + GLint iv[4] = { 0 };
1.396 + gl->fGetIntegerv(pname, iv);
1.397 + JSObject* obj = Int32Array::Create(cx, this, 4, iv);
1.398 + if (!obj) {
1.399 + rv = NS_ERROR_OUT_OF_MEMORY;
1.400 + }
1.401 + return JS::ObjectOrNullValue(obj);
1.402 + }
1.403 +
1.404 + // 4 bools
1.405 + case LOCAL_GL_COLOR_WRITEMASK: {
1.406 + realGLboolean gl_bv[4] = { 0 };
1.407 + gl->fGetBooleanv(pname, gl_bv);
1.408 + bool vals[4] = { bool(gl_bv[0]), bool(gl_bv[1]),
1.409 + bool(gl_bv[2]), bool(gl_bv[3]) };
1.410 + JS::Rooted<JS::Value> arr(cx);
1.411 + if (!ToJSValue(cx, vals, &arr)) {
1.412 + rv = NS_ERROR_OUT_OF_MEMORY;
1.413 + }
1.414 + return arr;
1.415 + }
1.416 +
1.417 + case LOCAL_GL_ARRAY_BUFFER_BINDING: {
1.418 + return WebGLObjectAsJSValue(cx, mBoundArrayBuffer.get(), rv);
1.419 + }
1.420 +
1.421 + case LOCAL_GL_TRANSFORM_FEEDBACK_BUFFER_BINDING: {
1.422 + if (!IsWebGL2()) {
1.423 + break;
1.424 + }
1.425 + return WebGLObjectAsJSValue(cx, mBoundTransformFeedbackBuffer.get(), rv);
1.426 + }
1.427 +
1.428 + case LOCAL_GL_ELEMENT_ARRAY_BUFFER_BINDING: {
1.429 + return WebGLObjectAsJSValue(cx, mBoundVertexArray->mBoundElementArrayBuffer.get(), rv);
1.430 + }
1.431 +
1.432 + case LOCAL_GL_RENDERBUFFER_BINDING: {
1.433 + return WebGLObjectAsJSValue(cx, mBoundRenderbuffer.get(), rv);
1.434 + }
1.435 +
1.436 + case LOCAL_GL_FRAMEBUFFER_BINDING: {
1.437 + return WebGLObjectAsJSValue(cx, mBoundFramebuffer.get(), rv);
1.438 + }
1.439 +
1.440 + case LOCAL_GL_CURRENT_PROGRAM: {
1.441 + return WebGLObjectAsJSValue(cx, mCurrentProgram.get(), rv);
1.442 + }
1.443 +
1.444 + case LOCAL_GL_TEXTURE_BINDING_2D: {
1.445 + return WebGLObjectAsJSValue(cx, mBound2DTextures[mActiveTexture].get(), rv);
1.446 + }
1.447 +
1.448 + case LOCAL_GL_TEXTURE_BINDING_CUBE_MAP: {
1.449 + return WebGLObjectAsJSValue(cx, mBoundCubeMapTextures[mActiveTexture].get(), rv);
1.450 + }
1.451 +
1.452 + default:
1.453 + break;
1.454 + }
1.455 +
1.456 + ErrorInvalidEnumInfo("getParameter: parameter", pname);
1.457 + return JS::NullValue();
1.458 +}
1.459 +
1.460 +void
1.461 +WebGLContext::GetParameterIndexed(JSContext* cx, GLenum pname, GLuint index,
1.462 + JS::MutableHandle<JS::Value> retval)
1.463 +{
1.464 + if (IsContextLost()) {
1.465 + retval.setNull();
1.466 + return;
1.467 + }
1.468 +
1.469 + MakeContextCurrent();
1.470 +
1.471 + switch (pname) {
1.472 + case LOCAL_GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
1.473 + {
1.474 + if (index >= mGLMaxTransformFeedbackSeparateAttribs) {
1.475 + ErrorInvalidValue("getParameterIndexed: index should be less than MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS", index);
1.476 + retval.setNull();
1.477 + return;
1.478 + }
1.479 + retval.setNull(); // See bug 903594
1.480 + return;
1.481 + }
1.482 +
1.483 + default:
1.484 + break;
1.485 + }
1.486 +
1.487 + ErrorInvalidEnumInfo("getParameterIndexed: parameter", pname);
1.488 + retval.setNull();
1.489 +}
1.490 +
1.491 +bool
1.492 +WebGLContext::IsEnabled(GLenum cap)
1.493 +{
1.494 + if (IsContextLost())
1.495 + return false;
1.496 +
1.497 + if (!ValidateCapabilityEnum(cap, "isEnabled"))
1.498 + return false;
1.499 +
1.500 + MakeContextCurrent();
1.501 + return gl->fIsEnabled(cap);
1.502 +}
1.503 +
1.504 +bool
1.505 +WebGLContext::ValidateCapabilityEnum(GLenum cap, const char* info)
1.506 +{
1.507 + switch (cap) {
1.508 + case LOCAL_GL_BLEND:
1.509 + case LOCAL_GL_CULL_FACE:
1.510 + case LOCAL_GL_DEPTH_TEST:
1.511 + case LOCAL_GL_DITHER:
1.512 + case LOCAL_GL_POLYGON_OFFSET_FILL:
1.513 + case LOCAL_GL_SAMPLE_ALPHA_TO_COVERAGE:
1.514 + case LOCAL_GL_SAMPLE_COVERAGE:
1.515 + case LOCAL_GL_SCISSOR_TEST:
1.516 + case LOCAL_GL_STENCIL_TEST:
1.517 + return true;
1.518 + case LOCAL_GL_RASTERIZER_DISCARD:
1.519 + return IsWebGL2();
1.520 + default:
1.521 + ErrorInvalidEnumInfo(info, cap);
1.522 + return false;
1.523 + }
1.524 +}
1.525 +
1.526 +realGLboolean*
1.527 +WebGLContext::GetStateTrackingSlot(GLenum cap)
1.528 +{
1.529 + switch (cap) {
1.530 + case LOCAL_GL_SCISSOR_TEST:
1.531 + return &mScissorTestEnabled;
1.532 + case LOCAL_GL_DITHER:
1.533 + return &mDitherEnabled;
1.534 + case LOCAL_GL_RASTERIZER_DISCARD:
1.535 + return &mRasterizerDiscardEnabled;
1.536 + }
1.537 +
1.538 + return nullptr;
1.539 +}
