Bug 1217290 - Remove WebGLContext::MinCapabilityMode
MozReview-Commit-ID: 8Ggsjm8ReeR
--- a/dom/canvas/WebGLContext.cpp
+++ b/dom/canvas/WebGLContext.cpp
@@ -99,20 +99,16 @@ WebGLContextOptions::WebGLContextOptions
, preserveDrawingBuffer(false)
, failIfMajorPerformanceCaveat(false)
{
// Set default alpha state based on preference.
if (gfxPrefs::WebGLDefaultNoAlpha())
alpha = false;
}
-
-/*static*/ const uint32_t WebGLContext::kMinMaxColorAttachments = 4;
-/*static*/ const uint32_t WebGLContext::kMinMaxDrawBuffers = 4;
-
WebGLContext::WebGLContext()
: WebGLContextUnchecked(nullptr)
, mMaxPerfWarnings(gfxPrefs::WebGLMaxPerfWarnings())
, mNumPerfWarnings(0)
, mMaxAcceptableFBStatusInvals(gfxPrefs::WebGLMaxAcceptableFBStatusInvals())
, mDataAllocGLCallCount(0)
, mBufferFetchingIsVerified(false)
, mBufferFetchingHasPerVertex(false)
@@ -129,17 +125,16 @@ WebGLContext::WebGLContext()
, mAllowFBInvalidation(gfxPrefs::WebGLFBInvalidation())
{
mGeneration = 0;
mInvalidated = false;
mCapturedFrameInvalidated = false;
mShouldPresent = true;
mResetLayer = true;
mOptionsFrozen = false;
- mMinCapability = false;
mDisableExtensions = false;
mIsMesa = false;
mEmitContextLostErrorOnce = false;
mWebGLError = 0;
mUnderlyingGLError = 0;
mActiveTexture = 0;
--- a/dom/canvas/WebGLContext.h
+++ b/dom/canvas/WebGLContext.h
@@ -327,19 +327,16 @@ class WebGLContext
UNPACK_REQUIRE_FASTPATH = 0x10001,
CONTEXT_LOST_WEBGL = 0x9242,
UNPACK_COLORSPACE_CONVERSION_WEBGL = 0x9243,
BROWSER_DEFAULT_WEBGL = 0x9244,
UNMASKED_VENDOR_WEBGL = 0x9245,
UNMASKED_RENDERER_WEBGL = 0x9246
};
- static const uint32_t kMinMaxColorAttachments;
- static const uint32_t kMinMaxDrawBuffers;
-
const uint32_t mMaxPerfWarnings;
mutable uint64_t mNumPerfWarnings;
const uint32_t mMaxAcceptableFBStatusInvals;
public:
WebGLContext();
protected:
@@ -497,18 +494,16 @@ public:
// It only clears the buffers we specify, and can reset its state without
// first having to query anything, as WebGL knows its state at all times.
void ForceClearFramebufferWithDefaultValues(GLbitfield bufferBits, bool fakeNoAlpha);
// Calls ForceClearFramebufferWithDefaultValues() for the Context's 'screen'.
void ClearScreen();
void ClearBackbufferIfNeeded();
- bool MinCapabilityMode() const { return mMinCapability; }
-
void RunContextLossTimer();
void UpdateContextLossStatus();
void EnqueueUpdateContextLossStatus();
bool TryToRestoreContext();
void AssertCachedBindings();
void AssertCachedGlobalState();
@@ -1440,17 +1435,16 @@ protected:
WebGLContextOptions mOptions;
bool mInvalidated;
bool mCapturedFrameInvalidated;
bool mResetLayer;
bool mLayerIsMirror;
bool mOptionsFrozen;
- bool mMinCapability;
bool mDisableExtensions;
bool mIsMesa;
bool mLoseContextOnMemoryPressure;
bool mCanLoseContextInForeground;
bool mRestoreWhenVisible;
bool mShouldPresent;
bool mBackbufferNeedsClear;
bool mDisableFragHighP;
--- a/dom/canvas/WebGLContextState.cpp
+++ b/dom/canvas/WebGLContextState.cpp
@@ -176,55 +176,16 @@ WebGLContext::GetParameter(JSContext* cx
{
const char funcName[] = "getParameter";
if (IsContextLost())
return JS::NullValue();
MakeContextCurrent();
- if (MinCapabilityMode()) {
- switch(pname) {
- ////////////////////////////
- // Single-value params
-
- // int
- case LOCAL_GL_MAX_VERTEX_ATTRIBS:
- return JS::Int32Value(MINVALUE_GL_MAX_VERTEX_ATTRIBS);
-
- case LOCAL_GL_MAX_FRAGMENT_UNIFORM_VECTORS:
- return JS::Int32Value(MINVALUE_GL_MAX_FRAGMENT_UNIFORM_VECTORS);
-
- case LOCAL_GL_MAX_VERTEX_UNIFORM_VECTORS:
- return JS::Int32Value(MINVALUE_GL_MAX_VERTEX_UNIFORM_VECTORS);
-
- case LOCAL_GL_MAX_VARYING_VECTORS:
- return JS::Int32Value(MINVALUE_GL_MAX_VARYING_VECTORS);
-
- case LOCAL_GL_MAX_TEXTURE_SIZE:
- return JS::Int32Value(MINVALUE_GL_MAX_TEXTURE_SIZE);
-
- case LOCAL_GL_MAX_CUBE_MAP_TEXTURE_SIZE:
- return JS::Int32Value(MINVALUE_GL_MAX_CUBE_MAP_TEXTURE_SIZE);
-
- case LOCAL_GL_MAX_TEXTURE_IMAGE_UNITS:
- return JS::Int32Value(MINVALUE_GL_MAX_TEXTURE_IMAGE_UNITS);
-
- case LOCAL_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
- return JS::Int32Value(MINVALUE_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS);
-
- case LOCAL_GL_MAX_RENDERBUFFER_SIZE:
- return JS::Int32Value(MINVALUE_GL_MAX_RENDERBUFFER_SIZE);
-
- default:
- // Return the real value; we're not overriding this one
- break;
- }
- }
-
if (IsWebGL2() || IsExtensionEnabled(WebGLExtensionID::WEBGL_draw_buffers)) {
if (pname == LOCAL_GL_MAX_COLOR_ATTACHMENTS) {
return JS::Int32Value(mImplMaxColorAttachments);
} else if (pname == LOCAL_GL_MAX_DRAW_BUFFERS) {
return JS::Int32Value(mImplMaxDrawBuffers);
} else if (pname >= LOCAL_GL_DRAW_BUFFER0 &&
--- a/dom/canvas/WebGLContextValidate.cpp
+++ b/dom/canvas/WebGLContextValidate.cpp
@@ -361,25 +361,21 @@ WebGLContext::InitAndValidateGL(FailureR
if (error != LOCAL_GL_NO_ERROR) {
const nsPrintfCString reason("GL error 0x%x occurred during OpenGL context"
" initialization, before WebGL initialization!",
error);
*out_failReason = { "FEATURE_FAILURE_WEBGL_GLERR_1", reason };
return false;
}
- mMinCapability = gfxPrefs::WebGLMinCapabilityMode();
mDisableExtensions = gfxPrefs::WebGLDisableExtensions();
mLoseContextOnMemoryPressure = gfxPrefs::WebGLLoseContextOnMemoryPressure();
mCanLoseContextInForeground = gfxPrefs::WebGLCanLoseContextInForeground();
mRestoreWhenVisible = gfxPrefs::WebGLRestoreWhenVisible();
- if (MinCapabilityMode())
- mDisableFragHighP = true;
-
// These are the default values, see 6.2 State tables in the
// OpenGL ES 2.0.25 spec.
mColorWriteMask[0] = 1;
mColorWriteMask[1] = 1;
mColorWriteMask[2] = 1;
mColorWriteMask[3] = 1;
mDepthWriteMask = 1;
mColorClearValue[0] = 0.f;
@@ -440,35 +436,29 @@ WebGLContext::InitAndValidateGL(FailureR
mCurrentProgram = nullptr;
mBoundDrawFramebuffer = nullptr;
mBoundReadFramebuffer = nullptr;
mBoundRenderbuffer = nullptr;
MakeContextCurrent();
- if (MinCapabilityMode())
- mGLMaxVertexAttribs = MINVALUE_GL_MAX_VERTEX_ATTRIBS;
- else
- gl->GetUIntegerv(LOCAL_GL_MAX_VERTEX_ATTRIBS, &mGLMaxVertexAttribs);
+ gl->GetUIntegerv(LOCAL_GL_MAX_VERTEX_ATTRIBS, &mGLMaxVertexAttribs);
if (mGLMaxVertexAttribs < 8) {
const nsPrintfCString reason("GL_MAX_VERTEX_ATTRIBS: %d is < 8!",
mGLMaxVertexAttribs);
*out_failReason = { "FEATURE_FAILURE_WEBGL_V_ATRB", reason };
return false;
}
// Note: GL_MAX_TEXTURE_UNITS is fixed at 4 for most desktop hardware,
// even though the hardware supports much more. The
// GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS value is the accurate value.
- if (MinCapabilityMode())
- mGLMaxTextureUnits = MINVALUE_GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS;
- else
- gl->fGetIntegerv(LOCAL_GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &mGLMaxTextureUnits);
+ gl->fGetIntegerv(LOCAL_GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &mGLMaxTextureUnits);
if (mGLMaxTextureUnits < 8) {
const nsPrintfCString reason("GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: %d is < 8!",
mGLMaxTextureUnits);
*out_failReason = { "FEATURE_FAILURE_WEBGL_T_UNIT", reason };
return false;
}
@@ -477,105 +467,81 @@ WebGLContext::InitAndValidateGL(FailureR
mBound3DTextures.SetLength(mGLMaxTextureUnits);
mBound2DArrayTextures.SetLength(mGLMaxTextureUnits);
mBoundSamplers.SetLength(mGLMaxTextureUnits);
gl->fGetIntegerv(LOCAL_GL_MAX_VIEWPORT_DIMS, (GLint*)mImplMaxViewportDims);
////////////////
- if (MinCapabilityMode()) {
- mImplMaxTextureSize = MINVALUE_GL_MAX_TEXTURE_SIZE;
- mImplMaxCubeMapTextureSize = MINVALUE_GL_MAX_CUBE_MAP_TEXTURE_SIZE;
- mImplMaxRenderbufferSize = MINVALUE_GL_MAX_RENDERBUFFER_SIZE;
-
- mImplMax3DTextureSize = MINVALUE_GL_MAX_3D_TEXTURE_SIZE;
- mImplMaxArrayTextureLayers = MINVALUE_GL_MAX_ARRAY_TEXTURE_LAYERS;
+ gl->fGetIntegerv(LOCAL_GL_MAX_TEXTURE_SIZE, (GLint*)&mImplMaxTextureSize);
+ gl->fGetIntegerv(LOCAL_GL_MAX_CUBE_MAP_TEXTURE_SIZE, (GLint*)&mImplMaxCubeMapTextureSize);
+ gl->fGetIntegerv(LOCAL_GL_MAX_RENDERBUFFER_SIZE, (GLint*)&mImplMaxRenderbufferSize);
- mGLMaxTextureImageUnits = MINVALUE_GL_MAX_TEXTURE_IMAGE_UNITS;
- mGLMaxVertexTextureImageUnits = MINVALUE_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS;
- } else {
- gl->fGetIntegerv(LOCAL_GL_MAX_TEXTURE_SIZE, (GLint*)&mImplMaxTextureSize);
- gl->fGetIntegerv(LOCAL_GL_MAX_CUBE_MAP_TEXTURE_SIZE, (GLint*)&mImplMaxCubeMapTextureSize);
- gl->fGetIntegerv(LOCAL_GL_MAX_RENDERBUFFER_SIZE, (GLint*)&mImplMaxRenderbufferSize);
+ if (!gl->GetPotentialInteger(LOCAL_GL_MAX_3D_TEXTURE_SIZE, (GLint*)&mImplMax3DTextureSize))
+ mImplMax3DTextureSize = 0;
+ if (!gl->GetPotentialInteger(LOCAL_GL_MAX_ARRAY_TEXTURE_LAYERS, (GLint*)&mImplMaxArrayTextureLayers))
+ mImplMaxArrayTextureLayers = 0;
- if (!gl->GetPotentialInteger(LOCAL_GL_MAX_3D_TEXTURE_SIZE, (GLint*)&mImplMax3DTextureSize))
- mImplMax3DTextureSize = 0;
- if (!gl->GetPotentialInteger(LOCAL_GL_MAX_ARRAY_TEXTURE_LAYERS, (GLint*)&mImplMaxArrayTextureLayers))
- mImplMaxArrayTextureLayers = 0;
-
- gl->fGetIntegerv(LOCAL_GL_MAX_TEXTURE_IMAGE_UNITS, &mGLMaxTextureImageUnits);
- gl->fGetIntegerv(LOCAL_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &mGLMaxVertexTextureImageUnits);
- }
+ gl->fGetIntegerv(LOCAL_GL_MAX_TEXTURE_IMAGE_UNITS, &mGLMaxTextureImageUnits);
+ gl->fGetIntegerv(LOCAL_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &mGLMaxVertexTextureImageUnits);
////////////////
mGLMaxColorAttachments = 1;
mGLMaxDrawBuffers = 1;
gl->GetPotentialInteger(LOCAL_GL_MAX_COLOR_ATTACHMENTS,
(GLint*)&mGLMaxColorAttachments);
gl->GetPotentialInteger(LOCAL_GL_MAX_DRAW_BUFFERS, (GLint*)&mGLMaxDrawBuffers);
- if (MinCapabilityMode()) {
- mGLMaxColorAttachments = std::min(mGLMaxColorAttachments,
- kMinMaxColorAttachments);
- mGLMaxDrawBuffers = std::min(mGLMaxDrawBuffers, kMinMaxDrawBuffers);
- }
-
if (IsWebGL2()) {
mImplMaxColorAttachments = mGLMaxColorAttachments;
mImplMaxDrawBuffers = std::min(mGLMaxDrawBuffers, mImplMaxColorAttachments);
} else {
mImplMaxColorAttachments = 1;
mImplMaxDrawBuffers = 1;
}
////////////////
- if (MinCapabilityMode()) {
- mGLMaxFragmentUniformVectors = MINVALUE_GL_MAX_FRAGMENT_UNIFORM_VECTORS;
- mGLMaxVertexUniformVectors = MINVALUE_GL_MAX_VERTEX_UNIFORM_VECTORS;
- mGLMaxVaryingVectors = MINVALUE_GL_MAX_VARYING_VECTORS;
+ if (gl->IsSupported(gl::GLFeature::ES2_compatibility)) {
+ gl->fGetIntegerv(LOCAL_GL_MAX_FRAGMENT_UNIFORM_VECTORS, &mGLMaxFragmentUniformVectors);
+ gl->fGetIntegerv(LOCAL_GL_MAX_VERTEX_UNIFORM_VECTORS, &mGLMaxVertexUniformVectors);
+ gl->fGetIntegerv(LOCAL_GL_MAX_VARYING_VECTORS, &mGLMaxVaryingVectors);
} else {
- if (gl->IsSupported(gl::GLFeature::ES2_compatibility)) {
- gl->fGetIntegerv(LOCAL_GL_MAX_FRAGMENT_UNIFORM_VECTORS, &mGLMaxFragmentUniformVectors);
- gl->fGetIntegerv(LOCAL_GL_MAX_VERTEX_UNIFORM_VECTORS, &mGLMaxVertexUniformVectors);
- gl->fGetIntegerv(LOCAL_GL_MAX_VARYING_VECTORS, &mGLMaxVaryingVectors);
- } else {
- gl->fGetIntegerv(LOCAL_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &mGLMaxFragmentUniformVectors);
- mGLMaxFragmentUniformVectors /= 4;
- gl->fGetIntegerv(LOCAL_GL_MAX_VERTEX_UNIFORM_COMPONENTS, &mGLMaxVertexUniformVectors);
- mGLMaxVertexUniformVectors /= 4;
+ gl->fGetIntegerv(LOCAL_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &mGLMaxFragmentUniformVectors);
+ mGLMaxFragmentUniformVectors /= 4;
+ gl->fGetIntegerv(LOCAL_GL_MAX_VERTEX_UNIFORM_COMPONENTS, &mGLMaxVertexUniformVectors);
+ mGLMaxVertexUniformVectors /= 4;
- /* We are now going to try to read GL_MAX_VERTEX_OUTPUT_COMPONENTS
- * and GL_MAX_FRAGMENT_INPUT_COMPONENTS, however these constants
- * only entered the OpenGL standard at OpenGL 3.2. So we will try
- * reading, and check OpenGL error for INVALID_ENUM.
- *
- * On the public_webgl list, "problematic GetParameter pnames"
- * thread, the following formula was given:
- * maxVaryingVectors = min(GL_MAX_VERTEX_OUTPUT_COMPONENTS,
- * GL_MAX_FRAGMENT_INPUT_COMPONENTS) / 4
- */
- GLint maxVertexOutputComponents = 0;
- GLint maxFragmentInputComponents = 0;
+ /* We are now going to try to read GL_MAX_VERTEX_OUTPUT_COMPONENTS
+ * and GL_MAX_FRAGMENT_INPUT_COMPONENTS, however these constants
+ * only entered the OpenGL standard at OpenGL 3.2. So we will try
+ * reading, and check OpenGL error for INVALID_ENUM.
+ *
+ * On the public_webgl list, "problematic GetParameter pnames"
+ * thread, the following formula was given:
+ * maxVaryingVectors = min(GL_MAX_VERTEX_OUTPUT_COMPONENTS,
+ * GL_MAX_FRAGMENT_INPUT_COMPONENTS) / 4
+ */
+ GLint maxVertexOutputComponents = 0;
+ GLint maxFragmentInputComponents = 0;
- const bool ok = (gl->GetPotentialInteger(LOCAL_GL_MAX_VERTEX_OUTPUT_COMPONENTS,
- &maxVertexOutputComponents) &&
- gl->GetPotentialInteger(LOCAL_GL_MAX_FRAGMENT_INPUT_COMPONENTS,
- &maxFragmentInputComponents));
+ const bool ok = (gl->GetPotentialInteger(LOCAL_GL_MAX_VERTEX_OUTPUT_COMPONENTS,
+ &maxVertexOutputComponents) &&
+ gl->GetPotentialInteger(LOCAL_GL_MAX_FRAGMENT_INPUT_COMPONENTS,
+ &maxFragmentInputComponents));
- if (ok) {
- mGLMaxVaryingVectors = std::min(maxVertexOutputComponents,
- maxFragmentInputComponents) / 4;
- } else {
- mGLMaxVaryingVectors = 16;
- // 16 = 64/4, and 64 is the min value for
- // maxVertexOutputComponents in the OpenGL 3.2 spec.
- }
+ if (ok) {
+ mGLMaxVaryingVectors = std::min(maxVertexOutputComponents,
+ maxFragmentInputComponents) / 4;
+ } else {
+ mGLMaxVaryingVectors = 16;
+ // 16 = 64/4, and 64 is the min value for
+ // maxVertexOutputComponents in the OpenGL 3.2 spec.
}
}
if (gl->IsCompatibilityProfile()) {
gl->fEnable(LOCAL_GL_POINT_SPRITE);
}
if (!gl->IsGLES()) {
--- a/dom/canvas/WebGLExtensionDrawBuffers.cpp
+++ b/dom/canvas/WebGLExtensionDrawBuffers.cpp
@@ -43,24 +43,14 @@ WebGLExtensionDrawBuffers::DrawBuffersWE
mContext->DrawBuffers(buffers);
}
bool
WebGLExtensionDrawBuffers::IsSupported(const WebGLContext* webgl)
{
gl::GLContext* gl = webgl->GL();
- if (!gl->IsSupported(gl::GLFeature::draw_buffers))
- return false;
-
- // WEBGL_draw_buffers requires at least 4 color attachments.
- if (webgl->mGLMaxDrawBuffers < webgl->kMinMaxDrawBuffers ||
- webgl->mGLMaxColorAttachments < webgl->kMinMaxColorAttachments)
- {
- return false;
- }
-
- return true;
+ return gl->IsSupported(gl::GLFeature::draw_buffers);
}
IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionDrawBuffers, WEBGL_draw_buffers)
} // namespace mozilla