ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

GL,Shaders: allow draw() and friends to be chained. 

It had a point originally, but with the new multidraw workflows it's
just annoying.
pull/518/head
Vladimír Vondruš 5 years ago
parent
c785ef2e4a
commit
007360a9c8
10 changed files with 236 additions and 35 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 9
      doc/changelog.dox
  2. 25
      doc/snippets/MagnumGL.cpp
  3. 40
      src/Magnum/GL/AbstractShaderProgram.cpp
  4. 43
      src/Magnum/GL/AbstractShaderProgram.h
  5. 22
      src/Magnum/Shaders/DistanceFieldVectorGL.h
  6. 22
      src/Magnum/Shaders/FlatGL.h
  7. 44
      src/Magnum/Shaders/MeshVisualizerGL.h
  8. 22
      src/Magnum/Shaders/PhongGL.h
  9. 22
      src/Magnum/Shaders/VectorGL.h
  10. 22
      src/Magnum/Shaders/VertexColorGL.h

9
doc/changelog.dox
Unescape View File

@ -228,6 +228,15 @@ See also:
@subsubsection changelog-latest-changes-gl GL library
- @ref GL::AbstractShaderProgram::draw(),
@relativeref{GL::AbstractShaderProgram,drawTransformFeedback()} and
@relativeref{GL::AbstractShaderProgram,dispatchCompute()} APIs now return
a reference to self and all subclasses in @ref Shaders return a subclass
reference from these. The functions used to @cpp void @ce as that made more
sense in the classic workflow where a large set of uniforms had to be set
prior to every draw, however with the new multidraw workflows that's no
longer the case and the inability to chain draw calls proved to be
annoying.
- The @ref GL::Context class got significantly optimized in terms of compile
time, header size and runtime as well, significantly reducing the amount of
allocations done at startup.

25
doc/snippets/MagnumGL.cpp
Unescape View File

