ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
10602 Commits
21 Branches
19 Tags
70 MiB
Tree: 5e23f09ffb
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5e23f09ffb'
${ noResults }
magnum/src/Magnum/GL/MeshView.cpp

144 lines
5.2 KiB
Raw Normal View History Unescape

Added MeshView class. Allows to use one mesh configuration for different views of the data (i.e. rendering object parts with different transformations).
13 years ago
/*
This file is part of Magnum.
Updated copyright year.
6 years ago
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019,
It's 2023 already!
3 years ago
2020, 2021, 2022, 2023 Vladimír Vondruš <mosra@centrum.cz>
Added MeshView class. Allows to use one mesh configuration for different views of the data (i.e. rendering object parts with different transformations).
13 years ago
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#include "MeshView.h"
Added support for glMultiDrawArrays()/glMultiDrawElements(). In OpenGL ES this is implemented in EXT_multi_draw_arrays extension, if it is not available, the functionality is emulated using sequence of normal draw() calls.
12 years ago
#include <Corrade/Containers/Array.h>
GL: implement the base instance and base vertex ES and WebGL extensions. AAAAAAAAAAAAAAAAAAAAAAAAAAAAA this was terrible! Why the hell it needs to have so many variants, special cases and exceptions!!!
5 years ago
#include <Corrade/Containers/ArrayTuple.h>
GL: use Containers::Iterable also in AbstractShaderProgram::draw(). Forgot about this case in 4ff655740e6fab52783be9ef984683e7d1031395.
4 years ago
#include <Corrade/Containers/Iterable.h>
Added support for glMultiDrawArrays()/glMultiDrawElements(). In OpenGL ES this is implemented in EXT_multi_draw_arrays extension, if it is not available, the functionality is emulated using sequence of normal draw() calls.
12 years ago
#include <Corrade/Utility/Assert.h>
Split the OpenGL layer out, pt 1: moving files to a new location. Minimal updates (just the include guards) so Git is hopefully able to detect the rename and track the history properly. Everything except Magnum::GL doesn't compile now.
8 years ago
#include "Magnum/GL/AbstractShaderProgram.h"
#include "Magnum/GL/Context.h"
#include "Magnum/GL/Mesh.h"
#include "Magnum/GL/Implementation/State.h"
#include "Magnum/GL/Implementation/MeshState.h"
Added support for glMultiDrawArrays()/glMultiDrawElements(). In OpenGL ES this is implemented in EXT_multi_draw_arrays extension, if it is not available, the functionality is emulated using sequence of normal draw() calls.
12 years ago
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
namespace Magnum { namespace GL {
Added MeshView class. Allows to use one mesh configuration for different views of the data (i.e. rendering object parts with different transformations).
13 years ago
GL: mesh.draw(shader) -> shader.draw(mesh). As usual, the old APIs are still present, but marked as deprecated. Existing code is not updated yet to ensure I didn't break anything with this. This way it's much more intuitive and makes the code shorter and nicer in many cases. Shaders are now also able to hide irrelevant draw/dispatch APIs to avoid accidents.
6 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
GL: taking just an init list in MeshView::draw() was a stupid idea. With just that, it wouldn't be possible to draw a runtime-dependent amount of MeshViews (for example when culling them).
6 years ago
void MeshView::draw(AbstractShaderProgram& shader, Containers::ArrayView<const Containers::Reference<MeshView>> meshes) {
GL: mesh.draw(shader) -> shader.draw(mesh). As usual, the old APIs are still present, but marked as deprecated. Existing code is not updated yet to ensure I didn't break anything with this. This way it's much more intuitive and makes the code shorter and nicer in many cases. Shaders are now also able to hide irrelevant draw/dispatch APIs to avoid accidents.
6 years ago
shader.draw(meshes);
}
Added support for glMultiDrawArrays()/glMultiDrawElements(). In OpenGL ES this is implemented in EXT_multi_draw_arrays extension, if it is not available, the functionality is emulated using sequence of normal draw() calls.
12 years ago
GL: mesh.draw(shader) -> shader.draw(mesh). As usual, the old APIs are still present, but marked as deprecated. Existing code is not updated yet to ensure I didn't break anything with this. This way it's much more intuitive and makes the code shorter and nicer in many cases. Shaders are now also able to hide irrelevant draw/dispatch APIs to avoid accidents.
6 years ago
void MeshView::draw(AbstractShaderProgram&& shader, Containers::ArrayView<const Containers::Reference<MeshView>> meshes) {
shader.draw(meshes);
}
Added support for glMultiDrawArrays()/glMultiDrawElements(). In OpenGL ES this is implemented in EXT_multi_draw_arrays extension, if it is not available, the functionality is emulated using sequence of normal draw() calls.
12 years ago
GL: mesh.draw(shader) -> shader.draw(mesh). As usual, the old APIs are still present, but marked as deprecated. Existing code is not updated yet to ensure I didn't break anything with this. This way it's much more intuitive and makes the code shorter and nicer in many cases. Shaders are now also able to hide irrelevant draw/dispatch APIs to avoid accidents.
6 years ago
void MeshView::draw(AbstractShaderProgram& shader, std::initializer_list<Containers::Reference<MeshView>> meshes) {
GL: use Containers::Iterable also in AbstractShaderProgram::draw(). Forgot about this case in 4ff655740e6fab52783be9ef984683e7d1031395.
4 years ago
shader.draw(Containers::arrayView(meshes));
GL: mesh.draw(shader) -> shader.draw(mesh). As usual, the old APIs are still present, but marked as deprecated. Existing code is not updated yet to ensure I didn't break anything with this. This way it's much more intuitive and makes the code shorter and nicer in many cases. Shaders are now also able to hide irrelevant draw/dispatch APIs to avoid accidents.
6 years ago
}
Added support for glMultiDrawArrays()/glMultiDrawElements(). In OpenGL ES this is implemented in EXT_multi_draw_arrays extension, if it is not available, the functionality is emulated using sequence of normal draw() calls.
12 years ago
GL: mesh.draw(shader) -> shader.draw(mesh). As usual, the old APIs are still present, but marked as deprecated. Existing code is not updated yet to ensure I didn't break anything with this. This way it's much more intuitive and makes the code shorter and nicer in many cases. Shaders are now also able to hide irrelevant draw/dispatch APIs to avoid accidents.
6 years ago
void MeshView::draw(AbstractShaderProgram&& shader, std::initializer_list<Containers::Reference<MeshView>> meshes) {
GL: use Containers::Iterable also in AbstractShaderProgram::draw(). Forgot about this case in 4ff655740e6fab52783be9ef984683e7d1031395.
4 years ago
shader.draw(Containers::arrayView(meshes));
Added support for glMultiDrawArrays()/glMultiDrawElements(). In OpenGL ES this is implemented in EXT_multi_draw_arrays extension, if it is not available, the functionality is emulated using sequence of normal draw() calls.
12 years ago
}
GL: mesh.draw(shader) -> shader.draw(mesh). As usual, the old APIs are still present, but marked as deprecated. Existing code is not updated yet to ensure I didn't break anything with this. This way it's much more intuitive and makes the code shorter and nicer in many cases. Shaders are now also able to hide irrelevant draw/dispatch APIs to avoid accidents.
6 years ago
#endif
Added support for glMultiDrawArrays()/glMultiDrawElements(). In OpenGL ES this is implemented in EXT_multi_draw_arrays extension, if it is not available, the functionality is emulated using sequence of normal draw() calls.
12 years ago
GL: deprecate MeshView::setIndexRange() in favor of setIndexOffset(). The name was CONFUSING every time I tried to use it.
3 years ago
MeshView& MeshView::setIndexOffset(Int offset) {
CORRADE_ASSERT(_original.get()._indexBuffer.id(),
"GL::MeshView::setIndexOffset(): mesh is not indexed", *this);
GL: deprecate Mesh::indexTypeSize() in favor of meshIndexTypeSize(). Because it makes no sense to only be able to query the index type size on a live mesh.
3 years ago
_indexOffset = _original.get()._indexOffset + offset*meshIndexTypeSize(_original.get().indexType());
GL: mesh.draw(shader) -> shader.draw(mesh). As usual, the old APIs are still present, but marked as deprecated. Existing code is not updated yet to ensure I didn't break anything with this. This way it's much more intuitive and makes the code shorter and nicer in many cases. Shaders are now also able to hide irrelevant draw/dispatch APIs to avoid accidents.
6 years ago
return *this;
GL: taking just an init list in MeshView::draw() was a stupid idea. With just that, it wouldn't be possible to draw a runtime-dependent amount of MeshViews (for example when culling them).
6 years ago
}
GL: mesh.draw(shader) -> shader.draw(mesh). As usual, the old APIs are still present, but marked as deprecated. Existing code is not updated yet to ensure I didn't break anything with this. This way it's much more intuitive and makes the code shorter and nicer in many cases. Shaders are now also able to hide irrelevant draw/dispatch APIs to avoid accidents.
6 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
MeshView& MeshView::draw(AbstractShaderProgram& shader) {
shader.draw(*this);
return *this;
GL: taking just an init list in MeshView::draw() was a stupid idea. With just that, it wouldn't be possible to draw a runtime-dependent amount of MeshViews (for example when culling them).
6 years ago
}
GL: mesh.draw(shader) -> shader.draw(mesh). As usual, the old APIs are still present, but marked as deprecated. Existing code is not updated yet to ensure I didn't break anything with this. This way it's much more intuitive and makes the code shorter and nicer in many cases. Shaders are now also able to hide irrelevant draw/dispatch APIs to avoid accidents.
6 years ago
MeshView& MeshView::draw(AbstractShaderProgram&& shader) {
shader.draw(*this);
return *this;
}
#ifndef MAGNUM_TARGET_GLES
MeshView& MeshView::draw(AbstractShaderProgram& shader, TransformFeedback& xfb, UnsignedInt stream) {
shader.drawTransformFeedback(*this, xfb, stream);
return *this;
}
MeshView& MeshView::draw(AbstractShaderProgram&& shader, TransformFeedback& xfb, UnsignedInt stream) {
shader.drawTransformFeedback(*this, xfb, stream);
return *this;
}
#endif
#endif
GL: use Containers::Iterable also in AbstractShaderProgram::draw(). Forgot about this case in 4ff655740e6fab52783be9ef984683e7d1031395.
4 years ago
void MeshView::multiDrawImplementationDefault(const Containers::Iterable<MeshView>& meshes) {
CORRADE_INTERNAL_ASSERT(!meshes.isEmpty());
Added support for glMultiDrawArrays()/glMultiDrawElements(). In OpenGL ES this is implemented in EXT_multi_draw_arrays extension, if it is not available, the functionality is emulated using sequence of normal draw() calls.
12 years ago
GL: use Containers::Iterable also in AbstractShaderProgram::draw(). Forgot about this case in 4ff655740e6fab52783be9ef984683e7d1031395.
4 years ago
Mesh& original = meshes.front()._original;
Added support for glMultiDrawArrays()/glMultiDrawElements(). In OpenGL ES this is implemented in EXT_multi_draw_arrays extension, if it is not available, the functionality is emulated using sequence of normal draw() calls.
12 years ago
/* Gather the parameters */
GL: AbstractShaderProgram::draw() that takes plain array views. Because a MeshView might not be the best thing to have when you are submitting a batch of thousand draws. It takes a strided array views to allow for more flexibility, but can also detect if the input is already contiguous and use it as-is. UNFORTUNATELY the GL 1.0 legacy still continues to stink and so there has to be a 64-bit-specific overload which is the *actual* variant that doesn't allocate because glMultiDrawElements takes a `void**` for INDEX OFFSETS and it's IN BYTES! Which foolish soul designed such a thing back in the 1860s, I wonder. There's no reason to not have an index offset in elements because all indices have to have the same type ANYWAY. And yes, I wasted about three hours debugging driver crashes because I THOUGHT this parameter takes offset in elements, not bytes. Also note: on 32-bit platforms this depends on latest Corrade with the CORRADE_TARGET_32BIT definition. Spent an embarrassing amount of time wondering why all local builds but Emscripten work.
5 years ago
Containers::ArrayView<UnsignedInt> counts;
Containers::ArrayView<UnsignedInt> vertexOffsets;
Containers::ArrayView<
#ifndef CORRADE_TARGET_32BIT
UnsignedLong
Added support for glMultiDrawArrays()/glMultiDrawElements(). In OpenGL ES this is implemented in EXT_multi_draw_arrays extension, if it is not available, the functionality is emulated using sequence of normal draw() calls.
12 years ago
#else
GL: AbstractShaderProgram::draw() that takes plain array views. Because a MeshView might not be the best thing to have when you are submitting a batch of thousand draws. It takes a strided array views to allow for more flexibility, but can also detect if the input is already contiguous and use it as-is. UNFORTUNATELY the GL 1.0 legacy still continues to stink and so there has to be a 64-bit-specific overload which is the *actual* variant that doesn't allocate because glMultiDrawElements takes a `void**` for INDEX OFFSETS and it's IN BYTES! Which foolish soul designed such a thing back in the 1860s, I wonder. There's no reason to not have an index offset in elements because all indices have to have the same type ANYWAY. And yes, I wasted about three hours debugging driver crashes because I THOUGHT this parameter takes offset in elements, not bytes. Also note: on 32-bit platforms this depends on latest Corrade with the CORRADE_TARGET_32BIT definition. Spent an embarrassing amount of time wondering why all local builds but Emscripten work.
5 years ago
UnsignedInt
Added support for glMultiDrawArrays()/glMultiDrawElements(). In OpenGL ES this is implemented in EXT_multi_draw_arrays extension, if it is not available, the functionality is emulated using sequence of normal draw() calls.
12 years ago
#endif
GL: AbstractShaderProgram::draw() that takes plain array views. Because a MeshView might not be the best thing to have when you are submitting a batch of thousand draws. It takes a strided array views to allow for more flexibility, but can also detect if the input is already contiguous and use it as-is. UNFORTUNATELY the GL 1.0 legacy still continues to stink and so there has to be a 64-bit-specific overload which is the *actual* variant that doesn't allocate because glMultiDrawElements takes a `void**` for INDEX OFFSETS and it's IN BYTES! Which foolish soul designed such a thing back in the 1860s, I wonder. There's no reason to not have an index offset in elements because all indices have to have the same type ANYWAY. And yes, I wasted about three hours debugging driver crashes because I THOUGHT this parameter takes offset in elements, not bytes. Also note: on 32-bit platforms this depends on latest Corrade with the CORRADE_TARGET_32BIT definition. Spent an embarrassing amount of time wondering why all local builds but Emscripten work.
5 years ago
> indexOffsets;
Containers::ArrayTuple data{
{NoInit, meshes.size(), counts},
{NoInit, meshes.size(), vertexOffsets},
{NoInit, meshes.size(), indexOffsets}
};
/* The vertexOffsets array is used for non-indexed meshes or if the base
vertex is specified for any of the meshes */
bool useVertexOffsets = !original.isIndexed();
for(std::size_t i = 0; i != meshes.size(); ++i) {
GL: use Containers::Iterable also in AbstractShaderProgram::draw(). Forgot about this case in 4ff655740e6fab52783be9ef984683e7d1031395.
4 years ago
CORRADE_ASSERT(meshes[i]._instanceCount == 1, "GL::AbstractShaderProgram::draw(): cannot multi-draw instanced meshes", );
GL: AbstractShaderProgram::draw() that takes plain array views. Because a MeshView might not be the best thing to have when you are submitting a batch of thousand draws. It takes a strided array views to allow for more flexibility, but can also detect if the input is already contiguous and use it as-is. UNFORTUNATELY the GL 1.0 legacy still continues to stink and so there has to be a 64-bit-specific overload which is the *actual* variant that doesn't allocate because glMultiDrawElements takes a `void**` for INDEX OFFSETS and it's IN BYTES! Which foolish soul designed such a thing back in the 1860s, I wonder. There's no reason to not have an index offset in elements because all indices have to have the same type ANYWAY. And yes, I wasted about three hours debugging driver crashes because I THOUGHT this parameter takes offset in elements, not bytes. Also note: on 32-bit platforms this depends on latest Corrade with the CORRADE_TARGET_32BIT definition. Spent an embarrassing amount of time wondering why all local builds but Emscripten work.
5 years ago
GL: use Containers::Iterable also in AbstractShaderProgram::draw(). Forgot about this case in 4ff655740e6fab52783be9ef984683e7d1031395.
4 years ago
counts[i] = meshes[i]._count;
vertexOffsets[i] = meshes[i]._baseVertex;
indexOffsets[i] = meshes[i]._indexOffset;
if(meshes[i]._baseVertex) useVertexOffsets = true;
Added support for glMultiDrawArrays()/glMultiDrawElements(). In OpenGL ES this is implemented in EXT_multi_draw_arrays extension, if it is not available, the functionality is emulated using sequence of normal draw() calls.
12 years ago
}
GL: AbstractShaderProgram::draw() that takes plain array views. Because a MeshView might not be the best thing to have when you are submitting a batch of thousand draws. It takes a strided array views to allow for more flexibility, but can also detect if the input is already contiguous and use it as-is. UNFORTUNATELY the GL 1.0 legacy still continues to stink and so there has to be a 64-bit-specific overload which is the *actual* variant that doesn't allocate because glMultiDrawElements takes a `void**` for INDEX OFFSETS and it's IN BYTES! Which foolish soul designed such a thing back in the 1860s, I wonder. There's no reason to not have an index offset in elements because all indices have to have the same type ANYWAY. And yes, I wasted about three hours debugging driver crashes because I THOUGHT this parameter takes offset in elements, not bytes. Also note: on 32-bit platforms this depends on latest Corrade with the CORRADE_TARGET_32BIT definition. Spent an embarrassing amount of time wondering why all local builds but Emscripten work.
5 years ago
original.drawInternal(counts, useVertexOffsets ? vertexOffsets : nullptr, indexOffsets);
Added support for glMultiDrawArrays()/glMultiDrawElements(). In OpenGL ES this is implemented in EXT_multi_draw_arrays extension, if it is not available, the functionality is emulated using sequence of normal draw() calls.
12 years ago
}
#ifdef MAGNUM_TARGET_GLES
GL: use Containers::Iterable also in AbstractShaderProgram::draw(). Forgot about this case in 4ff655740e6fab52783be9ef984683e7d1031395.
4 years ago
void MeshView::multiDrawImplementationFallback(const Containers::Iterable<MeshView>& meshes) {
Added support for glMultiDrawArrays()/glMultiDrawElements(). In OpenGL ES this is implemented in EXT_multi_draw_arrays extension, if it is not available, the functionality is emulated using sequence of normal draw() calls.
12 years ago
for(MeshView& mesh: meshes) {
Check for mesh emptiness even before binding the shader. Prevents unnecessary state touching.
10 years ago
/* Nothing to draw in this mesh */
if(!mesh._count) continue;
GL: clarify an assert. "Cannot draw multiple instanced meshes." is no better than "SOMETHING WENT WRONG PLEASE SHRED YOUR APPLE DEVICE."
5 years ago
CORRADE_ASSERT(mesh._instanceCount == 1, "GL::AbstractShaderProgram::draw(): cannot multi-draw instanced meshes", );
Properly handle instance count in the fallback multi draw implementation.
10 years ago
Added support for glMultiDrawArrays()/glMultiDrawElements(). In OpenGL ES this is implemented in EXT_multi_draw_arrays extension, if it is not available, the functionality is emulated using sequence of normal draw() calls.
12 years ago
#ifndef MAGNUM_TARGET_GLES2
GL: implement the base instance and base vertex ES and WebGL extensions. AAAAAAAAAAAAAAAAAAAAAAAAAAAAA this was terrible! Why the hell it needs to have so many variants, special cases and exceptions!!!
5 years ago
mesh._original.get().drawInternal(mesh._count, mesh._baseVertex, 1, mesh._baseInstance, mesh._indexOffset, mesh._indexStart, mesh._indexEnd);
Added support for glMultiDrawArrays()/glMultiDrawElements(). In OpenGL ES this is implemented in EXT_multi_draw_arrays extension, if it is not available, the functionality is emulated using sequence of normal draw() calls.
12 years ago
#else
Properly handle instance count in the fallback multi draw implementation.
10 years ago
mesh._original.get().drawInternal(mesh._count, mesh._baseVertex, 1, mesh._indexOffset);
Added support for glMultiDrawArrays()/glMultiDrawElements(). In OpenGL ES this is implemented in EXT_multi_draw_arrays extension, if it is not available, the functionality is emulated using sequence of normal draw() calls.
12 years ago
#endif
}
}
#endif
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
}}