Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-24 13:21:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1562331 - Make webgl.* static prefs follow the naming convention. r=KrisWright

Browse Source 
Also converts webgl.pref-16bpp from a VarCache pref to a normal pref, because
it doesn't need to be a VarCache pref.

Differential Revision: https://phabricator.services.mozilla.com/D36397

--HG--
extra : rebase_source : 5aa1d251b751c41ec525fef7d0467ffebe401d9a
This commit is contained in:
Nicholas Nethercote 2019-06-29 07:56:43 +10:00
parent d839ef58db
commit 76f416f162
14 changed files with 94 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
dom/canvas/WebGL2ContextSync.cpp
View File

@ -67,7 +67,7 @@ GLenum WebGL2Context::ClientWaitSync(const WebGLSync& sync, GLbitfield flags,
}
const bool canBeAvailable =
(sync.mCanBeAvailable || StaticPrefs::WebGLImmediateQueries());
(sync.mCanBeAvailable || StaticPrefs::webgl_allow_immediate_queries());
if (!canBeAvailable) {
if (timeout) {
GenerateWarning(
@ -118,7 +118,7 @@ void WebGL2Context::GetSyncParameter(JSContext*, const WebGLSync& sync,
////
const bool canBeAvailable =
(sync.mCanBeAvailable || StaticPrefs::WebGLImmediateQueries());
(sync.mCanBeAvailable || StaticPrefs::webgl_allow_immediate_queries());
if (!canBeAvailable && pname == LOCAL_GL_SYNC_STATUS) {
retval.set(JS::Int32Value(LOCAL_GL_UNSIGNALED));
return;

38
dom/canvas/WebGLContext.cpp
View File

@ -98,8 +98,8 @@ using namespace mozilla::layers;
WebGLContextOptions::WebGLContextOptions() {
// Set default alpha state based on preference.
alpha = !StaticPrefs::WebGLDefaultNoAlpha();
antialias = StaticPrefs::WebGLDefaultAntialias();
alpha = !StaticPrefs::webgl_default_no_alpha();
antialias = StaticPrefs::webgl_default_antialias();
}
bool WebGLContextOptions::operator==(const WebGLContextOptions& r) const {
@ -118,18 +118,18 @@ bool WebGLContextOptions::operator==(const WebGLContextOptions& r) const {
WebGLContext::WebGLContext()
: gl(mGL_OnlyClearInDestroyResourcesAndContext) // const reference
,
mMaxPerfWarnings(StaticPrefs::WebGLMaxPerfWarnings()),
mMaxPerfWarnings(StaticPrefs::webgl_perf_max_warnings()),
mNumPerfWarnings(0),
mMaxAcceptableFBStatusInvals(
StaticPrefs::WebGLMaxAcceptableFBStatusInvals()),
StaticPrefs::webgl_perf_max_acceptable_fb_status_invals()),
mDataAllocGLCallCount(0),
mEmptyTFO(0),
mContextLossHandler(this),
mNeedsFakeNoAlpha(false),
mNeedsFakeNoDepth(false),
mNeedsFakeNoStencil(false),
mAllowFBInvalidation(StaticPrefs::WebGLFBInvalidation()),
mMsaaSamples((uint8_t)StaticPrefs::WebGLMsaaSamples()) {
mAllowFBInvalidation(StaticPrefs::webgl_allow_fb_invalidation()),
mMsaaSamples((uint8_t)StaticPrefs::webgl_msaa_samples()) {
mGeneration = 0;
mInvalidated = false;
mCapturedFrameInvalidated = false;
@ -165,7 +165,7 @@ WebGLContext::WebGLContext()
mAlreadyWarnedAboutFakeVertexAttrib0 = false;
mAlreadyWarnedAboutViewportLargerThanDest = false;
mMaxWarnings = StaticPrefs::WebGLMaxWarningsPerContext();
mMaxWarnings = StaticPrefs::webgl_max_warnings_per_context();
if (mMaxWarnings < -1) {
GenerateWarning(
"webgl.max-warnings-per-context size is too large (seems like a "
@ -367,7 +367,7 @@ WebGLContext::SetContextOptions(JSContext* cx, JS::Handle<JS::Value> options,
newOpts.antialias = false;
}
if (newOpts.antialias && !StaticPrefs::WebGLForceMSAA()) {
if (newOpts.antialias && !StaticPrefs::webgl_msaa_force()) {
const nsCOMPtr<nsIGfxInfo> gfxInfo = services::GetGfxInfo();
nsCString blocklistId;
@ -479,7 +479,7 @@ bool WebGLContext::CreateAndInitGL(
if (IsWebGL2()) {
flags |= gl::CreateContextFlags::PREFER_ES3;
} else if (!StaticPrefs::WebGL1AllowCoreProfile()) {
} else if (!StaticPrefs::webgl_1_allow_core_profiles()) {
flags |= gl::CreateContextFlags::REQUIRE_COMPAT_PROFILE;
}
@ -504,7 +504,7 @@ bool WebGLContext::CreateAndInitGL(
// ads/trackers)
default:
highPower = true;
if (StaticPrefs::WebGLDefaultLowPower()) {
if (StaticPrefs::webgl_default_low_power()) {
highPower = false;
} else if (mCanvasElement && !mCanvasElement->GetParentNode()) {
GenerateWarning(
@ -559,12 +559,12 @@ bool WebGLContext::CreateAndInitGL(
tryNativeGL = false;
tryANGLE = true;
if (StaticPrefs::WebGLDisableWGL()) {
if (StaticPrefs::webgl_disable_wgl()) {
tryNativeGL = false;
}
if (StaticPrefs::WebGLDisableANGLE() || PR_GetEnv("MOZ_WEBGL_FORCE_OPENGL") ||
useEGL) {
if (StaticPrefs::webgl_disable_angle() ||
PR_GetEnv("MOZ_WEBGL_FORCE_OPENGL") || useEGL) {
tryNativeGL = true;
tryANGLE = false;
}
@ -819,7 +819,7 @@ WebGLContext::SetDimensions(int32_t signedWidth, int32_t signedHeight) {
// pick up the old generation.
++mGeneration;
bool disabled = StaticPrefs::WebGLDisabled();
bool disabled = StaticPrefs::webgl_disabled();
// TODO: When we have software webgl support we should use that instead.
disabled |= gfxPlatform::InSafeMode();
@ -835,7 +835,7 @@ WebGLContext::SetDimensions(int32_t signedWidth, int32_t signedHeight) {
return NS_ERROR_FAILURE;
}
if (StaticPrefs::WebGLDisableFailIfMajorPerformanceCaveat()) {
if (StaticPrefs::webgl_disable_fail_if_major_performance_caveat()) {
mOptions.failIfMajorPerformanceCaveat = false;
}
@ -852,7 +852,7 @@ WebGLContext::SetDimensions(int32_t signedWidth, int32_t signedHeight) {
}
// Alright, now let's start trying.
bool forceEnabled = StaticPrefs::WebGLForceEnabled();
bool forceEnabled = StaticPrefs::webgl_force_enabled();
ScopedGfxFeatureReporter reporter("WebGL", forceEnabled);
MOZ_ASSERT(!gl);
@ -984,9 +984,9 @@ WebGLContext::SetDimensions(int32_t signedWidth, int32_t signedHeight) {
}
void WebGLContext::LoseOldestWebGLContextIfLimitExceeded() {
const auto maxWebGLContexts = StaticPrefs::WebGLMaxContexts();
const auto maxWebGLContexts = StaticPrefs::webgl_max_contexts();
auto maxWebGLContextsPerPrincipal =
StaticPrefs::WebGLMaxContextsPerPrincipal();
StaticPrefs::webgl_max_contexts_per_principal();
// maxWebGLContextsPerPrincipal must be less than maxWebGLContexts
MOZ_ASSERT(maxWebGLContextsPerPrincipal <= maxWebGLContexts);
@ -1348,7 +1348,7 @@ ScopedPrepForResourceClear::~ScopedPrepForResourceClear() {
// -
void WebGLContext::OnEndOfFrame() const {
if (StaticPrefs::WebGLSpewFrameAllocs()) {
if (StaticPrefs::webgl_perf_spew_frame_allocs()) {
GeneratePerfWarning("[webgl.perf.spew-frame-allocs] %" PRIu64
" data allocations this frame.",
mDataAllocGLCallCount);

2
dom/canvas/WebGLContextExtensions.cpp
View File

@ -82,7 +82,7 @@ bool WebGLContext::IsExtensionSupported(dom::CallerType callerType,
allowPrivilegedExts = true;
}
if (StaticPrefs::WebGLPrivilegedExtensionsEnabled()) {
if (StaticPrefs::webgl_enable_privileged_extensions()) {
allowPrivilegedExts = true;
}

13
dom/canvas/WebGLContextValidate.cpp
View File

@ -288,10 +288,11 @@ bool WebGLContext::InitAndValidateGL(FailureReason* const out_failReason) {
return false;
}
mDisableExtensions = StaticPrefs::WebGLDisableExtensions();
mDisableExtensions = StaticPrefs::webgl_disable_extensions();
mLoseContextOnMemoryPressure =
StaticPrefs::WebGLLoseContextOnMemoryPressure();
mCanLoseContextInForeground = StaticPrefs::WebGLCanLoseContextInForeground();
StaticPrefs::webgl_lose_context_on_memory_pressure();
mCanLoseContextInForeground =
StaticPrefs::webgl_can_lose_context_in_foreground();
// These are the default values, see 6.2 State tables in the
// OpenGL ES 2.0.25 spec.
@ -476,7 +477,7 @@ bool WebGLContext::InitAndValidateGL(FailureReason* const out_failReason) {
////////////////
if (StaticPrefs::WebGLMinCapabilityMode()) {
if (StaticPrefs::webgl_min_capability_mode()) {
bool ok = true;
ok &= RestrictCap(&mGLMaxVertexTextureImageUnits,
@ -653,7 +654,7 @@ bool WebGLContext::InitAndValidateGL(FailureReason* const out_failReason) {
mNeedsIndexValidation =
!gl->IsSupported(gl::GLFeature::robust_buffer_access_behavior);
switch (StaticPrefs::WebGLForceIndexValidation()) {
switch (StaticPrefs::webgl_force_index_validation()) {
case -1:
mNeedsIndexValidation = false;
break;
@ -661,7 +662,7 @@ bool WebGLContext::InitAndValidateGL(FailureReason* const out_failReason) {
mNeedsIndexValidation = true;
break;
default:
MOZ_ASSERT(StaticPrefs::WebGLForceIndexValidation() == 0);
MOZ_ASSERT(StaticPrefs::webgl_force_index_validation() == 0);
break;
}

10
dom/canvas/WebGLExtensions.cpp
View File

@ -36,7 +36,7 @@ WebGLExtensionExplicitPresent::WebGLExtensionExplicitPresent(WebGLContext* const
}
bool WebGLExtensionExplicitPresent::IsSupported(const WebGLContext* const webgl) {
return StaticPrefs::WebGLDraftExtensionsEnabled();
return StaticPrefs::webgl_enable_draft_extensions();
}
void WebGLExtensionExplicitPresent::Present() const {
@ -81,7 +81,9 @@ WebGLExtensionFBORenderMipmap::~WebGLExtensionFBORenderMipmap() = default;
bool WebGLExtensionFBORenderMipmap::IsSupported(
const WebGLContext* const webgl) {
if (webgl->IsWebGL2()) return false;
if (!StaticPrefs::WebGLDraftExtensionsEnabled()) return false;
if (!StaticPrefs::webgl_enable_draft_extensions()) {
return false;
}
const auto& gl = webgl->gl;
if (!gl->IsGLES()) return true;
@ -102,7 +104,9 @@ WebGLExtensionMultiview::~WebGLExtensionMultiview() = default;
bool WebGLExtensionMultiview::IsSupported(const WebGLContext* const webgl) {
if (!webgl->IsWebGL2()) return false;
if (!StaticPrefs::WebGLDraftExtensionsEnabled()) return false;
if (!StaticPrefs::webgl_enable_draft_extensions()) {
return false;
}
const auto& gl = webgl->gl;
return gl->IsSupported(gl::GLFeature::multiview);

2
dom/canvas/WebGLQuery.cpp
View File

@ -116,7 +116,7 @@ void WebGLQuery::GetQueryParameter(GLenum pname,
// We must usually wait for an event loop before the query can be available.
const bool canBeAvailable =
(mCanBeAvailable || StaticPrefs::WebGLImmediateQueries());
(mCanBeAvailable || StaticPrefs::webgl_allow_immediate_queries());
if (!canBeAvailable) {
if (pname == LOCAL_GL_QUERY_RESULT_AVAILABLE) {
retval.set(JS::BooleanValue(false));

2
dom/canvas/WebGLShaderValidator.cpp
View File

@ -67,7 +67,7 @@ static ShCompileOptions ChooseValidatorCompileOptions(
}
}
if (StaticPrefs::WebGLAllANGLEOptions()) {
if (StaticPrefs::webgl_all_angle_options()) {
options = -1;
options ^= SH_INTERMEDIATE_TREE;

2
dom/canvas/WebGLTextureUpload.cpp
View File

@ -328,7 +328,7 @@ UniquePtr<webgl::TexUnpackBlob> WebGLContext::FromDomElem(
uint32_t elemWidth = 0;
uint32_t elemHeight = 0;
layers::Image* layersImage = nullptr;
if (!StaticPrefs::WebGLDisableDOMBlitUploads() && sfer.mLayersImage) {
if (!StaticPrefs::webgl_disable_DOM_blit_uploads() && sfer.mLayersImage) {
layersImage = sfer.mLayersImage;
elemWidth = layersImage->GetSize().width;
elemHeight = layersImage->GetSize().height;

10
gfx/gl/GLLibraryEGL.cpp
View File

@ -289,14 +289,14 @@ static EGLDisplay GetAndInitDisplayForAccelANGLE(
FeatureState& d3d11ANGLE = gfxConfig::GetFeature(Feature::D3D11_HW_ANGLE);
if (!StaticPrefs::WebGLANGLETryD3D11())
if (!StaticPrefs::webgl_angle_try_d3d11()) {
d3d11ANGLE.UserDisable("User disabled D3D11 ANGLE by pref",
NS_LITERAL_CSTRING("FAILURE_ID_ANGLE_PREF"));
if (StaticPrefs::WebGLANGLEForceD3D11())
}
if (StaticPrefs::webgl_angle_force_d3d11()) {
d3d11ANGLE.UserForceEnable(
"User force-enabled D3D11 ANGLE on disabled hardware");
}
gAngleErrorReporter.SetFailureId(out_failureId);
auto guardShutdown = mozilla::MakeScopeExit([&] {
@ -741,7 +741,7 @@ EGLDisplay GLLibraryEGL::CreateDisplay(bool forceAccel,
bool shouldTryWARP = !forceAccel; // Only if ANGLE not supported or fails
// If WARP preferred, will override ANGLE support
if (StaticPrefs::WebGLANGLEForceWARP()) {
if (StaticPrefs::webgl_angle_force_warp()) {
shouldTryWARP = true;
shouldTryAccel = false;
if (accelAngleFailureId.IsEmpty()) {

8
gfx/gl/GLScreenBuffer.cpp
View File

@ -66,11 +66,11 @@ UniquePtr<SurfaceFactory> GLScreenBuffer::CreateFactory(
const bool useANGLE = compositorConnection->GetCompositorUseANGLE();
const bool useGl =
!StaticPrefs::WebGLForceLayersReadback() &&
!StaticPrefs::webgl_force_layers_readback() &&
(backend == layers::LayersBackend::LAYERS_OPENGL ||
(backend == layers::LayersBackend::LAYERS_WR && !useANGLE));
const bool useD3D =
!StaticPrefs::WebGLForceLayersReadback() &&
!StaticPrefs::webgl_force_layers_readback() &&
(backend == layers::LayersBackend::LAYERS_D3D11 ||
(backend == layers::LayersBackend::LAYERS_WR && useANGLE));
@ -85,7 +85,7 @@ UniquePtr<SurfaceFactory> GLScreenBuffer::CreateFactory(
factory = MakeUnique<SurfaceFactory_GLTexture>(mGLContext, caps, ipcChannel,
mFlags);
#elif defined(MOZ_WIDGET_ANDROID)
if (XRE_IsParentProcess() && !StaticPrefs::WebGLSurfaceTextureEnabled()) {
if (XRE_IsParentProcess() && !StaticPrefs::webgl_enable_surface_texture()) {
factory = SurfaceFactory_EGLImage::Create(gl, caps, ipcChannel, flags);
} else {
factory =
@ -114,7 +114,7 @@ UniquePtr<SurfaceFactory> GLScreenBuffer::CreateFactory(
SurfaceFactory_ANGLEShareHandle::Create(gl, caps, ipcChannel, flags);
}
if (!factory && StaticPrefs::WebGLDXGLEnabled()) {
if (!factory && StaticPrefs::webgl_dxgl_enabled()) {
factory =
SurfaceFactory_D3D11Interop::Create(gl, caps, ipcChannel, flags);
}

2
gfx/gl/SharedSurfaceD3D11Interop.cpp
View File

@ -414,7 +414,7 @@ SharedSurface_D3D11Interop::SharedSurface_D3D11Interop(
mLockHandle(lockHandle),
mTexD3D(texD3D),
mDXGIHandle(dxgiHandle),
mNeedsFinish(StaticPrefs::WebGLDXGLNeedsFinish()),
mNeedsFinish(StaticPrefs::webgl_dxgl_needs_finish()),
mLockedForGL(false) {
MOZ_ASSERT(bool(mProdTex) == bool(mInteropFB));
}

6
gfx/src/DriverCrashGuard.cpp
View File

@ -509,11 +509,11 @@ bool GLContextCrashGuard::UpdateEnvironment() {
#if defined(XP_WIN)
changed |= CheckAndUpdateBoolPref("gfx.driver-init.webgl-angle-force-d3d11",
StaticPrefs::WebGLANGLEForceD3D11());
StaticPrefs::webgl_angle_force_d3d11());
changed |= CheckAndUpdateBoolPref("gfx.driver-init.webgl-angle-try-d3d11",
StaticPrefs::WebGLANGLETryD3D11());
StaticPrefs::webgl_angle_try_d3d11());
changed |= CheckAndUpdateBoolPref("gfx.driver-init.webgl-angle-force-warp",
StaticPrefs::WebGLANGLEForceWARP());
StaticPrefs::webgl_angle_force_warp());
changed |= CheckAndUpdateBoolPref(
"gfx.driver-init.webgl-angle",
FeatureEnabled(nsIGfxInfo::FEATURE_WEBGL_ANGLE, false));

11
gfx/thebes/gfxPlatform.cpp
View File

@ -922,11 +922,12 @@ void gfxPlatform::Init() {
StaticPrefs::layers_d3d11_force_warp());
// WebGL prefs
forcedPrefs.AppendPrintf(
"-W%d%d%d%d%d%d%d%d", StaticPrefs::WebGLANGLEForceD3D11(),
StaticPrefs::WebGLANGLEForceWARP(), StaticPrefs::WebGLDisabled(),
StaticPrefs::WebGLDisableANGLE(), StaticPrefs::WebGLDXGLEnabled(),
StaticPrefs::WebGLForceEnabled(),
StaticPrefs::WebGLForceLayersReadback(), StaticPrefs::WebGLForceMSAA());
"-W%d%d%d%d%d%d%d%d", StaticPrefs::webgl_angle_force_d3d11(),
StaticPrefs::webgl_angle_force_warp(), StaticPrefs::webgl_disabled(),
StaticPrefs::webgl_disable_angle(), StaticPrefs::webgl_dxgl_enabled(),
StaticPrefs::webgl_force_enabled(),
StaticPrefs::webgl_force_layers_readback(),
StaticPrefs::webgl_msaa_force());
// Prefs that don't fit into any of the other sections
forcedPrefs.AppendPrintf("-T%d%d%d) ",
StaticPrefs::gfx_android_rgb16_force(),

77
modules/libpref/init/StaticPrefList.h
View File

@ -7244,7 +7244,7 @@ VARCACHE_PREF(
VARCACHE_PREF(
Live,
"webgl.1.allow-core-profiles",
WebGL1AllowCoreProfile,
webgl_1_allow_core_profiles,
RelaxedAtomicBool, false
)
@ -7252,35 +7252,35 @@ VARCACHE_PREF(
VARCACHE_PREF(
Live,
"webgl.all-angle-options",
WebGLAllANGLEOptions,
webgl_all_angle_options,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"webgl.angle.force-d3d11",
WebGLANGLEForceD3D11,
webgl_angle_force_d3d11,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"webgl.angle.try-d3d11",
WebGLANGLETryD3D11,
webgl_angle_try_d3d11,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"webgl.angle.force-warp",
WebGLANGLEForceWARP,
webgl_angle_force_warp,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"webgl.can-lose-context-in-foreground",
WebGLCanLoseContextInForeground,
webgl_can_lose_context_in_foreground,
RelaxedAtomicBool, true
)
@ -7292,7 +7292,7 @@ VARCACHE_PREF(
VARCACHE_PREF(
Live,
"webgl.default-antialias",
WebGLDefaultAntialias,
webgl_default_antialias,
RelaxedAtomicBool, PREF_VALUE
)
#undef PREF_VALUE
@ -7300,49 +7300,49 @@ VARCACHE_PREF(
VARCACHE_PREF(
Live,
"webgl.default-low-power",
WebGLDefaultLowPower,
webgl_default_low_power,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"webgl.default-no-alpha",
WebGLDefaultNoAlpha,
webgl_default_no_alpha,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"webgl.disable-angle",
WebGLDisableANGLE,
webgl_disable_angle,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"webgl.disable-wgl",
WebGLDisableWGL,
webgl_disable_wgl,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"webgl.disable-extensions",
WebGLDisableExtensions,
webgl_disable_extensions,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"webgl.dxgl.enabled",
WebGLDXGLEnabled,
webgl_dxgl_enabled,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"webgl.dxgl.needs-finish",
WebGLDXGLNeedsFinish,
webgl_dxgl_needs_finish,
RelaxedAtomicBool, false
)
@ -7350,42 +7350,42 @@ VARCACHE_PREF(
VARCACHE_PREF(
Live,
"webgl.disable-fail-if-major-performance-caveat",
WebGLDisableFailIfMajorPerformanceCaveat,
webgl_disable_fail_if_major_performance_caveat,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"webgl.disable-DOM-blit-uploads",
WebGLDisableDOMBlitUploads,
webgl_disable_DOM_blit_uploads,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"webgl.disabled",
WebGLDisabled,
webgl_disabled,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"webgl.enable-draft-extensions",
WebGLDraftExtensionsEnabled,
webgl_enable_draft_extensions,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"webgl.enable-privileged-extensions",
WebGLPrivilegedExtensionsEnabled,
webgl_enable_privileged_extensions,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"webgl.enable-surface-texture",
WebGLSurfaceTextureEnabled,
webgl_enable_surface_texture,
RelaxedAtomicBool, false
)
@ -7399,91 +7399,86 @@ VARCACHE_PREF(
VARCACHE_PREF(
Live,
"webgl.force-enabled",
WebGLForceEnabled,
webgl_force_enabled,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"webgl.force-layers-readback",
WebGLForceLayersReadback,
webgl_force_layers_readback,
bool, false
)
VARCACHE_PREF(
Live,
"webgl.force-index-validation",
WebGLForceIndexValidation,
webgl_force_index_validation,
RelaxedAtomicInt32, 0
)
VARCACHE_PREF(
Live,
"webgl.lose-context-on-memory-pressure",
WebGLLoseContextOnMemoryPressure,
webgl_lose_context_on_memory_pressure,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"webgl.max-contexts",
WebGLMaxContexts,
webgl_max_contexts,
RelaxedAtomicUint32, 32
)
VARCACHE_PREF(
Live,
"webgl.max-contexts-per-principal",
WebGLMaxContextsPerPrincipal,
webgl_max_contexts_per_principal,
RelaxedAtomicUint32, 16
)
VARCACHE_PREF(
Live,
"webgl.max-warnings-per-context",
WebGLMaxWarningsPerContext,
webgl_max_warnings_per_context,
RelaxedAtomicUint32, 32
)
VARCACHE_PREF(
Live,
"webgl.min_capability_mode",
WebGLMinCapabilityMode,
webgl_min_capability_mode,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"webgl.msaa-force",
WebGLForceMSAA,
webgl_msaa_force,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"webgl.msaa-samples",
WebGLMsaaSamples,
webgl_msaa_samples,
RelaxedAtomicUint32, 4
)
VARCACHE_PREF(
Live,
"webgl.prefer-16bpp",
WebGLPrefer16bpp,
RelaxedAtomicBool, false
)
PREF("webgl.prefer-16bpp", bool, false)
VARCACHE_PREF(
Live,
"webgl.allow-immediate-queries",
WebGLImmediateQueries,
webgl_allow_immediate_queries,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"webgl.allow-fb-invalidation",
WebGLFBInvalidation,
webgl_allow_fb_invalidation,
RelaxedAtomicBool, false
)
@ -7491,21 +7486,21 @@ VARCACHE_PREF(
VARCACHE_PREF(
Live,
"webgl.perf.max-warnings",
WebGLMaxPerfWarnings,
webgl_perf_max_warnings,
RelaxedAtomicInt32, 0
)
VARCACHE_PREF(
Live,
"webgl.perf.max-acceptable-fb-status-invals",
WebGLMaxAcceptableFBStatusInvals,
webgl_perf_max_acceptable_fb_status_invals,
RelaxedAtomicInt32, 0
)
VARCACHE_PREF(
Live,
"webgl.perf.spew-frame-allocs",
WebGLSpewFrameAllocs,
webgl_perf_spew_frame_allocs,
RelaxedAtomicBool, true
)