Skip to content

A
angle
Commit 73872582 by Geoff Lang Committed by Commit Bot
Options

Update some implementation limits to match modern drivers.

Raise the implementation limits for some caps that should not affect performance and add a logging mode to print when caps have been limited. Fix missing caps limitation of max texture sizes. BUG=angleproject:2915 Change-Id: I51bd9544e1e1a9582e2beed61c624ef2b7079e99 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1852705Reviewed-by: 's avatarCourtney Goeltzenleuchter <courtneygo@google.com> Reviewed-by: 's avatarGeoff Lang <geofflang@chromium.org> Commit-Queue: Geoff Lang <geofflang@chromium.org>
parent d200a77a
Showing with 78 additions and 54 deletions
src/libANGLE/Constants.h
......@@ -44,7 +44,7 @@ enum
IMPLEMENTATION_MAX_UNIFORM_BUFFER_BINDINGS = 48,
// Transform feedback limits set to the minimum required by the spec.
IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 64,
IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 128,
IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 4,
IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 4,
IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS = 4,
......@@ -55,13 +55,13 @@ enum
// These are the maximums the implementation can support
// The actual GL caps are limited by the device caps
// and should be queried from the Context
IMPLEMENTATION_MAX_2D_TEXTURE_SIZE = 16384,
IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE = 16384,
IMPLEMENTATION_MAX_3D_TEXTURE_SIZE = 2048,
IMPLEMENTATION_MAX_2D_TEXTURE_SIZE = 32768,
IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE = 32768,
IMPLEMENTATION_MAX_3D_TEXTURE_SIZE = 16384,
IMPLEMENTATION_MAX_2D_ARRAY_TEXTURE_LAYERS = 2048,
// 1+log2 of max of MAX_*_TEXTURE_SIZE
IMPLEMENTATION_MAX_TEXTURE_LEVELS = 15,
IMPLEMENTATION_MAX_TEXTURE_LEVELS = 16,
// Limit active textures so we can use fast bitsets.
IMPLEMENTATION_MAX_SHADER_TEXTURES = 32,
......
src/libANGLE/Context.cpp
......@@ -270,12 +270,6 @@ void GetObjectLabelBase(const std::string &objectLabel,
}
}
template <typename CapT, typename MaxT>
void LimitCap(CapT *cap, MaxT maximum)
{
*cap = std::min(*cap, static_cast<CapT>(maximum));
}
// The rest default to false.
constexpr angle::PackedEnumMap<PrimitiveMode, bool, angle::EnumSize<PrimitiveMode>() + 1>
kValidBasicDrawModes = {{
......@@ -3488,8 +3482,27 @@ void Context::initCaps()
mState.mCaps.maxSmoothLineWidth = 1.0f;
}
#if 0
// This logging can generate a lot of spam in test suites that create many contexts
# define ANGLE_LOG_LIMITED_CAP(cap, limit) \
INFO() << "Limiting " << #cap << " to implementation limit " << (limit) << " (was " \
<< (cap) << ")."
#else
# define ANGLE_LOG_LIMITED_CAP(cap, limit)
#endif
#define ANGLE_LIMIT_CAP(cap, limit) \
do \
{ \
if ((cap) > (limit)) \
{ \
ANGLE_LOG_LIMITED_CAP(cap, limit); \
(cap) = (limit); \
} \
} while (0)
// Apply/Verify implementation limits
LimitCap(&mState.mCaps.maxVertexAttributes, MAX_VERTEX_ATTRIBS);
ANGLE_LIMIT_CAP(mState.mCaps.maxVertexAttributes, MAX_VERTEX_ATTRIBS);
ASSERT(mState.mCaps.minAliasedPointSize >= 1.0f);
......@@ -3499,66 +3512,77 @@ void Context::initCaps()
}
else
{
LimitCap(&mState.mCaps.maxVertexAttribBindings, MAX_VERTEX_ATTRIB_BINDINGS);
}
LimitCap(&mState.mCaps.maxShaderUniformBlocks[ShaderType::Vertex],
IMPLEMENTATION_MAX_VERTEX_SHADER_UNIFORM_BUFFERS);
LimitCap(&mState.mCaps.maxShaderUniformBlocks[ShaderType::Geometry],
IMPLEMENTATION_MAX_GEOMETRY_SHADER_UNIFORM_BUFFERS);
LimitCap(&mState.mCaps.maxShaderUniformBlocks[ShaderType::Fragment],
IMPLEMENTATION_MAX_FRAGMENT_SHADER_UNIFORM_BUFFERS);
LimitCap(&mState.mCaps.maxShaderUniformBlocks[ShaderType::Compute],
IMPLEMENTATION_MAX_COMPUTE_SHADER_UNIFORM_BUFFERS);
LimitCap(&mState.mCaps.maxCombinedUniformBlocks,
IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS);
LimitCap(&mState.mCaps.maxUniformBufferBindings, IMPLEMENTATION_MAX_UNIFORM_BUFFER_BINDINGS);
LimitCap(&mState.mCaps.maxVertexOutputComponents, IMPLEMENTATION_MAX_VARYING_VECTORS * 4);
LimitCap(&mState.mCaps.maxFragmentInputComponents, IMPLEMENTATION_MAX_VARYING_VECTORS * 4);
LimitCap(&mState.mCaps.maxTransformFeedbackInterleavedComponents,
IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS);
LimitCap(&mState.mCaps.maxTransformFeedbackSeparateAttributes,
IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS);
LimitCap(&mState.mCaps.maxTransformFeedbackSeparateComponents,
IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS);
ANGLE_LIMIT_CAP(mState.mCaps.maxVertexAttribBindings, MAX_VERTEX_ATTRIB_BINDINGS);
}
ANGLE_LIMIT_CAP(mState.mCaps.max2DTextureSize, IMPLEMENTATION_MAX_2D_TEXTURE_SIZE);
ANGLE_LIMIT_CAP(mState.mCaps.maxCubeMapTextureSize, IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE);
ANGLE_LIMIT_CAP(mState.mCaps.max3DTextureSize, IMPLEMENTATION_MAX_3D_TEXTURE_SIZE);
ANGLE_LIMIT_CAP(mState.mCaps.maxArrayTextureLayers, IMPLEMENTATION_MAX_2D_ARRAY_TEXTURE_LAYERS);
ANGLE_LIMIT_CAP(mState.mCaps.maxRectangleTextureSize, IMPLEMENTATION_MAX_2D_TEXTURE_SIZE);
ANGLE_LIMIT_CAP(mState.mCaps.maxShaderUniformBlocks[ShaderType::Vertex],
IMPLEMENTATION_MAX_VERTEX_SHADER_UNIFORM_BUFFERS);
ANGLE_LIMIT_CAP(mState.mCaps.maxShaderUniformBlocks[ShaderType::Geometry],
IMPLEMENTATION_MAX_GEOMETRY_SHADER_UNIFORM_BUFFERS);
ANGLE_LIMIT_CAP(mState.mCaps.maxShaderUniformBlocks[ShaderType::Fragment],
IMPLEMENTATION_MAX_FRAGMENT_SHADER_UNIFORM_BUFFERS);
ANGLE_LIMIT_CAP(mState.mCaps.maxShaderUniformBlocks[ShaderType::Compute],
IMPLEMENTATION_MAX_COMPUTE_SHADER_UNIFORM_BUFFERS);
ANGLE_LIMIT_CAP(mState.mCaps.maxCombinedUniformBlocks,
IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS);
ANGLE_LIMIT_CAP(mState.mCaps.maxUniformBufferBindings,
IMPLEMENTATION_MAX_UNIFORM_BUFFER_BINDINGS);
ANGLE_LIMIT_CAP(mState.mCaps.maxVertexOutputComponents, IMPLEMENTATION_MAX_VARYING_VECTORS * 4);
ANGLE_LIMIT_CAP(mState.mCaps.maxFragmentInputComponents,
IMPLEMENTATION_MAX_VARYING_VECTORS * 4);
ANGLE_LIMIT_CAP(mState.mCaps.maxTransformFeedbackInterleavedComponents,
IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS);
ANGLE_LIMIT_CAP(mState.mCaps.maxTransformFeedbackSeparateAttributes,
IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS);
ANGLE_LIMIT_CAP(mState.mCaps.maxTransformFeedbackSeparateComponents,
IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS);
// Limit textures as well, so we can use fast bitsets with texture bindings.
LimitCap(&mState.mCaps.maxCombinedTextureImageUnits, IMPLEMENTATION_MAX_ACTIVE_TEXTURES);
ANGLE_LIMIT_CAP(mState.mCaps.maxCombinedTextureImageUnits, IMPLEMENTATION_MAX_ACTIVE_TEXTURES);
for (ShaderType shaderType : AllShaderTypes())
{
LimitCap(&mState.mCaps.maxShaderTextureImageUnits[shaderType],
IMPLEMENTATION_MAX_SHADER_TEXTURES);
ANGLE_LIMIT_CAP(mState.mCaps.maxShaderTextureImageUnits[shaderType],
IMPLEMENTATION_MAX_SHADER_TEXTURES);
}
LimitCap(&mState.mCaps.maxImageUnits, IMPLEMENTATION_MAX_IMAGE_UNITS);
LimitCap(&mState.mCaps.maxCombinedImageUniforms, IMPLEMENTATION_MAX_IMAGE_UNITS);
ANGLE_LIMIT_CAP(mState.mCaps.maxImageUnits, IMPLEMENTATION_MAX_IMAGE_UNITS);
ANGLE_LIMIT_CAP(mState.mCaps.maxCombinedImageUniforms, IMPLEMENTATION_MAX_IMAGE_UNITS);
for (ShaderType shaderType : AllShaderTypes())
{
LimitCap(&mState.mCaps.maxShaderImageUniforms[shaderType], IMPLEMENTATION_MAX_IMAGE_UNITS);
ANGLE_LIMIT_CAP(mState.mCaps.maxShaderImageUniforms[shaderType],
IMPLEMENTATION_MAX_IMAGE_UNITS);
}
for (ShaderType shaderType : AllShaderTypes())
{
LimitCap(&mState.mCaps.maxShaderAtomicCounterBuffers[shaderType],
IMPLEMENTATION_MAX_ATOMIC_COUNTER_BUFFERS);
ANGLE_LIMIT_CAP(mState.mCaps.maxShaderAtomicCounterBuffers[shaderType],
IMPLEMENTATION_MAX_ATOMIC_COUNTER_BUFFERS);
}
LimitCap(&mState.mCaps.maxCombinedAtomicCounterBuffers,
IMPLEMENTATION_MAX_ATOMIC_COUNTER_BUFFERS);
ANGLE_LIMIT_CAP(mState.mCaps.maxCombinedAtomicCounterBuffers,
IMPLEMENTATION_MAX_ATOMIC_COUNTER_BUFFERS);
for (ShaderType shaderType : AllShaderTypes())
{
LimitCap(&mState.mCaps.maxShaderStorageBlocks[shaderType],
IMPLEMENTATION_MAX_SHADER_STORAGE_BUFFER_BINDINGS);
ANGLE_LIMIT_CAP(mState.mCaps.maxShaderStorageBlocks[shaderType],
IMPLEMENTATION_MAX_SHADER_STORAGE_BUFFER_BINDINGS);
}
LimitCap(&mState.mCaps.maxShaderStorageBufferBindings,
IMPLEMENTATION_MAX_SHADER_STORAGE_BUFFER_BINDINGS);
LimitCap(&mState.mCaps.maxCombinedShaderStorageBlocks,
IMPLEMENTATION_MAX_SHADER_STORAGE_BUFFER_BINDINGS);
ANGLE_LIMIT_CAP(mState.mCaps.maxShaderStorageBufferBindings,
IMPLEMENTATION_MAX_SHADER_STORAGE_BUFFER_BINDINGS);
ANGLE_LIMIT_CAP(mState.mCaps.maxCombinedShaderStorageBlocks,
IMPLEMENTATION_MAX_SHADER_STORAGE_BUFFER_BINDINGS);
ANGLE_LIMIT_CAP(mState.mCaps.maxSampleMaskWords, MAX_SAMPLE_MASK_WORDS);
mState.mCaps.maxSampleMaskWords =
std::min<GLuint>(mState.mCaps.maxSampleMaskWords, MAX_SAMPLE_MASK_WORDS);
#undef ANGLE_LIMIT_CAP
#undef ANGLE_LOG_CAP_LIMIT
// WebGL compatibility
mState.mExtensions.webglCompatibility = mWebGLContext;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment