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.
9088 Commits
21 Branches
19 Tags
70 MiB
Tree: 86d78aba10
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '86d78aba10'
${ noResults }
magnum/src/Magnum/GL/Test/MeshGLTest.cpp

4182 lines
158 KiB
Raw Normal View History Unescape

Support for object labels from KHR_debug and EXT_debug_label. Can't test EXT_debug_label, as that is apparently OSX 10.9-only. Added GL tests for all implemented objects. KHR_debug is selected first, if that is not available, fall back to EXT_debug_label. If neither is available, the functions are no-op. I hope EXT_debug_label gets replaced by KHR_debug later, thus it is now only "emulated" through KHR_debug enums.
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,
Updated copyright year.
5 years ago
2020, 2021 Vladimír Vondruš <mosra@centrum.cz>
Support for object labels from KHR_debug and EXT_debug_label. Can't test EXT_debug_label, as that is apparently OSX 10.9-only. Added GL tests for all implemented objects. KHR_debug is selected first, if that is not available, fall back to EXT_debug_label. If neither is available, the functions are no-op. I hope EXT_debug_label gets replaced by KHR_debug later, thus it is now only "emulated" through KHR_debug enums.
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.
*/
GL: assert that addVertexBuffer() is called with a valid Buffer.
8 years ago
#include <sstream>
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
#include <Corrade/Containers/StridedArrayView.h>
#include <Corrade/TestSuite/Compare/Numeric.h>
Adapted to Corrade changes. Mostly missing includes now.
7 years ago
#include <Corrade/Utility/DebugStl.h>
GL: improve message for the common mesh assert in multi-draw. In my case I was using a dangling MeshView reference there, and it was hard to debug without these.
5 years ago
#include <Corrade/Utility/FormatStl.h>
GL: assert that addVertexBuffer() is called with a valid Buffer.
8 years ago
Making includes absolute, part 5: absolute includes everywhere. The only places where they aren't absolute are: - when header is included from corresponding source file - when including headers which are not part of final installation (e.g. test-specific configuration, headers from Implementation/)
12 years ago
#include "Magnum/Image.h"
#include "Magnum/Mesh.h"
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
#include "Magnum/GL/AbstractShaderProgram.h"
#include "Magnum/GL/Buffer.h"
#include "Magnum/GL/Context.h"
#include "Magnum/GL/Extensions.h"
#include "Magnum/GL/Framebuffer.h"
#include "Magnum/GL/Mesh.h"
#include "Magnum/GL/MeshView.h"
#include "Magnum/GL/OpenGLTester.h"
#include "Magnum/GL/PixelFormat.h"
#include "Magnum/GL/Renderbuffer.h"
#include "Magnum/GL/RenderbufferFormat.h"
#include "Magnum/GL/Shader.h"
Moved Color to Math namespace. Apart from different include (<Magnum/Math/Color.h> instead of <Magnum/Color.h>) there shouldn't be any visible change to the user. The BasicColor3 and BasicColor4 classes are now Math::Color3 and Math::Color4. The Color3, Color4, Color3ub and Color4ub typedefs in Magnum namespace stayed the same. BasicColor3 and BasicColor4 is now an alias to Math::Color3 and Math::Color4, is marked as deprecated and will be removed in future release. The same goes for the <Magnum/Color.h> include, which now just includes the <Magnum/Math/Color.h> header.
11 years ago
#include "Magnum/Math/Color.h"
Test: we have halves now, so why not test them.
9 years ago
#include "Magnum/Math/Half.h"
Making includes absolute, part 5: absolute includes everywhere. The only places where they aren't absolute are: - when header is included from corresponding source file - when including headers which are not part of final installation (e.g. test-specific configuration, headers from Implementation/)
12 years ago
#include "Magnum/Math/Matrix.h"
#include "Magnum/Math/Vector4.h"
Support for object labels from KHR_debug and EXT_debug_label. Can't test EXT_debug_label, as that is apparently OSX 10.9-only. Added GL tests for all implemented objects. KHR_debug is selected first, if that is not available, fall back to EXT_debug_label. If neither is available, the functions are no-op. I hope EXT_debug_label gets replaced by KHR_debug later, thus it is now only "emulated" through KHR_debug enums.
13 years ago
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
namespace Magnum { namespace GL { namespace Test { namespace {
Support for object labels from KHR_debug and EXT_debug_label. Can't test EXT_debug_label, as that is apparently OSX 10.9-only. Added GL tests for all implemented objects. KHR_debug is selected first, if that is not available, fall back to EXT_debug_label. If neither is available, the functions are no-op. I hope EXT_debug_label gets replaced by KHR_debug later, thus it is now only "emulated" through KHR_debug enums.
13 years ago
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
/* Tests also the MeshView class. */
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Made Test/AbstractOpenGLTester.h a public and documented API. There will be numerous additions to this one so it made sense to make it a static library instead of a header-only library. That also allows CMake users to just link to Magnum::OpenGLTester instead of going through the pain of a huge branching in order to find a correct windowless application just to run their tests. It could have been done even without the static library using a INTERFACE target, but that wouldn't work on CMake < 3.0 (which, unfortunately, quite a few people are still stuck with). Unfortunately it's already heavily used elsewhere so I had to go through the pain of deprecating the old implementation. The old implementation was header-only so it can't be just typedef'd to the new one as there would be linker failures. So the old header is just kept as it was, with only the macros reduced.
9 years ago
struct MeshGLTest: OpenGLTester {
Making test declarations more compact. Yet again I experienced how insanely large this thing got over the years.
11 years ago
explicit MeshGLTest();
void construct();
void constructMove();
Ability to wrap and release existing OpenGL objects. Allows for better interaction with third-party libraries. I should probably write a new documentation page about OpenGL wrapping.
11 years ago
void wrap();
Making test declarations more compact. Yet again I experienced how insanely large this thing got over the years.
11 years ago
Split the OpenGL layer out, pt 11: generic MeshPrimitive and MeshIndexType. Similarly to pixel formats, there is now generic Magnum::MeshPrimitive and Magnum::MeshIndexType, which is convertible to GL::MeshPrimitive and GL::MeshIndexType using GL::meshPrimitive() and GL::meshIndexType(). In addition, the following is done: * The original GL::Mesh::IndexType is now GL::MeshIndexType, original name is now just a typedef. * GL::Mesh::indexSize() is deprecated in favor of Magnum::meshIndexTypeSize() and GL::Mesh::indexTypeSize(). * New GL::Mesh::indexType() and GL::MeshView::mesh() getters (not sure why they were omitted) * GL::Mesh::indexType(), GL::Mesh::indexTypeSize(), GL::MeshView::setIndexRange() now expect that the mesh is indexed (useful property in my opinion, also avoids getting random results). * The extra MeshPrimitive::LinesAdjacency etc. are still present for backwards compatibility, but marked as deprecated. Use GL::MeshPrimitive values instead.
8 years ago
template<class T> void primitive();
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#ifndef MAGNUM_TARGET_WEBGL
Making test declarations more compact. Yet again I experienced how insanely large this thing got over the years.
11 years ago
void label();
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#endif
Making test declarations more compact. Yet again I experienced how insanely large this thing got over the years.
11 years ago
#ifndef MAGNUM_TARGET_GLES2
void addVertexBufferUnsignedInt();
void addVertexBufferInt();
#endif
void addVertexBufferFloat();
#ifndef MAGNUM_TARGET_GLES
void addVertexBufferDouble();
#endif
#ifndef MAGNUM_TARGET_GLES2
void addVertexBufferVectorNui();
void addVertexBufferVectorNi();
#endif
void addVertexBufferVectorN();
#ifndef MAGNUM_TARGET_GLES
void addVertexBufferVectorNd();
#endif
void addVertexBufferMatrixNxN();
#ifndef MAGNUM_TARGET_GLES
void addVertexBufferMatrixNxNd();
#endif
#ifndef MAGNUM_TARGET_GLES2
void addVertexBufferMatrixMxN();
#endif
#ifndef MAGNUM_TARGET_GLES
void addVertexBufferMatrixMxNd();
#endif
#ifndef MAGNUM_TARGET_GLES2
void addVertexBufferUnsignedIntWithUnsignedShort();
void addVertexBufferUnsignedIntWithShort();
void addVertexBufferIntWithUnsignedShort();
void addVertexBufferIntWithShort();
#endif
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2))
Making test declarations more compact. Yet again I experienced how insanely large this thing got over the years.
11 years ago
/* Other Float types omitted (covered by addVertexBufferNormalized()) */
GL: rename PixelType::HalfFloat and Attribute::DataType::HalfFloat to Half. For consistency with the Half type we use elsewhere. The old enums are still available, but deprecated and scheduled for removal.
6 years ago
void addVertexBufferFloatWithHalf();
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#endif
Making test declarations more compact. Yet again I experienced how insanely large this thing got over the years.
11 years ago
#ifndef MAGNUM_TARGET_GLES
void addVertexBufferFloatWithDouble();
void addVertexBufferVector3WithUnsignedInt10f11f11fRev();
#endif
#ifndef MAGNUM_TARGET_GLES2
void addVertexBufferVector4WithUnsignedInt2101010Rev();
void addVertexBufferVector4WithInt2101010Rev();
#endif
void addVertexBufferLessVectorComponents();
void addVertexBufferNormalized();
#ifndef MAGNUM_TARGET_GLES
void addVertexBufferBGRA();
#endif
void addVertexBufferMultiple();
void addVertexBufferMultipleGaps();
GL: assert that addVertexBuffer() is called with a valid Buffer.
8 years ago
void addVertexBufferMovedOutInstance();
GL: make it possible for a Mesh to own the vertex/index buffers. I wanted to do this since 2015.
8 years ago
void addVertexBufferTransferOwnwership();
void addVertexBufferInstancedTransferOwnwership();
void addVertexBufferDynamicTransferOwnwership();
void addVertexBufferInstancedDynamicTransferOwnwership();
GL: assert that addVertexBuffer() is called with a valid Buffer.
8 years ago
Split the OpenGL layer out, pt 11: generic MeshPrimitive and MeshIndexType. Similarly to pixel formats, there is now generic Magnum::MeshPrimitive and Magnum::MeshIndexType, which is convertible to GL::MeshPrimitive and GL::MeshIndexType using GL::meshPrimitive() and GL::meshIndexType(). In addition, the following is done: * The original GL::Mesh::IndexType is now GL::MeshIndexType, original name is now just a typedef. * GL::Mesh::indexSize() is deprecated in favor of Magnum::meshIndexTypeSize() and GL::Mesh::indexTypeSize(). * New GL::Mesh::indexType() and GL::MeshView::mesh() getters (not sure why they were omitted) * GL::Mesh::indexType(), GL::Mesh::indexTypeSize(), GL::MeshView::setIndexRange() now expect that the mesh is indexed (useful property in my opinion, also avoids getting random results). * The extra MeshPrimitive::LinesAdjacency etc. are still present for backwards compatibility, but marked as deprecated. Use GL::MeshPrimitive values instead.
8 years ago
template<class T> void setIndexBuffer();
template<class T> void setIndexBufferRange();
Making test declarations more compact. Yet again I experienced how insanely large this thing got over the years.
11 years ago
void setIndexBufferUnsignedInt();
GL: assert that addVertexBuffer() is called with a valid Buffer.
8 years ago
void setIndexBufferMovedOutInstance();
GL: make it possible for a Mesh to own the vertex/index buffers. I wanted to do this since 2015.
8 years ago
template<class T> void setIndexBufferTransferOwnership();
template<class T> void setIndexBufferRangeTransferOwnership();
GL: assert that addVertexBuffer() is called with a valid Buffer.
8 years ago
Test that binding index buffer internally doesn't affect bound VAOs. Fails. Problem spotted on WebGL 2 and is an unfortunate consequence of these events: 1. Neither EXT_DSA nor ARB_DSA is available, but VAOs are available, which means virtually all ES 3 and WebGL 2 implementations and also ES 2 / WebGL 1 with OES_VAO available. 2. Index buffer gets created with TargetHint::ElementArray, bound to GL_ELEMENT_ARRAY_BUFFER and filled with data. 3. Mesh object with VAO inside is created and the index buffer from above gets bound to GL_ELEMENT_ARRAY_BUFFER again to attach it to the VAO. 4. Another index buffer, possibly for another mesh, gets created with TargetHint::ElementArray and bound to GL_ELEMENT_ARRAY_BUFFER in order to be filled with data. But because the VAO from above is still bound, the index buffer attachment is then stomped on. 5. Rendering such mesh will use a different index buffer, most probably causing some out-of-range GL error and nothing rendered.
9 years ago
void unbindVAOWhenSettingIndexBufferData();
GL: test yet another interaction of VAOs and index buffer binding. Fails (well, why else would I be adding the test, right?).
7 years ago
void unbindIndexBufferWhenBindingVao();
GL: further harden VAO and index buffer binding state interaction tests. This one crashes. Turns out the 169031fb7bf30e2c98c81cbf865aa5a4662aa716 contained a random temporary test state instead of the real solution (and so the comment didn't even match the code, it should have been resetting that to 0). That also made some tests fail with DSA disabled, but none of the tests were actual Mesh tests, just accidentally hitting the problematic code path. I took the opportunity to look at this more closely and investigate *why* this failed -- turns out, in setIndexBuffer(), I was resetting the state tracker to a VAO state that was about to be set in the very next step, and then, when doing that next step the state tracker "optimized away" the state change because it thought it was already done (even though it wasn't). The new test in MeshGLTest covers this particular case.
7 years ago
void resetIndexBufferBindingWhenBindingVao();
Improve state tracker resetting functionality.
8 years ago
void unbindVAOBeforeEnteringExternalSection();
GL: make it possible to bind a scratch VAO for external GL code. Used in those sad and unfortunate cases where we need to call shitty external GL code that's not VAO-aware.
8 years ago
void bindScratchVaoWhenEnteringExternalSection();
Test that binding index buffer internally doesn't affect bound VAOs. Fails. Problem spotted on WebGL 2 and is an unfortunate consequence of these events: 1. Neither EXT_DSA nor ARB_DSA is available, but VAOs are available, which means virtually all ES 3 and WebGL 2 implementations and also ES 2 / WebGL 1 with OES_VAO available. 2. Index buffer gets created with TargetHint::ElementArray, bound to GL_ELEMENT_ARRAY_BUFFER and filled with data. 3. Mesh object with VAO inside is created and the index buffer from above gets bound to GL_ELEMENT_ARRAY_BUFFER again to attach it to the VAO. 4. Another index buffer, possibly for another mesh, gets created with TargetHint::ElementArray and bound to GL_ELEMENT_ARRAY_BUFFER in order to be filled with data. But because the VAO from above is still bound, the index buffer attachment is then stomped on. 5. Rendering such mesh will use a different index buffer, most probably causing some out-of-range GL error and nothing rendered.
9 years ago
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
#if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2))
Making test declarations more compact. Yet again I experienced how insanely large this thing got over the years.
11 years ago
void setBaseVertex();
#endif
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
#ifdef MAGNUM_TARGET_GLES
void setBaseVertexNoExtensionAvailable();
void setBaseVertexRangeNoExtensionAvailable();
#endif
Making test declarations more compact. Yet again I experienced how insanely large this thing got over the years.
11 years ago
void setInstanceCount();
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
#ifndef MAGNUM_TARGET_GLES2
Making test declarations more compact. Yet again I experienced how insanely large this thing got over the years.
11 years ago
void setInstanceCountBaseInstance();
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
#ifdef MAGNUM_TARGET_GLES
void setInstanceCountBaseInstanceNoExtensionAvailable();
#endif
#endif
void setInstanceCountIndexed();
#ifndef MAGNUM_TARGET_GLES2
void setInstanceCountIndexedBaseInstance();
#ifdef MAGNUM_TARGET_GLES
void setInstanceCountIndexedBaseInstanceNoExtensionAvailable();
#endif
#endif
#ifndef MAGNUM_TARGET_GLES2
void setInstanceCountIndexedBaseVertex();
#endif
#ifdef MAGNUM_TARGET_GLES
void setInstanceCountIndexedBaseVertexNoExtensionAvailable();
#endif
#ifndef MAGNUM_TARGET_GLES2
void setInstanceCountIndexedBaseVertexBaseInstance();
#ifdef MAGNUM_TARGET_GLES
void setInstanceCountIndexedBaseVertexBaseInstanceNoExtensionAvailable();
#endif
Making test declarations more compact. Yet again I experienced how insanely large this thing got over the years.
11 years ago
#endif
void addVertexBufferInstancedFloat();
#ifndef MAGNUM_TARGET_GLES2
void addVertexBufferInstancedInteger();
#endif
#ifndef MAGNUM_TARGET_GLES
void addVertexBufferInstancedDouble();
#endif
GL: test that vertex attrib divisor is properly reset when not using VAOs. Fails, because it's not. Fix in next commit.
8 years ago
void resetDivisorAfterInstancedDraw();
Making test declarations more compact. Yet again I experienced how insanely large this thing got over the years.
11 years ago
void multiDraw();
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
void multiDrawSparseArrays();
void multiDrawViews();
Making test declarations more compact. Yet again I experienced how insanely large this thing got over the years.
11 years ago
void multiDrawIndexed();
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
void multiDrawIndexedSparseArrays();
void multiDrawIndexedViews();
void multiDrawWrongVertexOffsetSize();
void multiDrawIndexedWrongIndexOffsetSize();
void multiDrawIndexedWrongVertexOffsetSize();
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
#ifdef MAGNUM_TARGET_GLES
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
void multiDrawIndexedBaseVertexNoExtensionAvailable();
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
void multiDrawIndexedViewsBaseVertexNoExtensionAvailable();
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
#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
void multiDrawInstancedViews();
void multiDrawViewsDifferentMeshes();
Support for object labels from KHR_debug and EXT_debug_label. Can't test EXT_debug_label, as that is apparently OSX 10.9-only. Added GL tests for all implemented objects. KHR_debug is selected first, if that is not available, fall back to EXT_debug_label. If neither is available, the functions are no-op. I hope EXT_debug_label gets replaced by KHR_debug later, thus it is now only "emulated" through KHR_debug enums.
13 years ago
};
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
const struct {
const char* name;
bool vertexId;
bool drawId;
Vector4 values[4];
UnsignedInt counts[4];
UnsignedInt vertexOffsets[4];
Vector4 expected;
} MultiDrawData[] {
{"all skipped", false, false,
{{0.25f, 0.0f, 0.0f, 0.0f},
{0.5f, 0.0f, 0.0f, 0.0f},
{0.75f, 0.0f, 0.0f, 0.0f},
{1.0f, 0.0f, 0.0f, 0.0f}},
{0, 0, 0, 0},
{0, 0, 0, 0},
{0.0f, 0.0f, 0.0f, 0.0f}},
{"single draw", false, false,
{{0.25f, 0.0f, 0.0f, 0.0f},
{0.5f, 0.0f, 0.0f, 0.0f},
{0.75f, 0.0f, 0.0f, 0.0f},
{1.0f, 0.0f, 0.0f, 0.0f}},
{4, 0, 0, 0},
{0, 0, 0, 0},
{0.25f, 0.5f, 0.75f, 1.0f}},
#ifndef MAGNUM_TARGET_GLES2
{"single draw, vertex ID", true, false,
{{0.25f, 0.0f, 0.0f, 0.0f},
{0.0f, 0.5f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.75f, 0.0f},
{0.0f, 0.0f, 0.0f, 1.0f}},
{4, 0, 0, 0},
{0, 0, 0, 0},
{0.25f, 0.5f, 0.75f, 1.0f}},
#endif
{"single draw, draw ID", false, true,
{{0.25f, 0.0f, 0.0f, 0.0f},
{0.5f, 0.0f, 0.0f, 0.0f},
{0.75f, 0.0f, 0.0f, 0.0f},
{1.0f, 0.0f, 0.0f, 0.0f}},
{4, 0, 0, 0},
{0, 0, 0, 0},
{0.25f, 0.5f, 0.75f, 1.0f}},
{"multi draw", false, false,
{{0.25f, 0.0f, 0.0f, 0.0f},
{0.5f, 0.0f, 0.0f, 0.0f},
{0.75f, 0.0f, 0.0f, 0.0f},
{1.0f, 0.0f, 0.0f, 0.0f}},
{1, 1, 1, 1},
{0, 1, 2, 3},
{0.25f, 0.5f, 0.75f, 1.0f}},
#ifndef MAGNUM_TARGET_GLES2
{"multi draw, vertex ID", true, false,
/* Interestingly enough, the gl_VertexID includes the vertexOffset
(or the `first` parameter in glDrawArrays / glMultiDrawArrays). */
{{0.25f, 0.0f, 0.0f, 0.0f},
{0.0f, 0.5f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.75f, 0.0f},
{0.0f, 0.0f, 0.0f, 1.0f}},
{1, 1, 1, 1},
{0, 1, 2, 3},
{0.25f, 0.5f, 0.75f, 1.0f}},
#endif
{"multi draw, draw ID", false, true,
{{0.25f, 0.0f, 0.0f, 0.0f},
{0.0f, 0.5f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.75f, 0.0f},
{0.0f, 0.0f, 0.0f, 1.0f}},
{1, 1, 1, 1},
{0, 1, 2, 3},
{0.25f, 0.5f, 0.75f, 1.0f}},
{"multi draw, random order, one skipped", false, false,
{{0.25f, 0.0f, 0.0f, 0.0f},
{0.5f, 0.0f, 0.0f, 0.0f},
{0.75f, 0.0f, 0.0f, 0.0f},
{1.0f, 0.0f, 0.0f, 0.0f}},
{1, 0, 1, 1},
{1, 0, 3, 2},
/* The positions are fixed so this still renders in the same order */
{0.0f, 0.5f, 0.75f, 1.0f}},
};
const struct {
const char* name;
bool vertexId;
Vector4 values[4];
UnsignedInt indices[4];
UnsignedInt counts[4];
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
#ifdef CORRADE_TARGET_32BIT
UnsignedInt
#else
UnsignedLong
#endif
indexOffsetsInBytes[4];
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
UnsignedInt vertexOffsets[4];
Vector4 expected;
} MultiDrawIndexedData[] {
{"single draw", false,
{{0.25f, 0.0f, 0.0f, 0.0f},
{0.5f, 0.0f, 0.0f, 0.0f},
{0.75f, 0.0f, 0.0f, 0.0f},
{1.0f, 0.0f, 0.0f, 0.0f}},
{0, 1, 2, 3},
{4, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 0},
{0.25f, 0.5f, 0.75f, 1.0f}},
{"multi draw", false,
{{0.25f, 0.0f, 0.0f, 0.0f},
{0.5f, 0.0f, 0.0f, 0.0f},
{0.75f, 0.0f, 0.0f, 0.0f},
{1.0f, 0.0f, 0.0f, 0.0f}},
{0, 1, 2, 3},
{1, 1, 1, 1},
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
{0, 4, 8, 12},
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
{0, 0, 0, 0},
{0.25f, 0.5f, 0.75f, 1.0f}},
#if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2))
{"multi draw, base vertex", false,
{{0.25f, 0.0f, 0.0f, 0.0f},
{0.5f, 0.0f, 0.0f, 0.0f},
{0.75f, 0.0f, 0.0f, 0.0f},
{1.0f, 0.0f, 0.0f, 0.0f}},
{0, 1, 0, 1},
{1, 1, 1, 1},
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
{0, 4, 8, 12},
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
{0, 0, 2, 2},
{0.25f, 0.5f, 0.75f, 1.0f}},
#ifndef MAGNUM_TARGET_GLES2
{"multi draw, base vertex, vertex ID", true,
/* Same as in the non-indexed case, gl_VertexID includes the baseVertex
as well */
{{0.25f, 0.0f, 0.0f, 0.0f},
{0.0f, 0.5f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.75f, 0.0f},
{0.0f, 0.0f, 0.0f, 1.0f}},
{0, 1, 0, 1},
{1, 1, 1, 1},
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
{0, 4, 8, 12},
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
{0, 0, 2, 2},
{0.25f, 0.5f, 0.75f, 1.0f}},
#endif
#endif
{"multi draw, random index order & offset, one skipped", false,
{{0.25f, 0.0f, 0.0f, 0.0f},
{0.5f, 0.0f, 0.0f, 0.0f},
{0.75f, 0.0f, 0.0f, 0.0f},
{1.0f, 0.0f, 0.0f, 0.0f}},
{5, 1, 0, 3},
{1, 0, 1, 1},
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
{12, 0, 8, 4},
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
{0, 0, 0, 0},
/* The positions are fixed so this still renders in the same order */
{0.25f, 0.5f, 0.0f, 1.0f}}
};
using namespace Math::Literals;
Support for object labels from KHR_debug and EXT_debug_label. Can't test EXT_debug_label, as that is apparently OSX 10.9-only. Added GL tests for all implemented objects. KHR_debug is selected first, if that is not available, fall back to EXT_debug_label. If neither is available, the functions are no-op. I hope EXT_debug_label gets replaced by KHR_debug later, thus it is now only "emulated" through KHR_debug enums.
13 years ago
MeshGLTest::MeshGLTest() {
Testing Mesh move constructor and assignment.
13 years ago
addTests({&MeshGLTest::construct,
&MeshGLTest::constructMove,
Ability to wrap and release existing OpenGL objects. Allows for better interaction with third-party libraries. I should probably write a new documentation page about OpenGL wrapping.
11 years ago
&MeshGLTest::wrap,
Testing Mesh move constructor and assignment.
13 years ago
Split the OpenGL layer out, pt 11: generic MeshPrimitive and MeshIndexType. Similarly to pixel formats, there is now generic Magnum::MeshPrimitive and Magnum::MeshIndexType, which is convertible to GL::MeshPrimitive and GL::MeshIndexType using GL::meshPrimitive() and GL::meshIndexType(). In addition, the following is done: * The original GL::Mesh::IndexType is now GL::MeshIndexType, original name is now just a typedef. * GL::Mesh::indexSize() is deprecated in favor of Magnum::meshIndexTypeSize() and GL::Mesh::indexTypeSize(). * New GL::Mesh::indexType() and GL::MeshView::mesh() getters (not sure why they were omitted) * GL::Mesh::indexType(), GL::Mesh::indexTypeSize(), GL::MeshView::setIndexRange() now expect that the mesh is indexed (useful property in my opinion, also avoids getting random results). * The extra MeshPrimitive::LinesAdjacency etc. are still present for backwards compatibility, but marked as deprecated. Use GL::MeshPrimitive values instead.
8 years ago
&MeshGLTest::primitive<GL::MeshPrimitive>,
&MeshGLTest::primitive<Magnum::MeshPrimitive>,
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#ifndef MAGNUM_TARGET_WEBGL
&MeshGLTest::label
#endif
});
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
/* First instance is always using Attribute, second DynamicAttribute */
addInstancedTests({
#ifndef MAGNUM_TARGET_GLES2
&MeshGLTest::addVertexBufferUnsignedInt,
&MeshGLTest::addVertexBufferInt,
#endif
&MeshGLTest::addVertexBufferFloat,
#ifndef MAGNUM_TARGET_GLES
&MeshGLTest::addVertexBufferDouble,
#endif
#ifndef MAGNUM_TARGET_GLES2
&MeshGLTest::addVertexBufferVectorNui,
&MeshGLTest::addVertexBufferVectorNi,
#endif
&MeshGLTest::addVertexBufferVectorN,
#ifndef MAGNUM_TARGET_GLES
&MeshGLTest::addVertexBufferVectorNd,
#endif
&MeshGLTest::addVertexBufferMatrixNxN,
#ifndef MAGNUM_TARGET_GLES
&MeshGLTest::addVertexBufferMatrixNxNd,
#endif
#ifndef MAGNUM_TARGET_GLES2
&MeshGLTest::addVertexBufferMatrixMxN,
#endif
#ifndef MAGNUM_TARGET_GLES
&MeshGLTest::addVertexBufferMatrixMxNd,
#endif
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
#ifndef MAGNUM_TARGET_GLES2
&MeshGLTest::addVertexBufferUnsignedIntWithUnsignedShort,
&MeshGLTest::addVertexBufferUnsignedIntWithShort,
&MeshGLTest::addVertexBufferIntWithUnsignedShort,
&MeshGLTest::addVertexBufferIntWithShort,
#endif
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2))
GL: rename PixelType::HalfFloat and Attribute::DataType::HalfFloat to Half. For consistency with the Half type we use elsewhere. The old enums are still available, but deprecated and scheduled for removal.
6 years ago
&MeshGLTest::addVertexBufferFloatWithHalf,
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#endif
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
#ifndef MAGNUM_TARGET_GLES
&MeshGLTest::addVertexBufferFloatWithDouble,
&MeshGLTest::addVertexBufferVector3WithUnsignedInt10f11f11fRev,
#endif
#ifndef MAGNUM_TARGET_GLES2
&MeshGLTest::addVertexBufferVector4WithUnsignedInt2101010Rev,
&MeshGLTest::addVertexBufferVector4WithInt2101010Rev,
#endif
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
&MeshGLTest::addVertexBufferLessVectorComponents,
&MeshGLTest::addVertexBufferNormalized,
#ifndef MAGNUM_TARGET_GLES
&MeshGLTest::addVertexBufferBGRA
#endif
}, 2);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
addTests({&MeshGLTest::addVertexBufferMultiple,
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
&MeshGLTest::addVertexBufferMultipleGaps,
GL: assert that addVertexBuffer() is called with a valid Buffer.
8 years ago
&MeshGLTest::addVertexBufferMovedOutInstance,
GL: make it possible for a Mesh to own the vertex/index buffers. I wanted to do this since 2015.
8 years ago
&MeshGLTest::addVertexBufferTransferOwnwership,
&MeshGLTest::addVertexBufferInstancedTransferOwnwership,
&MeshGLTest::addVertexBufferDynamicTransferOwnwership,
&MeshGLTest::addVertexBufferInstancedDynamicTransferOwnwership,
GL: assert that addVertexBuffer() is called with a valid Buffer.
8 years ago
Split the OpenGL layer out, pt 11: generic MeshPrimitive and MeshIndexType. Similarly to pixel formats, there is now generic Magnum::MeshPrimitive and Magnum::MeshIndexType, which is convertible to GL::MeshPrimitive and GL::MeshIndexType using GL::meshPrimitive() and GL::meshIndexType(). In addition, the following is done: * The original GL::Mesh::IndexType is now GL::MeshIndexType, original name is now just a typedef. * GL::Mesh::indexSize() is deprecated in favor of Magnum::meshIndexTypeSize() and GL::Mesh::indexTypeSize(). * New GL::Mesh::indexType() and GL::MeshView::mesh() getters (not sure why they were omitted) * GL::Mesh::indexType(), GL::Mesh::indexTypeSize(), GL::MeshView::setIndexRange() now expect that the mesh is indexed (useful property in my opinion, also avoids getting random results). * The extra MeshPrimitive::LinesAdjacency etc. are still present for backwards compatibility, but marked as deprecated. Use GL::MeshPrimitive values instead.
8 years ago
&MeshGLTest::setIndexBuffer<GL::MeshIndexType>,
&MeshGLTest::setIndexBuffer<Magnum::MeshIndexType>,
&MeshGLTest::setIndexBufferRange<GL::MeshIndexType>,
&MeshGLTest::setIndexBufferRange<Magnum::MeshIndexType>,
Added test for mesh base vertex.
12 years ago
&MeshGLTest::setIndexBufferUnsignedInt,
GL: assert that addVertexBuffer() is called with a valid Buffer.
8 years ago
&MeshGLTest::setIndexBufferMovedOutInstance,
GL: make it possible for a Mesh to own the vertex/index buffers. I wanted to do this since 2015.
8 years ago
&MeshGLTest::setIndexBufferTransferOwnership<GL::MeshIndexType>,
&MeshGLTest::setIndexBufferTransferOwnership<Magnum::MeshIndexType>,
&MeshGLTest::setIndexBufferRangeTransferOwnership<GL::MeshIndexType>,
&MeshGLTest::setIndexBufferRangeTransferOwnership<Magnum::MeshIndexType>,
GL: assert that addVertexBuffer() is called with a valid Buffer.
8 years ago
Test that binding index buffer internally doesn't affect bound VAOs. Fails. Problem spotted on WebGL 2 and is an unfortunate consequence of these events: 1. Neither EXT_DSA nor ARB_DSA is available, but VAOs are available, which means virtually all ES 3 and WebGL 2 implementations and also ES 2 / WebGL 1 with OES_VAO available. 2. Index buffer gets created with TargetHint::ElementArray, bound to GL_ELEMENT_ARRAY_BUFFER and filled with data. 3. Mesh object with VAO inside is created and the index buffer from above gets bound to GL_ELEMENT_ARRAY_BUFFER again to attach it to the VAO. 4. Another index buffer, possibly for another mesh, gets created with TargetHint::ElementArray and bound to GL_ELEMENT_ARRAY_BUFFER in order to be filled with data. But because the VAO from above is still bound, the index buffer attachment is then stomped on. 5. Rendering such mesh will use a different index buffer, most probably causing some out-of-range GL error and nothing rendered.
9 years ago
&MeshGLTest::unbindVAOWhenSettingIndexBufferData,
GL: test yet another interaction of VAOs and index buffer binding. Fails (well, why else would I be adding the test, right?).
7 years ago
&MeshGLTest::unbindIndexBufferWhenBindingVao,
GL: further harden VAO and index buffer binding state interaction tests. This one crashes. Turns out the 169031fb7bf30e2c98c81cbf865aa5a4662aa716 contained a random temporary test state instead of the real solution (and so the comment didn't even match the code, it should have been resetting that to 0). That also made some tests fail with DSA disabled, but none of the tests were actual Mesh tests, just accidentally hitting the problematic code path. I took the opportunity to look at this more closely and investigate *why* this failed -- turns out, in setIndexBuffer(), I was resetting the state tracker to a VAO state that was about to be set in the very next step, and then, when doing that next step the state tracker "optimized away" the state change because it thought it was already done (even though it wasn't). The new test in MeshGLTest covers this particular case.
7 years ago
&MeshGLTest::resetIndexBufferBindingWhenBindingVao,
Improve state tracker resetting functionality.
8 years ago
&MeshGLTest::unbindVAOBeforeEnteringExternalSection,
GL: make it possible to bind a scratch VAO for external GL code. Used in those sad and unfortunate cases where we need to call shitty external GL code that's not VAO-aware.
8 years ago
&MeshGLTest::bindScratchVaoWhenEnteringExternalSection,
Test that binding index buffer internally doesn't affect bound VAOs. Fails. Problem spotted on WebGL 2 and is an unfortunate consequence of these events: 1. Neither EXT_DSA nor ARB_DSA is available, but VAOs are available, which means virtually all ES 3 and WebGL 2 implementations and also ES 2 / WebGL 1 with OES_VAO available. 2. Index buffer gets created with TargetHint::ElementArray, bound to GL_ELEMENT_ARRAY_BUFFER and filled with data. 3. Mesh object with VAO inside is created and the index buffer from above gets bound to GL_ELEMENT_ARRAY_BUFFER again to attach it to the VAO. 4. Another index buffer, possibly for another mesh, gets created with TargetHint::ElementArray and bound to GL_ELEMENT_ARRAY_BUFFER in order to be filled with data. But because the VAO from above is still bound, the index buffer attachment is then stomped on. 5. Rendering such mesh will use a different index buffer, most probably causing some out-of-range GL error and nothing rendered.
9 years ago
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
#if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2))
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
&MeshGLTest::setBaseVertex,
#endif
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
#ifdef MAGNUM_TARGET_GLES
&MeshGLTest::setBaseVertexNoExtensionAvailable,
&MeshGLTest::setBaseVertexRangeNoExtensionAvailable,
#endif
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
&MeshGLTest::setInstanceCount,
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
#ifndef MAGNUM_TARGET_GLES2
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
&MeshGLTest::setInstanceCountBaseInstance,
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
#ifdef MAGNUM_TARGET_GLES
&MeshGLTest::setInstanceCountBaseInstanceNoExtensionAvailable,
#endif
#endif
&MeshGLTest::setInstanceCountIndexed,
#ifndef MAGNUM_TARGET_GLES2
&MeshGLTest::setInstanceCountIndexedBaseInstance,
#ifdef MAGNUM_TARGET_GLES
&MeshGLTest::setInstanceCountIndexedBaseInstanceNoExtensionAvailable,
#endif
#endif
#ifndef MAGNUM_TARGET_GLES2
&MeshGLTest::setInstanceCountIndexedBaseVertex,
#endif
#ifdef MAGNUM_TARGET_GLES
&MeshGLTest::setInstanceCountIndexedBaseVertexNoExtensionAvailable,
#endif
#ifndef MAGNUM_TARGET_GLES2
&MeshGLTest::setInstanceCountIndexedBaseVertexBaseInstance,
#ifdef MAGNUM_TARGET_GLES
&MeshGLTest::setInstanceCountIndexedBaseVertexBaseInstanceNoExtensionAvailable,
#endif
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
#endif
&MeshGLTest::addVertexBufferInstancedFloat,
#ifndef MAGNUM_TARGET_GLES2
&MeshGLTest::addVertexBufferInstancedInteger,
#endif
#ifndef MAGNUM_TARGET_GLES
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
&MeshGLTest::addVertexBufferInstancedDouble,
#endif
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
&MeshGLTest::resetDivisorAfterInstancedDraw});
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
addInstancedTests({&MeshGLTest::multiDraw,
&MeshGLTest::multiDrawSparseArrays,
&MeshGLTest::multiDrawViews},
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
Containers::arraySize(MultiDrawData));
Testing Mesh move constructor and assignment.
13 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
addInstancedTests({&MeshGLTest::multiDrawIndexed,
&MeshGLTest::multiDrawIndexedSparseArrays,
&MeshGLTest::multiDrawIndexedViews},
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
Containers::arraySize(MultiDrawIndexedData));
addTests({
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
&MeshGLTest::multiDrawWrongVertexOffsetSize,
&MeshGLTest::multiDrawIndexedWrongIndexOffsetSize,
&MeshGLTest::multiDrawIndexedWrongVertexOffsetSize,
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
#ifdef MAGNUM_TARGET_GLES
&MeshGLTest::multiDrawIndexedBaseVertexNoExtensionAvailable,
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
&MeshGLTest::multiDrawIndexedViewsBaseVertexNoExtensionAvailable,
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 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
&MeshGLTest::multiDrawInstancedViews,
&MeshGLTest::multiDrawViewsDifferentMeshes
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
});
/* Reset clear color to something trivial first */
Renderer::setClearColor(0x000000_rgbf);
}
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
Testing Mesh move constructor and assignment.
13 years ago
void MeshGLTest::construct() {
{
const Mesh mesh;
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Mesh: set VAO id to 0 when the extension is not available. Also expect this case in test.
13 years ago
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(Context::current().isExtensionSupported<Extensions::ARB::vertex_array_object>())
Mesh: set VAO id to 0 when the extension is not available. Also expect this case in test.
13 years ago
#elif defined(MAGNUM_TARGET_GLES2)
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(Context::current().isExtensionSupported<Extensions::OES::vertex_array_object>())
Mesh: set VAO id to 0 when the extension is not available. Also expect this case in test.
13 years ago
#endif
{
CORRADE_VERIFY(mesh.id() > 0);
}
Testing Mesh move constructor and assignment.
13 years ago
}
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Testing Mesh move constructor and assignment.
13 years ago
}
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
struct FloatShader: AbstractShaderProgram {
explicit FloatShader(const std::string& type, const std::string& conversion);
};
GL: get rid of std::vector in Mesh header. This is actually a preparation to make buffer-owning meshes a possibility (where I would need an union of vectors otherwise), nevertheless it removes the dependency on a vector.
8 years ago
Testing Mesh move constructor and assignment.
13 years ago
void MeshGLTest::constructMove() {
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
const Float data = Math::unpack<Float, UnsignedByte>(
#ifndef MAGNUM_TARGET_GLES2
96
#else
/* Using only RGBA4, supply less precision. This has to be one on the
input because SwiftShader stores RGBA4 as RGBA8 internally, thus
preserving the full precision of the input. */
85
#endif
);
GL: get rid of std::vector in Mesh header. This is actually a preparation to make buffer-owning meshes a possibility (where I would need an union of vectors otherwise), nevertheless it removes the dependency on a vector.
8 years ago
Buffer buffer1, buffer2;
buffer1.setData({&data, 1}, BufferUsage::StaticDraw);
GL: fix various OOB / unaligned access issues in Mesh test.
8 years ago
buffer2.setData({nullptr, 8}, BufferUsage::StaticDraw);
GL: get rid of std::vector in Mesh header. This is actually a preparation to make buffer-owning meshes a possibility (where I would need an union of vectors otherwise), nevertheless it removes the dependency on a vector.
8 years ago
Testing Mesh move constructor and assignment.
13 years ago
Mesh a;
GL: get rid of std::vector in Mesh header. This is actually a preparation to make buffer-owning meshes a possibility (where I would need an union of vectors otherwise), nevertheless it removes the dependency on a vector.
8 years ago
a.addVertexBuffer(buffer1, 0, Attribute<0, Float>{});
Testing Mesh move constructor and assignment.
13 years ago
const Int id = a.id();
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Mesh: set VAO id to 0 when the extension is not available. Also expect this case in test.
13 years ago
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(Context::current().isExtensionSupported<Extensions::ARB::vertex_array_object>())
Mesh: set VAO id to 0 when the extension is not available. Also expect this case in test.
13 years ago
#elif defined(MAGNUM_TARGET_GLES2)
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(Context::current().isExtensionSupported<Extensions::OES::vertex_array_object>())
Mesh: set VAO id to 0 when the extension is not available. Also expect this case in test.
13 years ago
#endif
{
CORRADE_VERIFY(id > 0);
}
Testing Mesh move constructor and assignment.
13 years ago
GL: fix undefined behavior and potential leaks in Mesh. The change done in 680144f1c511997ee0530ea88bbb95aa20e058c8 was not properly handling these cases: * Mesh(NoCreateT) and wrap() were not constructing the internal vector, which blew up when move-assigning another instance. * ~Mesh() was not destructing the internal vector if the VAO ID was zero or non-owning wrap() was used. Strangely enough none of these were causing *any* problems for me on Linux (even ASan was totally quiet and due to the unfortunate combination of bugs even when I assigned totally random data to the storage vector). This however blew up on MSVC, assuming there the implementation is more checked. Because it's possible to construct Mesh with no GL context available, the move construction and destruction needs to avoid accessing Context unless really necessary (it would be also unclear which type of vector should be constructed if we have no context). Extended the tests to handle hopefully all the cases.
8 years ago
/* Move construct */
Testing Mesh move constructor and assignment.
13 years ago
Mesh b(std::move(a));
CORRADE_COMPARE(a.id(), 0);
CORRADE_COMPARE(b.id(), id);
GL: fix undefined behavior and potential leaks in Mesh. The change done in 680144f1c511997ee0530ea88bbb95aa20e058c8 was not properly handling these cases: * Mesh(NoCreateT) and wrap() were not constructing the internal vector, which blew up when move-assigning another instance. * ~Mesh() was not destructing the internal vector if the VAO ID was zero or non-owning wrap() was used. Strangely enough none of these were causing *any* problems for me on Linux (even ASan was totally quiet and due to the unfortunate combination of bugs even when I assigned totally random data to the storage vector). This however blew up on MSVC, assuming there the implementation is more checked. Because it's possible to construct Mesh with no GL context available, the move construction and destruction needs to avoid accessing Context unless really necessary (it would be also unclear which type of vector should be constructed if we have no context). Extended the tests to handle hopefully all the cases.
8 years ago
/* Move assign */
Testing Mesh move constructor and assignment.
13 years ago
Mesh c;
GL: fix various OOB / unaligned access issues in Mesh test.
8 years ago
c.addVertexBuffer(buffer2, 4, Attribute<1, Float>{});
Testing Mesh move constructor and assignment.
13 years ago
const Int cId = c.id();
c = std::move(b);
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Mesh: set VAO id to 0 when the extension is not available. Also expect this case in test.
13 years ago
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(Context::current().isExtensionSupported<Extensions::ARB::vertex_array_object>())
Mesh: set VAO id to 0 when the extension is not available. Also expect this case in test.
13 years ago
#elif defined(MAGNUM_TARGET_GLES2)
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(Context::current().isExtensionSupported<Extensions::OES::vertex_array_object>())
Mesh: set VAO id to 0 when the extension is not available. Also expect this case in test.
13 years ago
#endif
{
CORRADE_VERIFY(cId > 0);
}
Testing Mesh move constructor and assignment.
13 years ago
CORRADE_COMPARE(b.id(), cId);
CORRADE_COMPARE(c.id(), id);
GL: get rid of std::vector in Mesh header. This is actually a preparation to make buffer-owning meshes a possibility (where I would need an union of vectors otherwise), nevertheless it removes the dependency on a vector.
8 years ago
GL: fix undefined behavior and potential leaks in Mesh. The change done in 680144f1c511997ee0530ea88bbb95aa20e058c8 was not properly handling these cases: * Mesh(NoCreateT) and wrap() were not constructing the internal vector, which blew up when move-assigning another instance. * ~Mesh() was not destructing the internal vector if the VAO ID was zero or non-owning wrap() was used. Strangely enough none of these were causing *any* problems for me on Linux (even ASan was totally quiet and due to the unfortunate combination of bugs even when I assigned totally random data to the storage vector). This however blew up on MSVC, assuming there the implementation is more checked. Because it's possible to construct Mesh with no GL context available, the move construction and destruction needs to avoid accessing Context unless really necessary (it would be also unclear which type of vector should be constructed if we have no context). Extended the tests to handle hopefully all the cases.
8 years ago
/* Move assign to a NoCreate instance */
Mesh d{NoCreate};
d = std::move(c);
CORRADE_COMPARE(c.id(), 0);
CORRADE_COMPARE(d.id(), id);
/* Destroy */
b = Mesh{NoCreate};
GL: get rid of std::vector in Mesh header. This is actually a preparation to make buffer-owning meshes a possibility (where I would need an union of vectors otherwise), nevertheless it removes the dependency on a vector.
8 years ago
/* Test that drawing still works properly */
{
MAGNUM_VERIFY_NO_GL_ERROR();
Renderbuffer renderbuffer;
renderbuffer.setStorage(
#ifndef MAGNUM_TARGET_GLES2
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
Vector2i(1));
Framebuffer framebuffer{{{}, Vector2i(1)}};
framebuffer.attachRenderbuffer(Framebuffer::ColorAttachment(0), renderbuffer)
.bind();
GL: fix undefined behavior and potential leaks in Mesh. The change done in 680144f1c511997ee0530ea88bbb95aa20e058c8 was not properly handling these cases: * Mesh(NoCreateT) and wrap() were not constructing the internal vector, which blew up when move-assigning another instance. * ~Mesh() was not destructing the internal vector if the VAO ID was zero or non-owning wrap() was used. Strangely enough none of these were causing *any* problems for me on Linux (even ASan was totally quiet and due to the unfortunate combination of bugs even when I assigned totally random data to the storage vector). This however blew up on MSVC, assuming there the implementation is more checked. Because it's possible to construct Mesh with no GL context available, the move construction and destruction needs to avoid accessing Context unless really necessary (it would be also unclear which type of vector should be constructed if we have no context). Extended the tests to handle hopefully all the cases.
8 years ago
d.setPrimitive(MeshPrimitive::Points)
Adapted all code and doc snippets to GL library changes.
6 years ago
.setCount(1);
FloatShader shader{"float", "vec4(valueInterpolated, 0.0, 0.0, 0.0)"};
shader.draw(d);
GL: get rid of std::vector in Mesh header. This is actually a preparation to make buffer-owning meshes a possibility (where I would need an union of vectors otherwise), nevertheless it removes the dependency on a vector.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
GL: avoid using deprecated templated Image::data() in tests. This discovered quite a few potentially dangerous casts, so yay!
7 years ago
CORRADE_COMPARE(Containers::arrayCast<UnsignedByte>(framebuffer.read({{}, Vector2i{1}}, {PixelFormat::RGBA, PixelType::UnsignedByte}).data())[0], 96);
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#else /* RGBA4, so less precision */
GL: avoid using deprecated templated Image::data() in tests. This discovered quite a few potentially dangerous casts, so yay!
7 years ago
CORRADE_COMPARE(Containers::arrayCast<UnsignedByte>(framebuffer.read({{}, Vector2i{1}}, {PixelFormat::RGBA, PixelType::UnsignedByte}).data())[0], 85);
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#endif
GL: get rid of std::vector in Mesh header. This is actually a preparation to make buffer-owning meshes a possibility (where I would need an union of vectors otherwise), nevertheless it removes the dependency on a vector.
8 years ago
}
GL: test noexcept-movability of all GL classes. Not sure why this wasn't done for ages already, all other (non-GL) classes have it.
6 years ago
CORRADE_VERIFY(std::is_nothrow_move_constructible<Mesh>::value);
CORRADE_VERIFY(std::is_nothrow_move_assignable<Mesh>::value);
Support for object labels from KHR_debug and EXT_debug_label. Can't test EXT_debug_label, as that is apparently OSX 10.9-only. Added GL tests for all implemented objects. KHR_debug is selected first, if that is not available, fall back to EXT_debug_label. If neither is available, the functions are no-op. I hope EXT_debug_label gets replaced by KHR_debug later, thus it is now only "emulated" through KHR_debug enums.
13 years ago
}
Ability to wrap and release existing OpenGL objects. Allows for better interaction with third-party libraries. I should probably write a new documentation page about OpenGL wrapping.
11 years ago
void MeshGLTest::wrap() {
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_array_object>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() << "is not supported.");
Ability to wrap and release existing OpenGL objects. Allows for better interaction with third-party libraries. I should probably write a new documentation page about OpenGL wrapping.
11 years ago
#elif defined(MAGNUM_TARGET_GLES2)
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::OES::vertex_array_object>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::OES::vertex_array_object::string() << "is not supported.");
Ability to wrap and release existing OpenGL objects. Allows for better interaction with third-party libraries. I should probably write a new documentation page about OpenGL wrapping.
11 years ago
#endif
GLuint id;
Fix Mesh test build on ES2. Yeah, thanks, Jenkins, for being so thorough, but... eh.
11 years ago
#ifndef MAGNUM_TARGET_GLES2
Ability to wrap and release existing OpenGL objects. Allows for better interaction with third-party libraries. I should probably write a new documentation page about OpenGL wrapping.
11 years ago
glGenVertexArrays(1, &id);
Fix Mesh test build on ES2. Yeah, thanks, Jenkins, for being so thorough, but... eh.
11 years ago
#else
glGenVertexArraysOES(1, &id);
#endif
Ability to wrap and release existing OpenGL objects. Allows for better interaction with third-party libraries. I should probably write a new documentation page about OpenGL wrapping.
11 years ago
/* Releasing won't delete anything */
{
auto mesh = Mesh::wrap(id, ObjectFlag::DeleteOnDestruction);
CORRADE_COMPARE(mesh.release(), id);
}
/* ...so we can wrap it again */
Mesh::wrap(id);
Fix Mesh test build on ES2. Yeah, thanks, Jenkins, for being so thorough, but... eh.
11 years ago
#ifndef MAGNUM_TARGET_GLES2
Ability to wrap and release existing OpenGL objects. Allows for better interaction with third-party libraries. I should probably write a new documentation page about OpenGL wrapping.
11 years ago
glDeleteVertexArrays(1, &id);
Fix Mesh test build on ES2. Yeah, thanks, Jenkins, for being so thorough, but... eh.
11 years ago
#else
glDeleteVertexArraysOES(1, &id);
#endif
Ability to wrap and release existing OpenGL objects. Allows for better interaction with third-party libraries. I should probably write a new documentation page about OpenGL wrapping.
11 years ago
}
Split the OpenGL layer out, pt 11: generic MeshPrimitive and MeshIndexType. Similarly to pixel formats, there is now generic Magnum::MeshPrimitive and Magnum::MeshIndexType, which is convertible to GL::MeshPrimitive and GL::MeshIndexType using GL::meshPrimitive() and GL::meshIndexType(). In addition, the following is done: * The original GL::Mesh::IndexType is now GL::MeshIndexType, original name is now just a typedef. * GL::Mesh::indexSize() is deprecated in favor of Magnum::meshIndexTypeSize() and GL::Mesh::indexTypeSize(). * New GL::Mesh::indexType() and GL::MeshView::mesh() getters (not sure why they were omitted) * GL::Mesh::indexType(), GL::Mesh::indexTypeSize(), GL::MeshView::setIndexRange() now expect that the mesh is indexed (useful property in my opinion, also avoids getting random results). * The extra MeshPrimitive::LinesAdjacency etc. are still present for backwards compatibility, but marked as deprecated. Use GL::MeshPrimitive values instead.
8 years ago
template<class T> void MeshGLTest::primitive() {
Test: use the new setTestCaseTemplateName().
7 years ago
setTestCaseTemplateName(std::is_same<T, MeshPrimitive>::value ?
"GL::MeshPrimitive" : "Magnum::MeshPrimitive");
Split the OpenGL layer out, pt 11: generic MeshPrimitive and MeshIndexType. Similarly to pixel formats, there is now generic Magnum::MeshPrimitive and Magnum::MeshIndexType, which is convertible to GL::MeshPrimitive and GL::MeshIndexType using GL::meshPrimitive() and GL::meshIndexType(). In addition, the following is done: * The original GL::Mesh::IndexType is now GL::MeshIndexType, original name is now just a typedef. * GL::Mesh::indexSize() is deprecated in favor of Magnum::meshIndexTypeSize() and GL::Mesh::indexTypeSize(). * New GL::Mesh::indexType() and GL::MeshView::mesh() getters (not sure why they were omitted) * GL::Mesh::indexType(), GL::Mesh::indexTypeSize(), GL::MeshView::setIndexRange() now expect that the mesh is indexed (useful property in my opinion, also avoids getting random results). * The extra MeshPrimitive::LinesAdjacency etc. are still present for backwards compatibility, but marked as deprecated. Use GL::MeshPrimitive values instead.
8 years ago
{
Mesh mesh{T::LineLoop};
CORRADE_COMPARE(mesh.primitive(), MeshPrimitive::LineLoop);
} {
Mesh mesh;
mesh.setPrimitive(T::TriangleFan);
CORRADE_COMPARE(mesh.primitive(), MeshPrimitive::TriangleFan);
}
}
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#ifndef MAGNUM_TARGET_WEBGL
Support for object labels from KHR_debug and EXT_debug_label. Can't test EXT_debug_label, as that is apparently OSX 10.9-only. Added GL tests for all implemented objects. KHR_debug is selected first, if that is not available, fall back to EXT_debug_label. If neither is available, the functions are no-op. I hope EXT_debug_label gets replaced by KHR_debug later, thus it is now only "emulated" through KHR_debug enums.
13 years ago
void MeshGLTest::label() {
GL: don't try to test mesh labels if VAOs are disabled.
8 years ago
#ifndef MAGNUM_TARGET_GLES
if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_array_object>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() << "is not supported.");
GL: don't try to test mesh labels if VAOs are disabled.
8 years ago
#elif defined(MAGNUM_TARGET_GLES2)
if(!Context::current().isExtensionSupported<Extensions::OES::vertex_array_object>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::OES::vertex_array_object::string() << "is not supported.");
GL: don't try to test mesh labels if VAOs are disabled.
8 years ago
#endif
Support for object labels from KHR_debug and EXT_debug_label. Can't test EXT_debug_label, as that is apparently OSX 10.9-only. Added GL tests for all implemented objects. KHR_debug is selected first, if that is not available, fall back to EXT_debug_label. If neither is available, the functions are no-op. I hope EXT_debug_label gets replaced by KHR_debug later, thus it is now only "emulated" through KHR_debug enums.
13 years ago
/* No-Op version is tested in AbstractObjectGLTest */
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::KHR::debug>() &&
!Context::current().isExtensionSupported<Extensions::EXT::debug_label>())
Support for object labels from KHR_debug and EXT_debug_label. Can't test EXT_debug_label, as that is apparently OSX 10.9-only. Added GL tests for all implemented objects. KHR_debug is selected first, if that is not available, fall back to EXT_debug_label. If neither is available, the functions are no-op. I hope EXT_debug_label gets replaced by KHR_debug later, thus it is now only "emulated" through KHR_debug enums.
13 years ago
CORRADE_SKIP("Required extension is not available");
Mesh mesh;
Use object at least once before testing its label. Otherwise my NVidia emits GL_INVALID_VALUE with message "that <object> is not valid object", which isn't in the specs. I hate this "deferred everything" approach in GL. Is this even legal optimization?
12 years ago
Support for object labels from KHR_debug and EXT_debug_label. Can't test EXT_debug_label, as that is apparently OSX 10.9-only. Added GL tests for all implemented objects. KHR_debug is selected first, if that is not available, fall back to EXT_debug_label. If neither is available, the functions are no-op. I hope EXT_debug_label gets replaced by KHR_debug later, thus it is now only "emulated" through KHR_debug enums.
13 years ago
CORRADE_COMPARE(mesh.label(), "");
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Support for object labels from KHR_debug and EXT_debug_label. Can't test EXT_debug_label, as that is apparently OSX 10.9-only. Added GL tests for all implemented objects. KHR_debug is selected first, if that is not available, fall back to EXT_debug_label. If neither is available, the functions are no-op. I hope EXT_debug_label gets replaced by KHR_debug later, thus it is now only "emulated" through KHR_debug enums.
13 years ago
mesh.setLabel("MyMesh");
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Ensure that the mesh object is properly created before using it.
12 years ago
CORRADE_COMPARE(mesh.label(), "MyMesh");
Support for object labels from KHR_debug and EXT_debug_label. Can't test EXT_debug_label, as that is apparently OSX 10.9-only. Added GL tests for all implemented objects. KHR_debug is selected first, if that is not available, fall back to EXT_debug_label. If neither is available, the functions are no-op. I hope EXT_debug_label gets replaced by KHR_debug later, thus it is now only "emulated" through KHR_debug enums.
13 years ago
}
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#endif
Support for object labels from KHR_debug and EXT_debug_label. Can't test EXT_debug_label, as that is apparently OSX 10.9-only. Added GL tests for all implemented objects. KHR_debug is selected first, if that is not available, fall back to EXT_debug_label. If neither is available, the functions are no-op. I hope EXT_debug_label gets replaced by KHR_debug later, thus it is now only "emulated" through KHR_debug enums.
13 years ago
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
struct IntegerShader: AbstractShaderProgram {
explicit IntegerShader(const std::string& type);
};
#endif
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
#ifndef MAGNUM_TARGET_GLES
struct DoubleShader: AbstractShaderProgram {
explicit DoubleShader(const std::string& type, const std::string& outputType, const std::string& conversion);
};
#endif
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
struct Checker {
Checker(AbstractShaderProgram&& shader, RenderbufferFormat format, Mesh& mesh);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
template<class T> T get(PixelFormat format, PixelType type);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
Renderbuffer renderbuffer;
Framebuffer framebuffer;
};
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Various documentation fixes and updates. {} in Matrix constructor caused Doxygen to forget all functions after it.
13 years ago
#ifndef DOXYGEN_GENERATING_OUTPUT
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
FloatShader::FloatShader(const std::string& type, const std::string& conversion) {
/* We need special version for ES3, because GLSL in ES2 doesn't support
rectangle matrices */
#ifndef MAGNUM_TARGET_GLES
Don't use GLSL < 130 in GL tests on OSX. OSX doesn't support anything below what's in GL 3.1 when using core contexts.
10 years ago
Shader vert(
#ifndef CORRADE_TARGET_APPLE
Version::GL210
#else
Version::GL310
#endif
, Shader::Type::Vertex);
Shader frag(
#ifndef CORRADE_TARGET_APPLE
Version::GL210
#else
Version::GL310
#endif
, Shader::Type::Fragment);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#elif defined(MAGNUM_TARGET_GLES2)
Shader vert(Version::GLES200, Shader::Type::Vertex);
Make use of threaded shader compilation in MeshGLTest.
12 years ago
Shader frag(Version::GLES200, Shader::Type::Fragment);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#else
Shader vert(Version::GLES300, Shader::Type::Vertex);
Make use of threaded shader compilation in MeshGLTest.
12 years ago
Shader frag(Version::GLES300, Shader::Type::Fragment);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#endif
vert.addSource(
Define-out precision qualifiers in test shaders for GLSL 1.20. Causes the errors to abort on AMD cards.
11 years ago
"#if !defined(GL_ES) && __VERSION__ == 120\n"
"#define mediump\n"
"#endif\n"
GL: don't use old GLSL names in ES3 Mesh tests.
8 years ago
"#if (defined(GL_ES) && __VERSION__ < 300) || __VERSION__ == 120\n"
Don't use GLSL < 130 in GL tests on OSX. OSX doesn't support anything below what's in GL 3.1 when using core contexts.
10 years ago
"#define in attribute\n"
"#define out varying\n"
"#endif\n"
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
"in mediump " + type + " value;\n"
"out mediump " + type + " valueInterpolated;\n"
"void main() {\n"
" valueInterpolated = value;\n"
" gl_Position = vec4(0.0, 0.0, 0.0, 1.0);\n"
"}\n");
Don't use GLSL < 130 in GL tests on OSX. OSX doesn't support anything below what's in GL 3.1 when using core contexts.
10 years ago
frag.addSource(
"#if !defined(GL_ES) && __VERSION__ == 120\n"
"#define mediump\n"
"#endif\n"
GL: don't use old GLSL names in ES3 Mesh tests.
8 years ago
"#if (defined(GL_ES) && __VERSION__ < 300) || __VERSION__ == 120\n"
Don't use GLSL < 130 in GL tests on OSX. OSX doesn't support anything below what's in GL 3.1 when using core contexts.
10 years ago
"#define in varying\n"
"#define result gl_FragColor\n"
"#endif\n"
"in mediump " + type + " valueInterpolated;\n"
GL: don't use old GLSL names in ES3 Mesh tests.
8 years ago
"#if (defined(GL_ES) && __VERSION__ >= 300) || (!defined(GL_ES) && __VERSION__ >= 130)\n"
Don't use GLSL < 130 in GL tests on OSX. OSX doesn't support anything below what's in GL 3.1 when using core contexts.
10 years ago
"out mediump vec4 result;\n"
"#endif\n"
"void main() { result = " + conversion + "; }\n");
Make use of threaded shader compilation in MeshGLTest.
12 years ago
CORRADE_INTERNAL_ASSERT_OUTPUT(Shader::compile({vert, frag}));
Use threaded shader compilation etc. also in tests.
12 years ago
attachShaders({vert, frag});
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
bindAttributeLocation(0, "value");
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
}
#ifndef MAGNUM_TARGET_GLES2
IntegerShader::IntegerShader(const std::string& type) {
#ifndef MAGNUM_TARGET_GLES
Don't use GLSL < 130 in GL tests on OSX. OSX doesn't support anything below what's in GL 3.1 when using core contexts.
10 years ago
Shader vert(
#ifndef CORRADE_TARGET_APPLE
Version::GL300
#else
Version::GL310
#endif
, Shader::Type::Vertex);
Shader frag(
#ifndef CORRADE_TARGET_APPLE
Version::GL300
#else
Version::GL310
#endif
, Shader::Type::Fragment);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#else
Shader vert(Version::GLES300, Shader::Type::Vertex);
Make use of threaded shader compilation in MeshGLTest.
12 years ago
Shader frag(Version::GLES300, Shader::Type::Fragment);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#endif
Make use of threaded shader compilation in MeshGLTest.
12 years ago
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
vert.addSource("in mediump " + type + " value;\n"
"flat out mediump " + type + " valueInterpolated;\n"
"void main() {\n"
" valueInterpolated = value;\n"
" gl_Position = vec4(0.0, 0.0, 0.0, 1.0);\n"
"}\n");
frag.addSource("flat in mediump " + type + " valueInterpolated;\n"
"out mediump " + type + " result;\n"
"void main() { result = valueInterpolated; }\n");
Make use of threaded shader compilation in MeshGLTest.
12 years ago
CORRADE_INTERNAL_ASSERT_OUTPUT(Shader::compile({vert, frag}));
Use threaded shader compilation etc. also in tests.
12 years ago
attachShaders({vert, frag});
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
bindAttributeLocation(0, "value");
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
}
#endif
#ifndef MAGNUM_TARGET_GLES
DoubleShader::DoubleShader(const std::string& type, const std::string& outputType, const std::string& conversion) {
Test: don't require GLSL 4.10 if not strictly needed. Fixes test failures on soft Mesa drivers that support only GLSL 3.30.
9 years ago
constexpr const Version version =
#ifndef CORRADE_TARGET_APPLE
Version::GL300;
#else
Version::GL400;
#endif
Shader vert{version, Shader::Type::Vertex};
Shader frag(version, Shader::Type::Fragment);
Make use of threaded shader compilation in MeshGLTest.
12 years ago
Test: don't require GLSL 4.10 if not strictly needed. Fixes test failures on soft Mesa drivers that support only GLSL 3.30.
9 years ago
vert.addSource(
"#extension GL_ARB_vertex_attrib_64bit: require\n"
"#extension GL_ARB_gpu_shader_fp64: require\n"
"in " + type + " value;\n"
"out " + outputType + " valueInterpolated;\n"
"void main() {\n"
" valueInterpolated = " + conversion + ";\n"
" gl_Position = vec4(0.0, 0.0, 0.0, 1.0);\n"
"}\n");
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
frag.addSource("in " + outputType + " valueInterpolated;\n"
"out " + outputType + " result;\n"
"void main() { result = valueInterpolated; }\n");
Make use of threaded shader compilation in MeshGLTest.
12 years ago
CORRADE_INTERNAL_ASSERT_OUTPUT(Shader::compile({vert, frag}));
Use threaded shader compilation etc. also in tests.
12 years ago
attachShaders({vert, frag});
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
bindAttributeLocation(0, "value");
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
}
#endif
Checker::Checker(AbstractShaderProgram&& shader, RenderbufferFormat format, Mesh& mesh): framebuffer({{}, Vector2i(1)}) {
renderbuffer.setStorage(format, Vector2i(1));
framebuffer.attachRenderbuffer(Framebuffer::ColorAttachment(0), renderbuffer);
Simplified *Framebuffer::bind() functionality. This was a leftover from some not-well-thought-out design decision. The function is now used exclusively for binding for draw, as all framebuffer reading functions (blit(), read()) are doing the read binding internally. Moreover it required the user to be extra careful on ES2, because in many cases there are no separate binding points for reading and drawing. The function is now parameter-less and always bind the framebuffer for drawing. The logic for internal binding was also simplified and on ES2 there are separate implementations for single/separate binding points. For *Framebuffer::checkStatus() the documentation was updated to explain the meaning of the parameter on ES2 implementation. Also removed the need for FramebufferTarget::ReadDraw binding, as it was rather confusing. Old *Framebuffer::bind(FramebufferTarget) is now just an alias to the parameter-less function, ignoring the parameter. Along with FramebufferTarget::ReadDraw it is marked as deprecated and will be removed in some future release.
11 years ago
framebuffer.bind();
Don't differentiate between vertex and index count in Mesh. Only one value from these two was used in the end, wasting precious bytes. Also these two values were used to differentiate between indexed and non-indexed mesh (instead of relying on actual index buffer being bound), which was very confusing. This approach looks more clean. The MeshView class is not yet updated, as the change would expose some features that aren't possible in current implementation (base vertex specification). Merged Mesh::setVertexCount() and Mesh::setIndexCount() into one Mesh::setCount(), the two original functions are now guarded aliases to the new one, are marked as deprecated and will be removed in future release, similarly for the getters. In particular, if the mesh is indexed, setVertexCount() does nothing and vertexCount() returns 0. The setIndexCount() and indexCount() do and return the same regardless of whether the mesh is indexed or not.
12 years ago
mesh.setPrimitive(MeshPrimitive::Points)
.setCount(2);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
/* Skip first vertex so we test also offsets */
Split the OpenGL layer out, pt 11: generic MeshPrimitive and MeshIndexType. Similarly to pixel formats, there is now generic Magnum::MeshPrimitive and Magnum::MeshIndexType, which is convertible to GL::MeshPrimitive and GL::MeshIndexType using GL::meshPrimitive() and GL::meshIndexType(). In addition, the following is done: * The original GL::Mesh::IndexType is now GL::MeshIndexType, original name is now just a typedef. * GL::Mesh::indexSize() is deprecated in favor of Magnum::meshIndexTypeSize() and GL::Mesh::indexTypeSize(). * New GL::Mesh::indexType() and GL::MeshView::mesh() getters (not sure why they were omitted) * GL::Mesh::indexType(), GL::Mesh::indexTypeSize(), GL::MeshView::setIndexRange() now expect that the mesh is indexed (useful property in my opinion, also avoids getting random results). * The extra MeshPrimitive::LinesAdjacency etc. are still present for backwards compatibility, but marked as deprecated. Use GL::MeshPrimitive values instead.
8 years ago
MeshView view{mesh};
view.setCount(1)
Removed duplicate code from MeshGLTest. As there is now no distinction between vertex and index count we don't need separate checker utility for non-indexed and indexed meshes.
12 years ago
.setBaseVertex(mesh.baseVertex())
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
.setInstanceCount(mesh.instanceCount())
#ifndef MAGNUM_TARGET_GLES
.setBaseInstance(mesh.baseInstance())
#endif
Split the OpenGL layer out, pt 11: generic MeshPrimitive and MeshIndexType. Similarly to pixel formats, there is now generic Magnum::MeshPrimitive and Magnum::MeshIndexType, which is convertible to GL::MeshPrimitive and GL::MeshIndexType using GL::meshPrimitive() and GL::meshIndexType(). In addition, the following is done: * The original GL::Mesh::IndexType is now GL::MeshIndexType, original name is now just a typedef. * GL::Mesh::indexSize() is deprecated in favor of Magnum::meshIndexTypeSize() and GL::Mesh::indexTypeSize(). * New GL::Mesh::indexType() and GL::MeshView::mesh() getters (not sure why they were omitted) * GL::Mesh::indexType(), GL::Mesh::indexTypeSize(), GL::MeshView::setIndexRange() now expect that the mesh is indexed (useful property in my opinion, also avoids getting random results). * The extra MeshPrimitive::LinesAdjacency etc. are still present for backwards compatibility, but marked as deprecated. Use GL::MeshPrimitive values instead.
8 years ago
;
if(view.mesh().isIndexed()) view.setIndexRange(1);
Adapted all code and doc snippets to GL library changes.
6 years ago
shader.draw(view);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
}
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
template<class T> T Checker::get(PixelFormat format, PixelType type) {
GL: avoid using deprecated templated Image::data() in tests. This discovered quite a few potentially dangerous casts, so yay!
7 years ago
return Containers::arrayCast<T>(framebuffer.read({{}, Vector2i{1}}, {format, type}).data())[0];
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
}
Various documentation fixes and updates. {} in Matrix constructor caused Doxygen to forget all functions after it.
13 years ago
#endif
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#ifndef MAGNUM_TARGET_GLES2
void MeshGLTest::addVertexBufferUnsignedInt() {
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::EXT::gpu_shader4>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() << "is not supported.");
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#endif
constexpr UnsignedInt data[] = { 0, 157, 35681 };
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 4, Attribute<0, UnsignedInt>{});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 4, 4, DynamicAttribute{
DynamicAttribute::Kind::Integral, 0,
DynamicAttribute::Components::One,
DynamicAttribute::DataType::UnsignedInt});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
GL: fix MeshGLTest on WebGL. It doesn't allow anything except full RGBA and 32-bit types to be read from the framebuffer. Chromium browsers weren't complaining but Firefox did. I remember a similar restriction from GLES2 but all implementations I tested with including ANGLE and SwiftShader allow that already, so it's practically just a WebGL limitation.
5 years ago
const auto value = Checker(IntegerShader("uint"), RenderbufferFormat::R32UI, mesh).get<UnsignedInt>(
#ifndef MAGNUM_TARGET_WEBGL
PixelFormat::RedInteger,
#else
PixelFormat::RGBAInteger,
#endif
PixelType::UnsignedInt);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
CORRADE_COMPARE(value, 35681);
}
void MeshGLTest::addVertexBufferInt() {
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::EXT::gpu_shader4>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() << "is not supported.");
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#endif
constexpr Int data[] = { 0, 457931, 27530 };
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 4, Attribute<0, Int>{});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 4, 4, DynamicAttribute{
DynamicAttribute::Kind::Integral, 0,
DynamicAttribute::Components::One,
DynamicAttribute::DataType::Int});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
GL: fix MeshGLTest on WebGL. It doesn't allow anything except full RGBA and 32-bit types to be read from the framebuffer. Chromium browsers weren't complaining but Firefox did. I remember a similar restriction from GLES2 but all implementations I tested with including ANGLE and SwiftShader allow that already, so it's practically just a WebGL limitation.
5 years ago
const auto value = Checker(IntegerShader("int"), RenderbufferFormat::R32I, mesh).get<Int>(
#ifndef MAGNUM_TARGET_WEBGL
PixelFormat::RedInteger,
#else
PixelFormat::RGBAInteger,
#endif
PixelType::Int);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
CORRADE_COMPARE(value, 27530);
}
#endif
void MeshGLTest::addVertexBufferFloat() {
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
const Float data[] = { 0.0f, -0.7f, Math::unpack<Float, UnsignedByte>(
#ifndef MAGNUM_TARGET_GLES2
96
#else
GL: fix a confusing typo in a comment.
5 years ago
/* Using only RGBA4, supply less precision. This has to be done on the
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
input because SwiftShader stores RGBA4 as RGBA8 internally, thus
preserving the full precision of the input. */
85
#endif
) };
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 4, Attribute<0, Float>{});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 4, 4, DynamicAttribute{
DynamicAttribute::Kind::Generic, 0,
DynamicAttribute::Components::One,
DynamicAttribute::DataType::Float});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
const auto value = Checker(FloatShader("float", "vec4(valueInterpolated, 0.0, 0.0, 0.0)"),
#ifndef MAGNUM_TARGET_GLES2
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
mesh).get<UnsignedByte>(PixelFormat::RGBA, PixelType::UnsignedByte);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
CORRADE_COMPARE(value, 96);
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#else /* RGBA4, so less precision */
CORRADE_COMPARE(value, 85);
#endif
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
}
#ifndef MAGNUM_TARGET_GLES
void MeshGLTest::addVertexBufferDouble() {
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_attrib_64bit>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::vertex_attrib_64bit::string() << "is not supported.");
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Math: renamed {de,}normalize() to {,un}pack() in a new Packing.h header. To be more consistent with GLSL naming. Also, the original naming was quite misleading, as normalize() is used in GLSL for something completely different. If building with deprecated APIs, the Functions.h header includes the new Packing.h header and the {de,}normalize() functions are defined as deprecated aliases to the new functions. This will be removed at some point in the future.
9 years ago
const Double data[] = { 0.0, -0.7, Math::unpack<Double, UnsignedShort>(45828) };
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 8, Attribute<0, Double>{});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 8, 8, DynamicAttribute{
DynamicAttribute::Kind::Long, 0,
DynamicAttribute::Components::One,
DynamicAttribute::DataType::Double});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Fix type conversion errors in Mesh test shader code. Reported by latest NVidia drivers (352.09), apparently worked until now. Huh.
11 years ago
const auto value = Checker(DoubleShader("double", "float", "float(value)"),
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
RenderbufferFormat::R16, mesh).get<UnsignedShort>(PixelFormat::Red, PixelType::UnsignedShort);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
CORRADE_COMPARE(value, 45828);
}
#endif
#ifndef MAGNUM_TARGET_GLES2
void MeshGLTest::addVertexBufferVectorNui() {
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::EXT::gpu_shader4>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() << "is not supported.");
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#endif
constexpr Vector3ui data[] = { {}, {37448, 547686, 156}, {27592, 157, 25} };
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 3*4, Attribute<0, Vector3ui>{});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 3*4, 3*4, DynamicAttribute{
DynamicAttribute::Kind::Integral, 0,
DynamicAttribute::Components::Three,
DynamicAttribute::DataType::UnsignedInt});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
const auto value = Checker(IntegerShader("uvec3"), RenderbufferFormat::RGBA32UI, mesh)
GL: avoid using deprecated templated Image::data() in tests. This discovered quite a few potentially dangerous casts, so yay!
7 years ago
.get<Vector4ui>(PixelFormat::RGBAInteger, PixelType::UnsignedInt);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
GL: avoid using deprecated templated Image::data() in tests. This discovered quite a few potentially dangerous casts, so yay!
7 years ago
CORRADE_COMPARE(value.xyz(), Vector3ui(27592, 157, 25));
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
}
void MeshGLTest::addVertexBufferVectorNi() {
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::EXT::gpu_shader4>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() << "is not supported.");
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#endif
constexpr Vector2i data[] = { {}, {-37448, 547686}, {27592, -157} };
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 2*4, Attribute<0, Vector2i>{});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 2*4, 2*4, DynamicAttribute{
DynamicAttribute::Kind::Integral, 0,
DynamicAttribute::Components::Two,
DynamicAttribute::DataType::Int});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
GL: fix MeshGLTest on WebGL. It doesn't allow anything except full RGBA and 32-bit types to be read from the framebuffer. Chromium browsers weren't complaining but Firefox did. I remember a similar restriction from GLES2 but all implementations I tested with including ANGLE and SwiftShader allow that already, so it's practically just a WebGL limitation.
5 years ago
const auto value = Checker(IntegerShader("ivec2"), RenderbufferFormat::RG32I, mesh).get<Vector2i>(
#ifndef MAGNUM_TARGET_WEBGL
PixelFormat::RGInteger
#else
PixelFormat::RGBAInteger
#endif
, PixelType::Int);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
CORRADE_COMPARE(value, Vector2i(27592, -157));
}
#endif
void MeshGLTest::addVertexBufferVectorN() {
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
const Vector3 data[] = { {}, {0.0f, -0.9f, 1.0f},
#ifndef MAGNUM_TARGET_GLES2
0x60189c_rgbf
#else
GL: fix a confusing typo in a comment.
5 years ago
/* Using only RGBA4, supply less precision. This has to be done on the
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
input because SwiftShader stores RGBA4 as RGBA8 internally, thus
preserving the full precision of the input. */
0x551199_rgbf
#endif
};
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 3*4, Attribute<0, Vector3>{});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 3*4, 3*4, DynamicAttribute{
DynamicAttribute::Kind::Generic, 0,
DynamicAttribute::Components::Three,
DynamicAttribute::DataType::Float});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
const auto value = Checker(FloatShader("vec3", "vec4(valueInterpolated, 0.0)"),
#ifndef MAGNUM_TARGET_GLES2
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
GL: avoid using deprecated templated Image::data() in tests. This discovered quite a few potentially dangerous casts, so yay!
7 years ago
mesh).get<Color4ub>(PixelFormat::RGBA, PixelType::UnsignedByte);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
GL: avoid using deprecated templated Image::data() in tests. This discovered quite a few potentially dangerous casts, so yay!
7 years ago
CORRADE_COMPARE(value.xyz(), 0x60189c_rgb);
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#else /* RGBA4, so less precision */
GL: avoid using deprecated templated Image::data() in tests. This discovered quite a few potentially dangerous casts, so yay!
7 years ago
CORRADE_COMPARE(value.xyz(), 0x551199_rgb);
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#endif
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
}
#ifndef MAGNUM_TARGET_GLES
void MeshGLTest::addVertexBufferVectorNd() {
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_attrib_64bit>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::vertex_attrib_64bit::string() << "is not supported.");
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
const Vector4d data[] = {
{}, {0.0, -0.9, 1.0, 1.25},
Use the new half/packed typedefs where appropriate. Had this in a stash for a while, not sure why it wasn't commited already.
6 years ago
Math::unpack<Vector4d>(Vector4us{315, 65201, 2576, 12})
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
};
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 4*8, Attribute<0, Vector4d>{});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 4*8, 4*8, DynamicAttribute{
DynamicAttribute::Kind::Long, 0,
DynamicAttribute::Components::Four,
DynamicAttribute::DataType::Double});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
const auto value = Checker(DoubleShader("dvec4", "vec4", "vec4(value)"),
Use the new half/packed typedefs where appropriate. Had this in a stash for a while, not sure why it wasn't commited already.
6 years ago
RenderbufferFormat::RGBA16, mesh).get<Vector4us>(PixelFormat::RGBA, PixelType::UnsignedShort);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Use the new half/packed typedefs where appropriate. Had this in a stash for a while, not sure why it wasn't commited already.
6 years ago
CORRADE_COMPARE(value, (Vector4us{315, 65201, 2576, 12}));
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
}
#endif
void MeshGLTest::addVertexBufferMatrixNxN() {
const Matrix3x3 data[] = {
{},
Matrix3x3::fromDiagonal({0.0f, -0.9f, 1.0f}),
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
Matrix3x3::fromDiagonal(
#ifndef MAGNUM_TARGET_GLES2
0x60189c_rgbf
#else
GL: fix a confusing typo in a comment.
5 years ago
/* Using only RGBA4, supply less precision. This has to be done on
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
the input because SwiftShader stores RGBA4 as RGBA8 internally,
thus preserving the full precision of the input. */
0x551199_rgbf
#endif
)
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
};
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 3*3*4, Attribute<0, Matrix3x3>{});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 3*3*4, 3*3*4, DynamicAttribute{
GL: make it possible to describe matrix attributes with DynamicAttribute. Not sure why this wasn't done when originally implementing those.
6 years ago
DynamicAttribute::Kind::Generic, 0,
DynamicAttribute::Components::Three, 3,
DynamicAttribute::DataType::Float});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
const auto value = Checker(FloatShader("mat3",
"vec4(valueInterpolated[0][0], valueInterpolated[1][1], valueInterpolated[2][2], 0.0)"),
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#ifndef MAGNUM_TARGET_GLES2
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
GL: avoid using deprecated templated Image::data() in tests. This discovered quite a few potentially dangerous casts, so yay!
7 years ago
mesh).get<Color4ub>(PixelFormat::RGBA, PixelType::UnsignedByte);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
GL: avoid using deprecated templated Image::data() in tests. This discovered quite a few potentially dangerous casts, so yay!
7 years ago
CORRADE_COMPARE(value.xyz(), 0x60189c_rgb);
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#else /* RGBA4, so less precision */
GL: avoid using deprecated templated Image::data() in tests. This discovered quite a few potentially dangerous casts, so yay!
7 years ago
CORRADE_COMPARE(value.xyz(), 0x551199_rgb);
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#endif
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
}
#ifndef MAGNUM_TARGET_GLES
void MeshGLTest::addVertexBufferMatrixNxNd() {
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_attrib_64bit>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::vertex_attrib_64bit::string() << "is not supported.");
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
const Matrix3x3d data[] = {
{},
Matrix3x3d::fromDiagonal({0.0, -0.9, 1.0}),
Use the new half/packed typedefs where appropriate. Had this in a stash for a while, not sure why it wasn't commited already.
6 years ago
Matrix3x3d::fromDiagonal(Math::unpack<Vector3d>(Vector3us{315, 65201, 2576}))
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
};
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 3*3*8, Attribute<0, Matrix3x3d>{});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 3*3*8, 3*3*8, DynamicAttribute{
GL: make it possible to describe matrix attributes with DynamicAttribute. Not sure why this wasn't done when originally implementing those.
6 years ago
DynamicAttribute::Kind::Long, 0,
DynamicAttribute::Components::Three, 3,
DynamicAttribute::DataType::Double});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
const auto value = Checker(DoubleShader("dmat3", "vec4",
"vec4(value[0][0], value[1][1], value[2][2], 0.0)"),
Use the new half/packed typedefs where appropriate. Had this in a stash for a while, not sure why it wasn't commited already.
6 years ago
RenderbufferFormat::RGBA16, mesh).get<Vector4us>(PixelFormat::RGBA, PixelType::UnsignedShort);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Expect failure in MeshGLTest. After updating my NVidia drivers the double matrix tests are extracting only the first two values and I don't know why.
12 years ago
{
GL: Intel Windows drivers 26 are less shitty w/ double attributes.
7 years ago
/* Used to be a problem on Intel Windows drivers 23, not a problem on
26 anymore */
CORRADE_EXPECT_FAIL_IF(Context::current().detectedDriver() & (Context::DetectedDriver::Amd|Context::DetectedDriver::NVidia), "Somehow only first two values are extracted on AMD and NVidia drivers.");
Use the new half/packed typedefs where appropriate. Had this in a stash for a while, not sure why it wasn't commited already.
6 years ago
CORRADE_COMPARE(value.xyz(), (Vector3us{315, 65201, 2576}));
Expect failure in MeshGLTest. After updating my NVidia drivers the double matrix tests are extracting only the first two values and I don't know why.
12 years ago
}
More vendor-specific XFAIL cases in Mesh GL test.
11 years ago
Revert "More vendor-specific XFAIL cases in Mesh GL test." This is behaving properly on AMD 15.300.1025.0. This reverts commit 8dd4dfcf2b1daf6d7f27868e6831c4dbc23ff89e.
11 years ago
/* This is wrong, but check if it's still the right wrong. Fails on AMD
15.201.1151 but seems to be fixed in 15.300.1025.0 */
More consistent naming in Context::DetectedDriver. DetectedDriver::AMD is now DetectedDriver::Amd, DetectedDriver::ProbablyAngle is now just DetectedDriver::Angle. The old names are still present, but deprecated and will be removed in the future.
9 years ago
if(Context::current().detectedDriver() & (Context::DetectedDriver::Amd|Context::DetectedDriver::NVidia))
Use the new half/packed typedefs where appropriate. Had this in a stash for a while, not sure why it wasn't commited already.
6 years ago
CORRADE_COMPARE(value.xyz(), (Vector3us{315, 65201, 0}));
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
}
#endif
#ifndef MAGNUM_TARGET_GLES2
void MeshGLTest::addVertexBufferMatrixMxN() {
const Matrix3x4 data[] = {
{},
Matrix3x4::fromDiagonal({0.0f, -0.9f, 1.0f}),
Math: renamed {de,}normalize() to {,un}pack() in a new Packing.h header. To be more consistent with GLSL naming. Also, the original naming was quite misleading, as normalize() is used in GLSL for something completely different. If building with deprecated APIs, the Functions.h header includes the new Packing.h header and the {de,}normalize() functions are defined as deprecated aliases to the new functions. This will be removed at some point in the future.
9 years ago
Matrix3x4::fromDiagonal(Math::unpack<Vector3>(Color3ub(96, 24, 156)))
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
};
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 3*4*4, Attribute<0, Matrix3x4>{});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 3*4*4, 3*4*4, DynamicAttribute{
GL: make it possible to describe matrix attributes with DynamicAttribute. Not sure why this wasn't done when originally implementing those.
6 years ago
DynamicAttribute::Kind::Generic, 0,
DynamicAttribute::Components::Four, 3,
DynamicAttribute::DataType::Float});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
const auto value = Checker(FloatShader("mat3x4",
"vec4(valueInterpolated[0][0], valueInterpolated[1][1], valueInterpolated[2][2], 0.0)"),
GL: avoid using deprecated templated Image::data() in tests. This discovered quite a few potentially dangerous casts, so yay!
7 years ago
RenderbufferFormat::RGBA8, mesh).get<Color4ub>(PixelFormat::RGBA, PixelType::UnsignedByte);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
GL: avoid using deprecated templated Image::data() in tests. This discovered quite a few potentially dangerous casts, so yay!
7 years ago
CORRADE_COMPARE(value.xyz(), Color3ub(96, 24, 156));
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
}
#endif
#ifndef MAGNUM_TARGET_GLES
void MeshGLTest::addVertexBufferMatrixMxNd() {
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_attrib_64bit>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::vertex_attrib_64bit::string() << "is not supported.");
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
const Matrix3x4d data[] = {
{},
GL: use proper literals in a test.
7 years ago
Matrix3x4d::fromDiagonal({0.0, -0.9, 1.0}),
Use the new half/packed typedefs where appropriate. Had this in a stash for a while, not sure why it wasn't commited already.
6 years ago
Matrix3x4d::fromDiagonal(Math::unpack<Vector3d>(Vector3us{315, 65201, 2576}))
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
};
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 3*4*8, Attribute<0, Matrix3x4d>{});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 3*4*8, 3*4*8, DynamicAttribute{
GL: make it possible to describe matrix attributes with DynamicAttribute. Not sure why this wasn't done when originally implementing those.
6 years ago
DynamicAttribute::Kind::Long, 0,
DynamicAttribute::Components::Four, 3,
DynamicAttribute::DataType::Double});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
const auto value = Checker(DoubleShader("dmat3x4", "vec4",
"vec4(value[0][0], value[1][1], value[2][2], 0.0)"),
Use the new half/packed typedefs where appropriate. Had this in a stash for a while, not sure why it wasn't commited already.
6 years ago
RenderbufferFormat::RGBA16, mesh).get<Vector4us>(PixelFormat::RGBA, PixelType::UnsignedShort);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Expect failure in MeshGLTest. After updating my NVidia drivers the double matrix tests are extracting only the first two values and I don't know why.
12 years ago
{
GL: Intel Windows drivers 26 are less shitty w/ double attributes.
7 years ago
/* Used to be a problem on Intel Windows drivers 23, not a problem on
26 anymore */
CORRADE_EXPECT_FAIL_IF(Context::current().detectedDriver() & (Context::DetectedDriver::Amd|Context::DetectedDriver::NVidia), "Somehow only first two values are extracted on AMD and NVidia drivers.");
Use the new half/packed typedefs where appropriate. Had this in a stash for a while, not sure why it wasn't commited already.
6 years ago
CORRADE_COMPARE(value.xyz(), (Vector3us{315, 65201, 2576}));
Expect failure in MeshGLTest. After updating my NVidia drivers the double matrix tests are extracting only the first two values and I don't know why.
12 years ago
}
More vendor-specific XFAIL cases in Mesh GL test.
11 years ago
Revert "More vendor-specific XFAIL cases in Mesh GL test." This is behaving properly on AMD 15.300.1025.0. This reverts commit 8dd4dfcf2b1daf6d7f27868e6831c4dbc23ff89e.
11 years ago
/* This is wrong, but check if it's still the right wrong. Fails on AMD
15.201.1151 but seems to be fixed in 15.300.1025.0 */
More consistent naming in Context::DetectedDriver. DetectedDriver::AMD is now DetectedDriver::Amd, DetectedDriver::ProbablyAngle is now just DetectedDriver::Angle. The old names are still present, but deprecated and will be removed in the future.
9 years ago
if(Context::current().detectedDriver() & (Context::DetectedDriver::Amd|Context::DetectedDriver::NVidia))
Use the new half/packed typedefs where appropriate. Had this in a stash for a while, not sure why it wasn't commited already.
6 years ago
CORRADE_COMPARE(value.xyz(), (Vector3us{315, 65201, 0}));
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
}
#endif
#ifndef MAGNUM_TARGET_GLES2
void MeshGLTest::addVertexBufferUnsignedIntWithUnsignedShort() {
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::EXT::gpu_shader4>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() << "is not supported.");
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#endif
Fix AMD complaints about misaligned data in Mesh GL test.
11 years ago
constexpr UnsignedShort data[] = { 0, 49563, 2128, 3821, 16583 };
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 2, 2, Attribute<0, UnsignedInt>{Attribute<0, UnsignedInt>::DataType::UnsignedShort});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 4, 4, DynamicAttribute{
DynamicAttribute::Kind::Integral, 0,
DynamicAttribute::Components::One,
DynamicAttribute::DataType::UnsignedShort});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
GL: fix MeshGLTest on WebGL. It doesn't allow anything except full RGBA and 32-bit types to be read from the framebuffer. Chromium browsers weren't complaining but Firefox did. I remember a similar restriction from GLES2 but all implementations I tested with including ANGLE and SwiftShader allow that already, so it's practically just a WebGL limitation.
5 years ago
const UnsignedShort value = Checker(IntegerShader("uint"), RenderbufferFormat::R16UI, mesh)
#ifndef MAGNUM_TARGET_WEBGL
.get<UnsignedShort>(PixelFormat::RedInteger, PixelType::UnsignedShort)
#else
.get<UnsignedInt>(PixelFormat::RGBAInteger, PixelType::UnsignedInt)
#endif
;
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
GL: XFAIL on SwiftShader with integer data type mismatches. Accepted everywhere else (or so is my experience).
7 years ago
#if defined(MAGNUM_TARGET_GLES) && !defined(MAGNUM_TARGET_WEBGL)
CORRADE_EXPECT_FAIL_IF(Context::current().detectedDriver() & Context::DetectedDriver::SwiftShader,
"SwiftShader doesn't like integer buffers with anything else than (Unsigned)Int");
#endif
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
CORRADE_COMPARE(value, 16583);
}
void MeshGLTest::addVertexBufferUnsignedIntWithShort() {
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::EXT::gpu_shader4>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() << "is not supported.");
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#endif
Fix AMD complaints about misaligned data in Mesh GL test.
11 years ago
constexpr Short data[] = { 0, 24563, 2128, 3821, 16583 };
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 2, 2, Attribute<0, UnsignedInt>{Attribute<0, UnsignedInt>::DataType::Short});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 4, 4, DynamicAttribute{
DynamicAttribute::Kind::Integral, 0,
DynamicAttribute::Components::One,
DynamicAttribute::DataType::Short});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
GL: make renderbuffer format match the shader format in MeshGLTest. This doesn't actually fix the WebGL-specific error (there it additionally disallows mismatched signedness in a vertex attribute) but is nevertheless good to have correct.
5 years ago
const auto value = Checker(IntegerShader("uint"), RenderbufferFormat::R16UI, mesh)
.get<UnsignedShort>(PixelFormat::RedInteger, PixelType::UnsignedShort);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
GL: XFAIL on SwiftShader with integer data type mismatches. Accepted everywhere else (or so is my experience).
7 years ago
#if defined(MAGNUM_TARGET_GLES) && !defined(MAGNUM_TARGET_WEBGL)
CORRADE_EXPECT_FAIL_IF(Context::current().detectedDriver() & Context::DetectedDriver::SwiftShader,
"SwiftShader doesn't like integer buffers with anything else than (Unsigned)Int");
#endif
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
CORRADE_COMPARE(value, 16583);
}
void MeshGLTest::addVertexBufferIntWithUnsignedShort() {
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::EXT::gpu_shader4>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() << "is not supported.");
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#endif
Fix AMD complaints about misaligned data in Mesh GL test.
11 years ago
constexpr UnsignedShort data[] = { 0, 49563, 2128, 3821, 16583 };
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 2, 2, Attribute<0, Int>{Attribute<0, Int>::DataType::UnsignedShort});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 4, 4, DynamicAttribute{
DynamicAttribute::Kind::Integral, 0,
DynamicAttribute::Components::One,
DynamicAttribute::DataType::UnsignedShort});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
GL: make renderbuffer format match the shader format in MeshGLTest. This doesn't actually fix the WebGL-specific error (there it additionally disallows mismatched signedness in a vertex attribute) but is nevertheless good to have correct.
5 years ago
const auto value = Checker(IntegerShader("int"), RenderbufferFormat::R16I, mesh)
.get<Short>(PixelFormat::RedInteger, PixelType::Short);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
GL: XFAIL on SwiftShader with integer data type mismatches. Accepted everywhere else (or so is my experience).
7 years ago
#if defined(MAGNUM_TARGET_GLES) && !defined(MAGNUM_TARGET_WEBGL)
CORRADE_EXPECT_FAIL_IF(Context::current().detectedDriver() & Context::DetectedDriver::SwiftShader,
"SwiftShader doesn't like integer buffers with anything else than (Unsigned)Int");
#endif
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
CORRADE_COMPARE(value, 16583);
}
void MeshGLTest::addVertexBufferIntWithShort() {
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::EXT::gpu_shader4>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() << "is not supported.");
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#endif
Fix AMD complaints about misaligned data in Mesh GL test.
11 years ago
constexpr Short data[] = { 0, 24563, 2128, 3821, -16583 };
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 2, 2, Attribute<0, Int>{Attribute<0, Int>::DataType::Short});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 4, 4, DynamicAttribute{
DynamicAttribute::Kind::Integral, 0,
DynamicAttribute::Components::One,
DynamicAttribute::DataType::Short});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
GL: fix MeshGLTest on WebGL. It doesn't allow anything except full RGBA and 32-bit types to be read from the framebuffer. Chromium browsers weren't complaining but Firefox did. I remember a similar restriction from GLES2 but all implementations I tested with including ANGLE and SwiftShader allow that already, so it's practically just a WebGL limitation.
5 years ago
const Short value = Checker(IntegerShader("int"), RenderbufferFormat::R16I, mesh)
#ifndef MAGNUM_TARGET_WEBGL
.get<Short>(PixelFormat::RedInteger, PixelType::Short)
#else
.get<Int>(PixelFormat::RGBAInteger, PixelType::Int)
#endif
;
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
GL: XFAIL on SwiftShader with integer data type mismatches. Accepted everywhere else (or so is my experience).
7 years ago
#if defined(MAGNUM_TARGET_GLES) && !defined(MAGNUM_TARGET_WEBGL)
CORRADE_EXPECT_FAIL_IF(Context::current().detectedDriver() & Context::DetectedDriver::SwiftShader,
"SwiftShader doesn't like integer buffers with anything else than (Unsigned)Int");
#endif
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
CORRADE_COMPARE(value, -16583);
}
#endif
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2))
GL: rename PixelType::HalfFloat and Attribute::DataType::HalfFloat to Half. For consistency with the Half type we use elsewhere. The old enums are still available, but deprecated and scheduled for removal.
6 years ago
void MeshGLTest::addVertexBufferFloatWithHalf() {
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::half_float_vertex>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::half_float_vertex::string() << "is not supported.");
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#elif defined(MAGNUM_TARGET_GLES2)
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::OES::vertex_half_float>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::OES::vertex_half_float::string() << "is not supported.");
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#endif
Test: we have halves now, so why not test them.
9 years ago
const Half data[] = { 0.0_h, -0.7_h, Half(Math::unpack<Float, UnsignedByte>(186)) };
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Buffer buffer;
Test: we have halves now, so why not test them.
9 years ago
buffer.setData(data, BufferUsage::StaticDraw);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
GL: rename PixelType::HalfFloat and Attribute::DataType::HalfFloat to Half. For consistency with the Half type we use elsewhere. The old enums are still available, but deprecated and scheduled for removal.
6 years ago
mesh.addVertexBuffer(buffer, 2, Attribute<0, Float>{Attribute<0, Float>::DataType::Half});
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 2, 2, DynamicAttribute{
DynamicAttribute::Kind::Generic, 0,
DynamicAttribute::Components::One,
GL: rename PixelType::HalfFloat and Attribute::DataType::HalfFloat to Half. For consistency with the Half type we use elsewhere. The old enums are still available, but deprecated and scheduled for removal.
6 years ago
DynamicAttribute::DataType::Half});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Test: we have halves now, so why not test them.
9 years ago
const auto value = Checker(FloatShader("float", "vec4(valueInterpolated, 0.0, 0.0, 0.0)"),
Test: what am I doing here?! Fixes test failure on ES3.
8 years ago
RenderbufferFormat::RGBA8, mesh).get<UnsignedByte>(PixelFormat::RGBA, PixelType::UnsignedByte);
Test: we have halves now, so why not test them.
9 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Test: we have halves now, so why not test them.
9 years ago
CORRADE_COMPARE(value, 186);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
}
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#endif
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#ifndef MAGNUM_TARGET_GLES
void MeshGLTest::addVertexBufferFloatWithDouble() {
Math: renamed {de,}normalize() to {,un}pack() in a new Packing.h header. To be more consistent with GLSL naming. Also, the original naming was quite misleading, as normalize() is used in GLSL for something completely different. If building with deprecated APIs, the Functions.h header includes the new Packing.h header and the {de,}normalize() functions are defined as deprecated aliases to the new functions. This will be removed at some point in the future.
9 years ago
const Double data[] = { 0.0, -0.7, Math::unpack<Double, UnsignedByte>(186) };
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Removed duplicate code from MeshGLTest. As there is now no distinction between vertex and index count we don't need separate checker utility for non-indexed and indexed meshes.
12 years ago
mesh.setBaseVertex(1)
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
.addVertexBuffer(buffer, 8, Attribute<0, Float>(Attribute<0, Float>::DataType::Double));
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 8, Attribute<0, Float>{Attribute<0, Float>::DataType::Double});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 8, 8, DynamicAttribute{
DynamicAttribute::Kind::Generic, 0,
DynamicAttribute::Components::One,
DynamicAttribute::DataType::Double});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
const auto value = Checker(FloatShader("float", "vec4(valueInterpolated, 0.0, 0.0, 0.0)"),
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
RenderbufferFormat::RGBA8, mesh).get<UnsignedByte>(PixelFormat::RGBA, PixelType::UnsignedShort);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
CORRADE_COMPARE(value, 186);
}
Implemented ARB_vertex_type_10f_11f_11f_rev (GL 4.4). Please don't look into AbstractShaderProgram::Attribute implementation. Your life will never be the same afterwards.
12 years ago
void MeshGLTest::addVertexBufferVector3WithUnsignedInt10f11f11fRev() {
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_type_10f_11f_11f_rev>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::vertex_type_10f_11f_11f_rev::string() << "is not supported.");
Implemented ARB_vertex_type_10f_11f_11f_rev (GL 4.4). Please don't look into AbstractShaderProgram::Attribute implementation. Your life will never be the same afterwards.
12 years ago
#endif
Buffer buffer;
buffer.setData({nullptr, 12}, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 4, Attribute<0, Vector3>{Attribute<0, Vector3>::DataType::UnsignedInt10f11f11fRev});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 4, 4, DynamicAttribute{
DynamicAttribute::Kind::Generic, 0,
DynamicAttribute::Components::Three,
DynamicAttribute::DataType::UnsignedInt10f11f11fRev});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Implemented ARB_vertex_type_10f_11f_11f_rev (GL 4.4). Please don't look into AbstractShaderProgram::Attribute implementation. Your life will never be the same afterwards.
12 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Implemented ARB_vertex_type_10f_11f_11f_rev (GL 4.4). Please don't look into AbstractShaderProgram::Attribute implementation. Your life will never be the same afterwards.
12 years ago
/* Won't test the actual values */
}
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#endif
#ifndef MAGNUM_TARGET_GLES2
void MeshGLTest::addVertexBufferVector4WithUnsignedInt2101010Rev() {
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_type_2_10_10_10_rev>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::vertex_type_2_10_10_10_rev::string() << "is not supported.");
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#endif
Buffer buffer;
buffer.setData({nullptr, 12}, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 4, Attribute<0, Vector4>{Attribute<0, Vector4>::DataType::UnsignedInt2101010Rev});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 4, 4, DynamicAttribute{
DynamicAttribute::Kind::Generic, 0,
DynamicAttribute::Components::Four,
DynamicAttribute::DataType::UnsignedInt2101010Rev});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
/* Won't test the actual values */
}
void MeshGLTest::addVertexBufferVector4WithInt2101010Rev() {
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_type_2_10_10_10_rev>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::vertex_type_2_10_10_10_rev::string() << "is not supported.");
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#endif
Buffer buffer;
buffer.setData({nullptr, 12}, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 4, Attribute<0, Vector4>{Attribute<0, Vector4>::DataType::Int2101010Rev});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 4, 4, DynamicAttribute{
DynamicAttribute::Kind::Generic, 0,
DynamicAttribute::Components::Four,
DynamicAttribute::DataType::Int2101010Rev});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
/* Won't test the actual values */
}
#endif
void MeshGLTest::addVertexBufferLessVectorComponents() {
const Vector3 data[] = {
{}, {0.0f, -0.9f, 1.0f},
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
0x60189c_rgbf
#else
GL: fix a confusing typo in a comment.
5 years ago
/* Using only RGBA4, supply less precision. This has to be done on the
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
input because SwiftShader stores RGBA4 as RGBA8 internally, thus
preserving the full precision of the input. */
0x551199_rgbf
#endif
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
};
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
mesh.addVertexBuffer(buffer, 3*4, Attribute<0, Vector4>{Attribute<0, Vector4>::Components::Three});
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 3*4, 3*4, DynamicAttribute{
DynamicAttribute::Kind::Generic, 0,
DynamicAttribute::Components::Three,
DynamicAttribute::DataType::Float});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
const auto value = Checker(FloatShader("vec4", "valueInterpolated"),
#ifndef MAGNUM_TARGET_GLES2
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
mesh).get<Color4ub>(PixelFormat::RGBA, PixelType::UnsignedByte);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_COMPARE(value, 0x60189cff_rgba);
#else /* RGBA4, so less precision */
CORRADE_COMPARE(value, 0x551199ff_rgba);
#endif
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
}
void MeshGLTest::addVertexBufferNormalized() {
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
constexpr Color4ub data[] = { {}, {0, 128, 64},
#ifndef MAGNUM_TARGET_GLES2
0x209ce4_rgb
#else
GL: fix a confusing typo in a comment.
5 years ago
/* Using only RGBA4, supply less precision. This has to be done on the
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
input because SwiftShader stores RGBA4 as RGBA8 internally, thus
preserving the full precision of the input. */
0x1199dd_rgb
#endif
};
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
typedef Attribute<0, Vector3> Attribute;
mesh.addVertexBuffer(buffer, 4, Attribute(Attribute::DataType::UnsignedByte, Attribute::DataOption::Normalized), 1);
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 4, 4, DynamicAttribute{
DynamicAttribute::Kind::GenericNormalized, 0,
DynamicAttribute::Components::Three,
DynamicAttribute::DataType::UnsignedByte});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
const auto value = Checker(FloatShader("vec3", "vec4(valueInterpolated, 0.0)"),
#ifndef MAGNUM_TARGET_GLES2
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
GL: avoid using deprecated templated Image::data() in tests. This discovered quite a few potentially dangerous casts, so yay!
7 years ago
mesh).get<Color4ub>(PixelFormat::RGBA, PixelType::UnsignedByte);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
GL: avoid using deprecated templated Image::data() in tests. This discovered quite a few potentially dangerous casts, so yay!
7 years ago
CORRADE_COMPARE(value.xyz(), 0x209ce4_rgb);
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#else /* RGBA4, so less precision */
GL: avoid using deprecated templated Image::data() in tests. This discovered quite a few potentially dangerous casts, so yay!
7 years ago
CORRADE_COMPARE(value.xyz(), 0x1199dd_rgb);
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#endif
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
}
#ifndef MAGNUM_TARGET_GLES
void MeshGLTest::addVertexBufferBGRA() {
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_array_bgra>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::vertex_array_bgra::string() << "is not supported.");
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
constexpr Color4ub data[] = { {}, {0, 128, 64, 161}, {96, 24, 156, 225} };
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Ability to specify shader attribute properties fully at runtime. There's a new DynamicAttribute class that is very similar to Attribute, but it has the location and base type as runtime properties instead of them being a part of template. This allows for more flexibility, but OTOH also more typing and more responsibility on the user. See MeshGLTest for details and usage comparison to the Attribute API.
9 years ago
mesh.setBaseVertex(1);
if(testCaseInstanceId() == 0) {
setTestCaseDescription("Attribute");
typedef Attribute<0, Vector4> Attribute;
mesh.addVertexBuffer(buffer, 4, Attribute(Attribute::Components::BGRA, Attribute::DataType::UnsignedByte, Attribute::DataOption::Normalized));
} else if(testCaseInstanceId() == 1) {
setTestCaseDescription("DynamicAttribute");
mesh.addVertexBuffer(buffer, 4, 4, DynamicAttribute{
DynamicAttribute::Kind::GenericNormalized, 0,
DynamicAttribute::Components::BGRA,
DynamicAttribute::DataType::UnsignedByte});
Adapted to Corrade changes.
6 years ago
} else CORRADE_INTERNAL_ASSERT_UNREACHABLE();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
const auto value = Checker(FloatShader("vec4", "valueInterpolated"),
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
RenderbufferFormat::RGBA8, mesh).get<Color4ub>(PixelFormat::RGBA, PixelType::UnsignedByte);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
CORRADE_COMPARE(value, Color4ub(156, 24, 96, 225));
}
#endif
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
struct MultipleShader: AbstractShaderProgram {
typedef Attribute<0, Vector3> Position;
typedef Attribute<1, Vector3> Normal;
typedef Attribute<2, Vector2> TextureCoordinates;
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
explicit MultipleShader();
};
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Various documentation fixes and updates. {} in Matrix constructor caused Doxygen to forget all functions after it.
13 years ago
#ifndef DOXYGEN_GENERATING_OUTPUT
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
MultipleShader::MultipleShader() {
#ifndef MAGNUM_TARGET_GLES
Don't use GLSL < 130 in GL tests on OSX. OSX doesn't support anything below what's in GL 3.1 when using core contexts.
10 years ago
Shader vert(
#ifndef CORRADE_TARGET_APPLE
Version::GL210
#else
Version::GL310
#endif
, Shader::Type::Vertex);
Shader frag(
#ifndef CORRADE_TARGET_APPLE
Version::GL210
#else
Version::GL310
#endif
, Shader::Type::Fragment);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#else
Shader vert(Version::GLES200, Shader::Type::Vertex);
Make use of threaded shader compilation in MeshGLTest.
12 years ago
Shader frag(Version::GLES200, Shader::Type::Fragment);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#endif
Don't use GLSL < 130 in GL tests on OSX. OSX doesn't support anything below what's in GL 3.1 when using core contexts.
10 years ago
vert.addSource(
"#if !defined(GL_ES) && __VERSION__ == 120\n"
"#define mediump\n"
"#endif\n"
"#if defined(GL_ES) || __VERSION__ == 120\n"
"#define in attribute\n"
"#define out varying\n"
"#endif\n"
"in mediump vec4 position;\n"
"in mediump vec3 normal;\n"
"in mediump vec2 textureCoordinates;\n"
"out mediump vec4 valueInterpolated;\n"
"void main() {\n"
" valueInterpolated = position + vec4(normal, 0.0) + vec4(textureCoordinates, 0.0, 0.0);\n"
" gl_Position = vec4(0.0, 0.0, 0.0, 1.0);\n"
"}\n");
frag.addSource(
"#if !defined(GL_ES) && __VERSION__ == 120\n"
"#define mediump\n"
"#endif\n"
"#if defined(GL_ES) || __VERSION__ == 120\n"
"#define in varying\n"
"#define result gl_FragColor\n"
"#endif\n"
"in mediump vec4 valueInterpolated;\n"
"#if !defined(GL_ES) && __VERSION__ >= 130\n"
"out mediump vec4 result;\n"
"#endif\n"
"void main() { result = valueInterpolated; }\n");
Make use of threaded shader compilation in MeshGLTest.
12 years ago
CORRADE_INTERNAL_ASSERT_OUTPUT(Shader::compile({vert, frag}));
Use threaded shader compilation etc. also in tests.
12 years ago
attachShaders({vert, frag});
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
bindAttributeLocation(Position::Location, "position");
bindAttributeLocation(Normal::Location, "normal");
bindAttributeLocation(TextureCoordinates::Location, "textureCoordinates");
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
}
Various documentation fixes and updates. {} in Matrix constructor caused Doxygen to forget all functions after it.
13 years ago
#endif
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
void MeshGLTest::addVertexBufferMultiple() {
const Float data[] = {
0.0f, /* Offset */
/* First attribute */
0.3f, 0.1f, 0.5f,
0.4f, 0.0f, -0.9f,
1.0f, -0.5f,
/* Second attribute */
Math: renamed {de,}normalize() to {,un}pack() in a new Packing.h header. To be more consistent with GLSL naming. Also, the original naming was quite misleading, as normalize() is used in GLSL for something completely different. If building with deprecated APIs, the Functions.h header includes the new Packing.h header and the {de,}normalize() functions are defined as deprecated aliases to the new functions. This will be removed at some point in the future.
9 years ago
Math::unpack<Float, UnsignedByte>(64),
Math::unpack<Float, UnsignedByte>(17),
Math::unpack<Float, UnsignedByte>(56),
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
Math: renamed {de,}normalize() to {,un}pack() in a new Packing.h header. To be more consistent with GLSL naming. Also, the original naming was quite misleading, as normalize() is used in GLSL for something completely different. If building with deprecated APIs, the Functions.h header includes the new Packing.h header and the {de,}normalize() functions are defined as deprecated aliases to the new functions. This will be removed at some point in the future.
9 years ago
Math::unpack<Float, UnsignedByte>(15),
Math::unpack<Float, UnsignedByte>(164),
Math::unpack<Float, UnsignedByte>(17),
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#else
GL: fix a confusing typo in a comment.
5 years ago
/* Using only RGBA4, supply less precision. This has to be done on the
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
input because SwiftShader stores RGBA4 as RGBA8 internally, thus
preserving the full precision of the input. */
Math::unpack<Float, UnsignedByte>(9),
Math::unpack<Float, UnsignedByte>(159),
Math::unpack<Float, UnsignedByte>(12),
#endif
Math: renamed {de,}normalize() to {,un}pack() in a new Packing.h header. To be more consistent with GLSL naming. Also, the original naming was quite misleading, as normalize() is used in GLSL for something completely different. If building with deprecated APIs, the Functions.h header includes the new Packing.h header and the {de,}normalize() functions are defined as deprecated aliases to the new functions. This will be removed at some point in the future.
9 years ago
Math::unpack<Float, UnsignedByte>(97),
Math::unpack<Float, UnsignedByte>(28)
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
};
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Removed duplicate code from MeshGLTest. As there is now no distinction between vertex and index count we don't need separate checker utility for non-indexed and indexed meshes.
12 years ago
mesh.setBaseVertex(1)
.addVertexBuffer(buffer, 1*4, MultipleShader::Position(),
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
MultipleShader::Normal(), MultipleShader::TextureCoordinates());
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
const auto value = Checker(MultipleShader(),
#ifndef MAGNUM_TARGET_GLES2
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
mesh).get<Color4ub>(PixelFormat::RGBA, PixelType::UnsignedByte);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
CORRADE_COMPARE(value, Color4ub(64 + 15 + 97, 17 + 164 + 28, 56 + 17, 255));
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#else /* RGBA4, so less precision */
CORRADE_COMPARE(value, 0xaacc44ff_rgba);
#endif
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
}
void MeshGLTest::addVertexBufferMultipleGaps() {
const Float data[] = {
0.0f, 0.0f, 0.0f, 0.0f, /* Offset */
/* First attribute */
0.3f, 0.1f, 0.5f, 0.0f,
0.4f, 0.0f, -0.9f, 0.0f,
1.0f, -0.5f, 0.0f, 0.0f,
/* Second attribute */
Math: renamed {de,}normalize() to {,un}pack() in a new Packing.h header. To be more consistent with GLSL naming. Also, the original naming was quite misleading, as normalize() is used in GLSL for something completely different. If building with deprecated APIs, the Functions.h header includes the new Packing.h header and the {de,}normalize() functions are defined as deprecated aliases to the new functions. This will be removed at some point in the future.
9 years ago
Math::unpack<Float, UnsignedByte>(64),
Math::unpack<Float, UnsignedByte>(17),
Math::unpack<Float, UnsignedByte>(56), 0.0f,
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
Math: renamed {de,}normalize() to {,un}pack() in a new Packing.h header. To be more consistent with GLSL naming. Also, the original naming was quite misleading, as normalize() is used in GLSL for something completely different. If building with deprecated APIs, the Functions.h header includes the new Packing.h header and the {de,}normalize() functions are defined as deprecated aliases to the new functions. This will be removed at some point in the future.
9 years ago
Math::unpack<Float, UnsignedByte>(15),
Math::unpack<Float, UnsignedByte>(164),
Math::unpack<Float, UnsignedByte>(17), 0.0f,
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#else
/* Using only RGBA4, supply less precision. This has to be one on the
input because SwiftShader stores RGBA4 as RGBA8 internally, thus
preserving the full precision of the input. */
Math::unpack<Float, UnsignedByte>(9),
Math::unpack<Float, UnsignedByte>(159),
Math::unpack<Float, UnsignedByte>(12), 0.0f,
#endif
Math: renamed {de,}normalize() to {,un}pack() in a new Packing.h header. To be more consistent with GLSL naming. Also, the original naming was quite misleading, as normalize() is used in GLSL for something completely different. If building with deprecated APIs, the Functions.h header includes the new Packing.h header and the {de,}normalize() functions are defined as deprecated aliases to the new functions. This will be removed at some point in the future.
9 years ago
Math::unpack<Float, UnsignedByte>(97),
Math::unpack<Float, UnsignedByte>(28), 0.0f, 0.0f
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
};
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Removed duplicate code from MeshGLTest. As there is now no distinction between vertex and index count we don't need separate checker utility for non-indexed and indexed meshes.
12 years ago
mesh.setBaseVertex(1)
.addVertexBuffer(buffer, 4*4,
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
MultipleShader::Position(), 1*4,
MultipleShader::Normal(), 1*4,
MultipleShader::TextureCoordinates(), 2*4);
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
const auto value = Checker(MultipleShader(),
#ifndef MAGNUM_TARGET_GLES2
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
mesh).get<Color4ub>(PixelFormat::RGBA, PixelType::UnsignedByte);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
CORRADE_COMPARE(value, Color4ub(64 + 15 + 97, 17 + 164 + 28, 56 + 17, 255));
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#else /* RGBA4, so less precision */
CORRADE_COMPARE(value, 0xaacc44ff_rgba);
#endif
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
}
GL: assert that addVertexBuffer() is called with a valid Buffer.
8 years ago
void MeshGLTest::addVertexBufferMovedOutInstance() {
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
GL: assert that addVertexBuffer() is called with a valid Buffer.
8 years ago
Buffer buffer{NoCreate};
Mesh mesh;
std::ostringstream out;
Error redirectError{&out};
mesh.addVertexBuffer(buffer, 0, Attribute<0, Float>{});
CORRADE_COMPARE(out.str(), "GL::Mesh::addVertexBuffer(): empty or moved-out Buffer instance was passed\n");
}
GL: make it possible for a Mesh to own the vertex/index buffers. I wanted to do this since 2015.
8 years ago
void MeshGLTest::addVertexBufferTransferOwnwership() {
const Float data = 1.0f;
Buffer buffer;
buffer.setData({&data, 1}, BufferUsage::StaticDraw);
const GLuint id = buffer.id();
CORRADE_VERIFY(glIsBuffer(id));
{
Mesh mesh;
mesh.addVertexBuffer(buffer, 0, Attribute<0, Float>{});
CORRADE_VERIFY(buffer.id());
CORRADE_VERIFY(glIsBuffer(id));
}
CORRADE_VERIFY(glIsBuffer(id));
{
Mesh mesh;
mesh.addVertexBuffer(std::move(buffer), 0, Attribute<0, Float>{});
CORRADE_VERIFY(!buffer.id());
CORRADE_VERIFY(glIsBuffer(id));
}
CORRADE_VERIFY(!glIsBuffer(id));
}
void MeshGLTest::addVertexBufferInstancedTransferOwnwership() {
GL: disable indexed Mesh tests on drivers w/o indexed extensions.
7 years ago
#ifndef MAGNUM_TARGET_GLES
if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
GL: disable indexed Mesh tests on drivers w/o indexed extensions.
7 years ago
#elif defined(MAGNUM_TARGET_GLES2)
#ifndef MAGNUM_TARGET_WEBGL
if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>() &&
!Context::current().isExtensionSupported<Extensions::EXT::instanced_arrays>() &&
!Context::current().isExtensionSupported<Extensions::NV::instanced_arrays>())
CORRADE_SKIP("Required extension is not available.");
#else
if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ANGLE::instanced_arrays::string() << "is not supported.");
GL: disable indexed Mesh tests on drivers w/o indexed extensions.
7 years ago
#endif
#endif
GL: make it possible for a Mesh to own the vertex/index buffers. I wanted to do this since 2015.
8 years ago
const Float data = 1.0f;
Buffer buffer;
buffer.setData({&data, 1}, BufferUsage::StaticDraw);
const GLuint id = buffer.id();
CORRADE_VERIFY(glIsBuffer(id));
{
Mesh mesh;
mesh.addVertexBufferInstanced(buffer, 1, 0, Attribute<0, Float>{});
CORRADE_VERIFY(buffer.id());
CORRADE_VERIFY(glIsBuffer(id));
}
CORRADE_VERIFY(glIsBuffer(id));
{
Mesh mesh;
mesh.addVertexBufferInstanced(std::move(buffer), 1, 0, Attribute<0, Float>{});
CORRADE_VERIFY(!buffer.id());
CORRADE_VERIFY(glIsBuffer(id));
}
CORRADE_VERIFY(!glIsBuffer(id));
}
void MeshGLTest::addVertexBufferDynamicTransferOwnwership() {
const Float data = 1.0f;
Buffer buffer;
buffer.setData({&data, 1}, BufferUsage::StaticDraw);
const GLuint id = buffer.id();
CORRADE_VERIFY(glIsBuffer(id));
{
Mesh mesh;
mesh.addVertexBuffer(buffer, 0, 4, DynamicAttribute{
DynamicAttribute::Kind::GenericNormalized, 0,
DynamicAttribute::Components::One,
DynamicAttribute::DataType::Float});
CORRADE_VERIFY(buffer.id());
CORRADE_VERIFY(glIsBuffer(id));
}
CORRADE_VERIFY(glIsBuffer(id));
{
Mesh mesh;
mesh.addVertexBuffer(std::move(buffer), 0, 4, DynamicAttribute{
DynamicAttribute::Kind::GenericNormalized, 0,
DynamicAttribute::Components::One,
DynamicAttribute::DataType::Float});
CORRADE_VERIFY(!buffer.id());
CORRADE_VERIFY(glIsBuffer(id));
}
CORRADE_VERIFY(!glIsBuffer(id));
}
void MeshGLTest::addVertexBufferInstancedDynamicTransferOwnwership() {
GL: disable indexed Mesh tests on drivers w/o indexed extensions.
7 years ago
#ifndef MAGNUM_TARGET_GLES
if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
GL: disable indexed Mesh tests on drivers w/o indexed extensions.
7 years ago
#elif defined(MAGNUM_TARGET_GLES2)
#ifndef MAGNUM_TARGET_WEBGL
if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>() &&
!Context::current().isExtensionSupported<Extensions::EXT::instanced_arrays>() &&
!Context::current().isExtensionSupported<Extensions::NV::instanced_arrays>())
CORRADE_SKIP("Required extension is not available.");
#else
if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ANGLE::instanced_arrays::string() << "is not supported.");
GL: disable indexed Mesh tests on drivers w/o indexed extensions.
7 years ago
#endif
#endif
GL: make it possible for a Mesh to own the vertex/index buffers. I wanted to do this since 2015.
8 years ago
const Float data = 1.0f;
Buffer buffer;
buffer.setData({&data, 1}, BufferUsage::StaticDraw);
const GLuint id = buffer.id();
CORRADE_VERIFY(glIsBuffer(id));
{
Mesh mesh;
mesh.addVertexBufferInstanced(buffer, 1, 0, 4, DynamicAttribute{
DynamicAttribute::Kind::GenericNormalized, 0,
DynamicAttribute::Components::One,
DynamicAttribute::DataType::Float});
CORRADE_VERIFY(buffer.id());
CORRADE_VERIFY(glIsBuffer(id));
}
CORRADE_VERIFY(glIsBuffer(id));
{
Mesh mesh;
mesh.addVertexBufferInstanced(std::move(buffer), 1, 0, 4, DynamicAttribute{
DynamicAttribute::Kind::GenericNormalized, 0,
DynamicAttribute::Components::One,
DynamicAttribute::DataType::Float});
CORRADE_VERIFY(!buffer.id());
CORRADE_VERIFY(glIsBuffer(id));
}
CORRADE_VERIFY(!glIsBuffer(id));
}
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
const Float indexedVertexData[] = {
0.0f, /* Offset */
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
/* First vertex */
Math::unpack<Float, UnsignedByte>(64),
Math::unpack<Float, UnsignedByte>(17),
Math::unpack<Float, UnsignedByte>(56),
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
Math::unpack<Float, UnsignedByte>(15),
Math::unpack<Float, UnsignedByte>(164),
Math: renamed {de,}normalize() to {,un}pack() in a new Packing.h header. To be more consistent with GLSL naming. Also, the original naming was quite misleading, as normalize() is used in GLSL for something completely different. If building with deprecated APIs, the Functions.h header includes the new Packing.h header and the {de,}normalize() functions are defined as deprecated aliases to the new functions. This will be removed at some point in the future.
9 years ago
Math::unpack<Float, UnsignedByte>(17),
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#else
/* Using only RGBA4, supply less precision. This has to be one on the input
because SwiftShader stores RGBA4 as RGBA8 internally, thus preserving
the full precision of the input. */
Math::unpack<Float, UnsignedByte>(9),
Math::unpack<Float, UnsignedByte>(159),
Math::unpack<Float, UnsignedByte>(12),
#endif
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
Math::unpack<Float, UnsignedByte>(97),
Math::unpack<Float, UnsignedByte>(28),
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
/* Second vertex */
0.3f, 0.1f, 0.5f,
0.4f, 0.0f, -0.9f,
1.0f, -0.5f
};
Cleanup and code reorganization in MeshGLTest.
12 years ago
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
const Float indexedVertexDataBaseVertex[] = {
0.0f, 0.0f, /* Offset */
Cleanup and code reorganization in MeshGLTest.
12 years ago
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
/* First vertex */
0.0f, 0.0f, 0.0f,
Cleanup and code reorganization in MeshGLTest.
12 years ago
0.0f, 0.0f, 0.0f,
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
0.0f, 0.0f,
Cleanup and code reorganization in MeshGLTest.
12 years ago
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
/* Second vertex */
0.0f, 0.0f, 0.0f,
Cleanup and code reorganization in MeshGLTest.
12 years ago
0.0f, 0.0f, 0.0f,
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
0.0f, 0.0f,
/* Third vertex */
Math::unpack<Float, UnsignedByte>(64),
Math::unpack<Float, UnsignedByte>(17),
Math::unpack<Float, UnsignedByte>(56),
Math::unpack<Float, UnsignedByte>(15),
Math::unpack<Float, UnsignedByte>(164),
Math: renamed {de,}normalize() to {,un}pack() in a new Packing.h header. To be more consistent with GLSL naming. Also, the original naming was quite misleading, as normalize() is used in GLSL for something completely different. If building with deprecated APIs, the Functions.h header includes the new Packing.h header and the {de,}normalize() functions are defined as deprecated aliases to the new functions. This will be removed at some point in the future.
9 years ago
Math::unpack<Float, UnsignedByte>(17),
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
Math::unpack<Float, UnsignedByte>(97),
Math::unpack<Float, UnsignedByte>(28),
Cleanup and code reorganization in MeshGLTest.
12 years ago
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
/* Fourth vertex */
0.3f, 0.1f, 0.5f,
0.4f, 0.0f, -0.9f,
1.0f, -0.5f
};
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
constexpr Color4ub indexedResult{64 + 15 + 97, 17 + 164 + 28, 56 + 17, 255};
#else /* RGBA4, so less precision */
constexpr Color4ub indexedResult{0xaa, 0xcc, 0x44, 0xff};
#endif
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 11: generic MeshPrimitive and MeshIndexType. Similarly to pixel formats, there is now generic Magnum::MeshPrimitive and Magnum::MeshIndexType, which is convertible to GL::MeshPrimitive and GL::MeshIndexType using GL::meshPrimitive() and GL::meshIndexType(). In addition, the following is done: * The original GL::Mesh::IndexType is now GL::MeshIndexType, original name is now just a typedef. * GL::Mesh::indexSize() is deprecated in favor of Magnum::meshIndexTypeSize() and GL::Mesh::indexTypeSize(). * New GL::Mesh::indexType() and GL::MeshView::mesh() getters (not sure why they were omitted) * GL::Mesh::indexType(), GL::Mesh::indexTypeSize(), GL::MeshView::setIndexRange() now expect that the mesh is indexed (useful property in my opinion, also avoids getting random results). * The extra MeshPrimitive::LinesAdjacency etc. are still present for backwards compatibility, but marked as deprecated. Use GL::MeshPrimitive values instead.
8 years ago
template<class T> void MeshGLTest::setIndexBuffer() {
Test: use the new setTestCaseTemplateName().
7 years ago
setTestCaseTemplateName(std::is_same<T, MeshIndexType>::value ?
"GL::MeshIndexType" : "Magnum::MeshIndexType");
Split the OpenGL layer out, pt 11: generic MeshPrimitive and MeshIndexType. Similarly to pixel formats, there is now generic Magnum::MeshPrimitive and Magnum::MeshIndexType, which is convertible to GL::MeshPrimitive and GL::MeshIndexType using GL::meshPrimitive() and GL::meshIndexType(). In addition, the following is done: * The original GL::Mesh::IndexType is now GL::MeshIndexType, original name is now just a typedef. * GL::Mesh::indexSize() is deprecated in favor of Magnum::meshIndexTypeSize() and GL::Mesh::indexTypeSize(). * New GL::Mesh::indexType() and GL::MeshView::mesh() getters (not sure why they were omitted) * GL::Mesh::indexType(), GL::Mesh::indexTypeSize(), GL::MeshView::setIndexRange() now expect that the mesh is indexed (useful property in my opinion, also avoids getting random results). * The extra MeshPrimitive::LinesAdjacency etc. are still present for backwards compatibility, but marked as deprecated. Use GL::MeshPrimitive values instead.
8 years ago
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Buffer vertices;
vertices.setData(indexedVertexData, BufferUsage::StaticDraw);
Split the OpenGL layer out, pt 11: generic MeshPrimitive and MeshIndexType. Similarly to pixel formats, there is now generic Magnum::MeshPrimitive and Magnum::MeshIndexType, which is convertible to GL::MeshPrimitive and GL::MeshIndexType using GL::meshPrimitive() and GL::meshIndexType(). In addition, the following is done: * The original GL::Mesh::IndexType is now GL::MeshIndexType, original name is now just a typedef. * GL::Mesh::indexSize() is deprecated in favor of Magnum::meshIndexTypeSize() and GL::Mesh::indexTypeSize(). * New GL::Mesh::indexType() and GL::MeshView::mesh() getters (not sure why they were omitted) * GL::Mesh::indexType(), GL::Mesh::indexTypeSize(), GL::MeshView::setIndexRange() now expect that the mesh is indexed (useful property in my opinion, also avoids getting random results). * The extra MeshPrimitive::LinesAdjacency etc. are still present for backwards compatibility, but marked as deprecated. Use GL::MeshPrimitive values instead.
8 years ago
constexpr UnsignedByte indexData[] = { 2, 1, 0 };
Implemented indexed buffer binding. The indexed binding is allowed for only some types (atomic counters, uniforms, shader storage and transform feedback), thus we need separate enum for that. Because the bind() function will be used far more often than setTargetHint(), the original Target enum is now renamed to TargetHint and the new Target enum contains (in non-deprecated build) only three values. For backwards compatibility, though, we need to have all original Target values, thus the new Target enum contains also all other values from TargetHint, but they are marked as deprecated and (at least) run-time checked in bind() so they aren't accidentaly used for indexed binding. Similarly there are also deprecated Target overloads of Buffer() and setTargetHint(). It's ugly, but hopefully will suffice for now. This mess will be removed as soon as possible in some upcoming version.
12 years ago
Buffer indices{Buffer::TargetHint::ElementArray};
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
indices.setData(indexData, BufferUsage::StaticDraw);
Mesh mesh;
mesh.addVertexBuffer(vertices, 1*4, MultipleShader::Position(),
MultipleShader::Normal(), MultipleShader::TextureCoordinates())
GL: fix various OOB / unaligned access issues in Mesh test.
8 years ago
.setIndexBuffer(indices, 1, T::UnsignedByte);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Split the OpenGL layer out, pt 11: generic MeshPrimitive and MeshIndexType. Similarly to pixel formats, there is now generic Magnum::MeshPrimitive and Magnum::MeshIndexType, which is convertible to GL::MeshPrimitive and GL::MeshIndexType using GL::meshPrimitive() and GL::meshIndexType(). In addition, the following is done: * The original GL::Mesh::IndexType is now GL::MeshIndexType, original name is now just a typedef. * GL::Mesh::indexSize() is deprecated in favor of Magnum::meshIndexTypeSize() and GL::Mesh::indexTypeSize(). * New GL::Mesh::indexType() and GL::MeshView::mesh() getters (not sure why they were omitted) * GL::Mesh::indexType(), GL::Mesh::indexTypeSize(), GL::MeshView::setIndexRange() now expect that the mesh is indexed (useful property in my opinion, also avoids getting random results). * The extra MeshPrimitive::LinesAdjacency etc. are still present for backwards compatibility, but marked as deprecated. Use GL::MeshPrimitive values instead.
8 years ago
CORRADE_COMPARE(mesh.indexType(), MeshIndexType::UnsignedByte);
CORRADE_COMPARE(mesh.indexTypeSize(), 1);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Removed duplicate code from MeshGLTest. As there is now no distinction between vertex and index count we don't need separate checker utility for non-indexed and indexed meshes.
12 years ago
const auto value = Checker(MultipleShader{},
#ifndef MAGNUM_TARGET_GLES2
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
mesh).get<Color4ub>(PixelFormat::RGBA, PixelType::UnsignedByte);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
CORRADE_COMPARE(value, indexedResult);
}
Split the OpenGL layer out, pt 11: generic MeshPrimitive and MeshIndexType. Similarly to pixel formats, there is now generic Magnum::MeshPrimitive and Magnum::MeshIndexType, which is convertible to GL::MeshPrimitive and GL::MeshIndexType using GL::meshPrimitive() and GL::meshIndexType(). In addition, the following is done: * The original GL::Mesh::IndexType is now GL::MeshIndexType, original name is now just a typedef. * GL::Mesh::indexSize() is deprecated in favor of Magnum::meshIndexTypeSize() and GL::Mesh::indexTypeSize(). * New GL::Mesh::indexType() and GL::MeshView::mesh() getters (not sure why they were omitted) * GL::Mesh::indexType(), GL::Mesh::indexTypeSize(), GL::MeshView::setIndexRange() now expect that the mesh is indexed (useful property in my opinion, also avoids getting random results). * The extra MeshPrimitive::LinesAdjacency etc. are still present for backwards compatibility, but marked as deprecated. Use GL::MeshPrimitive values instead.
8 years ago
template<class T> void MeshGLTest::setIndexBufferRange() {
Test: use the new setTestCaseTemplateName().
7 years ago
setTestCaseTemplateName(std::is_same<T, MeshIndexType>::value ?
"GL::MeshIndexType" : "Magnum::MeshIndexType");
Split the OpenGL layer out, pt 11: generic MeshPrimitive and MeshIndexType. Similarly to pixel formats, there is now generic Magnum::MeshPrimitive and Magnum::MeshIndexType, which is convertible to GL::MeshPrimitive and GL::MeshIndexType using GL::meshPrimitive() and GL::meshIndexType(). In addition, the following is done: * The original GL::Mesh::IndexType is now GL::MeshIndexType, original name is now just a typedef. * GL::Mesh::indexSize() is deprecated in favor of Magnum::meshIndexTypeSize() and GL::Mesh::indexTypeSize(). * New GL::Mesh::indexType() and GL::MeshView::mesh() getters (not sure why they were omitted) * GL::Mesh::indexType(), GL::Mesh::indexTypeSize(), GL::MeshView::setIndexRange() now expect that the mesh is indexed (useful property in my opinion, also avoids getting random results). * The extra MeshPrimitive::LinesAdjacency etc. are still present for backwards compatibility, but marked as deprecated. Use GL::MeshPrimitive values instead.
8 years ago
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Buffer vertices;
vertices.setData(indexedVertexData, BufferUsage::StaticDraw);
constexpr UnsignedShort indexData[] = { 2, 1, 0 };
Implemented indexed buffer binding. The indexed binding is allowed for only some types (atomic counters, uniforms, shader storage and transform feedback), thus we need separate enum for that. Because the bind() function will be used far more often than setTargetHint(), the original Target enum is now renamed to TargetHint and the new Target enum contains (in non-deprecated build) only three values. For backwards compatibility, though, we need to have all original Target values, thus the new Target enum contains also all other values from TargetHint, but they are marked as deprecated and (at least) run-time checked in bind() so they aren't accidentaly used for indexed binding. Similarly there are also deprecated Target overloads of Buffer() and setTargetHint(). It's ugly, but hopefully will suffice for now. This mess will be removed as soon as possible in some upcoming version.
12 years ago
Buffer indices{Buffer::TargetHint::ElementArray};
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
indices.setData(indexData, BufferUsage::StaticDraw);
Mesh mesh;
mesh.addVertexBuffer(vertices, 1*4, MultipleShader::Position(),
MultipleShader::Normal(), MultipleShader::TextureCoordinates())
Split the OpenGL layer out, pt 11: generic MeshPrimitive and MeshIndexType. Similarly to pixel formats, there is now generic Magnum::MeshPrimitive and Magnum::MeshIndexType, which is convertible to GL::MeshPrimitive and GL::MeshIndexType using GL::meshPrimitive() and GL::meshIndexType(). In addition, the following is done: * The original GL::Mesh::IndexType is now GL::MeshIndexType, original name is now just a typedef. * GL::Mesh::indexSize() is deprecated in favor of Magnum::meshIndexTypeSize() and GL::Mesh::indexTypeSize(). * New GL::Mesh::indexType() and GL::MeshView::mesh() getters (not sure why they were omitted) * GL::Mesh::indexType(), GL::Mesh::indexTypeSize(), GL::MeshView::setIndexRange() now expect that the mesh is indexed (useful property in my opinion, also avoids getting random results). * The extra MeshPrimitive::LinesAdjacency etc. are still present for backwards compatibility, but marked as deprecated. Use GL::MeshPrimitive values instead.
8 years ago
.setIndexBuffer(indices, 2, T::UnsignedShort, 0, 1);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Split the OpenGL layer out, pt 11: generic MeshPrimitive and MeshIndexType. Similarly to pixel formats, there is now generic Magnum::MeshPrimitive and Magnum::MeshIndexType, which is convertible to GL::MeshPrimitive and GL::MeshIndexType using GL::meshPrimitive() and GL::meshIndexType(). In addition, the following is done: * The original GL::Mesh::IndexType is now GL::MeshIndexType, original name is now just a typedef. * GL::Mesh::indexSize() is deprecated in favor of Magnum::meshIndexTypeSize() and GL::Mesh::indexTypeSize(). * New GL::Mesh::indexType() and GL::MeshView::mesh() getters (not sure why they were omitted) * GL::Mesh::indexType(), GL::Mesh::indexTypeSize(), GL::MeshView::setIndexRange() now expect that the mesh is indexed (useful property in my opinion, also avoids getting random results). * The extra MeshPrimitive::LinesAdjacency etc. are still present for backwards compatibility, but marked as deprecated. Use GL::MeshPrimitive values instead.
8 years ago
CORRADE_COMPARE(mesh.indexType(), GL::MeshIndexType::UnsignedShort);
CORRADE_COMPARE(mesh.indexTypeSize(), 2);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Removed duplicate code from MeshGLTest. As there is now no distinction between vertex and index count we don't need separate checker utility for non-indexed and indexed meshes.
12 years ago
const auto value = Checker(MultipleShader{},
#ifndef MAGNUM_TARGET_GLES2
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
mesh).get<Color4ub>(PixelFormat::RGBA, PixelType::UnsignedByte);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
CORRADE_COMPARE(value, indexedResult);
}
void MeshGLTest::setIndexBufferUnsignedInt() {
#ifdef MAGNUM_TARGET_GLES2
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::OES::element_index_uint>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::OES::element_index_uint::string() << "is not supported.");
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
#endif
Buffer vertices;
vertices.setData(indexedVertexData, BufferUsage::StaticDraw);
constexpr UnsignedInt indexData[] = { 2, 1, 0 };
Implemented indexed buffer binding. The indexed binding is allowed for only some types (atomic counters, uniforms, shader storage and transform feedback), thus we need separate enum for that. Because the bind() function will be used far more often than setTargetHint(), the original Target enum is now renamed to TargetHint and the new Target enum contains (in non-deprecated build) only three values. For backwards compatibility, though, we need to have all original Target values, thus the new Target enum contains also all other values from TargetHint, but they are marked as deprecated and (at least) run-time checked in bind() so they aren't accidentaly used for indexed binding. Similarly there are also deprecated Target overloads of Buffer() and setTargetHint(). It's ugly, but hopefully will suffice for now. This mess will be removed as soon as possible in some upcoming version.
12 years ago
Buffer indices{Buffer::TargetHint::ElementArray};
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
indices.setData(indexData, BufferUsage::StaticDraw);
Mesh mesh;
mesh.addVertexBuffer(vertices, 1*4, MultipleShader::Position(),
MultipleShader::Normal(), MultipleShader::TextureCoordinates())
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
.setIndexBuffer(indices, 4, MeshIndexType::UnsignedInt);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Split the OpenGL layer out, pt 11: generic MeshPrimitive and MeshIndexType. Similarly to pixel formats, there is now generic Magnum::MeshPrimitive and Magnum::MeshIndexType, which is convertible to GL::MeshPrimitive and GL::MeshIndexType using GL::meshPrimitive() and GL::meshIndexType(). In addition, the following is done: * The original GL::Mesh::IndexType is now GL::MeshIndexType, original name is now just a typedef. * GL::Mesh::indexSize() is deprecated in favor of Magnum::meshIndexTypeSize() and GL::Mesh::indexTypeSize(). * New GL::Mesh::indexType() and GL::MeshView::mesh() getters (not sure why they were omitted) * GL::Mesh::indexType(), GL::Mesh::indexTypeSize(), GL::MeshView::setIndexRange() now expect that the mesh is indexed (useful property in my opinion, also avoids getting random results). * The extra MeshPrimitive::LinesAdjacency etc. are still present for backwards compatibility, but marked as deprecated. Use GL::MeshPrimitive values instead.
8 years ago
CORRADE_COMPARE(mesh.indexType(), GL::MeshIndexType::UnsignedInt);
CORRADE_COMPARE(mesh.indexTypeSize(), 4);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Removed duplicate code from MeshGLTest. As there is now no distinction between vertex and index count we don't need separate checker utility for non-indexed and indexed meshes.
12 years ago
const auto value = Checker(MultipleShader{},
#ifndef MAGNUM_TARGET_GLES2
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
mesh).get<Color4ub>(PixelFormat::RGBA, PixelType::UnsignedByte);
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Fully test mesh functionality. This was painful. The test currently fails for a few reasons, see following commits.
13 years ago
CORRADE_COMPARE(value, indexedResult);
}
GL: assert that addVertexBuffer() is called with a valid Buffer.
8 years ago
void MeshGLTest::setIndexBufferMovedOutInstance() {
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
GL: assert that addVertexBuffer() is called with a valid Buffer.
8 years ago
Buffer buffer{NoCreate};
Mesh mesh;
std::ostringstream out;
Error redirectError{&out};
mesh.setIndexBuffer(buffer, 0, MeshIndexType::UnsignedByte);
CORRADE_COMPARE(out.str(), "GL::Mesh::setIndexBuffer(): empty or moved-out Buffer instance was passed\n");
}
GL: make it possible for a Mesh to own the vertex/index buffers. I wanted to do this since 2015.
8 years ago
template<class T> void MeshGLTest::setIndexBufferTransferOwnership() {
Test: use the new setTestCaseTemplateName().
7 years ago
setTestCaseTemplateName(std::is_same<T, MeshIndexType>::value ?
"GL::MeshIndexType" : "Magnum::MeshIndexType");
GL: make it possible for a Mesh to own the vertex/index buffers. I wanted to do this since 2015.
8 years ago
const UnsignedShort data = 0;
GL: properly specify Buffer target hints for tests on WebGL.
8 years ago
Buffer buffer{Buffer::TargetHint::ElementArray};
GL: make it possible for a Mesh to own the vertex/index buffers. I wanted to do this since 2015.
8 years ago
buffer.setData({&data, 1}, BufferUsage::StaticDraw);
const GLuint id = buffer.id();
CORRADE_VERIFY(glIsBuffer(id));
{
Mesh mesh;
mesh.setIndexBuffer(buffer, 0, T::UnsignedShort);
CORRADE_VERIFY(buffer.id());
CORRADE_VERIFY(glIsBuffer(id));
}
CORRADE_VERIFY(glIsBuffer(id));
{
Mesh mesh;
mesh.setIndexBuffer(std::move(buffer), 0, T::UnsignedShort);
CORRADE_VERIFY(!buffer.id());
CORRADE_VERIFY(glIsBuffer(id));
}
CORRADE_VERIFY(!glIsBuffer(id));
}
template<class T> void MeshGLTest::setIndexBufferRangeTransferOwnership() {
Test: use the new setTestCaseTemplateName().
7 years ago
setTestCaseTemplateName(std::is_same<T, MeshIndexType>::value ?
"GL::MeshIndexType" : "Magnum::MeshIndexType");
GL: make it possible for a Mesh to own the vertex/index buffers. I wanted to do this since 2015.
8 years ago
const UnsignedShort data = 0;
GL: properly specify Buffer target hints for tests on WebGL.
8 years ago
Buffer buffer{Buffer::TargetHint::ElementArray};
GL: make it possible for a Mesh to own the vertex/index buffers. I wanted to do this since 2015.
8 years ago
buffer.setData({&data, 1}, BufferUsage::StaticDraw);
const GLuint id = buffer.id();
CORRADE_VERIFY(glIsBuffer(id));
{
Mesh mesh;
mesh.setIndexBuffer(buffer, 0, T::UnsignedShort, 0, 1);
CORRADE_VERIFY(buffer.id());
CORRADE_VERIFY(glIsBuffer(id));
}
CORRADE_VERIFY(glIsBuffer(id));
{
Mesh mesh;
mesh.setIndexBuffer(std::move(buffer), 0, T::UnsignedShort, 0, 1);
CORRADE_VERIFY(!buffer.id());
CORRADE_VERIFY(glIsBuffer(id));
}
CORRADE_VERIFY(!glIsBuffer(id));
}
Test that binding index buffer internally doesn't affect bound VAOs. Fails. Problem spotted on WebGL 2 and is an unfortunate consequence of these events: 1. Neither EXT_DSA nor ARB_DSA is available, but VAOs are available, which means virtually all ES 3 and WebGL 2 implementations and also ES 2 / WebGL 1 with OES_VAO available. 2. Index buffer gets created with TargetHint::ElementArray, bound to GL_ELEMENT_ARRAY_BUFFER and filled with data. 3. Mesh object with VAO inside is created and the index buffer from above gets bound to GL_ELEMENT_ARRAY_BUFFER again to attach it to the VAO. 4. Another index buffer, possibly for another mesh, gets created with TargetHint::ElementArray and bound to GL_ELEMENT_ARRAY_BUFFER in order to be filled with data. But because the VAO from above is still bound, the index buffer attachment is then stomped on. 5. Rendering such mesh will use a different index buffer, most probably causing some out-of-range GL error and nothing rendered.
9 years ago
void MeshGLTest::unbindVAOWhenSettingIndexBufferData() {
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_array_object>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() << "is not supported.");
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(Context::current().isExtensionSupported<Extensions::ARB::direct_state_access>())
Minor cleanup.
6 years ago
CORRADE_SKIP(Extensions::ARB::direct_state_access::string() + std::string(" is active which circumvents the issue tested here."));
Test that binding index buffer internally doesn't affect bound VAOs. Fails. Problem spotted on WebGL 2 and is an unfortunate consequence of these events: 1. Neither EXT_DSA nor ARB_DSA is available, but VAOs are available, which means virtually all ES 3 and WebGL 2 implementations and also ES 2 / WebGL 1 with OES_VAO available. 2. Index buffer gets created with TargetHint::ElementArray, bound to GL_ELEMENT_ARRAY_BUFFER and filled with data. 3. Mesh object with VAO inside is created and the index buffer from above gets bound to GL_ELEMENT_ARRAY_BUFFER again to attach it to the VAO. 4. Another index buffer, possibly for another mesh, gets created with TargetHint::ElementArray and bound to GL_ELEMENT_ARRAY_BUFFER in order to be filled with data. But because the VAO from above is still bound, the index buffer attachment is then stomped on. 5. Rendering such mesh will use a different index buffer, most probably causing some out-of-range GL error and nothing rendered.
9 years ago
#elif defined(MAGNUM_TARGET_GLES2)
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::OES::vertex_array_object>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::OES::vertex_array_object::string() << "is not supported.");
Test that binding index buffer internally doesn't affect bound VAOs. Fails. Problem spotted on WebGL 2 and is an unfortunate consequence of these events: 1. Neither EXT_DSA nor ARB_DSA is available, but VAOs are available, which means virtually all ES 3 and WebGL 2 implementations and also ES 2 / WebGL 1 with OES_VAO available. 2. Index buffer gets created with TargetHint::ElementArray, bound to GL_ELEMENT_ARRAY_BUFFER and filled with data. 3. Mesh object with VAO inside is created and the index buffer from above gets bound to GL_ELEMENT_ARRAY_BUFFER again to attach it to the VAO. 4. Another index buffer, possibly for another mesh, gets created with TargetHint::ElementArray and bound to GL_ELEMENT_ARRAY_BUFFER in order to be filled with data. But because the VAO from above is still bound, the index buffer attachment is then stomped on. 5. Rendering such mesh will use a different index buffer, most probably causing some out-of-range GL error and nothing rendered.
9 years ago
#endif
typedef Attribute<0, Float> Attribute;
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
const Float data[] = { -0.7f, Math::unpack<Float, UnsignedByte>(
#ifndef MAGNUM_TARGET_GLES2
92
#else
GL: fix a confusing typo in a comment.
5 years ago
/* Using only RGBA4, supply less precision. This has to be done on the
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
input because SwiftShader stores RGBA4 as RGBA8 internally, thus
preserving the full precision of the input. */
85
#endif
), Math::unpack<Float, UnsignedByte>(32) };
Test that binding index buffer internally doesn't affect bound VAOs. Fails. Problem spotted on WebGL 2 and is an unfortunate consequence of these events: 1. Neither EXT_DSA nor ARB_DSA is available, but VAOs are available, which means virtually all ES 3 and WebGL 2 implementations and also ES 2 / WebGL 1 with OES_VAO available. 2. Index buffer gets created with TargetHint::ElementArray, bound to GL_ELEMENT_ARRAY_BUFFER and filled with data. 3. Mesh object with VAO inside is created and the index buffer from above gets bound to GL_ELEMENT_ARRAY_BUFFER again to attach it to the VAO. 4. Another index buffer, possibly for another mesh, gets created with TargetHint::ElementArray and bound to GL_ELEMENT_ARRAY_BUFFER in order to be filled with data. But because the VAO from above is still bound, the index buffer attachment is then stomped on. 5. Rendering such mesh will use a different index buffer, most probably causing some out-of-range GL error and nothing rendered.
9 years ago
Buffer buffer{Buffer::TargetHint::Array};
buffer.setData(data, BufferUsage::StaticDraw);
Buffer indices{Buffer::TargetHint::ElementArray};
GL: remove Buffer::set[Sub]Data() taking std::array / std::vector. Instead make use of the ArrayView STL compatibility. To avoid breaking almost all existing code the Corrade/Containers/ArrayViewStl.h header is included implicitly when MAGNUM_BUILD_DEPRECATED is defined, but this will get removed in some future release to speed up the compilation.
7 years ago
indices.setData(std::initializer_list<UnsignedByte>{5, 0}, BufferUsage::StaticDraw);
Test that binding index buffer internally doesn't affect bound VAOs. Fails. Problem spotted on WebGL 2 and is an unfortunate consequence of these events: 1. Neither EXT_DSA nor ARB_DSA is available, but VAOs are available, which means virtually all ES 3 and WebGL 2 implementations and also ES 2 / WebGL 1 with OES_VAO available. 2. Index buffer gets created with TargetHint::ElementArray, bound to GL_ELEMENT_ARRAY_BUFFER and filled with data. 3. Mesh object with VAO inside is created and the index buffer from above gets bound to GL_ELEMENT_ARRAY_BUFFER again to attach it to the VAO. 4. Another index buffer, possibly for another mesh, gets created with TargetHint::ElementArray and bound to GL_ELEMENT_ARRAY_BUFFER in order to be filled with data. But because the VAO from above is still bound, the index buffer attachment is then stomped on. 5. Rendering such mesh will use a different index buffer, most probably causing some out-of-range GL error and nothing rendered.
9 years ago
Mesh mesh;
mesh.addVertexBuffer(buffer, 4, Attribute{})
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
.setIndexBuffer(indices, 0, MeshIndexType::UnsignedByte);
Test that binding index buffer internally doesn't affect bound VAOs. Fails. Problem spotted on WebGL 2 and is an unfortunate consequence of these events: 1. Neither EXT_DSA nor ARB_DSA is available, but VAOs are available, which means virtually all ES 3 and WebGL 2 implementations and also ES 2 / WebGL 1 with OES_VAO available. 2. Index buffer gets created with TargetHint::ElementArray, bound to GL_ELEMENT_ARRAY_BUFFER and filled with data. 3. Mesh object with VAO inside is created and the index buffer from above gets bound to GL_ELEMENT_ARRAY_BUFFER again to attach it to the VAO. 4. Another index buffer, possibly for another mesh, gets created with TargetHint::ElementArray and bound to GL_ELEMENT_ARRAY_BUFFER in order to be filled with data. But because the VAO from above is still bound, the index buffer attachment is then stomped on. 5. Rendering such mesh will use a different index buffer, most probably causing some out-of-range GL error and nothing rendered.
9 years ago
/* This buffer should have no effect on the mesh above */
Buffer otherIndices{Buffer::TargetHint::ElementArray};
GL: remove Buffer::set[Sub]Data() taking std::array / std::vector. Instead make use of the ArrayView STL compatibility. To avoid breaking almost all existing code the Corrade/Containers/ArrayViewStl.h header is included implicitly when MAGNUM_BUILD_DEPRECATED is defined, but this will get removed in some future release to speed up the compilation.
7 years ago
otherIndices.setData(std::initializer_list<UnsignedByte>{100, 1}, BufferUsage::StaticDraw);
Test that binding index buffer internally doesn't affect bound VAOs. Fails. Problem spotted on WebGL 2 and is an unfortunate consequence of these events: 1. Neither EXT_DSA nor ARB_DSA is available, but VAOs are available, which means virtually all ES 3 and WebGL 2 implementations and also ES 2 / WebGL 1 with OES_VAO available. 2. Index buffer gets created with TargetHint::ElementArray, bound to GL_ELEMENT_ARRAY_BUFFER and filled with data. 3. Mesh object with VAO inside is created and the index buffer from above gets bound to GL_ELEMENT_ARRAY_BUFFER again to attach it to the VAO. 4. Another index buffer, possibly for another mesh, gets created with TargetHint::ElementArray and bound to GL_ELEMENT_ARRAY_BUFFER in order to be filled with data. But because the VAO from above is still bound, the index buffer attachment is then stomped on. 5. Rendering such mesh will use a different index buffer, most probably causing some out-of-range GL error and nothing rendered.
9 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Test that binding index buffer internally doesn't affect bound VAOs. Fails. Problem spotted on WebGL 2 and is an unfortunate consequence of these events: 1. Neither EXT_DSA nor ARB_DSA is available, but VAOs are available, which means virtually all ES 3 and WebGL 2 implementations and also ES 2 / WebGL 1 with OES_VAO available. 2. Index buffer gets created with TargetHint::ElementArray, bound to GL_ELEMENT_ARRAY_BUFFER and filled with data. 3. Mesh object with VAO inside is created and the index buffer from above gets bound to GL_ELEMENT_ARRAY_BUFFER again to attach it to the VAO. 4. Another index buffer, possibly for another mesh, gets created with TargetHint::ElementArray and bound to GL_ELEMENT_ARRAY_BUFFER in order to be filled with data. But because the VAO from above is still bound, the index buffer attachment is then stomped on. 5. Rendering such mesh will use a different index buffer, most probably causing some out-of-range GL error and nothing rendered.
9 years ago
const auto value = Checker(FloatShader("float", "vec4(valueInterpolated, 0.0, 0.0, 0.0)"),
#ifndef MAGNUM_TARGET_GLES2
Improve state tracker resetting functionality.
8 years ago
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
mesh).get<UnsignedByte>(PixelFormat::RGBA, PixelType::UnsignedByte);
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
Improve state tracker resetting functionality.
8 years ago
CORRADE_COMPARE(value, 92);
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#else /* RGBA4, so less precision */
CORRADE_COMPARE(value, 85);
#endif
Improve state tracker resetting functionality.
8 years ago
}
GL: test yet another interaction of VAOs and index buffer binding. Fails (well, why else would I be adding the test, right?).
7 years ago
void MeshGLTest::unbindIndexBufferWhenBindingVao() {
#ifndef MAGNUM_TARGET_GLES
if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_array_object>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() << "is not supported.");
GL: test yet another interaction of VAOs and index buffer binding. Fails (well, why else would I be adding the test, right?).
7 years ago
if(Context::current().isExtensionSupported<Extensions::ARB::direct_state_access>())
Minor cleanup.
6 years ago
CORRADE_SKIP(Extensions::ARB::direct_state_access::string() + std::string(" is active which circumvents the issue tested here."));
GL: test yet another interaction of VAOs and index buffer binding. Fails (well, why else would I be adding the test, right?).
7 years ago
#elif defined(MAGNUM_TARGET_GLES2)
if(!Context::current().isExtensionSupported<Extensions::OES::vertex_array_object>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::OES::vertex_array_object::string() << "is not supported.");
GL: test yet another interaction of VAOs and index buffer binding. Fails (well, why else would I be adding the test, right?).
7 years ago
#endif
typedef Attribute<0, Float> Attribute;
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
const Float data[] = { -0.7f, Math::unpack<Float, UnsignedByte>(
#ifndef MAGNUM_TARGET_GLES2
92
#else
GL: fix a confusing typo in a comment.
5 years ago
/* Using only RGBA4, supply less precision. This has to be done on the
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
input because SwiftShader stores RGBA4 as RGBA8 internally, thus
preserving the full precision of the input. */
85
#endif
), Math::unpack<Float, UnsignedByte>(32) };
GL: test yet another interaction of VAOs and index buffer binding. Fails (well, why else would I be adding the test, right?).
7 years ago
Buffer vertices{Buffer::TargetHint::Array};
vertices.setData(data, BufferUsage::StaticDraw);
Buffer indices{Buffer::TargetHint::ElementArray};
/* Just reserve the memory first */
indices.setData({nullptr, 2}, BufferUsage::StaticDraw);
/* Create an indexed mesh first */
Mesh indexed;
indexed.addVertexBuffer(vertices, 0, Attribute{})
.setIndexBuffer(indices, 0, MeshIndexType::UnsignedByte);
/* Now bind an nonindexed mesh */
Mesh nonindexed;
nonindexed.addVertexBuffer(vertices, 0, Attribute{});
/* Fill index buffer for the indexed mesh */
GL: remove Buffer::set[Sub]Data() taking std::array / std::vector. Instead make use of the ArrayView STL compatibility. To avoid breaking almost all existing code the Corrade/Containers/ArrayViewStl.h header is included implicitly when MAGNUM_BUILD_DEPRECATED is defined, but this will get removed in some future release to speed up the compilation.
7 years ago
indices.setData(std::initializer_list<UnsignedByte>{5, 1}, BufferUsage::StaticDraw);
GL: test yet another interaction of VAOs and index buffer binding. Fails (well, why else would I be adding the test, right?).
7 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
/* Draw the indexed mesh. The index buffer should be correctly updated,
picking the second vertex with value of 92. */
const auto value = Checker(FloatShader("float", "vec4(valueInterpolated, 0.0, 0.0, 0.0)"),
#ifndef MAGNUM_TARGET_GLES2
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
indexed).get<UnsignedByte>(PixelFormat::RGBA, PixelType::UnsignedByte);
MAGNUM_VERIFY_NO_GL_ERROR();
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
GL: test yet another interaction of VAOs and index buffer binding. Fails (well, why else would I be adding the test, right?).
7 years ago
CORRADE_COMPARE(value, 92);
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#else /* RGBA4, so less precision */
CORRADE_COMPARE(value, 85);
#endif
GL: test yet another interaction of VAOs and index buffer binding. Fails (well, why else would I be adding the test, right?).
7 years ago
}
GL: further harden VAO and index buffer binding state interaction tests. This one crashes. Turns out the 169031fb7bf30e2c98c81cbf865aa5a4662aa716 contained a random temporary test state instead of the real solution (and so the comment didn't even match the code, it should have been resetting that to 0). That also made some tests fail with DSA disabled, but none of the tests were actual Mesh tests, just accidentally hitting the problematic code path. I took the opportunity to look at this more closely and investigate *why* this failed -- turns out, in setIndexBuffer(), I was resetting the state tracker to a VAO state that was about to be set in the very next step, and then, when doing that next step the state tracker "optimized away" the state change because it thought it was already done (even though it wasn't). The new test in MeshGLTest covers this particular case.
7 years ago
void MeshGLTest::resetIndexBufferBindingWhenBindingVao() {
#ifndef MAGNUM_TARGET_GLES
if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_array_object>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() << "is not supported.");
GL: further harden VAO and index buffer binding state interaction tests. This one crashes. Turns out the 169031fb7bf30e2c98c81cbf865aa5a4662aa716 contained a random temporary test state instead of the real solution (and so the comment didn't even match the code, it should have been resetting that to 0). That also made some tests fail with DSA disabled, but none of the tests were actual Mesh tests, just accidentally hitting the problematic code path. I took the opportunity to look at this more closely and investigate *why* this failed -- turns out, in setIndexBuffer(), I was resetting the state tracker to a VAO state that was about to be set in the very next step, and then, when doing that next step the state tracker "optimized away" the state change because it thought it was already done (even though it wasn't). The new test in MeshGLTest covers this particular case.
7 years ago
if(Context::current().isExtensionSupported<Extensions::ARB::direct_state_access>())
Minor cleanup.
6 years ago
CORRADE_SKIP(Extensions::ARB::direct_state_access::string() + std::string(" is active which circumvents the issue tested here."));
GL: further harden VAO and index buffer binding state interaction tests. This one crashes. Turns out the 169031fb7bf30e2c98c81cbf865aa5a4662aa716 contained a random temporary test state instead of the real solution (and so the comment didn't even match the code, it should have been resetting that to 0). That also made some tests fail with DSA disabled, but none of the tests were actual Mesh tests, just accidentally hitting the problematic code path. I took the opportunity to look at this more closely and investigate *why* this failed -- turns out, in setIndexBuffer(), I was resetting the state tracker to a VAO state that was about to be set in the very next step, and then, when doing that next step the state tracker "optimized away" the state change because it thought it was already done (even though it wasn't). The new test in MeshGLTest covers this particular case.
7 years ago
#elif defined(MAGNUM_TARGET_GLES2)
if(!Context::current().isExtensionSupported<Extensions::OES::vertex_array_object>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::OES::vertex_array_object::string() << "is not supported.");
GL: further harden VAO and index buffer binding state interaction tests. This one crashes. Turns out the 169031fb7bf30e2c98c81cbf865aa5a4662aa716 contained a random temporary test state instead of the real solution (and so the comment didn't even match the code, it should have been resetting that to 0). That also made some tests fail with DSA disabled, but none of the tests were actual Mesh tests, just accidentally hitting the problematic code path. I took the opportunity to look at this more closely and investigate *why* this failed -- turns out, in setIndexBuffer(), I was resetting the state tracker to a VAO state that was about to be set in the very next step, and then, when doing that next step the state tracker "optimized away" the state change because it thought it was already done (even though it wasn't). The new test in MeshGLTest covers this particular case.
7 years ago
#endif
typedef Attribute<0, Float> Attribute;
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
const Float data[] = { -0.7f, Math::unpack<Float, UnsignedByte>(
#ifndef MAGNUM_TARGET_GLES2
92
#else
GL: fix a confusing typo in a comment.
5 years ago
/* Using only RGBA4, supply less precision. This has to be done on the
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
input because SwiftShader stores RGBA4 as RGBA8 internally, thus
preserving the full precision of the input. */
85
#endif
), Math::unpack<Float, UnsignedByte>(32) };
GL: further harden VAO and index buffer binding state interaction tests. This one crashes. Turns out the 169031fb7bf30e2c98c81cbf865aa5a4662aa716 contained a random temporary test state instead of the real solution (and so the comment didn't even match the code, it should have been resetting that to 0). That also made some tests fail with DSA disabled, but none of the tests were actual Mesh tests, just accidentally hitting the problematic code path. I took the opportunity to look at this more closely and investigate *why* this failed -- turns out, in setIndexBuffer(), I was resetting the state tracker to a VAO state that was about to be set in the very next step, and then, when doing that next step the state tracker "optimized away" the state change because it thought it was already done (even though it wasn't). The new test in MeshGLTest covers this particular case.
7 years ago
Buffer vertices{Buffer::TargetHint::Array};
vertices.setData(data);
/* Create an indexed mesh */
Mesh indexed;
indexed.addVertexBuffer(vertices, 0, Attribute{});
/* Create an index buffer and fill it (the VAO is bound now, so it'll get
unbound to avoid messing with its state). */
Buffer indices{Buffer::TargetHint::ElementArray};
GL: remove Buffer::set[Sub]Data() taking std::array / std::vector. Instead make use of the ArrayView STL compatibility. To avoid breaking almost all existing code the Corrade/Containers/ArrayViewStl.h header is included implicitly when MAGNUM_BUILD_DEPRECATED is defined, but this will get removed in some future release to speed up the compilation.
7 years ago
indices.setData(std::initializer_list<UnsignedByte>{5, 1});
GL: further harden VAO and index buffer binding state interaction tests. This one crashes. Turns out the 169031fb7bf30e2c98c81cbf865aa5a4662aa716 contained a random temporary test state instead of the real solution (and so the comment didn't even match the code, it should have been resetting that to 0). That also made some tests fail with DSA disabled, but none of the tests were actual Mesh tests, just accidentally hitting the problematic code path. I took the opportunity to look at this more closely and investigate *why* this failed -- turns out, in setIndexBuffer(), I was resetting the state tracker to a VAO state that was about to be set in the very next step, and then, when doing that next step the state tracker "optimized away" the state change because it thought it was already done (even though it wasn't). The new test in MeshGLTest covers this particular case.
7 years ago
/* Add the index buffer. The VAO is unbound, so it gets bound. That resets
the element array buffer binding and then the buffer gets bound to the
VAO. */
indexed.setIndexBuffer(indices, 0, MeshIndexType::UnsignedByte);
MAGNUM_VERIFY_NO_GL_ERROR();
/* Draw the indexed mesh. The index buffer should be correctly bound,
picking the second vertex with value of 92. */
const auto value = Checker(FloatShader("float", "vec4(valueInterpolated, 0.0, 0.0, 0.0)"),
#ifndef MAGNUM_TARGET_GLES2
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
indexed).get<UnsignedByte>(PixelFormat::RGBA, PixelType::UnsignedByte);
MAGNUM_VERIFY_NO_GL_ERROR();
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
GL: further harden VAO and index buffer binding state interaction tests. This one crashes. Turns out the 169031fb7bf30e2c98c81cbf865aa5a4662aa716 contained a random temporary test state instead of the real solution (and so the comment didn't even match the code, it should have been resetting that to 0). That also made some tests fail with DSA disabled, but none of the tests were actual Mesh tests, just accidentally hitting the problematic code path. I took the opportunity to look at this more closely and investigate *why* this failed -- turns out, in setIndexBuffer(), I was resetting the state tracker to a VAO state that was about to be set in the very next step, and then, when doing that next step the state tracker "optimized away" the state change because it thought it was already done (even though it wasn't). The new test in MeshGLTest covers this particular case.
7 years ago
CORRADE_COMPARE(value, 92);
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#else /* RGBA4, so less precision */
CORRADE_COMPARE(value, 85);
#endif
GL: further harden VAO and index buffer binding state interaction tests. This one crashes. Turns out the 169031fb7bf30e2c98c81cbf865aa5a4662aa716 contained a random temporary test state instead of the real solution (and so the comment didn't even match the code, it should have been resetting that to 0). That also made some tests fail with DSA disabled, but none of the tests were actual Mesh tests, just accidentally hitting the problematic code path. I took the opportunity to look at this more closely and investigate *why* this failed -- turns out, in setIndexBuffer(), I was resetting the state tracker to a VAO state that was about to be set in the very next step, and then, when doing that next step the state tracker "optimized away" the state change because it thought it was already done (even though it wasn't). The new test in MeshGLTest covers this particular case.
7 years ago
}
Improve state tracker resetting functionality.
8 years ago
void MeshGLTest::unbindVAOBeforeEnteringExternalSection() {
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_array_object>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() << "is not supported.");
Improve state tracker resetting functionality.
8 years ago
#elif defined(MAGNUM_TARGET_GLES2)
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::OES::vertex_array_object>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::OES::vertex_array_object::string() << "is not supported.");
Improve state tracker resetting functionality.
8 years ago
#endif
typedef Attribute<0, Float> Attribute;
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
const Float data[] = { -0.7f, Math::unpack<Float, UnsignedByte>(
#ifndef MAGNUM_TARGET_GLES2
92
#else
GL: fix a confusing typo in a comment.
5 years ago
/* Using only RGBA4, supply less precision. This has to be done on the
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
input because SwiftShader stores RGBA4 as RGBA8 internally, thus
preserving the full precision of the input. */
85
#endif
), Math::unpack<Float, UnsignedByte>(32) };
Improve state tracker resetting functionality.
8 years ago
Buffer buffer{Buffer::TargetHint::Array};
buffer.setData(data, BufferUsage::StaticDraw);
Buffer indices{Buffer::TargetHint::ElementArray};
GL: remove Buffer::set[Sub]Data() taking std::array / std::vector. Instead make use of the ArrayView STL compatibility. To avoid breaking almost all existing code the Corrade/Containers/ArrayViewStl.h header is included implicitly when MAGNUM_BUILD_DEPRECATED is defined, but this will get removed in some future release to speed up the compilation.
7 years ago
indices.setData(std::initializer_list<UnsignedByte>{5, 0}, BufferUsage::StaticDraw);
Improve state tracker resetting functionality.
8 years ago
Mesh mesh;
mesh.addVertexBuffer(buffer, 4, Attribute{})
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
.setIndexBuffer(indices, 0, MeshIndexType::UnsignedByte);
Improve state tracker resetting functionality.
8 years ago
{
/* Comment this out to watch the world burn */
Context::current().resetState(Context::State::MeshVao);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
/* Be nice to the other tests */
Context::current().resetState(Context::State::ExitExternal);
}
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Improve state tracker resetting functionality.
8 years ago
const auto value = Checker(FloatShader("float", "vec4(valueInterpolated, 0.0, 0.0, 0.0)"),
#ifndef MAGNUM_TARGET_GLES2
Test that binding index buffer internally doesn't affect bound VAOs. Fails. Problem spotted on WebGL 2 and is an unfortunate consequence of these events: 1. Neither EXT_DSA nor ARB_DSA is available, but VAOs are available, which means virtually all ES 3 and WebGL 2 implementations and also ES 2 / WebGL 1 with OES_VAO available. 2. Index buffer gets created with TargetHint::ElementArray, bound to GL_ELEMENT_ARRAY_BUFFER and filled with data. 3. Mesh object with VAO inside is created and the index buffer from above gets bound to GL_ELEMENT_ARRAY_BUFFER again to attach it to the VAO. 4. Another index buffer, possibly for another mesh, gets created with TargetHint::ElementArray and bound to GL_ELEMENT_ARRAY_BUFFER in order to be filled with data. But because the VAO from above is still bound, the index buffer attachment is then stomped on. 5. Rendering such mesh will use a different index buffer, most probably causing some out-of-range GL error and nothing rendered.
9 years ago
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
mesh).get<UnsignedByte>(PixelFormat::RGBA, PixelType::UnsignedByte);
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
Test that binding index buffer internally doesn't affect bound VAOs. Fails. Problem spotted on WebGL 2 and is an unfortunate consequence of these events: 1. Neither EXT_DSA nor ARB_DSA is available, but VAOs are available, which means virtually all ES 3 and WebGL 2 implementations and also ES 2 / WebGL 1 with OES_VAO available. 2. Index buffer gets created with TargetHint::ElementArray, bound to GL_ELEMENT_ARRAY_BUFFER and filled with data. 3. Mesh object with VAO inside is created and the index buffer from above gets bound to GL_ELEMENT_ARRAY_BUFFER again to attach it to the VAO. 4. Another index buffer, possibly for another mesh, gets created with TargetHint::ElementArray and bound to GL_ELEMENT_ARRAY_BUFFER in order to be filled with data. But because the VAO from above is still bound, the index buffer attachment is then stomped on. 5. Rendering such mesh will use a different index buffer, most probably causing some out-of-range GL error and nothing rendered.
9 years ago
CORRADE_COMPARE(value, 92);
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#else /* RGBA4, so less precision */
CORRADE_COMPARE(value, 85);
#endif
Test that binding index buffer internally doesn't affect bound VAOs. Fails. Problem spotted on WebGL 2 and is an unfortunate consequence of these events: 1. Neither EXT_DSA nor ARB_DSA is available, but VAOs are available, which means virtually all ES 3 and WebGL 2 implementations and also ES 2 / WebGL 1 with OES_VAO available. 2. Index buffer gets created with TargetHint::ElementArray, bound to GL_ELEMENT_ARRAY_BUFFER and filled with data. 3. Mesh object with VAO inside is created and the index buffer from above gets bound to GL_ELEMENT_ARRAY_BUFFER again to attach it to the VAO. 4. Another index buffer, possibly for another mesh, gets created with TargetHint::ElementArray and bound to GL_ELEMENT_ARRAY_BUFFER in order to be filled with data. But because the VAO from above is still bound, the index buffer attachment is then stomped on. 5. Rendering such mesh will use a different index buffer, most probably causing some out-of-range GL error and nothing rendered.
9 years ago
}
GL: make it possible to bind a scratch VAO for external GL code. Used in those sad and unfortunate cases where we need to call shitty external GL code that's not VAO-aware.
8 years ago
void MeshGLTest::bindScratchVaoWhenEnteringExternalSection() {
typedef Attribute<0, Float> Attribute;
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
const Float data[] = { -0.7f, Math::unpack<Float, UnsignedByte>(
#ifndef MAGNUM_TARGET_GLES2
92
#else
GL: fix a confusing typo in a comment.
5 years ago
/* Using only RGBA4, supply less precision. This has to be done on the
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
input because SwiftShader stores RGBA4 as RGBA8 internally, thus
preserving the full precision of the input. */
85
#endif
), Math::unpack<Float, UnsignedByte>(32) };
GL: make it possible to bind a scratch VAO for external GL code. Used in those sad and unfortunate cases where we need to call shitty external GL code that's not VAO-aware.
8 years ago
Buffer buffer{Buffer::TargetHint::Array};
buffer.setData(data, BufferUsage::StaticDraw);
Buffer indices{Buffer::TargetHint::ElementArray};
GL: remove Buffer::set[Sub]Data() taking std::array / std::vector. Instead make use of the ArrayView STL compatibility. To avoid breaking almost all existing code the Corrade/Containers/ArrayViewStl.h header is included implicitly when MAGNUM_BUILD_DEPRECATED is defined, but this will get removed in some future release to speed up the compilation.
7 years ago
indices.setData(std::initializer_list<UnsignedByte>{5, 0}, BufferUsage::StaticDraw);
GL: make it possible to bind a scratch VAO for external GL code. Used in those sad and unfortunate cases where we need to call shitty external GL code that's not VAO-aware.
8 years ago
Mesh mesh;
mesh.addVertexBuffer(buffer, 4, Attribute{})
.setIndexBuffer(indices, 0, MeshIndexType::UnsignedByte);
{
GL: fix MeshGLTest::bindScratchVaoWhenEnteringExternalSection(). Would fail on an incomplete framebuffer error on framebuffer-less windowless contexts. Didn't happen before, I think it's because of a new check in a new Mesa.
7 years ago
/* Bind a scratch framebuffer so glDrawArrays() doesn't complain about
an incomplete framebuffer in case we're on a framebuffer-less
context */
Renderbuffer renderbuffer;
renderbuffer.setStorage(
#ifndef MAGNUM_TARGET_GLES2
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
Vector2i{1});
Framebuffer framebuffer{{{}, Vector2i{1}}};
framebuffer.attachRenderbuffer(Framebuffer::ColorAttachment{0}, renderbuffer)
.bind();
GL: make it possible to bind a scratch VAO for external GL code. Used in those sad and unfortunate cases where we need to call shitty external GL code that's not VAO-aware.
8 years ago
/* Should bind a scratch VAO only on desktop with core profile and be
a no-op everywhere else */
Context::current().resetState(Context::State::EnterExternal
|Context::State::BindScratchVao /* Comment this out to watch the world burn */
);
/* Should throw no GL error if scratch VAO is bound */
glDrawArrays(GL_POINTS, 0, 0);
/* Be nice to the other tests */
Context::current().resetState(Context::State::ExitExternal);
}
MAGNUM_VERIFY_NO_GL_ERROR();
const auto value = Checker(FloatShader("float", "vec4(valueInterpolated, 0.0, 0.0, 0.0)"),
#ifndef MAGNUM_TARGET_GLES2
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
mesh).get<UnsignedByte>(PixelFormat::RGBA, PixelType::UnsignedByte);
MAGNUM_VERIFY_NO_GL_ERROR();
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
GL: make it possible to bind a scratch VAO for external GL code. Used in those sad and unfortunate cases where we need to call shitty external GL code that's not VAO-aware.
8 years ago
CORRADE_COMPARE(value, 92);
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#else /* RGBA4, so less precision */
CORRADE_COMPARE(value, 85);
#endif
GL: make it possible to bind a scratch VAO for external GL code. Used in those sad and unfortunate cases where we need to call shitty external GL code that's not VAO-aware.
8 years ago
}
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
#if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2))
Added test for mesh base vertex.
12 years ago
void MeshGLTest::setBaseVertex() {
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
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::draw_elements_base_vertex>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::draw_elements_base_vertex::string() << "is not supported.");
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
#elif !defined(MAGNUM_TARGET_WEBGL)
if(!Context::current().isExtensionSupported<Extensions::OES::draw_elements_base_vertex>() &&
!Context::current().isExtensionSupported<Extensions::EXT::draw_elements_base_vertex>())
CORRADE_SKIP(std::string{"Neither "} + Extensions::OES::draw_elements_base_vertex::string() + " nor " + Extensions::EXT::draw_elements_base_vertex::string() + " is available.");
#else
if(!Context::current().isExtensionSupported<Extensions::WEBGL::draw_instanced_base_vertex_base_instance>())
CORRADE_SKIP(Extensions::WEBGL::draw_instanced_base_vertex_base_instance::string() + std::string{" is not available."});
#endif
glDrawElementsBaseVertex() needs ARB_draw_elements_base_vertex.
12 years ago
Added test for mesh base vertex.
12 years ago
Buffer vertices;
Cleanup and code reorganization in MeshGLTest.
12 years ago
vertices.setData(indexedVertexDataBaseVertex, BufferUsage::StaticDraw);
Added test for mesh base vertex.
12 years ago
constexpr UnsignedShort indexData[] = { 2, 1, 0 };
Implemented indexed buffer binding. The indexed binding is allowed for only some types (atomic counters, uniforms, shader storage and transform feedback), thus we need separate enum for that. Because the bind() function will be used far more often than setTargetHint(), the original Target enum is now renamed to TargetHint and the new Target enum contains (in non-deprecated build) only three values. For backwards compatibility, though, we need to have all original Target values, thus the new Target enum contains also all other values from TargetHint, but they are marked as deprecated and (at least) run-time checked in bind() so they aren't accidentaly used for indexed binding. Similarly there are also deprecated Target overloads of Buffer() and setTargetHint(). It's ugly, but hopefully will suffice for now. This mess will be removed as soon as possible in some upcoming version.
12 years ago
Buffer indices{Buffer::TargetHint::ElementArray};
Added test for mesh base vertex.
12 years ago
indices.setData(indexData, BufferUsage::StaticDraw);
Mesh mesh;
Cleanup and code reorganization in MeshGLTest.
12 years ago
mesh.setBaseVertex(2)
.addVertexBuffer(vertices, 2*4, MultipleShader::Position(),
Added test for mesh base vertex.
12 years ago
MultipleShader::Normal(), MultipleShader::TextureCoordinates())
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
.setIndexBuffer(indices, 2, MeshIndexType::UnsignedShort);
Added test for mesh base vertex.
12 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Added test for mesh base vertex.
12 years ago
Removed duplicate code from MeshGLTest. As there is now no distinction between vertex and index count we don't need separate checker utility for non-indexed and indexed meshes.
12 years ago
const auto value = Checker(MultipleShader{}, RenderbufferFormat::RGBA8,
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
mesh).get<Color4ub>(PixelFormat::RGBA, PixelType::UnsignedByte);
Added test for mesh base vertex.
12 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Added test for mesh base vertex.
12 years ago
CORRADE_COMPARE(value, indexedResult);
}
#endif
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
#ifdef MAGNUM_TARGET_GLES
void MeshGLTest::setBaseVertexNoExtensionAvailable() {
#ifndef MAGNUM_TARGET_WEBGL
if(Context::current().isVersionSupported(Version::GLES320))
CORRADE_SKIP("OpenGL ES 3.2 is available.");
if(Context::current().isExtensionSupported<Extensions::EXT::draw_elements_base_vertex>())
CORRADE_SKIP(Extensions::EXT::draw_elements_base_vertex::string() + std::string{" is available."});
if(Context::current().isExtensionSupported<Extensions::OES::draw_elements_base_vertex>())
CORRADE_SKIP(Extensions::OES::draw_elements_base_vertex::string() + std::string{" is available."});
#elif !defined(MAGNUM_TARGET_GLES2)
if(Context::current().isExtensionSupported<Extensions::WEBGL::draw_instanced_base_vertex_base_instance>())
CORRADE_SKIP(Extensions::WEBGL::draw_instanced_base_vertex_base_instance::string() + std::string{" is available."});
#endif
constexpr UnsignedShort indexData[] = { 2, 1, 0 };
Buffer indices{Buffer::TargetHint::ElementArray};
indices.setData(indexData, BufferUsage::StaticDraw);
Mesh mesh;
mesh.setCount(3)
.setBaseVertex(1)
.setIndexBuffer(indices, 0, MeshIndexType::UnsignedShort);
std::ostringstream out;
Error redirectError{&out};
MultipleShader{}.draw(mesh);
#if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2))
CORRADE_COMPARE(out.str(), "GL::AbstractShaderProgram::draw(): no extension available for indexed mesh draw with base vertex specification\n");
#else
CORRADE_COMPARE(out.str(), "GL::AbstractShaderProgram::draw(): indexed mesh draw with base vertex specification possible only since WebGL 2.0\n");
#endif
}
void MeshGLTest::setBaseVertexRangeNoExtensionAvailable() {
#ifndef MAGNUM_TARGET_WEBGL
if(Context::current().isVersionSupported(Version::GLES320))
CORRADE_SKIP("OpenGL ES 3.2 is available.");
if(Context::current().isExtensionSupported<Extensions::EXT::draw_elements_base_vertex>())
CORRADE_SKIP(Extensions::EXT::draw_elements_base_vertex::string() + std::string{" is available."});
if(Context::current().isExtensionSupported<Extensions::OES::draw_elements_base_vertex>())
CORRADE_SKIP(Extensions::OES::draw_elements_base_vertex::string() + std::string{" is available."});
#elif !defined(MAGNUM_TARGET_GLES2)
if(Context::current().isExtensionSupported<Extensions::WEBGL::draw_instanced_base_vertex_base_instance>())
CORRADE_SKIP(Extensions::WEBGL::draw_instanced_base_vertex_base_instance::string() + std::string{" is available."});
#endif
constexpr UnsignedShort indexData[] = { 2, 1, 0 };
Buffer indices{Buffer::TargetHint::ElementArray};
indices.setData(indexData, BufferUsage::StaticDraw);
Mesh mesh;
mesh.setCount(3)
.setBaseVertex(1)
.setIndexBuffer(indices, 0, MeshIndexType::UnsignedShort, 0, 2);
std::ostringstream out;
Error redirectError{&out};
MultipleShader{}.draw(mesh);
#if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2))
CORRADE_COMPARE(out.str(), "GL::AbstractShaderProgram::draw(): no extension available for indexed mesh draw with base vertex specification\n");
#else
CORRADE_COMPARE(out.str(), "GL::AbstractShaderProgram::draw(): indexed mesh draw with base vertex specification possible only since WebGL 2.0\n");
#endif
}
#endif
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
void MeshGLTest::setInstanceCount() {
/* Verbatim copy of addVertexBufferFloat() with added extension check and
setInstanceCount() call. It would just render three times the same
value. I'm too lazy to invent proper test case, so I'll just check that
it didn't generate any error and rendered something */
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
#elif defined(MAGNUM_TARGET_GLES2)
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#ifndef MAGNUM_TARGET_WEBGL
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>() &&
GL: wait, there's not just three ES instanced extensions, there's FIVE. Like, why can't they just depend on each other or something?
7 years ago
!Context::current().isExtensionSupported<Extensions::EXT::instanced_arrays>() &&
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
!Context::current().isExtensionSupported<Extensions::EXT::draw_instanced>() &&
GL: wait, there's not just three ES instanced extensions, there's FIVE. Like, why can't they just depend on each other or something?
7 years ago
!Context::current().isExtensionSupported<Extensions::NV::instanced_arrays>() &&
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
!Context::current().isExtensionSupported<Extensions::NV::draw_instanced>())
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
CORRADE_SKIP("Required extension is not available.");
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#else
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ANGLE::instanced_arrays::string() << "is not supported.");
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#endif
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
#endif
Moved Attribute class out of AbstractShaderProgram enum. No backward compatibility issues should exist, as the class is in most (if not all) cases used with unscoped name: class MyShader: public AbstractShaderProgram { public: typedef Attribute<0, Vector3> Position; // ... };
12 years ago
typedef Attribute<0, Float> Attribute;
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
Math: renamed {de,}normalize() to {,un}pack() in a new Packing.h header. To be more consistent with GLSL naming. Also, the original naming was quite misleading, as normalize() is used in GLSL for something completely different. If building with deprecated APIs, the Functions.h header includes the new Packing.h header and the {de,}normalize() functions are defined as deprecated aliases to the new functions. This will be removed at some point in the future.
9 years ago
const Float data[] = { 0.0f, -0.7f, Math::unpack<Float, UnsignedByte>(96) };
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
Removed duplicate code from MeshGLTest. As there is now no distinction between vertex and index count we don't need separate checker utility for non-indexed and indexed meshes.
12 years ago
mesh.setBaseVertex(1)
.setInstanceCount(3)
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
.addVertexBuffer(buffer, 4, Attribute());
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
const auto value = Checker(FloatShader("float", "vec4(valueInterpolated, 0.0, 0.0, 0.0)"),
#ifndef MAGNUM_TARGET_GLES2
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
mesh).get<UnsignedByte>(PixelFormat::RGBA, PixelType::UnsignedByte);
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
CORRADE_COMPARE(value, 96);
}
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
#ifndef MAGNUM_TARGET_GLES2
void MeshGLTest::setInstanceCountBaseInstance() {
/* Verbatim copy of setInstanceCount() with additional extension check and
setBaseInstance() call. It would just render three times the same
value. I'm too lazy to invent proper test case, so I'll just check that
it didn't generate any error and rendered something */
#ifndef MAGNUM_TARGET_GLES
if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
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
if(!Context::current().isExtensionSupported<Extensions::ARB::base_instance>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::base_instance::string() << "is not supported.");
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
#elif !defined(MAGNUM_TARGET_WEBGL)
if(!Context::current().isExtensionSupported<Extensions::ANGLE::base_vertex_base_instance>())
CORRADE_SKIP(Extensions::ANGLE::base_vertex_base_instance::string() + std::string{" is not available."});
#else
if(!Context::current().isExtensionSupported<Extensions::WEBGL::draw_instanced_base_vertex_base_instance>())
CORRADE_SKIP(Extensions::WEBGL::draw_instanced_base_vertex_base_instance::string() + std::string{" is not available."});
#endif
typedef Attribute<0, Float> Attribute;
const Float data[] = { 0.0f, -0.7f, Math::unpack<Float, UnsignedByte>(96) };
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
mesh.setBaseVertex(1)
.setInstanceCount(3)
.setBaseInstance(72)
.addVertexBuffer(buffer, 4, Attribute());
MAGNUM_VERIFY_NO_GL_ERROR();
const auto value = Checker(FloatShader("float", "vec4(valueInterpolated, 0.0, 0.0, 0.0)"),
RenderbufferFormat::RGBA8,
mesh).get<UnsignedByte>(PixelFormat::RGBA, PixelType::UnsignedByte);
MAGNUM_VERIFY_NO_GL_ERROR();
CORRADE_COMPARE(value, 96);
}
#ifdef MAGNUM_TARGET_GLES
void MeshGLTest::setInstanceCountBaseInstanceNoExtensionAvailable() {
#ifndef MAGNUM_TARGET_WEBGL
if(Context::current().isExtensionSupported<Extensions::ANGLE::base_vertex_base_instance>())
CORRADE_SKIP(Extensions::ANGLE::base_vertex_base_instance::string() + std::string{" is available."});
#else
if(Context::current().isExtensionSupported<Extensions::WEBGL::draw_instanced_base_vertex_base_instance>())
CORRADE_SKIP(Extensions::WEBGL::draw_instanced_base_vertex_base_instance::string() + std::string{" is available."});
#endif
Mesh mesh;
mesh.setCount(3)
.setInstanceCount(2)
.setBaseInstance(1);
std::ostringstream out;
Error redirectError{&out};
MultipleShader{}.draw(mesh);
CORRADE_COMPARE(out.str(), "GL::AbstractShaderProgram::draw(): no extension available for instanced mesh draw with base instance specification\n");
}
#endif
#endif
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
void MeshGLTest::setInstanceCountIndexed() {
/* Verbatim copy of setIndexBuffer() with added extension check and
setInstanceCount() call. It would just render three times the same
value. I'm too lazy to invent proper test case, so I'll just check that
it didn't generate any error and rendered something */
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
#elif defined(MAGNUM_TARGET_GLES2)
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#ifndef MAGNUM_TARGET_WEBGL
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>() &&
GL: wait, there's not just three ES instanced extensions, there's FIVE. Like, why can't they just depend on each other or something?
7 years ago
!Context::current().isExtensionSupported<Extensions::EXT::instanced_arrays>() &&
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
!Context::current().isExtensionSupported<Extensions::EXT::draw_instanced>() &&
GL: wait, there's not just three ES instanced extensions, there's FIVE. Like, why can't they just depend on each other or something?
7 years ago
!Context::current().isExtensionSupported<Extensions::NV::instanced_arrays>() &&
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
!Context::current().isExtensionSupported<Extensions::NV::draw_instanced>())
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
CORRADE_SKIP("Required extension is not available.");
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#else
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ANGLE::instanced_arrays::string() << "is not supported.");
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#endif
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
#endif
Buffer vertices;
vertices.setData(indexedVertexData, BufferUsage::StaticDraw);
constexpr UnsignedShort indexData[] = { 2, 1, 0 };
Implemented indexed buffer binding. The indexed binding is allowed for only some types (atomic counters, uniforms, shader storage and transform feedback), thus we need separate enum for that. Because the bind() function will be used far more often than setTargetHint(), the original Target enum is now renamed to TargetHint and the new Target enum contains (in non-deprecated build) only three values. For backwards compatibility, though, we need to have all original Target values, thus the new Target enum contains also all other values from TargetHint, but they are marked as deprecated and (at least) run-time checked in bind() so they aren't accidentaly used for indexed binding. Similarly there are also deprecated Target overloads of Buffer() and setTargetHint(). It's ugly, but hopefully will suffice for now. This mess will be removed as soon as possible in some upcoming version.
12 years ago
Buffer indices{Buffer::TargetHint::ElementArray};
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
indices.setData(indexData, BufferUsage::StaticDraw);
Mesh mesh;
mesh.setInstanceCount(3)
.addVertexBuffer(vertices, 1*4, MultipleShader::Position(),
MultipleShader::Normal(), MultipleShader::TextureCoordinates())
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
.setIndexBuffer(indices, 2, MeshIndexType::UnsignedShort);
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
Removed duplicate code from MeshGLTest. As there is now no distinction between vertex and index count we don't need separate checker utility for non-indexed and indexed meshes.
12 years ago
const auto value = Checker(MultipleShader{},
#ifndef MAGNUM_TARGET_GLES2
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
mesh).get<Color4ub>(PixelFormat::RGBA, PixelType::UnsignedByte);
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
CORRADE_COMPARE(value, indexedResult);
}
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
#ifndef MAGNUM_TARGET_GLES2
void MeshGLTest::setInstanceCountIndexedBaseInstance() {
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
/* Verbatim copy of setInstanceCountIndexed() with additional extension
check and setBaseInstance() call. It would just render three times the
same value. I'm too lazy to invent proper test case, so I'll just check
that it didn't generate any error and rendered something */
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
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::base_instance>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::base_instance::string() << "is not supported.");
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
#elif !defined(MAGNUM_TARGET_WEBGL)
if(!Context::current().isExtensionSupported<Extensions::ANGLE::base_vertex_base_instance>())
CORRADE_SKIP(Extensions::ANGLE::base_vertex_base_instance::string() + std::string{" is not available."});
#else
if(!Context::current().isExtensionSupported<Extensions::WEBGL::draw_instanced_base_vertex_base_instance>())
CORRADE_SKIP(Extensions::WEBGL::draw_instanced_base_vertex_base_instance::string() + std::string{" is not available."});
#endif
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
Buffer vertices;
vertices.setData(indexedVertexData, BufferUsage::StaticDraw);
constexpr UnsignedShort indexData[] = { 2, 1, 0 };
Implemented indexed buffer binding. The indexed binding is allowed for only some types (atomic counters, uniforms, shader storage and transform feedback), thus we need separate enum for that. Because the bind() function will be used far more often than setTargetHint(), the original Target enum is now renamed to TargetHint and the new Target enum contains (in non-deprecated build) only three values. For backwards compatibility, though, we need to have all original Target values, thus the new Target enum contains also all other values from TargetHint, but they are marked as deprecated and (at least) run-time checked in bind() so they aren't accidentaly used for indexed binding. Similarly there are also deprecated Target overloads of Buffer() and setTargetHint(). It's ugly, but hopefully will suffice for now. This mess will be removed as soon as possible in some upcoming version.
12 years ago
Buffer indices{Buffer::TargetHint::ElementArray};
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
indices.setData(indexData, BufferUsage::StaticDraw);
Mesh mesh;
mesh.setInstanceCount(3)
.setBaseInstance(72)
.addVertexBuffer(vertices, 1*4, MultipleShader::Position(),
MultipleShader::Normal(), MultipleShader::TextureCoordinates())
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
.setIndexBuffer(indices, 2, MeshIndexType::UnsignedShort);
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
Removed duplicate code from MeshGLTest. As there is now no distinction between vertex and index count we don't need separate checker utility for non-indexed and indexed meshes.
12 years ago
const auto value = Checker(MultipleShader{}, RenderbufferFormat::RGBA8,
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
mesh).get<Color4ub>(PixelFormat::RGBA, PixelType::UnsignedByte);
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
CORRADE_COMPARE(value, indexedResult);
}
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
#ifdef MAGNUM_TARGET_GLES
void MeshGLTest::setInstanceCountIndexedBaseInstanceNoExtensionAvailable() {
#ifndef MAGNUM_TARGET_WEBGL
if(Context::current().isExtensionSupported<Extensions::ANGLE::base_vertex_base_instance>())
CORRADE_SKIP(Extensions::ANGLE::base_vertex_base_instance::string() + std::string{" is available."});
#else
if(Context::current().isExtensionSupported<Extensions::WEBGL::draw_instanced_base_vertex_base_instance>())
CORRADE_SKIP(Extensions::WEBGL::draw_instanced_base_vertex_base_instance::string() + std::string{" is available."});
#endif
constexpr UnsignedShort indexData[] = { 2, 1, 0 };
Buffer indices{Buffer::TargetHint::ElementArray};
indices.setData(indexData, BufferUsage::StaticDraw);
Mesh mesh;
mesh.setCount(3)
.setInstanceCount(2)
.setBaseInstance(1)
.setIndexBuffer(indices, 0, MeshIndexType::UnsignedShort);
std::ostringstream out;
Error redirectError{&out};
MultipleShader{}.draw(mesh);
CORRADE_COMPARE(out.str(), "GL::AbstractShaderProgram::draw(): no extension available for instanced indexed mesh draw with base instance specification\n");
}
#endif
#endif
#ifndef MAGNUM_TARGET_GLES2
void MeshGLTest::setInstanceCountIndexedBaseVertex() {
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
/* Verbatim copy of setBaseVertex() with additional extension check and
setInstanceCount() call. It would just render three times the same
value. I'm too lazy to invent proper test case, so I'll just check
that it didn't generate any error and rendered something */
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
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::draw_elements_base_vertex>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::draw_elements_base_vertex::string() << "is not supported.");
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
#elif !defined(MAGNUM_TARGET_WEBGL)
if(!Context::current().isExtensionSupported<Extensions::OES::draw_elements_base_vertex>() &&
!Context::current().isExtensionSupported<Extensions::EXT::draw_elements_base_vertex>())
CORRADE_SKIP(std::string{"Neither "} + Extensions::OES::draw_elements_base_vertex::string() + " nor " + Extensions::EXT::draw_elements_base_vertex::string() + " is available.");
#else
if(!Context::current().isExtensionSupported<Extensions::WEBGL::draw_instanced_base_vertex_base_instance>())
CORRADE_SKIP(Extensions::WEBGL::draw_instanced_base_vertex_base_instance::string() + std::string{" is not available."});
#endif
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
Buffer vertices;
vertices.setData(indexedVertexDataBaseVertex, BufferUsage::StaticDraw);
constexpr UnsignedShort indexData[] = { 2, 1, 0 };
Implemented indexed buffer binding. The indexed binding is allowed for only some types (atomic counters, uniforms, shader storage and transform feedback), thus we need separate enum for that. Because the bind() function will be used far more often than setTargetHint(), the original Target enum is now renamed to TargetHint and the new Target enum contains (in non-deprecated build) only three values. For backwards compatibility, though, we need to have all original Target values, thus the new Target enum contains also all other values from TargetHint, but they are marked as deprecated and (at least) run-time checked in bind() so they aren't accidentaly used for indexed binding. Similarly there are also deprecated Target overloads of Buffer() and setTargetHint(). It's ugly, but hopefully will suffice for now. This mess will be removed as soon as possible in some upcoming version.
12 years ago
Buffer indices{Buffer::TargetHint::ElementArray};
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
indices.setData(indexData, BufferUsage::StaticDraw);
Mesh mesh;
mesh.setBaseVertex(2)
.setInstanceCount(3)
.addVertexBuffer(vertices, 2*4, MultipleShader::Position(),
MultipleShader::Normal(), MultipleShader::TextureCoordinates())
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
.setIndexBuffer(indices, 2, MeshIndexType::UnsignedShort);
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
Removed duplicate code from MeshGLTest. As there is now no distinction between vertex and index count we don't need separate checker utility for non-indexed and indexed meshes.
12 years ago
const auto value = Checker(MultipleShader{}, RenderbufferFormat::RGBA8,
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
mesh).get<Color4ub>(PixelFormat::RGBA, PixelType::UnsignedByte);
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
CORRADE_COMPARE(value, indexedResult);
}
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
#endif
#ifdef MAGNUM_TARGET_GLES
void MeshGLTest::setInstanceCountIndexedBaseVertexNoExtensionAvailable() {
#ifndef MAGNUM_TARGET_GLES2
#ifndef MAGNUM_TARGET_WEBGL
if(Context::current().isVersionSupported(Version::GLES320))
CORRADE_SKIP("OpenGL ES 3.2 is available.");
if(Context::current().isExtensionSupported<Extensions::EXT::draw_elements_base_vertex>())
CORRADE_SKIP(Extensions::EXT::draw_elements_base_vertex::string() + std::string{" is available."});
if(Context::current().isExtensionSupported<Extensions::OES::draw_elements_base_vertex>())
CORRADE_SKIP(Extensions::OES::draw_elements_base_vertex::string() + std::string{" is available."});
#else
if(Context::current().isExtensionSupported<Extensions::WEBGL::draw_instanced_base_vertex_base_instance>())
CORRADE_SKIP(Extensions::WEBGL::draw_instanced_base_vertex_base_instance::string() + std::string{" is available."});
#endif
#endif
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
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
constexpr UnsignedShort indexData[] = { 2, 1, 0 };
Buffer indices{Buffer::TargetHint::ElementArray};
indices.setData(indexData, BufferUsage::StaticDraw);
Mesh mesh;
mesh.setCount(3)
.setInstanceCount(2)
.setBaseVertex(1)
.setIndexBuffer(indices, 0, MeshIndexType::UnsignedShort);
std::ostringstream out;
Error redirectError{&out};
MultipleShader{}.draw(mesh);
#ifndef MAGNUM_TARGET_GLES2
CORRADE_COMPARE(out.str(), "GL::AbstractShaderProgram::draw(): no extension available for instanced indexed mesh draw with base vertex specification\n");
#else
CORRADE_COMPARE(out.str(), "GL::AbstractShaderProgram::draw(): instanced indexed mesh draw with base vertex specification possible only since OpenGL ES 3.0\n");
#endif
}
#endif
#ifndef MAGNUM_TARGET_GLES2
void MeshGLTest::setInstanceCountIndexedBaseVertexBaseInstance() {
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
/* Verbatim copy of setInstanceCountBaseVertex() with added extension check
and setBaseInstance() call. It would just render three times the same
value. I'm too lazy to invent proper test case, so I'll just check
that it didn't generate any error and rendered something */
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
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::draw_elements_base_vertex>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::draw_elements_base_vertex::string() << "is not supported.");
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::base_instance>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::base_instance::string() << "is not supported.");
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
#elif !defined(MAGNUM_TARGET_WEBGL)
if(!Context::current().isExtensionSupported<Extensions::ANGLE::base_vertex_base_instance>())
CORRADE_SKIP(Extensions::ANGLE::base_vertex_base_instance::string() + std::string{" is not available."});
#else
if(!Context::current().isExtensionSupported<Extensions::WEBGL::draw_instanced_base_vertex_base_instance>())
CORRADE_SKIP(Extensions::WEBGL::draw_instanced_base_vertex_base_instance::string() + std::string{" is not available."});
#endif
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
Buffer vertices;
vertices.setData(indexedVertexDataBaseVertex, BufferUsage::StaticDraw);
constexpr UnsignedShort indexData[] = { 2, 1, 0 };
Implemented indexed buffer binding. The indexed binding is allowed for only some types (atomic counters, uniforms, shader storage and transform feedback), thus we need separate enum for that. Because the bind() function will be used far more often than setTargetHint(), the original Target enum is now renamed to TargetHint and the new Target enum contains (in non-deprecated build) only three values. For backwards compatibility, though, we need to have all original Target values, thus the new Target enum contains also all other values from TargetHint, but they are marked as deprecated and (at least) run-time checked in bind() so they aren't accidentaly used for indexed binding. Similarly there are also deprecated Target overloads of Buffer() and setTargetHint(). It's ugly, but hopefully will suffice for now. This mess will be removed as soon as possible in some upcoming version.
12 years ago
Buffer indices{Buffer::TargetHint::ElementArray};
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
indices.setData(indexData, BufferUsage::StaticDraw);
Mesh mesh;
mesh.setBaseVertex(2)
.setInstanceCount(3)
.setBaseInstance(72)
.addVertexBuffer(vertices, 2*4, MultipleShader::Position(),
MultipleShader::Normal(), MultipleShader::TextureCoordinates())
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
.setIndexBuffer(indices, 2, MeshIndexType::UnsignedShort);
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
Removed duplicate code from MeshGLTest. As there is now no distinction between vertex and index count we don't need separate checker utility for non-indexed and indexed meshes.
12 years ago
const auto value = Checker(MultipleShader{}, RenderbufferFormat::RGBA8,
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
mesh).get<Color4ub>(PixelFormat::RGBA, PixelType::UnsignedByte);
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
CORRADE_COMPARE(value, indexedResult);
}
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
#ifdef MAGNUM_TARGET_GLES
void MeshGLTest::setInstanceCountIndexedBaseVertexBaseInstanceNoExtensionAvailable() {
#ifndef MAGNUM_TARGET_WEBGL
if(Context::current().isExtensionSupported<Extensions::ANGLE::base_vertex_base_instance>())
CORRADE_SKIP(Extensions::ANGLE::base_vertex_base_instance::string() + std::string{" is available."});
#else
if(Context::current().isExtensionSupported<Extensions::WEBGL::draw_instanced_base_vertex_base_instance>())
CORRADE_SKIP(Extensions::WEBGL::draw_instanced_base_vertex_base_instance::string() + std::string{" is available."});
#endif
constexpr UnsignedShort indexData[] = { 2, 1, 0 };
Buffer indices{Buffer::TargetHint::ElementArray};
indices.setData(indexData, BufferUsage::StaticDraw);
Mesh mesh;
mesh.setCount(3)
.setInstanceCount(2)
.setBaseVertex(1)
.setBaseInstance(1)
.setIndexBuffer(indices, 0, MeshIndexType::UnsignedShort);
std::ostringstream out;
Error redirectError{&out};
MultipleShader{}.draw(mesh);
#ifndef MAGNUM_TARGET_GLES2
CORRADE_COMPARE(out.str(), "GL::AbstractShaderProgram::draw(): no extension available for instanced indexed mesh draw with base vertex and base instance specification\n");
#else
CORRADE_COMPARE(out.str(), "GL::AbstractShaderProgram::draw(): instanced indexed mesh draw with base vertex specification possible only since OpenGL 3.0\n");
#endif
}
#endif
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
#endif
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
void MeshGLTest::addVertexBufferInstancedFloat() {
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::instanced_arrays>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::instanced_arrays::string() << "is not supported.");
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
#elif defined(MAGNUM_TARGET_GLES2)
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#ifndef MAGNUM_TARGET_WEBGL
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>() &&
!Context::current().isExtensionSupported<Extensions::EXT::instanced_arrays>() &&
!Context::current().isExtensionSupported<Extensions::NV::instanced_arrays>())
GL: wait, there's not just three ES instanced extensions, there's FIVE. Like, why can't they just depend on each other or something?
7 years ago
CORRADE_SKIP("Required extension is not available.");
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#else
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ANGLE::instanced_arrays::string() << "is not supported.");
Test: make the GL tests compile on WebGL 1. Not WebGL 2 yet, though.
8 years ago
#endif
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
#endif
Moved Attribute class out of AbstractShaderProgram enum. No backward compatibility issues should exist, as the class is in most (if not all) cases used with unscoped name: class MyShader: public AbstractShaderProgram { public: typedef Attribute<0, Vector3> Position; // ... };
12 years ago
typedef Attribute<0, Float> Attribute;
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
const Float data[] = {
0.0f, /* Offset */
/* Base vertex is ignored for instanced arrays */
-0.7f, /* First instance */
0.3f, /* Second instance */
Math: renamed {de,}normalize() to {,un}pack() in a new Packing.h header. To be more consistent with GLSL naming. Also, the original naming was quite misleading, as normalize() is used in GLSL for something completely different. If building with deprecated APIs, the Functions.h header includes the new Packing.h header and the {de,}normalize() functions are defined as deprecated aliases to the new functions. This will be removed at some point in the future.
9 years ago
Math::unpack<Float, UnsignedByte>(96) /* Third instance */
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
};
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
mesh.setInstanceCount(3)
.addVertexBufferInstanced(buffer, 1, 4, Attribute{});
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
const auto value = Checker(FloatShader("float", "vec4(valueInterpolated, 0.0, 0.0, 0.0)"),
#ifndef MAGNUM_TARGET_GLES2
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
mesh).get<UnsignedByte>(PixelFormat::RGBA, PixelType::UnsignedByte);
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
CORRADE_COMPARE(value, 96);
}
#ifndef MAGNUM_TARGET_GLES2
void MeshGLTest::addVertexBufferInstancedInteger() {
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::instanced_arrays>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::instanced_arrays::string() << "is not supported.");
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::EXT::gpu_shader4>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::EXT::gpu_shader4::string() << "is not supported.");
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
#endif
Moved Attribute class out of AbstractShaderProgram enum. No backward compatibility issues should exist, as the class is in most (if not all) cases used with unscoped name: class MyShader: public AbstractShaderProgram { public: typedef Attribute<0, Vector3> Position; // ... };
12 years ago
typedef Attribute<0, UnsignedInt> Attribute;
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
constexpr UnsignedInt data[] = {
0, /* Offset */
/* Base vertex is ignored for instanced arrays */
157, /* First instance */
25, /* Second instance */
35681 /* Third instance */
};
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
mesh.setInstanceCount(3)
.addVertexBufferInstanced(buffer, 1, 4, Attribute{});
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
GL: fix MeshGLTest on WebGL. It doesn't allow anything except full RGBA and 32-bit types to be read from the framebuffer. Chromium browsers weren't complaining but Firefox did. I remember a similar restriction from GLES2 but all implementations I tested with including ANGLE and SwiftShader allow that already, so it's practically just a WebGL limitation.
5 years ago
const auto value = Checker(IntegerShader("uint"), RenderbufferFormat::R32UI, mesh).get<UnsignedInt>(
#ifndef MAGNUM_TARGET_WEBGL
PixelFormat::RedInteger,
#else
PixelFormat::RGBAInteger,
#endif
PixelType::UnsignedInt);
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
CORRADE_COMPARE(value, 35681);
}
#endif
#ifndef MAGNUM_TARGET_GLES
void MeshGLTest::addVertexBufferInstancedDouble() {
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::instanced_arrays>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::instanced_arrays::string() << "is not supported.");
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::vertex_attrib_64bit>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::vertex_attrib_64bit::string() << "is not supported.");
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
Moved Attribute class out of AbstractShaderProgram enum. No backward compatibility issues should exist, as the class is in most (if not all) cases used with unscoped name: class MyShader: public AbstractShaderProgram { public: typedef Attribute<0, Vector3> Position; // ... };
12 years ago
typedef Attribute<0, Double> Attribute;
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
const Double data[] = {
0.0, /* Offset */
/* Base vertex is ignored for instanced arrays */
-0.7, /* First instance */
0.3, /* Second instance */
Math: renamed {de,}normalize() to {,un}pack() in a new Packing.h header. To be more consistent with GLSL naming. Also, the original naming was quite misleading, as normalize() is used in GLSL for something completely different. If building with deprecated APIs, the Functions.h header includes the new Packing.h header and the {de,}normalize() functions are defined as deprecated aliases to the new functions. This will be removed at some point in the future.
9 years ago
Math::unpack<Double, UnsignedShort>(45828) /* Third instance */
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
};
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Mesh mesh;
mesh.setInstanceCount(3)
.addVertexBufferInstanced(buffer, 1, 8, Attribute{});
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
Fix type conversion errors in Mesh test shader code. Reported by latest NVidia drivers (352.09), apparently worked until now. Huh.
11 years ago
const auto value = Checker(DoubleShader("double", "float", "float(value)"),
Pixel storage support, part 2: renamed ColorFormat to PixelFormat etc. Yeah, sorry, I know, the enums are renamed for second or third time in a row, first they were Image::Format, then ImageFormat, then ColorFormat and now PixelFormat. But this time it's final and last time they are renamed and now everything is finally consistent: * ColorFormat::DepthComponent -- depth is not a color, thus PixelFormat::DepthComponent makes a lot more sense. * There will be PixelStorage classes, which will be stored in images alonside PixelFormat/PixelType enums, making everything nicely aligned. * The GL documentation about glTexImage2D() etc. denotes the <format> and <type> parameters as format and type of *pixel* data, so now we are _finally_ consistent with the official naming. I wonder why did I not choose PixelFormat originally. Anyway, the old <Magnum/ColorFormat.h> header, ColorFormat, ColorType and CompressedColorFormat types are now aliases to the new ones, are marked as deprecated and will be removed in some future release (as always, I'm waiting at least six months before removing the deprecated functionality).
11 years ago
RenderbufferFormat::R16, mesh).get<UnsignedShort>(PixelFormat::Red, PixelType::UnsignedShort);
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
Split the OpenGL layer out, pt 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
CORRADE_COMPARE(value, 45828);
}
#endif
GL: test that vertex attrib divisor is properly reset when not using VAOs. Fails, because it's not. Fix in next commit.
8 years ago
void MeshGLTest::resetDivisorAfterInstancedDraw() {
#ifndef MAGNUM_TARGET_GLES
if(!Context::current().isExtensionSupported<Extensions::ARB::draw_instanced>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::draw_instanced::string() << "is not supported.");
GL: test that vertex attrib divisor is properly reset when not using VAOs. Fails, because it's not. Fix in next commit.
8 years ago
if(!Context::current().isExtensionSupported<Extensions::ARB::instanced_arrays>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ARB::instanced_arrays::string() << "is not supported.");
GL: test that vertex attrib divisor is properly reset when not using VAOs. Fails, because it's not. Fix in next commit.
8 years ago
#elif defined(MAGNUM_TARGET_GLES2)
#ifndef MAGNUM_TARGET_WEBGL
if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>() &&
!Context::current().isExtensionSupported<Extensions::EXT::instanced_arrays>() &&
!Context::current().isExtensionSupported<Extensions::NV::instanced_arrays>())
GL: wait, there's not just three ES instanced extensions, there's FIVE. Like, why can't they just depend on each other or something?
7 years ago
CORRADE_SKIP("Required extension is not available.");
GL: test that vertex attrib divisor is properly reset when not using VAOs. Fails, because it's not. Fix in next commit.
8 years ago
#else
if(!Context::current().isExtensionSupported<Extensions::ANGLE::instanced_arrays>())
Test: adapt to changes in CORRADE_SKIP(). Chose to update the tests instead of adding a compatibility DebugStl.h include to Tester.h, which would have a significant impact on compile times.
5 years ago
CORRADE_SKIP(Extensions::ANGLE::instanced_arrays::string() << "is not supported.");
GL: test that vertex attrib divisor is properly reset when not using VAOs. Fails, because it's not. Fix in next commit.
8 years ago
#endif
#endif
/* This doesn't affect VAOs, because they encapsulate the state */
#ifndef MAGNUM_TARGET_GLES
if(Context::current().isExtensionSupported<Extensions::ARB::vertex_array_object>())
CORRADE_SKIP(Extensions::ARB::vertex_array_object::string() + std::string(" is enabled, can't test."));
#elif defined(MAGNUM_TARGET_GLES2)
if(Context::current().isExtensionSupported<Extensions::OES::vertex_array_object>())
CORRADE_SKIP(Extensions::OES::vertex_array_object::string() + std::string(" is enabled, can't test."));
#endif
typedef Attribute<0, Float> Attribute;
const Float data[]{
0,
Math::unpack<Float, UnsignedByte>(96),
Math::unpack<Float, UnsignedByte>(48),
};
Buffer buffer;
buffer.setData(data, BufferUsage::StaticDraw);
Renderbuffer renderbuffer;
renderbuffer.setStorage(
#ifndef MAGNUM_TARGET_GLES2
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
Vector2i(1));
Framebuffer framebuffer{{{}, Vector2i(1)}};
framebuffer.attachRenderbuffer(Framebuffer::ColorAttachment(0), renderbuffer)
.bind();
FloatShader shader{"float", "vec4(valueInterpolated, 0.0, 0.0, 0.0)"};
MAGNUM_VERIFY_NO_GL_ERROR();
/* Draw instanced first. Two single-vertex instances of an attribute with
divisor 1, first draws 0, second draws 96 */
{
Mesh mesh;
mesh.setInstanceCount(2)
.addVertexBufferInstanced(buffer, 1, 0, Attribute{})
.setPrimitive(MeshPrimitive::Points)
Adapted all code and doc snippets to GL library changes.
6 years ago
.setCount(1);
shader.draw(mesh);
GL: test that vertex attrib divisor is properly reset when not using VAOs. Fails, because it's not. Fix in next commit.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
GL: avoid using deprecated templated Image::data() in tests. This discovered quite a few potentially dangerous casts, so yay!
7 years ago
CORRADE_COMPARE(Containers::arrayCast<UnsignedByte>(framebuffer.read({{}, Vector2i{1}}, {PixelFormat::RGBA, PixelType::UnsignedByte}).data())[0], 96);
GL: test that vertex attrib divisor is properly reset when not using VAOs. Fails, because it's not. Fix in next commit.
8 years ago
}
/* Draw normal after. One two-vertex instance of an attribute with divisor
0, first draws 96, second 48. In case divisor is not properly reset,
I'll get 96 on both. */
{
Mesh mesh;
mesh.setInstanceCount(1)
.addVertexBuffer(buffer, 4, Attribute{})
.setPrimitive(MeshPrimitive::Points)
Adapted all code and doc snippets to GL library changes.
6 years ago
.setCount(2);
shader.draw(mesh);
GL: test that vertex attrib divisor is properly reset when not using VAOs. Fails, because it's not. Fix in next commit.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
GL: avoid using deprecated templated Image::data() in tests. This discovered quite a few potentially dangerous casts, so yay!
7 years ago
CORRADE_COMPARE(Containers::arrayCast<UnsignedByte>(framebuffer.read({{}, Vector2i{1}}, {PixelFormat::RGBA, PixelType::UnsignedByte}).data())[0], 48);
GL: test that vertex attrib divisor is properly reset when not using VAOs. Fails, because it's not. Fix in next commit.
8 years ago
}
}
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
struct MultiDrawShader: AbstractShaderProgram {
typedef Attribute<0, Vector2> Position;
typedef Attribute<1, Vector4> Value;
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: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
explicit MultiDrawShader(bool vertexId = false, bool drawId = false);
};
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: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
MultiDrawShader::MultiDrawShader(bool vertexId, bool drawId) {
/* Pick GLSL 3.0 / ESSL 3.0 for gl_VertexID, if available */
#ifndef MAGNUM_TARGET_GLES
#ifndef CORRADE_TARGET_APPLE
const Version version = Context::current().supportedVersion({Version::GL300, Version::GL210});
#else
const Version version = Version::GL310;
#endif
#else
const Version version = Context::current().supportedVersion({Version::GLES300, Version::GLES200});
#endif
Shader vert{version, Shader::Type::Vertex};
Shader frag{version, Shader::Type::Fragment};
if(drawId) vert.addSource(
"#ifndef GL_ES\n"
"#extension GL_ARB_shader_draw_parameters: require\n"
"#define vertexOrDrawId gl_DrawIDARB\n"
"#else /* covers WebGL as well */\n"
"#extension GL_ANGLE_multi_draw: require\n"
"#define vertexOrDrawId gl_DrawID\n"
"#endif\n");
else if(vertexId) vert.addSource(
"#define vertexOrDrawId gl_VertexID\n");
else vert.addSource(
"#define vertexOrDrawId 0\n");
vert.addSource(
"#if !defined(GL_ES) && __VERSION__ == 120\n"
"#define mediump\n"
"#endif\n"
"#if (defined(GL_ES) && __VERSION__ == 100) || __VERSION__ == 120\n"
"#define in attribute\n"
"#define out varying\n"
"#endif\n"
"in mediump vec2 position;\n"
"in mediump vec4 value;\n"
"out mediump float valueInterpolated;\n"
"void main() {\n"
" valueInterpolated = value[vertexOrDrawId];\n"
" gl_Position = vec4(position, 0.0, 1.0);\n"
"}\n");
frag.addSource(
"#if !defined(GL_ES) && __VERSION__ == 120\n"
"#define mediump\n"
"#endif\n"
"#if (defined(GL_ES) && __VERSION__ == 100) || __VERSION__ == 120\n"
"#define in varying\n"
"#define result gl_FragColor\n"
"#endif\n"
"in mediump float valueInterpolated;\n"
"#if (defined(GL_ES) && __VERSION__ >= 300) || __VERSION__ >= 130\n"
"out mediump vec4 result;\n"
"#endif\n"
"void main() { result.r = valueInterpolated; }\n");
CORRADE_INTERNAL_ASSERT_OUTPUT(Shader::compile({vert, frag}));
attachShaders({vert, frag});
bindAttributeLocation(Position::Location, "position");
bindAttributeLocation(Value::Location, "value");
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
}
struct MultiDrawChecker {
explicit MultiDrawChecker();
Vector4 get();
Renderbuffer _renderbuffer;
Framebuffer _framebuffer;
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 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 DOXYGEN_GENERATING_OUTPUT
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
MultiDrawChecker::MultiDrawChecker(): _framebuffer{{{}, Vector2i{2}}} {
_renderbuffer.setStorage(
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
RenderbufferFormat::RGBA8,
#else
RenderbufferFormat::RGBA4,
#endif
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
Vector2i{2});
_framebuffer.attachRenderbuffer(Framebuffer::ColorAttachment{0}, _renderbuffer);
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: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
_framebuffer
.clear(FramebufferClear::Color)
.bind();
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: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
Vector4 MultiDrawChecker::get() {
const Image2D image = _framebuffer.read({{}, Vector2i{2}}, {PixelFormat::RGBA, PixelType::UnsignedByte});
const Containers::StridedArrayView2D<const UnsignedByte> redChannel = Containers::arrayCast<const UnsignedByte>(image.pixels<Vector4ub>());
return Math::unpack<Vector4>(Vector4ub{redChannel[0][0],
redChannel[0][1],
redChannel[1][0],
redChannel[1][1]});
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
void MeshGLTest::multiDraw() {
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
auto&& data = MultiDrawData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES2
if(data.vertexId && !GL::Context::current().isExtensionSupported<GL::Extensions::MAGNUM::shader_vertex_id>())
CORRADE_SKIP("gl_VertexID not supported");
#endif
if(data.drawId) {
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::shader_draw_parameters>())
CORRADE_SKIP(GL::Extensions::ARB::shader_draw_parameters::string() << "is not supported.");
#elif !defined(MAGNUM_TARGET_WEBGL)
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ANGLE::multi_draw>())
CORRADE_SKIP(GL::Extensions::ANGLE::multi_draw::string() << "is not supported.");
#else
if(!GL::Context::current().isExtensionSupported<GL::Extensions::WEBGL::multi_draw>())
CORRADE_SKIP(GL::Extensions::WEBGL::multi_draw::string() << "is not supported.");
#endif
}
GL: implement ANGLE_multi_draw and WEBGL_multi_draw support.
5 years ago
#ifdef MAGNUM_TARGET_GLES
#ifndef MAGNUM_TARGET_WEBGL
if(!Context::current().isExtensionSupported<Extensions::EXT::multi_draw_arrays>() &&
!Context::current().isExtensionSupported<Extensions::ANGLE::multi_draw>())
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
CORRADE_INFO("Neither" << Extensions::EXT::multi_draw_arrays::string() << "nor" << Extensions::ANGLE::multi_draw::string() << "is supported, using fallback implementation");
GL: implement ANGLE_multi_draw and WEBGL_multi_draw support.
5 years ago
#else
if(!Context::current().isExtensionSupported<Extensions::WEBGL::multi_draw>())
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
CORRADE_INFO(Extensions::WEBGL::multi_draw::string() << "is not supported, using fallback implementation");
GL: implement ANGLE_multi_draw and WEBGL_multi_draw support.
5 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
#endif
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
const struct {
Vector2 position;
Vector4 value;
} vertexData[] {
{}, /* initial offset */
{{-1.0f/3.0f, -1.0f/3.0f}, data.values[0]},
{{ 1.0f/3.0f, -1.0f/3.0f}, data.values[1]},
{{-1.0f/3.0f, 1.0f/3.0f}, data.values[2]},
{{ 1.0f/3.0f, 1.0f/3.0f}, data.values[3]},
};
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: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
Mesh mesh{MeshPrimitive::Points};
mesh.addVertexBuffer(Buffer{vertexData}, sizeof(vertexData[0]), MultiDrawShader::Position{}, MultiDrawShader::Value{});
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
MAGNUM_VERIFY_NO_GL_ERROR();
MultiDrawChecker checker;
MultiDrawShader{data.vertexId, data.drawId}.draw(mesh, data.counts, data.vertexOffsets, nullptr);
Vector4 value = checker.get();
MAGNUM_VERIFY_NO_GL_ERROR();
#ifndef MAGNUM_TARGET_GLES2
CORRADE_COMPARE_WITH(value, data.expected,
TestSuite::Compare::around(Vector4{1.0f/255.0f}));
#else
CORRADE_COMPARE_WITH(value, data.expected, /* it's only RGBA4 */
TestSuite::Compare::around(Vector4{1.0f/15.0f}));
#endif
}
void MeshGLTest::multiDrawSparseArrays() {
auto&& data = MultiDrawData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES2
if(data.vertexId && !GL::Context::current().isExtensionSupported<GL::Extensions::MAGNUM::shader_vertex_id>())
CORRADE_SKIP("gl_VertexID not supported");
#endif
if(data.drawId) {
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::shader_draw_parameters>())
CORRADE_SKIP(GL::Extensions::ARB::shader_draw_parameters::string() << "is not supported.");
#elif !defined(MAGNUM_TARGET_WEBGL)
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ANGLE::multi_draw>())
CORRADE_SKIP(GL::Extensions::ANGLE::multi_draw::string() << "is not supported.");
#else
if(!GL::Context::current().isExtensionSupported<GL::Extensions::WEBGL::multi_draw>())
CORRADE_SKIP(GL::Extensions::WEBGL::multi_draw::string() << "is not supported.");
#endif
}
#ifdef MAGNUM_TARGET_GLES
#ifndef MAGNUM_TARGET_WEBGL
if(!Context::current().isExtensionSupported<Extensions::EXT::multi_draw_arrays>() &&
!Context::current().isExtensionSupported<Extensions::ANGLE::multi_draw>())
CORRADE_INFO("Neither" << Extensions::EXT::multi_draw_arrays::string() << "nor" << Extensions::ANGLE::multi_draw::string() << "is supported, using fallback implementation");
#else
if(!Context::current().isExtensionSupported<Extensions::WEBGL::multi_draw>())
CORRADE_INFO(Extensions::WEBGL::multi_draw::string() << "is not supported, using fallback implementation");
#endif
#endif
const struct {
Vector2 position;
Vector4 value;
} vertexData[] {
{}, /* initial offset */
{{-1.0f/3.0f, -1.0f/3.0f}, data.values[0]},
{{ 1.0f/3.0f, -1.0f/3.0f}, data.values[1]},
{{-1.0f/3.0f, 1.0f/3.0f}, data.values[2]},
{{ 1.0f/3.0f, 1.0f/3.0f}, data.values[3]},
};
Mesh mesh{MeshPrimitive::Points};
mesh.addVertexBuffer(Buffer{vertexData}, sizeof(vertexData[0]), MultiDrawShader::Position{}, MultiDrawShader::Value{});
MAGNUM_VERIFY_NO_GL_ERROR();
/* The signature accepted by glMultiDrawArraysIndirect() */
struct Command {
UnsignedInt count;
UnsignedInt instanceCount;
UnsignedInt first;
UnsignedInt baseInstance;
} commands[] {
{data.counts[0], 0, data.vertexOffsets[0], 0},
{data.counts[1], 0, data.vertexOffsets[1], 0},
{data.counts[2], 0, data.vertexOffsets[2], 0},
{data.counts[3], 0, data.vertexOffsets[3], 0},
};
MultiDrawChecker checker;
MultiDrawShader{data.vertexId, data.drawId}.draw(mesh,
Containers::stridedArrayView(commands).slice(&Command::count),
Containers::stridedArrayView(commands).slice(&Command::first),
nullptr);
Vector4 value = checker.get();
MAGNUM_VERIFY_NO_GL_ERROR();
#ifndef MAGNUM_TARGET_GLES2
CORRADE_COMPARE_WITH(value, data.expected,
TestSuite::Compare::around(Vector4{1.0f/255.0f}));
#else
CORRADE_COMPARE_WITH(value, data.expected, /* it's only RGBA4 */
TestSuite::Compare::around(Vector4{1.0f/15.0f}));
#endif
}
void MeshGLTest::multiDrawViews() {
auto&& data = MultiDrawData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES2
if(data.vertexId && !GL::Context::current().isExtensionSupported<GL::Extensions::MAGNUM::shader_vertex_id>())
CORRADE_SKIP("gl_VertexID not supported");
#endif
if(data.drawId) {
#ifndef MAGNUM_TARGET_GLES
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::shader_draw_parameters>())
CORRADE_SKIP(GL::Extensions::ARB::shader_draw_parameters::string() << "is not supported.");
#elif !defined(MAGNUM_TARGET_WEBGL)
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ANGLE::multi_draw>())
CORRADE_SKIP(GL::Extensions::ANGLE::multi_draw::string() << "is not supported.");
#else
if(!GL::Context::current().isExtensionSupported<GL::Extensions::WEBGL::multi_draw>())
CORRADE_SKIP(GL::Extensions::WEBGL::multi_draw::string() << "is not supported.");
#endif
}
#ifdef MAGNUM_TARGET_GLES
#ifndef MAGNUM_TARGET_WEBGL
if(!Context::current().isExtensionSupported<Extensions::EXT::multi_draw_arrays>() &&
!Context::current().isExtensionSupported<Extensions::ANGLE::multi_draw>())
CORRADE_INFO("Neither" << Extensions::EXT::multi_draw_arrays::string() << "nor" << Extensions::ANGLE::multi_draw::string() << "is supported, using fallback implementation");
#else
if(!Context::current().isExtensionSupported<Extensions::WEBGL::multi_draw>())
CORRADE_INFO(Extensions::WEBGL::multi_draw::string() << "is not supported, using fallback implementation");
#endif
#endif
const struct {
Vector2 position;
Vector4 value;
} vertexData[] {
{}, /* initial offset */
{{-1.0f/3.0f, -1.0f/3.0f}, data.values[0]},
{{ 1.0f/3.0f, -1.0f/3.0f}, data.values[1]},
{{-1.0f/3.0f, 1.0f/3.0f}, data.values[2]},
{{ 1.0f/3.0f, 1.0f/3.0f}, data.values[3]},
};
Mesh mesh{MeshPrimitive::Points};
mesh.addVertexBuffer(Buffer{vertexData}, sizeof(vertexData[0]), MultiDrawShader::Position{}, MultiDrawShader::Value{});
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
MeshView a{mesh}, b{mesh}, c{mesh}, d{mesh};
a.setCount(data.counts[0])
.setBaseVertex(data.vertexOffsets[0]);
b.setCount(data.counts[1])
.setBaseVertex(data.vertexOffsets[1]);
c.setCount(data.counts[2])
.setBaseVertex(data.vertexOffsets[2]);
d.setCount(data.counts[3])
.setBaseVertex(data.vertexOffsets[3]);
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 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
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: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
MultiDrawChecker checker;
MultiDrawShader{data.vertexId, data.drawId}.draw({a, b, c, d});
Vector4 value = checker.get();
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 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 years ago
#ifndef MAGNUM_TARGET_GLES2
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
CORRADE_COMPARE_WITH(value, data.expected,
TestSuite::Compare::around(Vector4{1.0f/255.0f}));
#else
CORRADE_COMPARE_WITH(value, data.expected, /* it's only RGBA4 */
TestSuite::Compare::around(Vector4{1.0f/15.0f}));
GL: expect less precision on ES2 tests that use RGBA4 renderbuffers.
7 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
}
void MeshGLTest::multiDrawIndexed() {
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
auto&& data = MultiDrawIndexedData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES2
if(data.vertexId && !GL::Context::current().isExtensionSupported<GL::Extensions::MAGNUM::shader_vertex_id>())
CORRADE_SKIP("gl_VertexID not supported");
#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
bool hasBaseVertex = data.vertexOffsets[0] || data.vertexOffsets[1] || data.vertexOffsets[2] || data.vertexOffsets[3];
if(hasBaseVertex) {
#ifndef MAGNUM_TARGET_GLES
if(!Context::current().isExtensionSupported<Extensions::ARB::draw_elements_base_vertex>())
CORRADE_SKIP(Extensions::ARB::draw_elements_base_vertex::string() << "is not supported.");
#elif !defined(MAGNUM_TARGET_WEBGL)
if(!Context::current().isExtensionSupported<Extensions::OES::draw_elements_base_vertex>() &&
!Context::current().isExtensionSupported<Extensions::EXT::draw_elements_base_vertex>())
CORRADE_SKIP(std::string{"Neither "} + Extensions::OES::draw_elements_base_vertex::string() + " nor " + Extensions::EXT::draw_elements_base_vertex::string() + " is available.");
#elif !defined(MAGNUM_TARGET_GLES2)
if(!Context::current().isExtensionSupported<Extensions::WEBGL::multi_draw_instanced_base_vertex_base_instance>())
CORRADE_SKIP(Extensions::WEBGL::multi_draw_instanced_base_vertex_base_instance::string() + std::string{" is not available."});
#else
CORRADE_FAIL_IF(false, "Can't do base vertex here.");
#endif
}
#ifdef MAGNUM_TARGET_GLES
#ifndef MAGNUM_TARGET_WEBGL
if(!Context::current().isExtensionSupported<Extensions::EXT::multi_draw_arrays>() &&
!Context::current().isExtensionSupported<Extensions::ANGLE::multi_draw>())
CORRADE_INFO("Neither" << Extensions::EXT::multi_draw_arrays::string() << "nor" << Extensions::ANGLE::multi_draw::string() << "is supported, using fallback implementation");
#else
if(!Context::current().isExtensionSupported<Extensions::WEBGL::multi_draw>())
CORRADE_INFO(Extensions::WEBGL::multi_draw::string() << "is not supported, using fallback implementation");
#endif
#endif
const struct {
Vector2 position;
Vector4 value;
} vertexData[] {
{}, /* initial offset */
{{-1.0f/3.0f, -1.0f/3.0f}, data.values[0]},
{{ 1.0f/3.0f, -1.0f/3.0f}, data.values[1]},
{{-1.0f/3.0f, 1.0f/3.0f}, data.values[2]},
{{ 1.0f/3.0f, 1.0f/3.0f}, data.values[3]},
};
Mesh mesh{MeshPrimitive::Points};
mesh.addVertexBuffer(Buffer{vertexData}, sizeof(vertexData[0]), MultiDrawShader::Position{}, MultiDrawShader::Value{})
.setIndexBuffer(Buffer{Buffer::TargetHint::ElementArray, data.indices}, 0, MeshIndexType::UnsignedInt);
MAGNUM_VERIFY_NO_GL_ERROR();
MultiDrawChecker checker;
MultiDrawShader{data.vertexId, false}.draw(mesh, data.counts, hasBaseVertex ? Containers::arrayView(data.vertexOffsets) : nullptr, data.indexOffsetsInBytes);
Vector4 value = checker.get();
MAGNUM_VERIFY_NO_GL_ERROR();
#ifndef MAGNUM_TARGET_GLES2
CORRADE_COMPARE_WITH(value, data.expected,
TestSuite::Compare::around(Vector4{1.0f/255.0f}));
#else
CORRADE_COMPARE_WITH(value, data.expected, /* it's only RGBA4 */
TestSuite::Compare::around(Vector4{1.0f/15.0f}));
#endif
}
void MeshGLTest::multiDrawIndexedSparseArrays() {
auto&& data = MultiDrawIndexedData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES2
if(data.vertexId && !GL::Context::current().isExtensionSupported<GL::Extensions::MAGNUM::shader_vertex_id>())
CORRADE_SKIP("gl_VertexID not supported");
#endif
bool hasBaseVertex = data.vertexOffsets[0] || data.vertexOffsets[1] || data.vertexOffsets[2] || data.vertexOffsets[3];
if(hasBaseVertex) {
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
#ifndef MAGNUM_TARGET_GLES
if(!Context::current().isExtensionSupported<Extensions::ARB::draw_elements_base_vertex>())
CORRADE_SKIP(Extensions::ARB::draw_elements_base_vertex::string() << "is not supported.");
#elif !defined(MAGNUM_TARGET_WEBGL)
if(!Context::current().isExtensionSupported<Extensions::OES::draw_elements_base_vertex>() &&
!Context::current().isExtensionSupported<Extensions::EXT::draw_elements_base_vertex>())
CORRADE_SKIP(std::string{"Neither "} + Extensions::OES::draw_elements_base_vertex::string() + " nor " + Extensions::EXT::draw_elements_base_vertex::string() + " is available.");
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
#elif !defined(MAGNUM_TARGET_GLES2)
if(!Context::current().isExtensionSupported<Extensions::WEBGL::multi_draw_instanced_base_vertex_base_instance>())
CORRADE_SKIP(Extensions::WEBGL::multi_draw_instanced_base_vertex_base_instance::string() + std::string{" is not available."});
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 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
CORRADE_FAIL_IF(false, "Can't do base vertex here.");
#endif
}
#ifdef MAGNUM_TARGET_GLES
#ifndef MAGNUM_TARGET_WEBGL
if(!Context::current().isExtensionSupported<Extensions::EXT::multi_draw_arrays>() &&
!Context::current().isExtensionSupported<Extensions::ANGLE::multi_draw>())
CORRADE_INFO("Neither" << Extensions::EXT::multi_draw_arrays::string() << "nor" << Extensions::ANGLE::multi_draw::string() << "is supported, using fallback implementation");
#else
if(!Context::current().isExtensionSupported<Extensions::WEBGL::multi_draw>())
CORRADE_INFO(Extensions::WEBGL::multi_draw::string() << "is not supported, using fallback implementation");
#endif
#endif
const struct {
Vector2 position;
Vector4 value;
} vertexData[] {
{}, /* initial offset */
{{-1.0f/3.0f, -1.0f/3.0f}, data.values[0]},
{{ 1.0f/3.0f, -1.0f/3.0f}, data.values[1]},
{{-1.0f/3.0f, 1.0f/3.0f}, data.values[2]},
{{ 1.0f/3.0f, 1.0f/3.0f}, data.values[3]},
};
Mesh mesh{MeshPrimitive::Points};
mesh.addVertexBuffer(Buffer{vertexData}, sizeof(vertexData[0]), MultiDrawShader::Position{}, MultiDrawShader::Value{})
.setIndexBuffer(Buffer{Buffer::TargetHint::ElementArray, data.indices}, 0, MeshIndexType::UnsignedInt);
MAGNUM_VERIFY_NO_GL_ERROR();
/* The signature accepted by glMultiDrawElementsIndirect() EXCEPT that
here we need firstIndex to be in bytes */
struct Command {
UnsignedInt count;
UnsignedInt instanceCount;
UnsignedInt firstIndexInBytes; /* !! */
UnsignedInt baseVertex;
UnsignedInt baseInstance;
} commands[] {
{data.counts[0], 0, UnsignedInt(data.indexOffsetsInBytes[0]), data.vertexOffsets[0], 0},
{data.counts[1], 0, UnsignedInt(data.indexOffsetsInBytes[1]), data.vertexOffsets[1], 0},
{data.counts[2], 0, UnsignedInt(data.indexOffsetsInBytes[2]), data.vertexOffsets[2], 0},
{data.counts[3], 0, UnsignedInt(data.indexOffsetsInBytes[3]), data.vertexOffsets[3], 0}
};
MultiDrawChecker checker;
MultiDrawShader{data.vertexId, false}.draw(mesh,
Containers::stridedArrayView(commands).slice(&Command::count),
hasBaseVertex ? Containers::stridedArrayView(commands).slice(&Command::baseVertex) : nullptr,
Containers::stridedArrayView(commands).slice(&Command::firstIndexInBytes));
Vector4 value = checker.get();
MAGNUM_VERIFY_NO_GL_ERROR();
#ifndef MAGNUM_TARGET_GLES2
CORRADE_COMPARE_WITH(value, data.expected,
TestSuite::Compare::around(Vector4{1.0f/255.0f}));
#else
CORRADE_COMPARE_WITH(value, data.expected, /* it's only RGBA4 */
TestSuite::Compare::around(Vector4{1.0f/15.0f}));
#endif
}
void MeshGLTest::multiDrawIndexedViews() {
auto&& data = MultiDrawIndexedData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef MAGNUM_TARGET_GLES2
if(data.vertexId && !GL::Context::current().isExtensionSupported<GL::Extensions::MAGNUM::shader_vertex_id>())
CORRADE_SKIP("gl_VertexID not supported");
#endif
if(data.vertexOffsets[0] || data.vertexOffsets[1] || data.vertexOffsets[2] || data.vertexOffsets[3]) {
#ifndef MAGNUM_TARGET_GLES
if(!Context::current().isExtensionSupported<Extensions::ARB::draw_elements_base_vertex>())
CORRADE_SKIP(Extensions::ARB::draw_elements_base_vertex::string() << "is not supported.");
#elif !defined(MAGNUM_TARGET_WEBGL)
if(!Context::current().isExtensionSupported<Extensions::OES::draw_elements_base_vertex>() &&
!Context::current().isExtensionSupported<Extensions::EXT::draw_elements_base_vertex>())
CORRADE_SKIP(std::string{"Neither "} + Extensions::OES::draw_elements_base_vertex::string() + " nor " + Extensions::EXT::draw_elements_base_vertex::string() + " is available.");
#elif !defined(MAGNUM_TARGET_GLES2)
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
if(!Context::current().isExtensionSupported<Extensions::WEBGL::multi_draw_instanced_base_vertex_base_instance>())
CORRADE_SKIP(Extensions::WEBGL::multi_draw_instanced_base_vertex_base_instance::string() + std::string{" is not available."});
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
#else
CORRADE_FAIL_IF(false, "Can't do base vertex here.");
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
#endif
}
GL: implement ANGLE_multi_draw and WEBGL_multi_draw support.
5 years ago
#ifdef MAGNUM_TARGET_GLES
#ifndef MAGNUM_TARGET_WEBGL
if(!Context::current().isExtensionSupported<Extensions::EXT::multi_draw_arrays>() &&
!Context::current().isExtensionSupported<Extensions::ANGLE::multi_draw>())
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
CORRADE_INFO("Neither" << Extensions::EXT::multi_draw_arrays::string() << "nor" << Extensions::ANGLE::multi_draw::string() << "is supported, using fallback implementation");
GL: implement ANGLE_multi_draw and WEBGL_multi_draw support.
5 years ago
#else
if(!Context::current().isExtensionSupported<Extensions::WEBGL::multi_draw>())
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
CORRADE_INFO(Extensions::WEBGL::multi_draw::string() << "is not supported, using fallback implementation");
GL: implement ANGLE_multi_draw and WEBGL_multi_draw support.
5 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
#endif
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
const struct {
Vector2 position;
Vector4 value;
} vertexData[] {
{}, /* initial offset */
{{-1.0f/3.0f, -1.0f/3.0f}, data.values[0]},
{{ 1.0f/3.0f, -1.0f/3.0f}, data.values[1]},
{{-1.0f/3.0f, 1.0f/3.0f}, data.values[2]},
{{ 1.0f/3.0f, 1.0f/3.0f}, data.values[3]},
};
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: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
Mesh mesh{MeshPrimitive::Points};
mesh.addVertexBuffer(Buffer{vertexData}, sizeof(vertexData[0]), MultiDrawShader::Position{}, MultiDrawShader::Value{})
.setIndexBuffer(Buffer{Buffer::TargetHint::ElementArray, data.indices}, 0, MeshIndexType::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
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
MeshView a{mesh}, b{mesh}, c{mesh}, d{mesh};
a.setCount(data.counts[0])
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
.setIndexRange(data.indexOffsetsInBytes[0]/sizeof(UnsignedInt))
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
.setBaseVertex(data.vertexOffsets[0]);
b.setCount(data.counts[1])
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
.setIndexRange(data.indexOffsetsInBytes[1]/sizeof(UnsignedInt))
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
.setBaseVertex(data.vertexOffsets[1]);
c.setCount(data.counts[2])
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
.setIndexRange(data.indexOffsetsInBytes[2]/sizeof(UnsignedInt))
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
.setBaseVertex(data.vertexOffsets[2]);
d.setCount(data.counts[3])
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
.setIndexRange(data.indexOffsetsInBytes[3]/sizeof(UnsignedInt))
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
.setBaseVertex(data.vertexOffsets[3]);
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 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
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: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
MultiDrawChecker checker;
MultiDrawShader{data.vertexId, false}.draw({a, b, c, d});
Vector4 value = checker.get();
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 17: adapted GL tests. Now the library compiles together with tests w/o deprecation warnings ... except for documentation snippets.
8 years ago
MAGNUM_VERIFY_NO_GL_ERROR();
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
#ifndef MAGNUM_TARGET_GLES2
CORRADE_COMPARE_WITH(value, data.expected,
TestSuite::Compare::around(Vector4{1.0f/255.0f}));
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
#else
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
CORRADE_COMPARE_WITH(value, data.expected, /* it's only RGBA4 */
TestSuite::Compare::around(Vector4{1.0f/15.0f}));
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
#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: 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
void MeshGLTest::multiDrawWrongVertexOffsetSize() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Mesh mesh;
MultiDrawShader shader;
UnsignedInt counts[3]{};
UnsignedInt vertexOffsets[2]{};
std::ostringstream out;
Error redirectError{&out};
shader.draw(mesh, counts, vertexOffsets, nullptr);
shader.draw(mesh, counts, nullptr, nullptr);
CORRADE_COMPARE(out.str(),
"GL::AbstractShaderProgram::draw(): expected 3 vertex offset items but got 2\n"
"GL::AbstractShaderProgram::draw(): expected 3 vertex offset items but got 0\n");
}
void MeshGLTest::multiDrawIndexedWrongIndexOffsetSize() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Mesh mesh;
mesh.setIndexBuffer(Buffer{Buffer::TargetHint::ElementArray, {2, 1, 0}}, 0, MeshIndexType::UnsignedInt);
MultiDrawShader shader;
UnsignedInt counts[3]{};
UnsignedInt indexOffsets[2]{};
std::ostringstream out;
Error redirectError{&out};
shader.draw(mesh, counts, nullptr, indexOffsets);
shader.draw(mesh, counts, nullptr, nullptr);
CORRADE_COMPARE(out.str(),
"GL::AbstractShaderProgram::draw(): expected 3 index offset items but got 2\n"
"GL::AbstractShaderProgram::draw(): expected 3 index offset items but got 0\n");
}
void MeshGLTest::multiDrawIndexedWrongVertexOffsetSize() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Mesh mesh;
mesh.setIndexBuffer(Buffer{Buffer::TargetHint::ElementArray, {2, 1, 0}}, 0, MeshIndexType::UnsignedInt);
MultiDrawShader shader;
UnsignedInt counts[3]{};
UnsignedInt vertexOffsets[2]{};
UnsignedInt indexOffsets[3]{};
std::ostringstream out;
Error redirectError{&out};
shader.draw(mesh, counts, vertexOffsets, indexOffsets);
CORRADE_COMPARE(out.str(),
"GL::AbstractShaderProgram::draw(): expected 3 vertex offset items but got 2\n");
}
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
#ifdef MAGNUM_TARGET_GLES
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
void MeshGLTest::multiDrawIndexedBaseVertexNoExtensionAvailable() {
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
#ifdef MAGNUM_TARGET_GLES
/* If the multidraw extensions aren't available, we can't test this assert,
only the assert in the fallback path, which is already tested above. */
#ifndef MAGNUM_TARGET_WEBGL
if(!Context::current().isExtensionSupported<Extensions::EXT::multi_draw_arrays>() &&
!Context::current().isExtensionSupported<Extensions::ANGLE::multi_draw>())
CORRADE_SKIP(std::string{"Neither "} + Extensions::EXT::multi_draw_arrays::string() + " nor " + Extensions::ANGLE::multi_draw::string() + " is available.");
#else
if(!Context::current().isExtensionSupported<Extensions::WEBGL::multi_draw>())
CORRADE_SKIP(Extensions::WEBGL::multi_draw::string() + std::string{" is not available."});
#endif
#endif
#ifndef MAGNUM_TARGET_WEBGL
if(Context::current().isExtensionSupported<Extensions::EXT::draw_elements_base_vertex>())
CORRADE_SKIP(Extensions::EXT::draw_elements_base_vertex::string() + std::string{" is available."});
if(Context::current().isExtensionSupported<Extensions::OES::draw_elements_base_vertex>())
CORRADE_SKIP(Extensions::OES::draw_elements_base_vertex::string() + std::string{" is available."});
#elif !defined(MAGNUM_TARGET_GLES2)
if(Context::current().isExtensionSupported<Extensions::WEBGL::multi_draw_instanced_base_vertex_base_instance>())
CORRADE_SKIP(Extensions::WEBGL::multi_draw_instanced_base_vertex_base_instance::string() + std::string{" is available."});
#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
Mesh mesh;
mesh.setIndexBuffer(Buffer{Buffer::TargetHint::ElementArray, {2, 1, 0}}, 0, MeshIndexType::UnsignedInt);
UnsignedInt counts[]{3};
UnsignedInt vertexOffsets[]{0};
UnsignedInt indexOffsets[]{0};
std::ostringstream out;
Error redirectError{&out};
MultiDrawShader{}.draw(mesh, counts, vertexOffsets, indexOffsets);
#if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2))
CORRADE_COMPARE(out.str(), "GL::AbstractShaderProgram::draw(): no extension available for indexed mesh multi-draw with base vertex specification\n");
#else
CORRADE_COMPARE(out.str(), "GL::AbstractShaderProgram::draw(): indexed mesh multi-draw with base vertex specification possible only since WebGL 2.0\n");
#endif
}
void MeshGLTest::multiDrawIndexedViewsBaseVertexNoExtensionAvailable() {
#ifdef MAGNUM_TARGET_GLES
/* If the multidraw extensions aren't available, we can't test this assert,
only the assert in the fallback path, which is already tested above. */
#ifndef MAGNUM_TARGET_WEBGL
if(!Context::current().isExtensionSupported<Extensions::EXT::multi_draw_arrays>() &&
!Context::current().isExtensionSupported<Extensions::ANGLE::multi_draw>())
CORRADE_SKIP(std::string{"Neither "} + Extensions::EXT::multi_draw_arrays::string() + " nor " + Extensions::ANGLE::multi_draw::string() + " is available.");
#else
if(!Context::current().isExtensionSupported<Extensions::WEBGL::multi_draw>())
CORRADE_SKIP(Extensions::WEBGL::multi_draw::string() + std::string{" is not available."});
#endif
#endif
#ifndef MAGNUM_TARGET_WEBGL
if(Context::current().isExtensionSupported<Extensions::EXT::draw_elements_base_vertex>())
CORRADE_SKIP(Extensions::EXT::draw_elements_base_vertex::string() + std::string{" is available."});
if(Context::current().isExtensionSupported<Extensions::OES::draw_elements_base_vertex>())
CORRADE_SKIP(Extensions::OES::draw_elements_base_vertex::string() + std::string{" is available."});
#elif !defined(MAGNUM_TARGET_GLES2)
if(Context::current().isExtensionSupported<Extensions::WEBGL::multi_draw_instanced_base_vertex_base_instance>())
CORRADE_SKIP(Extensions::WEBGL::multi_draw_instanced_base_vertex_base_instance::string() + std::string{" is available."});
#endif
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 mesh;
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
mesh.setIndexBuffer(Buffer{Buffer::TargetHint::ElementArray, {2, 1, 0}}, 0, MeshIndexType::UnsignedInt);
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
MeshView view{mesh};
view.setCount(3)
.setBaseVertex(1);
std::ostringstream out;
Error redirectError{&out};
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
MultiDrawShader{}.draw({view, view});
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
#if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2))
CORRADE_COMPARE(out.str(), "GL::AbstractShaderProgram::draw(): no extension available for indexed mesh multi-draw with base vertex specification\n");
#else
CORRADE_COMPARE(out.str(), "GL::AbstractShaderProgram::draw(): indexed mesh multi-draw with base vertex specification possible only since WebGL 2.0\n");
#endif
}
#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
void MeshGLTest::multiDrawInstancedViews() {
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Mesh mesh;
MeshView view{mesh};
view.setCount(3)
.setInstanceCount(2);
std::ostringstream out;
Error redirectError{&out};
MultiDrawShader{}.draw({view, view});
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_COMPARE(out.str(), "GL::AbstractShaderProgram::draw(): cannot multi-draw instanced meshes\n");
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 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
void MeshGLTest::multiDrawViewsDifferentMeshes() {
GL: improve message for the common mesh assert in multi-draw. In my case I was using a dangling MeshView reference there, and it was hard to debug without these.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Mesh a, b;
MeshView viewA{a}, viewB{b};
std::ostringstream out;
Error redirectError{&out};
GL: the multi-draw test for Mesh was underwhelming, to say the least. Or, the horror when I comment-out half of it and it still kinda passes. The new code tests it more thoroughly, with actually checking that different draw produce different results instead of one draw overwriting the other. Plus also verifying interaction with gl_VertexID and gl_DrawID to ensure it really behaves correctly: - gl_VertexID should get the same value regardless of whether we perform a multi-draw or a one-by-one fallback, so this catches issues where the mesh would get reconfigured in some nasty way, losing this information - gl_DrawID should get properly populated if and only if we use the multi-draw code path, so this catches issues where the fallback would get used instead of the actual multi-draw code path
5 years ago
MultiDrawShader{}.draw({viewA, viewB});
GL: improve message for the common mesh assert in multi-draw. In my case I was using a dangling MeshView reference there, and it was hard to debug without these.
5 years ago
CORRADE_COMPARE(out.str(), Utility::formatString("GL::AbstractShaderProgram::draw(): all meshes must be views of the same original mesh, expected 0x{:x} but got 0x{:x} at index 1\n", reinterpret_cast<std::uintptr_t>(&a), reinterpret_cast<std::uintptr_t>(&b)));
}
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
}}}}
Support for object labels from KHR_debug and EXT_debug_label. Can't test EXT_debug_label, as that is apparently OSX 10.9-only. Added GL tests for all implemented objects. KHR_debug is selected first, if that is not available, fall back to EXT_debug_label. If neither is available, the functions are no-op. I hope EXT_debug_label gets replaced by KHR_debug later, thus it is now only "emulated" through KHR_debug enums.
13 years ago
Split the OpenGL layer out, pt 11: generic MeshPrimitive and MeshIndexType. Similarly to pixel formats, there is now generic Magnum::MeshPrimitive and Magnum::MeshIndexType, which is convertible to GL::MeshPrimitive and GL::MeshIndexType using GL::meshPrimitive() and GL::meshIndexType(). In addition, the following is done: * The original GL::Mesh::IndexType is now GL::MeshIndexType, original name is now just a typedef. * GL::Mesh::indexSize() is deprecated in favor of Magnum::meshIndexTypeSize() and GL::Mesh::indexTypeSize(). * New GL::Mesh::indexType() and GL::MeshView::mesh() getters (not sure why they were omitted) * GL::Mesh::indexType(), GL::Mesh::indexTypeSize(), GL::MeshView::setIndexRange() now expect that the mesh is indexed (useful property in my opinion, also avoids getting random results). * The extra MeshPrimitive::LinesAdjacency etc. are still present for backwards compatibility, but marked as deprecated. Use GL::MeshPrimitive values instead.
8 years ago
CORRADE_TEST_MAIN(Magnum::GL::Test::MeshGLTest)