Browse Source

GL: deprecate MeshView::setIndexRange() in favor of setIndexOffset().

The name was CONFUSING every time I tried to use it.
pull/168/head
Vladimír Vondruš 3 years ago
parent
commit
78befae123
  1. 4
      doc/changelog-old.dox
  2. 2
      doc/changelog.dox
  3. 2
      src/Magnum/GL/AbstractShaderProgram.h
  4. 3
      src/Magnum/GL/Mesh.h
  5. 7
      src/Magnum/GL/MeshView.cpp
  6. 45
      src/Magnum/GL/MeshView.h
  7. 26
      src/Magnum/GL/Test/MeshGLTest.cpp
  8. 8
      src/Magnum/Shaders/Test/DistanceFieldVectorGLTest.cpp
  9. 16
      src/Magnum/Shaders/Test/FlatGLTest.cpp
  10. 8
      src/Magnum/Shaders/Test/LineGLTest.cpp
  11. 8
      src/Magnum/Shaders/Test/MeshVisualizerGLTest.cpp
  12. 8
      src/Magnum/Shaders/Test/PhongGLTest.cpp
  13. 8
      src/Magnum/Shaders/Test/VectorGLTest.cpp
  14. 8
      src/Magnum/Shaders/Test/VertexColorGLTest.cpp

4
doc/changelog-old.dox

@ -143,7 +143,7 @@ Released 2018-05-01, tagged as
@subsubsection changelog-2018-04-changes-gl GL library
- The @ref GL::Mesh::indexTypeSize() and @ref GL::MeshView::setIndexRange()
- The @ref GL::Mesh::indexTypeSize() and @cpp GL::MeshView::setIndexRange() @ce
now expect that the mesh is indexed (instead of silently not doing
anything)
@ -1152,7 +1152,7 @@ a high-level overview.
instead
- Removed deprecated `Mesh*::set*{Range,Count}()` functions, use
@ref GL::Mesh::setCount() "Mesh*::setCount()" and
@ref GL::MeshView::setIndexRange() "MeshView::setIndexRange()" instead
@cpp MeshView::setIndexRange() @ce instead
- Removed deprecated parameterless @cpp GL::Mesh::draw() @ce overload, use
the one with explicit shader parameter instead
- Removed deprecated `Context::Flag::Robustness` enum value, use

2
doc/changelog.dox