@ -269,11 +269,32 @@ enum: UnsignedInt {
/* [AbstractShaderProgram-output-attributes] */
#if !defined(MAGNUM_TARGET_GLES) && !defined(MAGNUM_TARGET_WEBGL)
/* [AbstractShaderProgram-hide-irrelevant] */
/* [AbstractShaderProgram-return-hide-irrelevant] */
public:
MyShader& draw(GL::Mesh& mesh) {
return static_cast<MyShader&>(GL::AbstractShaderProgram::draw(mesh));
}
MyShader& draw(GL::Mesh&& mesh) {
return static_cast<MyShader&>(GL::AbstractShaderProgram::draw(mesh));
}
MyShader& draw(GL::MeshView& mesh) {
return static_cast<MyShader&>(GL::AbstractShaderProgram::draw(mesh));
}
MyShader& draw(GL::MeshView&& mesh) {
return static_cast<MyShader&>(GL::AbstractShaderProgram::draw(mesh));
}
/* Omit these if the shader is not ready for multidraw */
MyShader& draw(Containers::ArrayView<const Containers::Reference<GL::MeshView>> meshes) {
return static_cast<MyShader&>(GL::AbstractShaderProgram::draw(meshes));
}
MyShader& draw(std::initializer_list<Containers::Reference<GL::MeshView>> meshes) {
return static_cast<MyShader&>(GL::AbstractShaderProgram::draw(meshes));
}
private:
using GL::AbstractShaderProgram::drawTransformFeedback;
using GL::AbstractShaderProgram::dispatchCompute;
/* [AbstractShaderProgram-hide-irrelevant] */
/* [AbstractShaderProgram-return-hide-irrelevant] */
public:
#endif

40
src/Magnum/GL/AbstractShaderProgram.cpp
Unescape View File

@ -350,11 +350,11 @@ std::pair<bool, std::string> AbstractShaderProgram::validate() {
return {success, std::move(message)};
}
void AbstractShaderProgram::draw(Mesh& mesh) {
CORRADE_ASSERT(mesh._countSet, "GL::AbstractShaderProgram::draw(): Mesh::setCount() was never called, probably a mistake?", );
AbstractShaderProgram& AbstractShaderProgram::draw(Mesh& mesh) {
CORRADE_ASSERT(mesh._countSet, "GL::AbstractShaderProgram::draw(): Mesh::setCount() was never called, probably a mistake?", *this);
/* Nothing to draw, exit without touching any state */
if(!mesh._count || !mesh._instanceCount) return;
if(!mesh._count || !mesh._instanceCount) return *this;
use();
@ -363,13 +363,14 @@ void AbstractShaderProgram::draw(Mesh& mesh) {
#else
mesh.drawInternal(mesh._count, mesh._baseVertex, mesh._instanceCount, mesh._indexOffset);
#endif
return *this;
}
void AbstractShaderProgram::draw(MeshView& mesh) {
CORRADE_ASSERT(mesh._countSet, "GL::AbstractShaderProgram::draw(): MeshView::setCount() was never called, probably a mistake?", );
AbstractShaderProgram& AbstractShaderProgram::draw(MeshView& mesh) {
CORRADE_ASSERT(mesh._countSet, "GL::AbstractShaderProgram::draw(): MeshView::setCount() was never called, probably a mistake?", *this);
/* Nothing to draw, exit without touching any state */
if(!mesh._count || !mesh._instanceCount) return;
if(!mesh._count || !mesh._instanceCount) return *this;
use();
@ -378,17 +379,18 @@ void AbstractShaderProgram::draw(MeshView& mesh) {
#else
mesh._original->drawInternal(mesh._count, mesh._baseVertex, mesh._instanceCount, mesh._indexOffset);
#endif
return *this;
}
void AbstractShaderProgram::draw(Containers::ArrayView<const Containers::Reference<MeshView>> meshes) {
if(meshes.empty()) return;
AbstractShaderProgram& AbstractShaderProgram::draw(Containers::ArrayView<const Containers::Reference<MeshView>> meshes) {
if(meshes.empty()) return *this;
use();
#ifndef CORRADE_NO_ASSERT
const Mesh* original = &*meshes.front()->_original;
for(std::size_t i = 0; i != meshes.size(); ++i)
CORRADE_ASSERT(&*meshes[i]->_original == original, "GL::AbstractShaderProgram::draw(): all meshes must be views of the same original mesh, expected" << original << "but got" << &*meshes[i]->_original << "at index" << i, );
CORRADE_ASSERT(&*meshes[i]->_original == original, "GL::AbstractShaderProgram::draw(): all meshes must be views of the same original mesh, expected" << original << "but got" << &*meshes[i]->_original << "at index" << i, *this);
#endif
#ifndef MAGNUM_TARGET_GLES
@ -396,34 +398,38 @@ void AbstractShaderProgram::draw(Containers::ArrayView<const Containers::Referen
#else
Context::current().state().mesh.multiDrawImplementation(meshes);
#endif
return *this;
}
void AbstractShaderProgram::draw(std::initializer_list<Containers::Reference<MeshView>> meshes) {
draw(Containers::arrayView(meshes));
AbstractShaderProgram& AbstractShaderProgram::draw(std::initializer_list<Containers::Reference<MeshView>> meshes) {
return draw(Containers::arrayView(meshes));
}
#ifndef MAGNUM_TARGET_GLES
void AbstractShaderProgram::drawTransformFeedback(Mesh& mesh, TransformFeedback& xfb, UnsignedInt stream) {
AbstractShaderProgram& AbstractShaderProgram::drawTransformFeedback(Mesh& mesh, TransformFeedback& xfb, UnsignedInt stream) {
/* Nothing to draw, exit without touching any state */
if(!mesh._instanceCount) return;
if(!mesh._instanceCount) return *this;
use();
mesh.drawInternal(xfb, stream, mesh._instanceCount);
return *this;
}
void AbstractShaderProgram::drawTransformFeedback(MeshView& mesh, TransformFeedback& xfb, UnsignedInt stream) {
/* Nothing to draw, exit without touching any state */
if(!mesh._instanceCount) return;
AbstractShaderProgram& AbstractShaderProgram::drawTransformFeedback(MeshView& mesh, TransformFeedback& xfb, UnsignedInt stream) {
/* If nothing to draw, exit without touching any state */
if(mesh._instanceCount) return *this;
use();
mesh._original->drawInternal(xfb, stream, mesh._instanceCount);
return *this;
}
#endif
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
void AbstractShaderProgram::dispatchCompute(const Vector3ui& workgroupCount) {
AbstractShaderProgram& AbstractShaderProgram::dispatchCompute(const Vector3ui& workgroupCount) {
use();
glDispatchCompute(workgroupCount.x(), workgroupCount.y(), workgroupCount.z());
return *this;
}
#endif

43
src/Magnum/GL/AbstractShaderProgram.h
Unescape View File

@ -87,12 +87,14 @@ functions and properties:
@snippet MagnumGL.cpp AbstractShaderProgram-xfb
</li>
<li>And optionally, **hiding irrelevant draw/dispatch functions** to prevent
users from accidentally calling @ref draw() on compute shaders,
@ref drawTransformFeedback() on shaders that don't have transform feedback
or @ref dispatchCompute() on shaders that aren't compute. For example:
@snippet MagnumGL.cpp AbstractShaderProgram-hide-irrelevant
<li>And optionally, **return derived type from relevant draw/dispatch functions**
to make it possible for users to easily chain draw calls, and on the other
hand **hide the irrelevant APIs** to prevent users from accidentally
calling @ref draw() on compute shaders, @ref drawTransformFeedback() on
shaders that don't have transform feedback or @ref dispatchCompute() on
shaders that aren't compute. For example:
@snippet MagnumGL.cpp AbstractShaderProgram-return-hide-irrelevant
</ul>
@subsection GL-AbstractShaderProgram-attribute-location Binding attribute and fragment data location
@ -751,7 +753,7 @@ class MAGNUM_GL_EXPORT AbstractShaderProgram: public AbstractObject {
/**
* @brief Draw a mesh
* @param mesh Mesh to draw
* @return Reference to self (for method chaining)
* @m_since{2020,06}
*
* Expects that @p mesh is compatible with this shader and is fully set
@ -794,16 +796,19 @@ class MAGNUM_GL_EXPORT AbstractShaderProgram: public AbstractObject {
* @requires_gl Specifying base vertex for indexed meshes is not
* available in OpenGL ES or WebGL.
*/
void draw(Mesh& mesh);
AbstractShaderProgram& draw(Mesh& mesh);
/**
* @overload
* @m_since{2020,06}
*/
void draw(Mesh&& mesh) { draw(mesh); }
AbstractShaderProgram& draw(Mesh&& mesh) {
return draw(mesh);
}
/**
* @brief Draw a mesh view
* @return Reference to self (for method chaining)
* @m_since{2020,06}
*
* See @ref draw(Mesh&) for more information.
@ -828,16 +833,19 @@ class MAGNUM_GL_EXPORT AbstractShaderProgram: public AbstractObject {
* @requires_gl Specifying base vertex for indexed meshes is not
* available in OpenGL ES or WebGL.
*/
void draw(MeshView& mesh);
AbstractShaderProgram& draw(MeshView& mesh);
/**
* @overload
* @m_since{2020,06}
*/
void draw(MeshView&& mesh) { draw(mesh); }
AbstractShaderProgram& draw(MeshView&& mesh) {
return draw(mesh);
}
/**
* @brief Draw multiple meshes at once
* @return Reference to self (for method chaining)
* @m_since{2020,06}
*
* On OpenGL ES, if neither @gl_extension{EXT,multi_draw_arrays} nor
@ -872,13 +880,13 @@ class MAGNUM_GL_EXPORT AbstractShaderProgram: public AbstractObject {
* if the mesh is indexed and @ref MeshView::baseVertex() is not
* `0`
*/
void draw(Containers::ArrayView<const Containers::Reference<MeshView>> meshes);
AbstractShaderProgram& draw(Containers::ArrayView<const Containers::Reference<MeshView>> meshes);
/**
* @overload
* @m_since{2020,06}
*/
void draw(std::initializer_list<Containers::Reference<MeshView>> meshes);
AbstractShaderProgram& draw(std::initializer_list<Containers::Reference<MeshView>> meshes);
#ifndef MAGNUM_TARGET_GLES
/**
@ -886,6 +894,7 @@ class MAGNUM_GL_EXPORT AbstractShaderProgram: public AbstractObject {
* @param mesh Mesh to draw
* @param xfb Transform feedback to use for vertex count
* @param stream Transform feedback stream ID
* @return Reference to self (for method chaining)
* @m_since{2020,06}
*
* Expects that @p mesh is compatible with this shader, is fully set up
@ -911,10 +920,11 @@ class MAGNUM_GL_EXPORT AbstractShaderProgram: public AbstractObject {
* @requires_gl42 Extension @gl_extension{ARB,transform_feedback_instanced}
* if @ref Mesh::instanceCount() is more than `1`
*/
void drawTransformFeedback(Mesh& mesh, TransformFeedback& xfb, UnsignedInt stream = 0);
AbstractShaderProgram& drawTransformFeedback(Mesh& mesh, TransformFeedback& xfb, UnsignedInt stream = 0);
/**
* @brief Draw a mesh view with vertices coming out of transform feedback
* @return Reference to self (for method chaining)
* @m_since{2020,06}
*
* Everything set by @ref MeshView::setCount(),
@ -931,13 +941,14 @@ class MAGNUM_GL_EXPORT AbstractShaderProgram: public AbstractObject {
* @requires_gl42 Extension @gl_extension{ARB,transform_feedback_instanced}
* if @ref MeshView::instanceCount() is more than `1`
*/
void drawTransformFeedback(MeshView& mesh, TransformFeedback& xfb, UnsignedInt stream = 0);
AbstractShaderProgram& drawTransformFeedback(MeshView& mesh, TransformFeedback& xfb, UnsignedInt stream = 0);
#endif
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
/**
* @brief Dispatch compute
* @param workgroupCount Workgroup count in given dimension
* @return Reference to self (for method chaining)
*
* Valid only on programs with compute shader attached.
* @see @fn_gl{DispatchCompute}
@ -946,7 +957,7 @@ class MAGNUM_GL_EXPORT AbstractShaderProgram: public AbstractObject {
* and older.
* @requires_gles Compute shaders are not available in WebGL.
*/
void dispatchCompute(const Vector3ui& workgroupCount);
AbstractShaderProgram& dispatchCompute(const Vector3ui& workgroupCount);
#endif
protected:

22
src/Magnum/Shaders/DistanceFieldVectorGL.h
Unescape View File

@ -531,6 +531,28 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT DistanceFieldVector
* @}
*/
/* Overloads to remove WTF-factor from method chaining order */
#ifndef DOXYGEN_GENERATING_OUTPUT
DistanceFieldVectorGL<dimensions>& draw(GL::Mesh& mesh) {
return static_cast<DistanceFieldVectorGL<dimensions>&>(GL::AbstractShaderProgram::draw(mesh));
}
DistanceFieldVectorGL<dimensions>& draw(GL::Mesh&& mesh) {
return static_cast<DistanceFieldVectorGL<dimensions>&>(GL::AbstractShaderProgram::draw(mesh));
}
DistanceFieldVectorGL<dimensions>& draw(GL::MeshView& mesh) {
return static_cast<DistanceFieldVectorGL<dimensions>&>(GL::AbstractShaderProgram::draw(mesh));
}
DistanceFieldVectorGL<dimensions>& draw(GL::MeshView&& mesh) {
return static_cast<DistanceFieldVectorGL<dimensions>&>(GL::AbstractShaderProgram::draw(mesh));
}
DistanceFieldVectorGL<dimensions>& draw(Containers::ArrayView<const Containers::Reference<GL::MeshView>> meshes) {
return static_cast<DistanceFieldVectorGL<dimensions>&>(GL::AbstractShaderProgram::draw(meshes));
}
DistanceFieldVectorGL<dimensions>& draw(std::initializer_list<Containers::Reference<GL::MeshView>> meshes) {
return static_cast<DistanceFieldVectorGL<dimensions>&>(GL::AbstractShaderProgram::draw(meshes));
}
#endif
private:
/* Prevent accidentally calling irrelevant functions */
#ifndef MAGNUM_TARGET_GLES

22
src/Magnum/Shaders/FlatGL.h
Unescape View File

@ -860,6 +860,28 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT FlatGL: public GL::
* @}
*/
/* Overloads to remove WTF-factor from method chaining order */
#ifndef DOXYGEN_GENERATING_OUTPUT
FlatGL<dimensions>& draw(GL::Mesh& mesh) {
return static_cast<FlatGL<dimensions>&>(GL::AbstractShaderProgram::draw(mesh));
}
FlatGL<dimensions>& draw(GL::Mesh&& mesh) {
return static_cast<FlatGL<dimensions>&>(GL::AbstractShaderProgram::draw(mesh));
}
FlatGL<dimensions>& draw(GL::MeshView& mesh) {
return static_cast<FlatGL<dimensions>&>(GL::AbstractShaderProgram::draw(mesh));
}
FlatGL<dimensions>& draw(GL::MeshView&& mesh) {
return static_cast<FlatGL<dimensions>&>(GL::AbstractShaderProgram::draw(mesh));
}
FlatGL<dimensions>& draw(Containers::ArrayView<const Containers::Reference<GL::MeshView>> meshes) {
return static_cast<FlatGL<dimensions>&>(GL::AbstractShaderProgram::draw(meshes));
}
FlatGL<dimensions>& draw(std::initializer_list<Containers::Reference<GL::MeshView>> meshes) {
return static_cast<FlatGL<dimensions>&>(GL::AbstractShaderProgram::draw(meshes));
}
#endif
private:
/* Prevent accidentally calling irrelevant functions */
#ifndef MAGNUM_TARGET_GLES

44
src/Magnum/Shaders/MeshVisualizerGL.h
Unescape View File

@ -595,6 +595,28 @@ class MAGNUM_SHADERS_EXPORT MeshVisualizerGL2D: public Implementation::MeshVisua
* @}
*/
/* Overloads to remove WTF-factor from method chaining order */
#ifndef DOXYGEN_GENERATING_OUTPUT
MeshVisualizerGL2D& draw(GL::Mesh& mesh) {
return static_cast<MeshVisualizerGL2D&>(GL::AbstractShaderProgram::draw(mesh));
}
MeshVisualizerGL2D& draw(GL::Mesh&& mesh) {
return static_cast<MeshVisualizerGL2D&>(GL::AbstractShaderProgram::draw(mesh));
}
MeshVisualizerGL2D& draw(GL::MeshView& mesh) {
return static_cast<MeshVisualizerGL2D&>(GL::AbstractShaderProgram::draw(mesh));
}
MeshVisualizerGL2D& draw(GL::MeshView&& mesh) {
return static_cast<MeshVisualizerGL2D&>(GL::AbstractShaderProgram::draw(mesh));
}
MeshVisualizerGL2D& draw(Containers::ArrayView<const Containers::Reference<GL::MeshView>> meshes) {
return static_cast<MeshVisualizerGL2D&>(GL::AbstractShaderProgram::draw(meshes));
}
MeshVisualizerGL2D& draw(std::initializer_list<Containers::Reference<GL::MeshView>> meshes) {
return static_cast<MeshVisualizerGL2D&>(GL::AbstractShaderProgram::draw(meshes));
}
#endif
private:
Int _transformationProjectionMatrixUniform{6};
};
@ -1574,6 +1596,28 @@ class MAGNUM_SHADERS_EXPORT MeshVisualizerGL3D: public Implementation::MeshVisua
* @}
*/
/* Overloads to remove WTF-factor from method chaining order */
#ifndef DOXYGEN_GENERATING_OUTPUT
MeshVisualizerGL3D& draw(GL::Mesh& mesh) {
return static_cast<MeshVisualizerGL3D&>(GL::AbstractShaderProgram::draw(mesh));
}
MeshVisualizerGL3D& draw(GL::Mesh&& mesh) {
return static_cast<MeshVisualizerGL3D&>(GL::AbstractShaderProgram::draw(mesh));
}
MeshVisualizerGL3D& draw(GL::MeshView& mesh) {
return static_cast<MeshVisualizerGL3D&>(GL::AbstractShaderProgram::draw(mesh));
}
MeshVisualizerGL3D& draw(GL::MeshView&& mesh) {
return static_cast<MeshVisualizerGL3D&>(GL::AbstractShaderProgram::draw(mesh));
}
MeshVisualizerGL3D& draw(Containers::ArrayView<const Containers::Reference<GL::MeshView>> meshes) {
return static_cast<MeshVisualizerGL3D&>(GL::AbstractShaderProgram::draw(meshes));
}
MeshVisualizerGL3D& draw(std::initializer_list<Containers::Reference<GL::MeshView>> meshes) {
return static_cast<MeshVisualizerGL3D&>(GL::AbstractShaderProgram::draw(meshes));
}
#endif
private:
Int _transformationMatrixUniform{6},
_projectionMatrixUniform{7};

22
src/Magnum/Shaders/PhongGL.h
Unescape View File

@ -1561,6 +1561,28 @@ class MAGNUM_SHADERS_EXPORT PhongGL: public GL::AbstractShaderProgram {
* @}
*/
/* Overloads to remove WTF-factor from method chaining order */
#ifndef DOXYGEN_GENERATING_OUTPUT
PhongGL& draw(GL::Mesh& mesh) {
return static_cast<PhongGL&>(GL::AbstractShaderProgram::draw(mesh));
}
PhongGL& draw(GL::Mesh&& mesh) {
return static_cast<PhongGL&>(GL::AbstractShaderProgram::draw(mesh));
}
PhongGL& draw(GL::MeshView& mesh) {
return static_cast<PhongGL&>(GL::AbstractShaderProgram::draw(mesh));
}
PhongGL& draw(GL::MeshView&& mesh) {
return static_cast<PhongGL&>(GL::AbstractShaderProgram::draw(mesh));
}
PhongGL& draw(Containers::ArrayView<const Containers::Reference<GL::MeshView>> meshes) {
return static_cast<PhongGL&>(GL::AbstractShaderProgram::draw(meshes));
}
PhongGL& draw(std::initializer_list<Containers::Reference<GL::MeshView>> meshes) {
return static_cast<PhongGL&>(GL::AbstractShaderProgram::draw(meshes));
}
#endif
private:
/* Prevent accidentally calling irrelevant functions */
#ifndef MAGNUM_TARGET_GLES

22
src/Magnum/Shaders/VectorGL.h
Unescape View File

@ -483,6 +483,28 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT VectorGL: public GL
* @}
*/
/* Overloads to remove WTF-factor from method chaining order */
#ifndef DOXYGEN_GENERATING_OUTPUT
VectorGL<dimensions>& draw(GL::Mesh& mesh) {
return static_cast<VectorGL<dimensions>&>(GL::AbstractShaderProgram::draw(mesh));
}
VectorGL<dimensions>& draw(GL::Mesh&& mesh) {
return static_cast<VectorGL<dimensions>&>(GL::AbstractShaderProgram::draw(mesh));
}
VectorGL<dimensions>& draw(GL::MeshView& mesh) {
return static_cast<VectorGL<dimensions>&>(GL::AbstractShaderProgram::draw(mesh));
}
VectorGL<dimensions>& draw(GL::MeshView&& mesh) {
return static_cast<VectorGL<dimensions>&>(GL::AbstractShaderProgram::draw(mesh));
}
VectorGL<dimensions>& draw(Containers::ArrayView<const Containers::Reference<GL::MeshView>> meshes) {
return static_cast<VectorGL<dimensions>&>(GL::AbstractShaderProgram::draw(meshes));
}
VectorGL<dimensions>& draw(std::initializer_list<Containers::Reference<GL::MeshView>> meshes) {
return static_cast<VectorGL<dimensions>&>(GL::AbstractShaderProgram::draw(meshes));
}
#endif
private:
/* Prevent accidentally calling irrelevant functions */
#ifndef MAGNUM_TARGET_GLES

22
src/Magnum/Shaders/VertexColorGL.h
Unescape View File

@ -341,6 +341,28 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT VertexColorGL: publ
*/
#endif
/* Overloads to remove WTF-factor from method chaining order */
#ifndef DOXYGEN_GENERATING_OUTPUT
VertexColorGL<dimensions>& draw(GL::Mesh& mesh) {
return static_cast<VertexColorGL<dimensions>&>(GL::AbstractShaderProgram::draw(mesh));
}
VertexColorGL<dimensions>& draw(GL::Mesh&& mesh) {
return static_cast<VertexColorGL<dimensions>&>(GL::AbstractShaderProgram::draw(mesh));
}
VertexColorGL<dimensions>& draw(GL::MeshView& mesh) {
return static_cast<VertexColorGL<dimensions>&>(GL::AbstractShaderProgram::draw(mesh));
}
VertexColorGL<dimensions>& draw(GL::MeshView&& mesh) {
return static_cast<VertexColorGL<dimensions>&>(GL::AbstractShaderProgram::draw(mesh));
}
VertexColorGL<dimensions>& draw(Containers::ArrayView<const Containers::Reference<GL::MeshView>> meshes) {
return static_cast<VertexColorGL<dimensions>&>(GL::AbstractShaderProgram::draw(meshes));
}
VertexColorGL<dimensions>& draw(std::initializer_list<Containers::Reference<GL::MeshView>> meshes) {
return static_cast<VertexColorGL<dimensions>&>(GL::AbstractShaderProgram::draw(meshes));
}
#endif
private:
/* Prevent accidentally calling irrelevant functions */
#ifndef MAGNUM_TARGET_GLES

Write Preview
Loading…
Cancel
Save