From 5997d446a9c92d381cd45f45bb46620d4d6bfa78 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= Date: Wed, 26 May 2021 23:31:32 +0200 Subject: [PATCH] Shaders: add multidraw benchmark variants. --- src/Magnum/Shaders/DistanceFieldVectorGL.h | 17 +-- src/Magnum/Shaders/FlatGL.h | 17 +-- src/Magnum/Shaders/MeshVisualizerGL.h | 34 ++--- src/Magnum/Shaders/PhongGL.h | 17 +-- .../Shaders/Test/ShadersGLBenchmark.cpp | 120 ++++++++++++++++++ src/Magnum/Shaders/VectorGL.h | 17 +-- src/Magnum/Shaders/VertexColorGL.h | 17 +-- 7 files changed, 183 insertions(+), 56 deletions(-) diff --git a/src/Magnum/Shaders/DistanceFieldVectorGL.h b/src/Magnum/Shaders/DistanceFieldVectorGL.h index 4284cd7c1..ffd3a40fe 100644 --- a/src/Magnum/Shaders/DistanceFieldVectorGL.h +++ b/src/Magnum/Shaders/DistanceFieldVectorGL.h @@ -155,14 +155,15 @@ template class MAGNUM_SHADERS_EXPORT DistanceFieldVector * used for regular draws as well. * @requires_gl46 Extension @gl_extension{ARB,uniform_buffer_object} * and @gl_extension{ARB,shader_draw_parameters} - * @requires_es_extension OpenGL ES 3.0 and extension @m_class{m-doc-external} [ANGLE_multi_draw](https://chromium.googlesource.com/angle/angle/+/master/extensions/ANGLE_multi_draw.txt) (unlisted). - * While the extension alone needs only OpenGL ES 2.0, the - * shader implementation relies on uniform buffers, which - * require OpenGL ES 3.0. - * @requires_webgl_extension WebGL 2.0 Extension @webgl_extension{ANGLE,multi_draw}. - * While the extension alone needs only WebGL 1.0, the shader - * implementation relies on uniform buffers, which require - * WebGL 2.0. + * @requires_es_extension OpenGL ES 3.0 and extension + * @m_class{m-doc-external} [ANGLE_multi_draw](https://chromium.googlesource.com/angle/angle/+/master/extensions/ANGLE_multi_draw.txt) + * (unlisted). While the extension alone needs only OpenGL ES + * 2.0, the shader implementation relies on uniform buffers, + * which require OpenGL ES 3.0. + * @requires_webgl_extension WebGL 2.0 and extension + * @webgl_extension{ANGLE,multi_draw}. While the extension + * alone needs only WebGL 1.0, the shader implementation + * relies on uniform buffers, which require WebGL 2.0. * @m_since_latest */ MultiDraw = UniformBuffers|(1 << 2) diff --git a/src/Magnum/Shaders/FlatGL.h b/src/Magnum/Shaders/FlatGL.h index 1daa1c6c4..421b240b6 100644 --- a/src/Magnum/Shaders/FlatGL.h +++ b/src/Magnum/Shaders/FlatGL.h @@ -403,14 +403,15 @@ template class MAGNUM_SHADERS_EXPORT FlatGL: public GL:: * used for regular draws as well. * @requires_gl46 Extension @gl_extension{ARB,uniform_buffer_object} * and @gl_extension{ARB,shader_draw_parameters} - * @requires_es_extension OpenGL ES 3.0 and extension @m_class{m-doc-external} [ANGLE_multi_draw](https://chromium.googlesource.com/angle/angle/+/master/extensions/ANGLE_multi_draw.txt) (unlisted). - * While the extension alone needs only OpenGL ES 2.0, the - * shader implementation relies on uniform buffers, which - * require OpenGL ES 3.0. - * @requires_webgl_extension WebGL 2.0 Extension @webgl_extension{ANGLE,multi_draw}. - * While the extension alone needs only WebGL 1.0, the shader - * implementation relies on uniform buffers, which require - * WebGL 2.0. + * @requires_es_extension OpenGL ES 3.0 and extension + * @m_class{m-doc-external} [ANGLE_multi_draw](https://chromium.googlesource.com/angle/angle/+/master/extensions/ANGLE_multi_draw.txt) + * (unlisted). While the extension alone needs only OpenGL ES + * 2.0, the shader implementation relies on uniform buffers, + * which require OpenGL ES 3.0. + * @requires_webgl_extension WebGL 2.0 and extension + * @webgl_extension{ANGLE,multi_draw}. While the extension + * alone needs only WebGL 1.0, the shader implementation + * relies on uniform buffers, which require WebGL 2.0. * @m_since_latest */ MultiDraw = UniformBuffers|(1 << 9) diff --git a/src/Magnum/Shaders/MeshVisualizerGL.h b/src/Magnum/Shaders/MeshVisualizerGL.h index 6e0df5a3c..d96773057 100644 --- a/src/Magnum/Shaders/MeshVisualizerGL.h +++ b/src/Magnum/Shaders/MeshVisualizerGL.h @@ -251,14 +251,15 @@ class MAGNUM_SHADERS_EXPORT MeshVisualizerGL2D: public Implementation::MeshVisua * used for regular draws as well. * @requires_gl46 Extension @gl_extension{ARB,uniform_buffer_object} * and @gl_extension{ARB,shader_draw_parameters} - * @requires_es_extension OpenGL ES 3.0 and extension @m_class{m-doc-external} [ANGLE_multi_draw](https://chromium.googlesource.com/angle/angle/+/master/extensions/ANGLE_multi_draw.txt) (unlisted). - * While the extension alone needs only OpenGL ES 2.0, the - * shader implementation relies on uniform buffers, which - * require OpenGL ES 3.0. - * @requires_webgl_extension WebGL 2.0 Extension @webgl_extension{ANGLE,multi_draw}. - * While the extension alone needs only WebGL 1.0, the shader - * implementation relies on uniform buffers, which require - * WebGL 2.0. + * @requires_es_extension OpenGL ES 3.0 and extension + * @m_class{m-doc-external} [ANGLE_multi_draw](https://chromium.googlesource.com/angle/angle/+/master/extensions/ANGLE_multi_draw.txt) + * (unlisted). While the extension alone needs only OpenGL ES + * 2.0, the shader implementation relies on uniform buffers, + * which require OpenGL ES 3.0. + * @requires_webgl_extension WebGL 2.0 and extension + * @webgl_extension{ANGLE,multi_draw}. While the extension + * alone needs only WebGL 1.0, the shader implementation + * relies on uniform buffers, which require WebGL 2.0. * @m_since_latest */ MultiDraw = UniformBuffers|(1 << 11) @@ -1041,14 +1042,15 @@ class MAGNUM_SHADERS_EXPORT MeshVisualizerGL3D: public Implementation::MeshVisua * used for regular draws as well. * @requires_gl46 Extension @gl_extension{ARB,uniform_buffer_object} * and @gl_extension{ARB,shader_draw_parameters} - * @requires_es_extension OpenGL ES 3.0 and extension @m_class{m-doc-external} [ANGLE_multi_draw](https://chromium.googlesource.com/angle/angle/+/master/extensions/ANGLE_multi_draw.txt) (unlisted). - * While the extension alone needs only OpenGL ES 2.0, the - * shader implementation relies on uniform buffers, which - * require OpenGL ES 3.0. - * @requires_webgl_extension WebGL 2.0 Extension @webgl_extension{ANGLE,multi_draw}. - * While the extension alone needs only WebGL 1.0, the shader - * implementation relies on uniform buffers, which require - * WebGL 2.0. + * @requires_es_extension OpenGL ES 3.0 and extension + * @m_class{m-doc-external} [ANGLE_multi_draw](https://chromium.googlesource.com/angle/angle/+/master/extensions/ANGLE_multi_draw.txt) + * (unlisted). While the extension alone needs only OpenGL ES + * 2.0, the shader implementation relies on uniform buffers, + * which require OpenGL ES 3.0. + * @requires_webgl_extension WebGL 2.0 and extension + * @webgl_extension{ANGLE,multi_draw}. While the extension + * alone needs only WebGL 1.0, the shader implementation + * relies on uniform buffers, which require WebGL 2.0. * @m_since_latest */ MultiDraw = UniformBuffers|(1 << 11) diff --git a/src/Magnum/Shaders/PhongGL.h b/src/Magnum/Shaders/PhongGL.h index 7e949613c..1e0f743e3 100644 --- a/src/Magnum/Shaders/PhongGL.h +++ b/src/Magnum/Shaders/PhongGL.h @@ -591,14 +591,15 @@ class MAGNUM_SHADERS_EXPORT PhongGL: public GL::AbstractShaderProgram { * used for regular draws as well. * @requires_gl46 Extension @gl_extension{ARB,uniform_buffer_object} * and @gl_extension{ARB,shader_draw_parameters} - * @requires_es_extension OpenGL ES 3.0 and extension @m_class{m-doc-external} [ANGLE_multi_draw](https://chromium.googlesource.com/angle/angle/+/master/extensions/ANGLE_multi_draw.txt) (unlisted). - * While the extension alone needs only OpenGL ES 2.0, the - * shader implementation relies on uniform buffers, which - * require OpenGL ES 3.0. - * @requires_webgl_extension WebGL 2.0 Extension @webgl_extension{ANGLE,multi_draw}. - * While the extension alone needs only WebGL 1.0, the shader - * implementation relies on uniform buffers, which require - * WebGL 2.0. + * @requires_es_extension OpenGL ES 3.0 and extension + * @m_class{m-doc-external} [ANGLE_multi_draw](https://chromium.googlesource.com/angle/angle/+/master/extensions/ANGLE_multi_draw.txt) + * (unlisted). While the extension alone needs only OpenGL ES + * 2.0, the shader implementation relies on uniform buffers, + * which require OpenGL ES 3.0. + * @requires_webgl_extension WebGL 2.0 and extension + * @webgl_extension{ANGLE,multi_draw}. While the extension + * alone needs only WebGL 1.0, the shader implementation + * relies on uniform buffers, which require WebGL 2.0. * @m_since_latest */ MultiDraw = UniformBuffers|(1 << 13) diff --git a/src/Magnum/Shaders/Test/ShadersGLBenchmark.cpp b/src/Magnum/Shaders/Test/ShadersGLBenchmark.cpp index 6a2d42ff4..814059a16 100644 --- a/src/Magnum/Shaders/Test/ShadersGLBenchmark.cpp +++ b/src/Magnum/Shaders/Test/ShadersGLBenchmark.cpp @@ -150,6 +150,7 @@ const struct { {"UBO single", FlatGL2D::Flag::UniformBuffers, 1}, {"UBO single, texture transformation", FlatGL2D::Flag::UniformBuffers|FlatGL2D::Flag::Textured|FlatGL2D::Flag::TextureTransformation, 1}, {"UBO multi", FlatGL2D::Flag::UniformBuffers, 128}, + {"multidraw", FlatGL2D::Flag::MultiDraw, 128}, #endif }; @@ -183,6 +184,7 @@ const struct { {"UBO single five lights", PhongGL::Flag::UniformBuffers, 5, 1, 1}, {"UBO single, ADS textures + transformation", PhongGL::Flag::UniformBuffers|PhongGL::Flag::AmbientTexture|PhongGL::Flag::DiffuseTexture|PhongGL::Flag::SpecularTexture|PhongGL::Flag::TextureTransformation, 1, 1, 1}, {"UBO multi, one light", PhongGL::Flag::UniformBuffers, 1, 32, 128}, + {"multidraw, one light", PhongGL::Flag::MultiDraw, 1, 32, 128}, #endif }; @@ -195,6 +197,7 @@ const struct { #ifndef MAGNUM_TARGET_GLES2 {"UBO single", VertexColorGL2D::Flag::UniformBuffers, 1}, {"UBO multi", VertexColorGL2D::Flag::UniformBuffers, 128}, + {"multidraw", VertexColorGL2D::Flag::MultiDraw, 128} #endif }; @@ -210,6 +213,7 @@ const struct { {"UBO single, texture transformation", VectorGL2D::Flag::UniformBuffers|VectorGL2D::Flag::TextureTransformation, 1}, {"UBO multi", VectorGL2D::Flag::UniformBuffers, 128}, {"UBO multi, texture transformation", VectorGL2D::Flag::UniformBuffers|VectorGL2D::Flag::TextureTransformation, 128}, + {"multidraw", VectorGL2D::Flag::MultiDraw, 128}, #endif }; @@ -225,6 +229,7 @@ const struct { {"UBO single, texture transformation", DistanceFieldVectorGL2D::Flag::UniformBuffers|DistanceFieldVectorGL2D::Flag::TextureTransformation, 1, 1}, {"UBO multi", DistanceFieldVectorGL2D::Flag::UniformBuffers, 32, 128}, {"UBO multi, texture transformation", DistanceFieldVectorGL2D::Flag::UniformBuffers|DistanceFieldVectorGL2D::Flag::TextureTransformation, 32, 128}, + {"multidraw", DistanceFieldVectorGL2D::Flag::MultiDraw, 32, 128}, #endif }; @@ -256,6 +261,11 @@ const struct { #endif {"UBO multi, wireframe w/o a GS", MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader, 32, 128}, {"UBO multi, vertex ID", MeshVisualizerGL2D::Flag::UniformBuffers|MeshVisualizerGL2D::Flag::VertexId, 32, 128}, + #ifndef MAGNUM_TARGET_WEBGL + {"multidraw, wireframe", MeshVisualizerGL2D::Flag::MultiDraw|MeshVisualizerGL2D::Flag::Wireframe, 32, 128}, + #endif + {"multidraw, wireframe w/o a GS", MeshVisualizerGL2D::Flag::MultiDraw|MeshVisualizerGL2D::Flag::Wireframe|MeshVisualizerGL2D::Flag::NoGeometryShader, 32, 128}, + {"multidraw, vertex ID", MeshVisualizerGL2D::Flag::MultiDraw|MeshVisualizerGL2D::Flag::VertexId, 32, 128}, #endif }; @@ -287,6 +297,11 @@ const struct { #endif {"UBO multi, wireframe w/o a GS", MeshVisualizerGL3D::Flag::UniformBuffers|MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader, 32, 128}, {"UBO multi, vertex ID", MeshVisualizerGL3D::Flag::UniformBuffers|MeshVisualizerGL3D::Flag::VertexId, 32, 128}, + #ifndef MAGNUM_TARGET_WEBGL + {"multidraw, wireframe", MeshVisualizerGL3D::Flag::MultiDraw|MeshVisualizerGL3D::Flag::Wireframe, 32, 128}, + #endif + {"multidraw, wireframe w/o a GS", MeshVisualizerGL3D::Flag::MultiDraw|MeshVisualizerGL3D::Flag::Wireframe|MeshVisualizerGL3D::Flag::NoGeometryShader, 32, 128}, + {"multidraw, vertex ID", MeshVisualizerGL3D::Flag::MultiDraw|MeshVisualizerGL3D::Flag::VertexId, 32, 128}, #endif }; @@ -509,6 +524,21 @@ template void ShadersGLBenchmark::flat() { CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported."); #endif + #ifndef MAGNUM_TARGET_GLES2 + if(data.flags >= FlatGL2D::Flag::MultiDraw) { + #ifndef MAGNUM_TARGET_GLES + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::ARB::shader_draw_parameters::string() << "is not supported."); + #elif !defined(MAGNUM_TARGET_WEBGL) + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::ANGLE::multi_draw::string() << "is not supported."); + #else + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::WEBGL::multi_draw::string() << "is not supported."); + #endif + } + #endif + FlatGL shader{data.flags #ifndef MAGNUM_TARGET_GLES2 , data.drawCount @@ -594,6 +624,21 @@ void ShadersGLBenchmark::phong() { CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported."); #endif + #ifndef MAGNUM_TARGET_GLES2 + if(data.flags >= PhongGL::Flag::MultiDraw) { + #ifndef MAGNUM_TARGET_GLES + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::ARB::shader_draw_parameters::string() << "is not supported."); + #elif !defined(MAGNUM_TARGET_WEBGL) + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::ANGLE::multi_draw::string() << "is not supported."); + #else + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::WEBGL::multi_draw::string() << "is not supported."); + #endif + } + #endif + PhongGL shader{data.flags, data.lightCount #ifndef MAGNUM_TARGET_GLES2 , data.materialCount, data.drawCount @@ -702,6 +747,21 @@ template void ShadersGLBenchmark::vertexColor() { CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported."); #endif + #ifndef MAGNUM_TARGET_GLES2 + if(data.flags >= VertexColorGL2D::Flag::MultiDraw) { + #ifndef MAGNUM_TARGET_GLES + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::ARB::shader_draw_parameters::string() << "is not supported."); + #elif !defined(MAGNUM_TARGET_WEBGL) + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::ANGLE::multi_draw::string() << "is not supported."); + #else + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::WEBGL::multi_draw::string() << "is not supported."); + #endif + } + #endif + VertexColorGL shader{data.flags #ifndef MAGNUM_TARGET_GLES2 , data.drawCount @@ -746,6 +806,21 @@ template void ShadersGLBenchmark::vector() { CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported."); #endif + #ifndef MAGNUM_TARGET_GLES2 + if(data.flags >= VectorGL2D::Flag::MultiDraw) { + #ifndef MAGNUM_TARGET_GLES + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::ARB::shader_draw_parameters::string() << "is not supported."); + #elif !defined(MAGNUM_TARGET_WEBGL) + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::ANGLE::multi_draw::string() << "is not supported."); + #else + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::WEBGL::multi_draw::string() << "is not supported."); + #endif + } + #endif + VectorGL shader{data.flags #ifndef MAGNUM_TARGET_GLES2 , data.drawCount @@ -800,6 +875,21 @@ template void ShadersGLBenchmark::distanceFieldVector() CORRADE_SKIP(GL::Extensions::ARB::uniform_buffer_object::string() << "is not supported."); #endif + #ifndef MAGNUM_TARGET_GLES2 + if(data.flags >= DistanceFieldVectorGL2D::Flag::MultiDraw) { + #ifndef MAGNUM_TARGET_GLES + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::ARB::shader_draw_parameters::string() << "is not supported."); + #elif !defined(MAGNUM_TARGET_WEBGL) + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::ANGLE::multi_draw::string() << "is not supported."); + #else + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::WEBGL::multi_draw::string() << "is not supported."); + #endif + } + #endif + DistanceFieldVectorGL shader{data.flags #ifndef MAGNUM_TARGET_GLES2 , data.materialCount, data.drawCount @@ -897,6 +987,21 @@ void ShadersGLBenchmark::meshVisualizer2D() { } #endif + #ifndef MAGNUM_TARGET_GLES2 + if(data.flags >= MeshVisualizerGL2D::Flag::MultiDraw) { + #ifndef MAGNUM_TARGET_GLES + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::ARB::shader_draw_parameters::string() << "is not supported."); + #elif !defined(MAGNUM_TARGET_WEBGL) + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::ANGLE::multi_draw::string() << "is not supported."); + #else + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::WEBGL::multi_draw::string() << "is not supported."); + #endif + } + #endif + MeshVisualizerGL2D shader{data.flags}; shader.setViewportSize(Vector2{RenderSize}); #ifndef MAGNUM_TARGET_GLES2 @@ -1016,6 +1121,21 @@ void ShadersGLBenchmark::meshVisualizer3D() { } #endif + #ifndef MAGNUM_TARGET_GLES2 + if(data.flags >= MeshVisualizerGL3D::Flag::MultiDraw) { + #ifndef MAGNUM_TARGET_GLES + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::ARB::shader_draw_parameters::string() << "is not supported."); + #elif !defined(MAGNUM_TARGET_WEBGL) + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::ANGLE::multi_draw::string() << "is not supported."); + #else + if(!GL::Context::current().isExtensionSupported()) + CORRADE_SKIP(GL::Extensions::WEBGL::multi_draw::string() << "is not supported."); + #endif + } + #endif + MeshVisualizerGL3D shader{data.flags}; shader.setViewportSize(Vector2{RenderSize}); diff --git a/src/Magnum/Shaders/VectorGL.h b/src/Magnum/Shaders/VectorGL.h index 898ac1ba3..d5fd88d10 100644 --- a/src/Magnum/Shaders/VectorGL.h +++ b/src/Magnum/Shaders/VectorGL.h @@ -150,14 +150,15 @@ template class MAGNUM_SHADERS_EXPORT VectorGL: public GL * used for regular draws as well. * @requires_gl46 Extension @gl_extension{ARB,uniform_buffer_object} * and @gl_extension{ARB,shader_draw_parameters} - * @requires_es_extension OpenGL ES 3.0 and extension @m_class{m-doc-external} [ANGLE_multi_draw](https://chromium.googlesource.com/angle/angle/+/master/extensions/ANGLE_multi_draw.txt) (unlisted). - * While the extension alone needs only OpenGL ES 2.0, the - * shader implementation relies on uniform buffers, which - * require OpenGL ES 3.0. - * @requires_webgl_extension WebGL 2.0 Extension @webgl_extension{ANGLE,multi_draw}. - * While the extension alone needs only WebGL 1.0, the shader - * implementation relies on uniform buffers, which require - * WebGL 2.0. + * @requires_es_extension OpenGL ES 3.0 and extension + * @m_class{m-doc-external} [ANGLE_multi_draw](https://chromium.googlesource.com/angle/angle/+/master/extensions/ANGLE_multi_draw.txt) + * (unlisted). While the extension alone needs only OpenGL ES + * 2.0, the shader implementation relies on uniform buffers, + * which require OpenGL ES 3.0. + * @requires_webgl_extension WebGL 2.0 and extension + * @webgl_extension{ANGLE,multi_draw}. While the extension + * alone needs only WebGL 1.0, the shader implementation + * relies on uniform buffers, which require WebGL 2.0. * @m_since_latest */ MultiDraw = UniformBuffers|(1 << 2) diff --git a/src/Magnum/Shaders/VertexColorGL.h b/src/Magnum/Shaders/VertexColorGL.h index 7df6556e1..c13e29f76 100644 --- a/src/Magnum/Shaders/VertexColorGL.h +++ b/src/Magnum/Shaders/VertexColorGL.h @@ -151,14 +151,15 @@ template class MAGNUM_SHADERS_EXPORT VertexColorGL: publ * used for regular draws as well. * @requires_gl46 Extension @gl_extension{ARB,uniform_buffer_object} * and @gl_extension{ARB,shader_draw_parameters} - * @requires_es_extension OpenGL ES 3.0 and extension @m_class{m-doc-external} [ANGLE_multi_draw](https://chromium.googlesource.com/angle/angle/+/master/extensions/ANGLE_multi_draw.txt) (unlisted). - * While the extension alone needs only OpenGL ES 2.0, the - * shader implementation relies on uniform buffers, which - * require OpenGL ES 3.0. - * @requires_webgl_extension WebGL 2.0 Extension @webgl_extension{ANGLE,multi_draw}. - * While the extension alone needs only WebGL 1.0, the shader - * implementation relies on uniform buffers, which require - * WebGL 2.0. + * @requires_es_extension OpenGL ES 3.0 and extension + * @m_class{m-doc-external} [ANGLE_multi_draw](https://chromium.googlesource.com/angle/angle/+/master/extensions/ANGLE_multi_draw.txt) + * (unlisted). While the extension alone needs only OpenGL ES + * 2.0, the shader implementation relies on uniform buffers, + * which require OpenGL ES 3.0. + * @requires_webgl_extension WebGL 2.0 and extension + * @webgl_extension{ANGLE,multi_draw}. While the extension + * alone needs only WebGL 1.0, the shader implementation + * relies on uniform buffers, which require WebGL 2.0. * @m_since_latest */ MultiDraw = UniformBuffers|(1 << 1)