@ -1073,6 +1073,8 @@ See also:
callback function pointer is deprecated in favor of a version taking a
@ref Containers::StringView. See also [mosra/magnum#499](https://github.com/mosra/magnum/pull/499)
and [mosra/magnum#596](https://github.com/mosra/magnum/pull/596).
- @cpp GL::MeshView::setIndexRange() @ce is deprecated in favor of
@ref GL::MeshView::setIndexOffset() that has a much less confusing name
- The @cpp Array @ce, @cpp Array1D @ce, @cpp Array2D @ce and
@cpp Array3D @ce types that were used exclusively for specifying
@ref SamplerWrapping in various texture APIs are deprecated in favor of

2
src/Magnum/GL/AbstractShaderProgram.h

@ -1301,7 +1301,7 @@ class MAGNUM_GL_EXPORT AbstractShaderProgram: public AbstractObject {
*
* Everything set by @ref MeshView::setCount(),
* @ref MeshView::setBaseInstance(), @ref MeshView::setBaseVertex(),
* @ref MeshView::setIndexRange() and @ref Mesh::setIndexBuffer() is
* @ref MeshView::setIndexOffset() and @ref Mesh::setIndexBuffer() is
* ignored, the mesh is drawn as non-indexed and the vertex count is
* taken from the @p xfb object. See
* @ref drawTransformFeedback(Mesh&, TransformFeedback&, UnsignedInt)

3
src/Magnum/GL/Mesh.h

@ -1037,7 +1037,8 @@ class MAGNUM_GL_EXPORT Mesh: public AbstractObject {
*
* Alternative to @ref setIndexBuffer(Buffer&, GLintptr, MeshIndexType, UnsignedInt, UnsignedInt)
* with unspecified index limits, see its documentation for more
* information. Prefer to set index limits for better performance.
* information. Prefer to set index limits for better performance on
* certain drivers.
*/
Mesh& setIndexBuffer(Buffer& buffer, GLintptr offset, MeshIndexType type) {
return setIndexBuffer(buffer, offset, type, 0, 0);

7
src/Magnum/GL/MeshView.cpp

@ -56,9 +56,10 @@ void MeshView::draw(AbstractShaderProgram&& shader, std::initializer_list<Contai
}
#endif
MeshView& MeshView::setIndexRange(Int first) {
CORRADE_ASSERT(_original.get()._indexBuffer.id(), "MeshView::setIndexRange(): mesh is not indexed", *this);
_indexOffset = _original.get()._indexOffset + first*_original.get().indexTypeSize();
MeshView& MeshView::setIndexOffset(Int offset) {
CORRADE_ASSERT(_original.get()._indexBuffer.id(),
"GL::MeshView::setIndexOffset(): mesh is not indexed", *this);
_indexOffset = _original.get()._indexOffset + offset*_original.get().indexTypeSize();
return *this;
}

45
src/Magnum/GL/MeshView.h

@ -147,16 +147,17 @@ class MAGNUM_GL_EXPORT MeshView {
}
/**
* @brief Set index range
* @param first First vertex
* @brief Set index offset
* @param offset First index
* @param start Minimum array index contained in the buffer
* @param end Maximum array index contained in the buffer
* @return Reference to self (for method chaining)
* @m_since_latest
*
* The @p start and @p end parameters may help to improve memory access
* performance, as only a portion of vertex buffer needs to be
* acccessed. On OpenGL ES 2.0 this function behaves the same as
* @ref setIndexRange(Int), as index range functionality is not
* @ref setIndexOffset(Int), as index range functionality is not
* available there. Ignored when calling
* @ref AbstractShaderProgram::drawTransformFeedback().
*
@ -164,21 +165,41 @@ class MAGNUM_GL_EXPORT MeshView {
* @see @ref setCount(), @ref mesh(), @ref Mesh::isIndexed()
*/
/* MinGW/MSVC needs inline also here to avoid linkage conflicts */
inline MeshView& setIndexRange(Int first, UnsignedInt start, UnsignedInt end);
inline MeshView& setIndexOffset(Int offset, UnsignedInt start, UnsignedInt end);
#ifdef MAGNUM_BUILD_DEPRECATED
/**
* @brief Set index range
* @param first First index
* @brief @copybrief setIndexOffset(Int, UnsignedInt, UnsignedInt)
* @m_deprecated_since_latest Use @ref setIndexOffset(Int, UnsignedInt, UnsignedInt) instead.
*/
CORRADE_DEPRECATED("use setIndexOffset() instead") MeshView& setIndexRange(Int offset, UnsignedInt start, UnsignedInt end) {
return setIndexOffset(offset, start, end);
}
#endif
/**
* @brief Set index offset
* @return Reference to self (for method chaining)
* @m_since_latest
*
* Prefer to use @ref setIndexRange(Int, UnsignedInt, UnsignedInt) for
* better performance. Ignored when calling
* @ref AbstractShaderProgram::drawTransformFeedback().
* Prefer to use @ref setIndexOffset(Int, UnsignedInt, UnsignedInt) for
* potential better performance in certain drivers. Ignored when
* calling @ref AbstractShaderProgram::drawTransformFeedback().
*
* Expects that the original mesh is indexed.
* @see @ref setCount(), @ref mesh(), @ref Mesh::isIndexed()
*/
MeshView& setIndexRange(Int first);
MeshView& setIndexOffset(Int offset);
#ifdef MAGNUM_BUILD_DEPRECATED
/**
* @brief @copybrief setIndexOffset(Int)
* @m_deprecated_since_latest Use @ref setIndexOffset(Int) instead.
*/
CORRADE_DEPRECATED("use setIndexOffset() instead") MeshView& setIndexRange(Int offset) {
return setIndexOffset(offset);
}
#endif
/** @brief Instance count */
Int instanceCount() const { return _instanceCount; }
@ -283,8 +304,8 @@ class MAGNUM_GL_EXPORT MeshView {
inline MeshView::MeshView(Mesh& original): _original{original} {}
inline MeshView& MeshView::setIndexRange(Int first, UnsignedInt start, UnsignedInt end) {
setIndexRange(first);
inline MeshView& MeshView::setIndexOffset(Int first, UnsignedInt start, UnsignedInt end) {
setIndexOffset(first);
#ifndef MAGNUM_TARGET_GLES2
_indexStart = start;
_indexEnd = end;

26
src/Magnum/GL/Test/MeshGLTest.cpp

@ -141,6 +141,8 @@ struct MeshGLTest: OpenGLTester {
template<class T> void setIndexBufferTransferOwnership();
template<class T> void setIndexBufferRangeTransferOwnership();
void setIndexOffsetNotIndexed();
void unbindVAOWhenSettingIndexBufferData();
void unbindIndexBufferWhenBindingVao();
void resetIndexBufferBindingWhenBindingVao();
@ -631,6 +633,8 @@ MeshGLTest::MeshGLTest() {
&MeshGLTest::setIndexBufferRangeTransferOwnership<GL::MeshIndexType>,
&MeshGLTest::setIndexBufferRangeTransferOwnership<Magnum::MeshIndexType>,
&MeshGLTest::setIndexOffsetNotIndexed,
&MeshGLTest::unbindVAOWhenSettingIndexBufferData,
&MeshGLTest::unbindIndexBufferWhenBindingVao,
&MeshGLTest::resetIndexBufferBindingWhenBindingVao,
@ -1133,7 +1137,7 @@ Checker::Checker(AbstractShaderProgram&& shader, RenderbufferFormat format, Mesh
#endif
;
if(view.mesh().isIndexed()) view.setIndexRange(1);
if(view.mesh().isIndexed()) view.setIndexOffset(1);
shader.draw(view);
}
@ -2676,6 +2680,18 @@ template<class T> void MeshGLTest::setIndexBufferRangeTransferOwnership() {
CORRADE_VERIFY(!glIsBuffer(id));
}
void MeshGLTest::setIndexOffsetNotIndexed() {
CORRADE_SKIP_IF_NO_ASSERT();
Mesh mesh;
MeshView view{mesh};
std::ostringstream out;
Error redirectError{&out};
view.setIndexOffset(3);
CORRADE_COMPARE(out.str(), "GL::MeshView::setIndexOffset(): mesh is not indexed\n");
}
void MeshGLTest::unbindVAOWhenSettingIndexBufferData() {
#ifndef MAGNUM_TARGET_GLES
if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_array_object>())
@ -4368,16 +4384,16 @@ void MeshGLTest::multiDrawIndexedViews() {
MeshView a{mesh}, b{mesh}, c{mesh}, d{mesh};
a.setCount(data.counts[0])
.setIndexRange(data.indexOffsetsInBytes[0]/sizeof(UnsignedInt))
.setIndexOffset(data.indexOffsetsInBytes[0]/sizeof(UnsignedInt))
.setBaseVertex(data.vertexOffsets[0]);
b.setCount(data.counts[1])
.setIndexRange(data.indexOffsetsInBytes[1]/sizeof(UnsignedInt))
.setIndexOffset(data.indexOffsetsInBytes[1]/sizeof(UnsignedInt))
.setBaseVertex(data.vertexOffsets[1]);
c.setCount(data.counts[2])
.setIndexRange(data.indexOffsetsInBytes[2]/sizeof(UnsignedInt))
.setIndexOffset(data.indexOffsetsInBytes[2]/sizeof(UnsignedInt))
.setBaseVertex(data.vertexOffsets[2]);
d.setCount(data.counts[3])
.setIndexRange(data.indexOffsetsInBytes[3]/sizeof(UnsignedInt))
.setIndexOffset(data.indexOffsetsInBytes[3]/sizeof(UnsignedInt))
.setBaseVertex(data.vertexOffsets[3]);
MAGNUM_VERIFY_NO_GL_ERROR();

8
src/Magnum/Shaders/Test/DistanceFieldVectorGLTest.cpp

@ -1344,10 +1344,10 @@ void DistanceFieldVectorGLTest::renderMulti2D() {
circle.setCount(circleData.indexCount());
GL::MeshView square{mesh};
square.setCount(squareData.indexCount())
.setIndexRange(circleData.indexCount());
.setIndexOffset(circleData.indexCount());
GL::MeshView triangle{mesh};
triangle.setCount(triangleData.indexCount())
.setIndexRange(circleData.indexCount() + squareData.indexCount());
.setIndexOffset(circleData.indexCount() + squareData.indexCount());
/* Some drivers have uniform offset alignment as high as 256, which means
the subsequent sets of uniforms have to be aligned to a multiply of it.
@ -1564,10 +1564,10 @@ void DistanceFieldVectorGLTest::renderMulti3D() {
sphere.setCount(sphereData.indexCount());
GL::MeshView plane{mesh};
plane.setCount(planeData.indexCount())
.setIndexRange(sphereData.indexCount());
.setIndexOffset(sphereData.indexCount());
GL::MeshView cone{mesh};
cone.setCount(coneData.indexCount())
.setIndexRange(sphereData.indexCount() + planeData.indexCount());
.setIndexOffset(sphereData.indexCount() + planeData.indexCount());
/* Some drivers have uniform offset alignment as high as 256, which means
the subsequent sets of uniforms have to be aligned to a multiply of it.

16
src/Magnum/Shaders/Test/FlatGLTest.cpp

@ -5069,10 +5069,10 @@ void FlatGLTest::renderMulti2D() {
circle.setCount(circleData.indexCount());
GL::MeshView square{mesh};
square.setCount(squareData.indexCount())
.setIndexRange(circleData.indexCount());
.setIndexOffset(circleData.indexCount());
GL::MeshView triangle{mesh};
triangle.setCount(triangleData.indexCount())
.setIndexRange(circleData.indexCount() + squareData.indexCount());
.setIndexOffset(circleData.indexCount() + squareData.indexCount());
/* Some drivers have uniform offset alignment as high as 256, which means
the subsequent sets of uniforms have to be aligned to a multiply of it.
@ -5434,10 +5434,10 @@ void FlatGLTest::renderMulti3D() {
sphere.setCount(sphereData.indexCount());
GL::MeshView plane{mesh};
plane.setCount(planeData.indexCount())
.setIndexRange(sphereData.indexCount());
.setIndexOffset(sphereData.indexCount());
GL::MeshView cone{mesh};
cone.setCount(coneData.indexCount())
.setIndexRange(sphereData.indexCount() + planeData.indexCount());
.setIndexOffset(sphereData.indexCount() + planeData.indexCount());
/* Some drivers have uniform offset alignment as high as 256, which means
the subsequent sets of uniforms have to be aligned to a multiply of it.
@ -5742,10 +5742,10 @@ void FlatGLTest::renderMultiSkinning2D() {
square.setCount(6);
GL::MeshView triangle1{mesh};
triangle1.setCount(3)
.setIndexRange(6);
.setIndexOffset(6);
GL::MeshView triangle2{mesh};
triangle2.setCount(3)
.setIndexRange(9);
.setIndexOffset(9);
/* Some drivers have uniform offset alignment as high as 256, which means
the subsequent sets of uniforms have to be aligned to a multiply of it.
@ -5994,10 +5994,10 @@ void FlatGLTest::renderMultiSkinning3D() {
square.setCount(6);
GL::MeshView triangle1{mesh};
triangle1.setCount(3)
.setIndexRange(6);
.setIndexOffset(6);
GL::MeshView triangle2{mesh};
triangle2.setCount(3)
.setIndexRange(9);
.setIndexOffset(9);
/* Some drivers have uniform offset alignment as high as 256, which means
the subsequent sets of uniforms have to be aligned to a multiply of it.

8
src/Magnum/Shaders/Test/LineGLTest.cpp

@ -2709,10 +2709,10 @@ void LineGLTest::renderMulti2D() {
wave.setCount(30);
GL::MeshView cross{lines};
cross.setCount(12)
.setIndexRange(30);
.setIndexOffset(30);
GL::MeshView point{lines};
point.setCount(6)
.setIndexRange(42);
.setIndexOffset(42);
LineGL2D shader{LineGL2D::Configuration{}
.setFlags(LineGL2D::Flag::UniformBuffers|data.flags)
@ -2940,10 +2940,10 @@ void LineGLTest::renderMulti3D() {
wave.setCount(30);
GL::MeshView cross{lines};
cross.setCount(12)
.setIndexRange(30);
.setIndexOffset(30);
GL::MeshView point{lines};
point.setCount(6)
.setIndexRange(42);
.setIndexOffset(42);
LineGL3D shader{LineGL3D::Configuration{}
.setFlags(LineGL3D::Flag::UniformBuffers|data.flags)

8
src/Magnum/Shaders/Test/MeshVisualizerGLTest.cpp

@ -6693,13 +6693,13 @@ void MeshVisualizerGLTest::renderMulti2D() {
if(data.flags & MeshVisualizerGL2D::Flag::NoGeometryShader)
square.setBaseVertex(circleData.vertexCount());
else
square.setIndexRange(circleData.indexCount());
square.setIndexOffset(circleData.indexCount());
GL::MeshView triangle{mesh};
triangle.setCount(data.flags & MeshVisualizerGL2D::Flag::NoGeometryShader ?
triangleData.vertexCount() : triangleData.indexCount());
if(data.flags & MeshVisualizerGL2D::Flag::NoGeometryShader)
triangle.setBaseVertex(circleData.vertexCount() + squareData.vertexCount());
else triangle.setIndexRange(circleData.indexCount() + squareData.indexCount());
else triangle.setIndexOffset(circleData.indexCount() + squareData.indexCount());
/* Some drivers have uniform offset alignment as high as 256, which means
the subsequent sets of uniforms have to be aligned to a multiply of it.
@ -7035,13 +7035,13 @@ void MeshVisualizerGLTest::renderMulti3D() {
if(data.flags & MeshVisualizerGL3D::Flag::NoGeometryShader)
plane.setBaseVertex(sphereData.vertexCount());
else
plane.setIndexRange(sphereData.indexCount());
plane.setIndexOffset(sphereData.indexCount());
GL::MeshView cone{mesh};
cone.setCount(data.flags & MeshVisualizerGL3D::Flag::NoGeometryShader ?
coneData.vertexCount() : coneData.indexCount());
if(data.flags & MeshVisualizerGL3D::Flag::NoGeometryShader)
cone.setBaseVertex(sphereData.vertexCount() + planeData.vertexCount());
else cone.setIndexRange(sphereData.indexCount() + planeData.indexCount());
else cone.setIndexOffset(sphereData.indexCount() + planeData.indexCount());
GL::Buffer projectionUniform{GL::Buffer::TargetHint::Uniform, {
ProjectionUniform3D{}.setProjectionMatrix(

8
src/Magnum/Shaders/Test/PhongGLTest.cpp

@ -5481,10 +5481,10 @@ void PhongGLTest::renderMulti() {
sphere.setCount(sphereData.indexCount());
GL::MeshView plane{mesh};
plane.setCount(planeData.indexCount())
.setIndexRange(sphereData.indexCount());
.setIndexOffset(sphereData.indexCount());
GL::MeshView cone{mesh};
cone.setCount(coneData.indexCount())
.setIndexRange(sphereData.indexCount() + planeData.indexCount());
.setIndexOffset(sphereData.indexCount() + planeData.indexCount());
GL::Buffer projectionUniform{GL::Buffer::TargetHint::Uniform, {
ProjectionUniform3D{}.setProjectionMatrix(
@ -5830,10 +5830,10 @@ void PhongGLTest::renderMultiSkinning() {
square.setCount(6);
GL::MeshView triangle1{mesh};
triangle1.setCount(3)
.setIndexRange(6);
.setIndexOffset(6);
GL::MeshView triangle2{mesh};
triangle2.setCount(3)
.setIndexRange(9);
.setIndexOffset(9);
GL::Buffer projectionUniform{GL::Buffer::TargetHint::Uniform, {
ProjectionUniform3D{}

8
src/Magnum/Shaders/Test/VectorGLTest.cpp

@ -1309,10 +1309,10 @@ void VectorGLTest::renderMulti2D() {
circle.setCount(circleData.indexCount());
GL::MeshView square{mesh};
square.setCount(squareData.indexCount())
.setIndexRange(circleData.indexCount());
.setIndexOffset(circleData.indexCount());
GL::MeshView triangle{mesh};
triangle.setCount(triangleData.indexCount())
.setIndexRange(circleData.indexCount() + squareData.indexCount());
.setIndexOffset(circleData.indexCount() + squareData.indexCount());
/* Some drivers have uniform offset alignment as high as 256, which means
the subsequent sets of uniforms have to be aligned to a multiply of it.
@ -1529,10 +1529,10 @@ void VectorGLTest::renderMulti3D() {
sphere.setCount(sphereData.indexCount());
GL::MeshView plane{mesh};
plane.setCount(planeData.indexCount())
.setIndexRange(sphereData.indexCount());
.setIndexOffset(sphereData.indexCount());
GL::MeshView cone{mesh};
cone.setCount(coneData.indexCount())
.setIndexRange(sphereData.indexCount() + planeData.indexCount());
.setIndexOffset(sphereData.indexCount() + planeData.indexCount());
/* Some drivers have uniform offset alignment as high as 256, which means
the subsequent sets of uniforms have to be aligned to a multiply of it.

8
src/Magnum/Shaders/Test/VertexColorGLTest.cpp

@ -1058,10 +1058,10 @@ void VertexColorGLTest::renderMulti2D() {
circle.setCount(circleData.indexCount());
GL::MeshView square{mesh};
square.setCount(squareData.indexCount())
.setIndexRange(circleData.indexCount());
.setIndexOffset(circleData.indexCount());
GL::MeshView triangle{mesh};
triangle.setCount(triangleData.indexCount())
.setIndexRange(circleData.indexCount() + squareData.indexCount());
.setIndexOffset(circleData.indexCount() + squareData.indexCount());
/* Some drivers have uniform offset alignment as high as 256, which means
the subsequent sets of uniforms have to be aligned to a multiply of it.
@ -1204,10 +1204,10 @@ void VertexColorGLTest::renderMulti3D() {
sphere.setCount(sphereData.indexCount());
GL::MeshView plane{mesh};
plane.setCount(planeData.indexCount())
.setIndexRange(sphereData.indexCount());
.setIndexOffset(sphereData.indexCount());
GL::MeshView cone{mesh};
cone.setCount(coneData.indexCount())
.setIndexRange(sphereData.indexCount() + planeData.indexCount());
.setIndexOffset(sphereData.indexCount() + planeData.indexCount());
/* Some drivers have uniform offset alignment as high as 256, which means
the subsequent sets of uniforms have to be aligned to a multiply of it.

Loading…
Cancel
Save