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

3000 lines
142 KiB
Raw Normal View History Unescape

Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
/*
This file is part of Magnum.
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019
Vladimír Vondruš <mosra@centrum.cz>
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#include <sstream>
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/TestSuite/Compare/Container.h>
#include <Corrade/Utility/DebugStl.h>
#include "Magnum/Math/Color.h"
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
#include "Magnum/Math/Half.h"
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
#include "Magnum/Trade/MeshData.h"
namespace Magnum { namespace Trade { namespace Test { namespace {
struct MeshDataTest: TestSuite::Tester {
explicit MeshDataTest();
void customAttributeName();
void customAttributeNameTooLarge();
void customAttributeNameNotCustom();
void debugAttributeName();
void constructIndex();
void constructIndexTypeErased();
void constructIndexTypeErasedWrongSize();
Trade: typeless access to MeshData indices. Like with attributes, it returns a 2D strided view with the second dimension having the same size as the index type.
6 years ago
void constructIndex2D();
Trade: make creation of non-owning MeshData references easier. While 27f6cc309d4636adb0f65e559de8e5cc109483cb made it easier to create references to attribute-less meshes by avoiding a branch on attributeCount() (and then using a constructor with explicit vertex count), code still had to branch on isIndexed() because indices() could be called only on indexed meshes. This change allows code like Trade::MeshData reference{data.primitive(), {}, data.indexData(), Trade::MeshIndexData{data.indices()}, {}, data.vertexData(), Trade::meshAttributeDataNonOwningArray(data.attributeData()), data.vertexCount()}; which works correctly for all cases and doesn't introduce extra branches and code paths that would need to be tested. While definitely better, I might still give up at some point and introduce some Trade::MeshData::nonOwningImmutableReference() helper for this.
6 years ago
void constructIndex2DNotIndexed();
Trade: typeless access to MeshData indices. Like with attributes, it returns a 2D strided view with the second dimension having the same size as the index type.
6 years ago
void constructIndex2DWrongSize();
void constructIndex2DNonContiguous();
void constructIndexNullptr();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void constructAttribute();
void constructAttributeCustom();
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
void constructAttribute2D();
void constructAttribute2DWrongSize();
void constructAttribute2DNonContiguous();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void constructAttributeTypeErased();
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
void constructAttributeNullptr();
Trade: make it possible to construct a "padding" MeshAttributeData. Will be used in MeshTools algorithms. Also harden the MeshData constructor to reject such instances.
6 years ago
void constructAttributePadding();
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
void constructAttributeNonOwningArray();
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
void constructAttributeOffsetOnly();
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
void constructAttributeImplementationSpecificFormat();
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
void constructAttributeWrongFormat();
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
void constructAttributeWrongStride();
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
void constructAttributeWrongDataAccess();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
void constructArrayAttribute();
void constructArrayAttributeNonContiguous();
void constructArrayAttribute2D();
void constructArrayAttribute2DWrongSize();
void constructArrayAttribute2DNonContiguous();
void constructArrayAttributeTypeErased();
Trade: fix ambiguity when instantiating nullptr array MeshAttributeData.
6 years ago
void constructArrayAttributeNullptr();
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
void constructArrayAttributeOffsetOnly();
void constructArrayAttributeNotAllowed();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void construct();
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
Trade: relax index/attribute/vertex count restrictions in MeshData. Allow to make: - an indexed mesh with zero indices - a mesh with non-zero attribute count but zero vertices - a mesh with non-zero vertex count but zero attributes All of these are valid use cases as explained in the tests, and will also make the release*() behavior defined better.
6 years ago
void constructZeroIndices();
void constructZeroAttributes();
void constructZeroVertices();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void constructIndexless();
void constructIndexlessZeroVertices();
void constructAttributeless();
void constructIndexlessAttributeless();
void constructIndexlessAttributelessZeroVertices();
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
void constructNotOwned();
void constructIndicesNotOwned();
void constructVerticesNotOwned();
void constructIndexlessNotOwned();
void constructAttributelessNotOwned();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void constructIndexDataButNotIndexed();
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
void constructAttributelessImplicitVertexCount();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void constructIndicesNotContained();
void constructAttributeNotContained();
void constructInconsitentVertexCount();
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
void constructNotOwnedIndexFlagOwned();
void constructNotOwnedVertexFlagOwned();
void constructIndicesNotOwnedFlagOwned();
void constructVerticesNotOwnedFlagOwned();
void constructIndexlessNotOwnedFlagOwned();
void constructAttributelessNotOwnedFlagOwned();
Trade: make it possible to construct a "padding" MeshAttributeData. Will be used in MeshTools algorithms. Also harden the MeshData constructor to reject such instances.
6 years ago
void constructInvalidAttributeData();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void constructCopy();
void constructMove();
template<class T> void indicesAsArray();
void indicesIntoArrayInvalidSize();
template<class T> void positions2DAsArray();
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
template<class T> void positions2DAsArrayPackedUnsigned();
template<class T> void positions2DAsArrayPackedSigned();
template<class T> void positions2DAsArrayPackedUnsignedNormalized();
template<class T> void positions2DAsArrayPackedSignedNormalized();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void positions2DIntoArrayInvalidSize();
template<class T> void positions3DAsArray();
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
template<class T> void positions3DAsArrayPackedUnsigned();
template<class T> void positions3DAsArrayPackedSigned();
template<class T> void positions3DAsArrayPackedUnsignedNormalized();
template<class T> void positions3DAsArrayPackedSignedNormalized();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void positions3DIntoArrayInvalidSize();
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
template<class T> void tangentsAsArray();
template<class T> void tangentsAsArrayPackedSignedNormalized();
void tangentsIntoArrayInvalidSize();
template<class T> void bitangentSignsAsArray();
template<class T> void bitangentSignsAsArrayPackedSignedNormalized();
void bitangentSignsAsArrayNotFourComponent();
void bitangentSignsIntoArrayInvalidSize();
template<class T> void bitangentsAsArray();
template<class T> void bitangentsAsArrayPackedSignedNormalized();
void bitangentsIntoArrayInvalidSize();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
template<class T> void normalsAsArray();
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
template<class T> void normalsAsArrayPackedSignedNormalized();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void normalsIntoArrayInvalidSize();
template<class T> void textureCoordinates2DAsArray();
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
template<class T> void textureCoordinates2DAsArrayPackedUnsigned();
template<class T> void textureCoordinates2DAsArrayPackedSigned();
template<class T> void textureCoordinates2DAsArrayPackedUnsignedNormalized();
template<class T> void textureCoordinates2DAsArrayPackedSignedNormalized();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void textureCoordinates2DIntoArrayInvalidSize();
template<class T> void colorsAsArray();
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
template<class T> void colorsAsArrayPackedUnsignedNormalized();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void colorsIntoArrayInvalidSize();
Trade: implement support for object IDs in MeshData.
6 years ago
template<class T> void objectIdsAsArray();
void objectIdsIntoArrayInvalidSize();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
void implementationSpecificVertexFormat();
void implementationSpecificVertexFormatWrongAccess();
void implementationSpecificVertexFormatNotContained();
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
void arrayAttribute();
void arrayAttributeWrongAccess();
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
void mutableAccessNotAllowed();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void indicesNotIndexed();
void indicesWrongType();
void attributeNotFound();
void attributeWrongType();
void releaseIndexData();
Trade: make MeshData::release*() less brutal, add releaseAttributeData(). It only resets count of released thing to zero, not going all nuclear. Otherwise it wouldn't be possible to release attribute data and then vertex data as releasing one would wipe the other.
6 years ago
void releaseAttributeData();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void releaseVertexData();
};
Trade: minor.
6 years ago
const struct {
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
const char* name;
UnsignedInt vertexCount, expectedVertexCount;
} ConstructData[] {
{"implicit vertex count", MeshData::ImplicitVertexCount, 3},
{"explicit vertex count", 3, 3},
{"explicit large vertex count", 17, 17},
{"explicit zero vertex count", 0, 0}
};
Trade: minor.
6 years ago
const struct {
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
const char* name;
DataFlags indexDataFlags, vertexDataFlags;
} NotOwnedData[] {
{"", {}, {}},
{"indices mutable", DataFlag::Mutable, {}},
{"vertices mutable", {}, DataFlag::Mutable},
{"both mutable", DataFlag::Mutable, DataFlag::Mutable}
};
Trade: minor.
6 years ago
const struct {
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
const char* name;
DataFlags dataFlags;
} SingleNotOwnedData[] {
{"", {}},
{"mutable", DataFlag::Mutable}
};
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
MeshDataTest::MeshDataTest() {
addTests({&MeshDataTest::customAttributeName,
&MeshDataTest::customAttributeNameTooLarge,
&MeshDataTest::customAttributeNameNotCustom,
&MeshDataTest::debugAttributeName,
&MeshDataTest::constructIndex,
&MeshDataTest::constructIndexTypeErased,
&MeshDataTest::constructIndexTypeErasedWrongSize,
Trade: typeless access to MeshData indices. Like with attributes, it returns a 2D strided view with the second dimension having the same size as the index type.
6 years ago
&MeshDataTest::constructIndex2D,
Trade: make creation of non-owning MeshData references easier. While 27f6cc309d4636adb0f65e559de8e5cc109483cb made it easier to create references to attribute-less meshes by avoiding a branch on attributeCount() (and then using a constructor with explicit vertex count), code still had to branch on isIndexed() because indices() could be called only on indexed meshes. This change allows code like Trade::MeshData reference{data.primitive(), {}, data.indexData(), Trade::MeshIndexData{data.indices()}, {}, data.vertexData(), Trade::meshAttributeDataNonOwningArray(data.attributeData()), data.vertexCount()}; which works correctly for all cases and doesn't introduce extra branches and code paths that would need to be tested. While definitely better, I might still give up at some point and introduce some Trade::MeshData::nonOwningImmutableReference() helper for this.
6 years ago
&MeshDataTest::constructIndex2DNotIndexed,
Trade: typeless access to MeshData indices. Like with attributes, it returns a 2D strided view with the second dimension having the same size as the index type.
6 years ago
&MeshDataTest::constructIndex2DWrongSize,
&MeshDataTest::constructIndex2DNonContiguous,
&MeshDataTest::constructIndexNullptr,
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
&MeshDataTest::constructAttribute,
&MeshDataTest::constructAttributeCustom,
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
&MeshDataTest::constructAttribute2D,
&MeshDataTest::constructAttribute2DWrongSize,
&MeshDataTest::constructAttribute2DNonContiguous,
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
&MeshDataTest::constructAttributeTypeErased,
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
&MeshDataTest::constructAttributeNullptr,
Trade: make it possible to construct a "padding" MeshAttributeData. Will be used in MeshTools algorithms. Also harden the MeshData constructor to reject such instances.
6 years ago
&MeshDataTest::constructAttributePadding,
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
&MeshDataTest::constructAttributeNonOwningArray,
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
&MeshDataTest::constructAttributeOffsetOnly,
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
&MeshDataTest::constructAttributeImplementationSpecificFormat,
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
&MeshDataTest::constructAttributeWrongFormat,
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
&MeshDataTest::constructAttributeWrongStride,
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
&MeshDataTest::constructAttributeWrongDataAccess,
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
&MeshDataTest::constructArrayAttribute,
&MeshDataTest::constructArrayAttributeNonContiguous,
&MeshDataTest::constructArrayAttribute2D,
&MeshDataTest::constructArrayAttribute2DWrongSize,
&MeshDataTest::constructArrayAttribute2DNonContiguous,
&MeshDataTest::constructArrayAttributeTypeErased,
Trade: fix ambiguity when instantiating nullptr array MeshAttributeData.
6 years ago
&MeshDataTest::constructArrayAttributeNullptr,
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
&MeshDataTest::constructArrayAttributeOffsetOnly,
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
&MeshDataTest::constructArrayAttributeNotAllowed});
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
addInstancedTests({&MeshDataTest::construct},
Containers::arraySize(ConstructData));
addTests({&MeshDataTest::constructZeroIndices,
Trade: relax index/attribute/vertex count restrictions in MeshData. Allow to make: - an indexed mesh with zero indices - a mesh with non-zero attribute count but zero vertices - a mesh with non-zero vertex count but zero attributes All of these are valid use cases as explained in the tests, and will also make the release*() behavior defined better.
6 years ago
&MeshDataTest::constructZeroAttributes,
&MeshDataTest::constructZeroVertices,
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
&MeshDataTest::constructIndexless,
&MeshDataTest::constructIndexlessZeroVertices,
&MeshDataTest::constructAttributeless,
&MeshDataTest::constructIndexlessAttributeless,
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
&MeshDataTest::constructIndexlessAttributelessZeroVertices});
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
addInstancedTests({&MeshDataTest::constructNotOwned},
Containers::arraySize(NotOwnedData));
addInstancedTests({&MeshDataTest::constructIndicesNotOwned,
&MeshDataTest::constructVerticesNotOwned,
&MeshDataTest::constructIndexlessNotOwned,
&MeshDataTest::constructAttributelessNotOwned},
Containers::arraySize(SingleNotOwnedData));
addTests({&MeshDataTest::constructIndexDataButNotIndexed,
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
&MeshDataTest::constructAttributelessImplicitVertexCount,
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
&MeshDataTest::constructIndicesNotContained,
&MeshDataTest::constructAttributeNotContained,
&MeshDataTest::constructInconsitentVertexCount,
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
&MeshDataTest::constructNotOwnedIndexFlagOwned,
&MeshDataTest::constructNotOwnedVertexFlagOwned,
&MeshDataTest::constructIndicesNotOwnedFlagOwned,
&MeshDataTest::constructVerticesNotOwnedFlagOwned,
&MeshDataTest::constructIndexlessNotOwnedFlagOwned,
&MeshDataTest::constructAttributelessNotOwnedFlagOwned,
Trade: make it possible to construct a "padding" MeshAttributeData. Will be used in MeshTools algorithms. Also harden the MeshData constructor to reject such instances.
6 years ago
&MeshDataTest::constructInvalidAttributeData,
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
&MeshDataTest::constructCopy,
&MeshDataTest::constructMove,
&MeshDataTest::indicesAsArray<UnsignedByte>,
&MeshDataTest::indicesAsArray<UnsignedShort>,
&MeshDataTest::indicesAsArray<UnsignedInt>,
&MeshDataTest::indicesIntoArrayInvalidSize,
&MeshDataTest::positions2DAsArray<Vector2>,
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
&MeshDataTest::positions2DAsArray<Vector2h>,
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
&MeshDataTest::positions2DAsArray<Vector3>,
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
&MeshDataTest::positions2DAsArray<Vector3h>,
&MeshDataTest::positions2DAsArrayPackedUnsigned<Vector2ub>,
&MeshDataTest::positions2DAsArrayPackedUnsigned<Vector2us>,
&MeshDataTest::positions2DAsArrayPackedUnsigned<Vector3ub>,
&MeshDataTest::positions2DAsArrayPackedUnsigned<Vector3us>,
&MeshDataTest::positions2DAsArrayPackedSigned<Vector2b>,
&MeshDataTest::positions2DAsArrayPackedSigned<Vector2s>,
&MeshDataTest::positions2DAsArrayPackedSigned<Vector3b>,
&MeshDataTest::positions2DAsArrayPackedSigned<Vector3s>,
&MeshDataTest::positions2DAsArrayPackedUnsignedNormalized<Vector2ub>,
&MeshDataTest::positions2DAsArrayPackedUnsignedNormalized<Vector2us>,
&MeshDataTest::positions2DAsArrayPackedUnsignedNormalized<Vector3ub>,
&MeshDataTest::positions2DAsArrayPackedUnsignedNormalized<Vector3us>,
&MeshDataTest::positions2DAsArrayPackedSignedNormalized<Vector2b>,
&MeshDataTest::positions2DAsArrayPackedSignedNormalized<Vector2s>,
&MeshDataTest::positions2DAsArrayPackedSignedNormalized<Vector3b>,
&MeshDataTest::positions2DAsArrayPackedSignedNormalized<Vector3s>,
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
&MeshDataTest::positions2DIntoArrayInvalidSize,
&MeshDataTest::positions3DAsArray<Vector2>,
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
&MeshDataTest::positions3DAsArray<Vector2h>,
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
&MeshDataTest::positions3DAsArray<Vector3>,
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
&MeshDataTest::positions3DAsArray<Vector3h>,
&MeshDataTest::positions3DAsArrayPackedUnsigned<Vector2ub>,
&MeshDataTest::positions3DAsArrayPackedUnsigned<Vector2us>,
&MeshDataTest::positions3DAsArrayPackedUnsigned<Vector3ub>,
&MeshDataTest::positions3DAsArrayPackedUnsigned<Vector3us>,
&MeshDataTest::positions3DAsArrayPackedSigned<Vector2b>,
&MeshDataTest::positions3DAsArrayPackedSigned<Vector2s>,
&MeshDataTest::positions3DAsArrayPackedSigned<Vector3b>,
&MeshDataTest::positions3DAsArrayPackedSigned<Vector3s>,
&MeshDataTest::positions3DAsArrayPackedUnsignedNormalized<Vector2ub>,
&MeshDataTest::positions3DAsArrayPackedUnsignedNormalized<Vector2us>,
&MeshDataTest::positions3DAsArrayPackedUnsignedNormalized<Vector3ub>,
&MeshDataTest::positions3DAsArrayPackedUnsignedNormalized<Vector3us>,
&MeshDataTest::positions3DAsArrayPackedSignedNormalized<Vector2b>,
&MeshDataTest::positions3DAsArrayPackedSignedNormalized<Vector2s>,
&MeshDataTest::positions3DAsArrayPackedSignedNormalized<Vector3b>,
&MeshDataTest::positions3DAsArrayPackedSignedNormalized<Vector3s>,
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
&MeshDataTest::positions3DIntoArrayInvalidSize,
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
&MeshDataTest::tangentsAsArray<Vector3>,
&MeshDataTest::tangentsAsArray<Vector3h>,
Trade: fix tangent retrieval from four-component normalized types. By accident this code path was not tested, and of course it had a bug.
6 years ago
&MeshDataTest::tangentsAsArray<Vector4>,
&MeshDataTest::tangentsAsArray<Vector4h>,
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
&MeshDataTest::tangentsAsArrayPackedSignedNormalized<Vector3b>,
&MeshDataTest::tangentsAsArrayPackedSignedNormalized<Vector3s>,
Trade: fix tangent retrieval from four-component normalized types. By accident this code path was not tested, and of course it had a bug.
6 years ago
&MeshDataTest::tangentsAsArrayPackedSignedNormalized<Vector4b>,
&MeshDataTest::tangentsAsArrayPackedSignedNormalized<Vector4s>,
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
&MeshDataTest::tangentsIntoArrayInvalidSize,
&MeshDataTest::bitangentSignsAsArray<Float>,
&MeshDataTest::bitangentSignsAsArray<Half>,
&MeshDataTest::bitangentSignsAsArrayPackedSignedNormalized<Byte>,
&MeshDataTest::bitangentSignsAsArrayPackedSignedNormalized<Short>,
&MeshDataTest::bitangentSignsAsArrayNotFourComponent,
&MeshDataTest::bitangentSignsIntoArrayInvalidSize,
&MeshDataTest::bitangentsAsArray<Vector3>,
&MeshDataTest::bitangentsAsArray<Vector3h>,
&MeshDataTest::bitangentsAsArrayPackedSignedNormalized<Vector3b>,
&MeshDataTest::bitangentsAsArrayPackedSignedNormalized<Vector3s>,
&MeshDataTest::bitangentsIntoArrayInvalidSize,
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
&MeshDataTest::normalsAsArray<Vector3>,
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
&MeshDataTest::normalsAsArray<Vector3h>,
&MeshDataTest::normalsAsArrayPackedSignedNormalized<Vector3b>,
&MeshDataTest::normalsAsArrayPackedSignedNormalized<Vector3s>,
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
&MeshDataTest::normalsIntoArrayInvalidSize,
&MeshDataTest::textureCoordinates2DAsArray<Vector2>,
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
&MeshDataTest::textureCoordinates2DAsArray<Vector2h>,
&MeshDataTest::textureCoordinates2DAsArrayPackedUnsigned<Vector2ub>,
&MeshDataTest::textureCoordinates2DAsArrayPackedUnsigned<Vector2us>,
&MeshDataTest::textureCoordinates2DAsArrayPackedSigned<Vector2b>,
&MeshDataTest::textureCoordinates2DAsArrayPackedSigned<Vector2s>,
&MeshDataTest::textureCoordinates2DAsArrayPackedUnsignedNormalized<Vector2ub>,
&MeshDataTest::textureCoordinates2DAsArrayPackedUnsignedNormalized<Vector2us>,
&MeshDataTest::textureCoordinates2DAsArrayPackedSignedNormalized<Vector2b>,
&MeshDataTest::textureCoordinates2DAsArrayPackedSignedNormalized<Vector2s>,
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
&MeshDataTest::textureCoordinates2DIntoArrayInvalidSize,
&MeshDataTest::colorsAsArray<Color3>,
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
&MeshDataTest::colorsAsArray<Color3h>,
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
&MeshDataTest::colorsAsArray<Color4>,
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
&MeshDataTest::colorsAsArray<Color4h>,
&MeshDataTest::colorsAsArrayPackedUnsignedNormalized<Color3ub>,
&MeshDataTest::colorsAsArrayPackedUnsignedNormalized<Color3us>,
&MeshDataTest::colorsAsArrayPackedUnsignedNormalized<Color4ub>,
&MeshDataTest::colorsAsArrayPackedUnsignedNormalized<Color4us>,
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
&MeshDataTest::colorsIntoArrayInvalidSize,
Trade: implement support for object IDs in MeshData.
6 years ago
&MeshDataTest::objectIdsAsArray<UnsignedByte>,
&MeshDataTest::objectIdsAsArray<UnsignedShort>,
&MeshDataTest::objectIdsAsArray<UnsignedInt>,
&MeshDataTest::objectIdsIntoArrayInvalidSize,
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
&MeshDataTest::implementationSpecificVertexFormat,
&MeshDataTest::implementationSpecificVertexFormatWrongAccess,
&MeshDataTest::implementationSpecificVertexFormatNotContained,
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
&MeshDataTest::arrayAttribute,
&MeshDataTest::arrayAttributeWrongAccess,
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
&MeshDataTest::mutableAccessNotAllowed,
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
&MeshDataTest::indicesNotIndexed,
&MeshDataTest::indicesWrongType,
&MeshDataTest::attributeNotFound,
&MeshDataTest::attributeWrongType,
&MeshDataTest::releaseIndexData,
Trade: make MeshData::release*() less brutal, add releaseAttributeData(). It only resets count of released thing to zero, not going all nuclear. Otherwise it wouldn't be possible to release attribute data and then vertex data as releasing one would wipe the other.
6 years ago
&MeshDataTest::releaseAttributeData,
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
&MeshDataTest::releaseVertexData});
}
void MeshDataTest::customAttributeName() {
CORRADE_VERIFY(!isMeshAttributeCustom(MeshAttribute::Position));
CORRADE_VERIFY(!isMeshAttributeCustom(MeshAttribute(32767)));
CORRADE_VERIFY(isMeshAttributeCustom(MeshAttribute::Custom));
CORRADE_VERIFY(isMeshAttributeCustom(MeshAttribute(65535)));
CORRADE_COMPARE(UnsignedShort(meshAttributeCustom(0)), 32768);
CORRADE_COMPARE(UnsignedShort(meshAttributeCustom(8290)), 41058);
CORRADE_COMPARE(UnsignedShort(meshAttributeCustom(32767)), 65535);
CORRADE_COMPARE(meshAttributeCustom(MeshAttribute::Custom), 0);
CORRADE_COMPARE(meshAttributeCustom(MeshAttribute(41058)), 8290);
CORRADE_COMPARE(meshAttributeCustom(MeshAttribute(65535)), 32767);
constexpr bool is = isMeshAttributeCustom(MeshAttribute(41058));
CORRADE_VERIFY(is);
constexpr MeshAttribute a = meshAttributeCustom(8290);
CORRADE_COMPARE(UnsignedShort(a), 41058);
constexpr UnsignedShort b = meshAttributeCustom(a);
CORRADE_COMPARE(b, 8290);
}
void MeshDataTest::customAttributeNameTooLarge() {
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
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
std::ostringstream out;
Error redirectError{&out};
meshAttributeCustom(32768);
CORRADE_COMPARE(out.str(), "Trade::meshAttributeCustom(): index 32768 too large\n");
}
void MeshDataTest::customAttributeNameNotCustom() {
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
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
std::ostringstream out;
Error redirectError{&out};
meshAttributeCustom(MeshAttribute::TextureCoordinates);
CORRADE_COMPARE(out.str(), "Trade::meshAttributeCustom(): Trade::MeshAttribute::TextureCoordinates is not custom\n");
}
void MeshDataTest::debugAttributeName() {
std::ostringstream out;
Debug{&out} << MeshAttribute::Position << meshAttributeCustom(73) << MeshAttribute(0x73);
CORRADE_COMPARE(out.str(), "Trade::MeshAttribute::Position Trade::MeshAttribute::Custom(73) Trade::MeshAttribute(0x73)\n");
}
using namespace Math::Literals;
Trade: make MeshIndexData constexpr. First step towards an ability to expose data compiled into an executable through MeshData without having to allocate anything.
6 years ago
constexpr UnsignedByte IndexBytes[]{25, 132, 3};
constexpr UnsignedShort IndexShorts[]{2575, 13224, 3};
constexpr UnsignedInt IndexInts[]{2110122, 132257, 3};
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void MeshDataTest::constructIndex() {
{
Trade: expose getters in MeshIndexData. It made testing and everything harder than strictly necessary. OTOH still keeping MeshData as a friend and accessing members directly since those are heavily interconnected anyway.
6 years ago
const UnsignedByte indexData[]{25, 132, 3};
MeshIndexData indices{indexData};
CORRADE_COMPARE(indices.type(), MeshIndexType::UnsignedByte);
CORRADE_COMPARE(indices.data().data(), indexData);
Trade: make MeshIndexData constexpr. First step towards an ability to expose data compiled into an executable through MeshData without having to allocate anything.
6 years ago
constexpr MeshIndexData cindices{IndexBytes};
Trade: expose getters in MeshIndexData. It made testing and everything harder than strictly necessary. OTOH still keeping MeshData as a friend and accessing members directly since those are heavily interconnected anyway.
6 years ago
constexpr MeshIndexType type = cindices.type();
constexpr Containers::ArrayView<const void> data = cindices.data();
CORRADE_COMPARE(type, MeshIndexType::UnsignedByte);
CORRADE_COMPARE(data.data(), IndexBytes);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
} {
Trade: expose getters in MeshIndexData. It made testing and everything harder than strictly necessary. OTOH still keeping MeshData as a friend and accessing members directly since those are heavily interconnected anyway.
6 years ago
const UnsignedShort indexData[]{2575, 13224, 3};
MeshIndexData indices{indexData};
CORRADE_COMPARE(indices.type(), MeshIndexType::UnsignedShort);
CORRADE_COMPARE(indices.data().data(), indexData);
Trade: make MeshIndexData constexpr. First step towards an ability to expose data compiled into an executable through MeshData without having to allocate anything.
6 years ago
constexpr MeshIndexData cindices{IndexShorts};
Trade: expose getters in MeshIndexData. It made testing and everything harder than strictly necessary. OTOH still keeping MeshData as a friend and accessing members directly since those are heavily interconnected anyway.
6 years ago
constexpr MeshIndexType type = cindices.type();
constexpr Containers::ArrayView<const void> data = cindices.data();
CORRADE_COMPARE(type, MeshIndexType::UnsignedShort);
CORRADE_COMPARE(data.data(), IndexShorts);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
} {
Trade: expose getters in MeshIndexData. It made testing and everything harder than strictly necessary. OTOH still keeping MeshData as a friend and accessing members directly since those are heavily interconnected anyway.
6 years ago
const UnsignedInt indexData[]{2110122, 132257, 3};
MeshIndexData indices{indexData};
CORRADE_COMPARE(indices.type(), MeshIndexType::UnsignedInt);
CORRADE_COMPARE(indices.data().data(), indexData);
Trade: make MeshIndexData constexpr. First step towards an ability to expose data compiled into an executable through MeshData without having to allocate anything.
6 years ago
constexpr MeshIndexData cindices{IndexInts};
Trade: expose getters in MeshIndexData. It made testing and everything harder than strictly necessary. OTOH still keeping MeshData as a friend and accessing members directly since those are heavily interconnected anyway.
6 years ago
constexpr MeshIndexType type = cindices.type();
constexpr Containers::ArrayView<const void> data = cindices.data();
CORRADE_COMPARE(type, MeshIndexType::UnsignedInt);
CORRADE_COMPARE(data.data(), IndexInts);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
}
void MeshDataTest::constructIndexTypeErased() {
Trade: expose getters in MeshIndexData. It made testing and everything harder than strictly necessary. OTOH still keeping MeshData as a friend and accessing members directly since those are heavily interconnected anyway.
6 years ago
const char indexData[3*2]{};
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
MeshIndexData indices{MeshIndexType::UnsignedShort, indexData};
Trade: expose getters in MeshIndexData. It made testing and everything harder than strictly necessary. OTOH still keeping MeshData as a friend and accessing members directly since those are heavily interconnected anyway.
6 years ago
CORRADE_COMPARE(indices.type(), MeshIndexType::UnsignedShort);
CORRADE_VERIFY(indices.data().data() == indexData);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
void MeshDataTest::constructIndexTypeErasedWrongSize() {
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
Trade: expose getters in MeshIndexData. It made testing and everything harder than strictly necessary. OTOH still keeping MeshData as a friend and accessing members directly since those are heavily interconnected anyway.
6 years ago
const char indexData[3*2]{};
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
std::ostringstream out;
Error redirectError{&out};
MeshIndexData{MeshIndexType::UnsignedInt, indexData};
CORRADE_COMPARE(out.str(), "Trade::MeshIndexData: view size 6 does not correspond to MeshIndexType::UnsignedInt\n");
}
Trade: typeless access to MeshData indices. Like with attributes, it returns a 2D strided view with the second dimension having the same size as the index type.
6 years ago
void MeshDataTest::constructIndex2D() {
{
const UnsignedByte indexData[]{25, 132, 3};
MeshIndexData indices{Containers::arrayCast<2, const char>(Containers::stridedArrayView(indexData))};
CORRADE_COMPARE(indices.type(), MeshIndexType::UnsignedByte);
CORRADE_COMPARE(indices.data().data(), indexData);
} {
const UnsignedShort indexData[]{2575, 13224, 3};
MeshIndexData indices{Containers::arrayCast<2, const char>(Containers::stridedArrayView(indexData))};
CORRADE_COMPARE(indices.type(), MeshIndexType::UnsignedShort);
CORRADE_COMPARE(indices.data().data(), indexData);
} {
const UnsignedInt indexData[]{2110122, 132257, 3};
MeshIndexData indices{Containers::arrayCast<2, const char>(Containers::stridedArrayView(indexData))};
CORRADE_COMPARE(indices.type(), MeshIndexType::UnsignedInt);
CORRADE_COMPARE(indices.data().data(), indexData);
}
}
Trade: make creation of non-owning MeshData references easier. While 27f6cc309d4636adb0f65e559de8e5cc109483cb made it easier to create references to attribute-less meshes by avoiding a branch on attributeCount() (and then using a constructor with explicit vertex count), code still had to branch on isIndexed() because indices() could be called only on indexed meshes. This change allows code like Trade::MeshData reference{data.primitive(), {}, data.indexData(), Trade::MeshIndexData{data.indices()}, {}, data.vertexData(), Trade::meshAttributeDataNonOwningArray(data.attributeData()), data.vertexCount()}; which works correctly for all cases and doesn't introduce extra branches and code paths that would need to be tested. While definitely better, I might still give up at some point and introduce some Trade::MeshData::nonOwningImmutableReference() helper for this.
6 years ago
void MeshDataTest::constructIndex2DNotIndexed() {
MeshIndexData indices{Containers::StridedArrayView2D<const char>{}};
CORRADE_COMPARE(indices.type(), MeshIndexType{});
CORRADE_COMPARE(indices.data().data(), nullptr);
}
Trade: typeless access to MeshData indices. Like with attributes, it returns a 2D strided view with the second dimension having the same size as the index type.
6 years ago
void MeshDataTest::constructIndex2DWrongSize() {
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
Trade: typeless access to MeshData indices. Like with attributes, it returns a 2D strided view with the second dimension having the same size as the index type.
6 years ago
const char data[3*3]{};
std::ostringstream out;
Error redirectError{&out};
MeshIndexData{Containers::StridedArrayView2D<const char>{data, {3, 3}}};
CORRADE_COMPARE(out.str(), "Trade::MeshIndexData: expected index type size 1, 2 or 4 but got 3\n");
}
void MeshDataTest::constructIndex2DNonContiguous() {
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
Trade: typeless access to MeshData indices. Like with attributes, it returns a 2D strided view with the second dimension having the same size as the index type.
6 years ago
const char data[3*4]{};
std::ostringstream out;
Error redirectError{&out};
MeshIndexData{Containers::StridedArrayView2D<const char>{data, {3, 2}, {4, 2}}};
CORRADE_COMPARE(out.str(), "Trade::MeshIndexData: view is not contiguous\n");
}
void MeshDataTest::constructIndexNullptr() {
/* Just verify it's not ambiguous */
MeshIndexData data{nullptr};
CORRADE_VERIFY(!data.data());
}
Trade: make MeshAttributeData constexpr. This makes it possible to have fully allocation-less MeshData, with statically defined indices and attributes. Only the final MeshData construction needs to be done at runtime because Array is not constexpr, but that isn't anything heavy anyway.
6 years ago
constexpr Vector2 Positions[] {
{1.2f, 0.2f},
{2.2f, 1.1f},
{-0.2f, 7.2f}
};
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void MeshDataTest::constructAttribute() {
Trade: expose getters in MeshAttributeData.
6 years ago
const Vector2 positionData[3];
MeshAttributeData positions{MeshAttribute::Position, Containers::arrayView(positionData)};
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
CORRADE_VERIFY(!positions.isOffsetOnly());
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
CORRADE_COMPARE(positions.arraySize(), 0);
Trade: expose getters in MeshAttributeData.
6 years ago
CORRADE_COMPARE(positions.name(), MeshAttribute::Position);
CORRADE_COMPARE(positions.format(), VertexFormat::Vector2);
Trade: add getters for offset and stride in MeshAttributeData. Less code and complexity than first creating a StridedArrayView in data() and then extracting offset/stride from there.
6 years ago
CORRADE_COMPARE(positions.offset(positionData), 0);
CORRADE_COMPARE(positions.stride(), sizeof(Vector2));
Trade: expose getters in MeshAttributeData.
6 years ago
CORRADE_VERIFY(positions.data().data() == positionData);
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
/* This is allowed too for simplicity, it just ignores the parameter */
CORRADE_VERIFY(positions.data(positionData).data() == positionData);
Trade: make MeshAttributeData constexpr. This makes it possible to have fully allocation-less MeshData, with statically defined indices and attributes. Only the final MeshData construction needs to be done at runtime because Array is not constexpr, but that isn't anything heavy anyway.
6 years ago
constexpr MeshAttributeData cpositions{MeshAttribute::Position, Containers::arrayView(Positions)};
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
constexpr bool isOffsetOnly = cpositions.isOffsetOnly();
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
constexpr UnsignedShort arraySize = cpositions.arraySize();
Trade: expose getters in MeshAttributeData.
6 years ago
constexpr MeshAttribute name = cpositions.name();
constexpr VertexFormat format = cpositions.format();
Trade: add getters for offset and stride in MeshAttributeData. Less code and complexity than first creating a StridedArrayView in data() and then extracting offset/stride from there.
6 years ago
constexpr Short stride = cpositions.stride();
Trade: expose getters in MeshAttributeData.
6 years ago
constexpr Containers::StridedArrayView1D<const void> data = cpositions.data();
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
CORRADE_VERIFY(!isOffsetOnly);
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
CORRADE_COMPARE(arraySize, 0);
Trade: expose getters in MeshAttributeData.
6 years ago
CORRADE_COMPARE(name, MeshAttribute::Position);
CORRADE_COMPARE(format, VertexFormat::Vector2);
Trade: add getters for offset and stride in MeshAttributeData. Less code and complexity than first creating a StridedArrayView in data() and then extracting offset/stride from there.
6 years ago
CORRADE_COMPARE(stride, sizeof(Vector2));
Trade: expose getters in MeshAttributeData.
6 years ago
CORRADE_COMPARE(data.data(), Positions);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
void MeshDataTest::constructAttributeCustom() {
Trade: expose getters in MeshAttributeData.
6 years ago
const Short idData[3]{};
MeshAttributeData ids{meshAttributeCustom(13), Containers::arrayView(idData)};
CORRADE_COMPARE(ids.name(), meshAttributeCustom(13));
CORRADE_COMPARE(ids.format(), VertexFormat::Short);
CORRADE_VERIFY(ids.data().data() == idData);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
void MeshDataTest::constructAttribute2D() {
Trade: expose getters in MeshAttributeData.
6 years ago
char positionData[4*sizeof(Vector2)]{};
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
auto positionView = Containers::StridedArrayView2D<char>{positionData,
{4, sizeof(Vector2)}}.every(2);
MeshAttributeData positions{MeshAttribute::Position, VertexFormat::Vector2, positionView};
Primitives: use offset-only attribs for Line and Gradient. One less allocation for each.
6 years ago
CORRADE_VERIFY(!positions.isOffsetOnly());
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
CORRADE_COMPARE(positions.arraySize(), 0);
Trade: expose getters in MeshAttributeData.
6 years ago
CORRADE_COMPARE(positions.name(), MeshAttribute::Position);
CORRADE_COMPARE(positions.format(), VertexFormat::Vector2);
CORRADE_COMPARE(positions.data().data(), positionView.data());
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
}
void MeshDataTest::constructAttribute2DWrongSize() {
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
Trade: expose getters in MeshAttributeData.
6 years ago
char positionData[4*sizeof(Vector2)]{};
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
std::ostringstream out;
Error redirectError{&out};
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector3,
Containers::StridedArrayView2D<char>{positionData,
{4, sizeof(Vector2)}}.every(2)};
CORRADE_COMPARE(out.str(), "Trade::MeshAttributeData: second view dimension size 8 doesn't match VertexFormat::Vector3\n");
}
void MeshDataTest::constructAttribute2DNonContiguous() {
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
Trade: expose getters in MeshAttributeData.
6 years ago
char positionData[4*sizeof(Vector2)]{};
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
std::ostringstream out;
Error redirectError{&out};
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector2,
Containers::StridedArrayView2D<char>{positionData,
{2, sizeof(Vector2)*2}}.every({1, 2})};
CORRADE_COMPARE(out.str(), "Trade::MeshAttributeData: second view dimension is not contiguous\n");
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void MeshDataTest::constructAttributeTypeErased() {
Trade: expose getters in MeshAttributeData.
6 years ago
const Vector3 positionData[3]{};
MeshAttributeData positions{MeshAttribute::Position, VertexFormat::Vector3, Containers::arrayCast<const char>(Containers::stridedArrayView(positionData))};
Primitives: use offset-only attribs for Line and Gradient. One less allocation for each.
6 years ago
CORRADE_VERIFY(!positions.isOffsetOnly());
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
CORRADE_COMPARE(positions.arraySize(), 0);
Trade: expose getters in MeshAttributeData.
6 years ago
CORRADE_COMPARE(positions.name(), MeshAttribute::Position);
CORRADE_COMPARE(positions.format(), VertexFormat::Vector3);
CORRADE_VERIFY(positions.data().data() == positionData);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
void MeshDataTest::constructAttributeNullptr() {
MeshAttributeData positions{MeshAttribute::Position, VertexFormat::Vector2, nullptr};
Primitives: use offset-only attribs for Line and Gradient. One less allocation for each.
6 years ago
CORRADE_VERIFY(!positions.isOffsetOnly());
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
CORRADE_COMPARE(positions.arraySize(), 0);
Trade: expose getters in MeshAttributeData.
6 years ago
CORRADE_COMPARE(positions.name(), MeshAttribute::Position);
CORRADE_COMPARE(positions.format(), VertexFormat::Vector2);
CORRADE_VERIFY(!positions.data().data());
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
}
Trade: make it possible to construct a "padding" MeshAttributeData. Will be used in MeshTools algorithms. Also harden the MeshData constructor to reject such instances.
6 years ago
void MeshDataTest::constructAttributePadding() {
MeshAttributeData padding{-35};
Primitives: use offset-only attribs for Line and Gradient. One less allocation for each.
6 years ago
CORRADE_VERIFY(!padding.isOffsetOnly());
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
CORRADE_COMPARE(padding.arraySize(), 0);
Trade: make it possible to construct a "padding" MeshAttributeData. Will be used in MeshTools algorithms. Also harden the MeshData constructor to reject such instances.
6 years ago
CORRADE_COMPARE(padding.name(), MeshAttribute{});
CORRADE_COMPARE(padding.format(), VertexFormat{});
CORRADE_COMPARE(padding.data().size(), 0);
CORRADE_COMPARE(padding.data().stride(), -35);
CORRADE_VERIFY(!padding.data());
}
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
void MeshDataTest::constructAttributeNonOwningArray() {
const MeshAttributeData data[3];
Containers::Array<MeshAttributeData> array = meshAttributeDataNonOwningArray(data);
CORRADE_COMPARE(array.size(), 3);
CORRADE_COMPARE(static_cast<const void*>(array.data()), data);
}
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
void MeshDataTest::constructAttributeOffsetOnly() {
struct {
Vector2 position;
Vector2 textureCoordinates;
} vertexData[] {
{{}, {1.0f, 0.3f}},
{{}, {0.5f, 0.7f}},
};
MeshAttributeData a{MeshAttribute::TextureCoordinates, VertexFormat::Vector2, sizeof(Vector2), 2, 2*sizeof(Vector2)};
CORRADE_VERIFY(a.isOffsetOnly());
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
CORRADE_COMPARE(a.arraySize(), 0);
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
CORRADE_COMPARE(a.name(), MeshAttribute::TextureCoordinates);
CORRADE_COMPARE(a.format(), VertexFormat::Vector2);
Trade: add getters for offset and stride in MeshAttributeData. Less code and complexity than first creating a StridedArrayView in data() and then extracting offset/stride from there.
6 years ago
CORRADE_COMPARE(a.offset(vertexData), sizeof(Vector2));
CORRADE_COMPARE(a.stride(), 2*sizeof(Vector2));
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
CORRADE_COMPARE_AS(Containers::arrayCast<const Vector2>(a.data(vertexData)),
Containers::arrayView<Vector2>({{1.0f, 0.3f}, {0.5f, 0.7f}}),
TestSuite::Compare::Container);
constexpr MeshAttributeData ca{MeshAttribute::TextureCoordinates, VertexFormat::Vector2, sizeof(Vector2), 2, 2*sizeof(Vector2)};
CORRADE_VERIFY(ca.isOffsetOnly());
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
CORRADE_COMPARE(ca.arraySize(), 0);
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
CORRADE_COMPARE(ca.name(), MeshAttribute::TextureCoordinates);
CORRADE_COMPARE(ca.format(), VertexFormat::Vector2);
Trade: add getters for offset and stride in MeshAttributeData. Less code and complexity than first creating a StridedArrayView in data() and then extracting offset/stride from there.
6 years ago
CORRADE_COMPARE(ca.offset(vertexData), sizeof(Vector2));
CORRADE_COMPARE(ca.stride(), 2*sizeof(Vector2));
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
CORRADE_COMPARE_AS(Containers::arrayCast<const Vector2>(a.data(vertexData)),
Containers::arrayView<Vector2>({{1.0f, 0.3f}, {0.5f, 0.7f}}),
TestSuite::Compare::Container);
}
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
void MeshDataTest::constructAttributeImplementationSpecificFormat() {
Vector2 positions[]{{1.0f, 0.3f}, {0.5f, 0.7f}};
/* This should not fire any asserts */
MeshAttributeData a{MeshAttribute::TextureCoordinates, vertexFormatWrap(0x3a), positions};
CORRADE_COMPARE(a.name(), MeshAttribute::TextureCoordinates);
CORRADE_COMPARE(a.format(), vertexFormatWrap(0x3a));
CORRADE_COMPARE_AS(Containers::arrayCast<const Vector2>(a.data()),
Containers::arrayView<Vector2>({{1.0f, 0.3f}, {0.5f, 0.7f}}),
TestSuite::Compare::Container);
}
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
void MeshDataTest::constructAttributeWrongFormat() {
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
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
Vector2 positionData[3];
std::ostringstream out;
Error redirectError{&out};
MeshAttributeData{MeshAttribute::Color, Containers::arrayView(positionData)};
MeshAttributeData{MeshAttribute::Color, VertexFormat::Vector2, 0, 3, sizeof(Vector2)};
CORRADE_COMPARE(out.str(),
"Trade::MeshAttributeData: VertexFormat::Vector2 is not a valid format for Trade::MeshAttribute::Color\n"
"Trade::MeshAttributeData: VertexFormat::Vector2 is not a valid format for Trade::MeshAttribute::Color\n");
}
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
void MeshDataTest::constructAttributeWrongStride() {
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
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
char positionData[3*sizeof(Vector3)]{};
std::ostringstream out;
Error redirectError{&out};
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector3, Containers::arrayCast<const char>(positionData)};
Trade: properly include array size in attribute stride checks.
6 years ago
MeshAttributeData{meshAttributeCustom(1), VertexFormat::Float, 4, Containers::arrayCast<const Vector3>(positionData)};
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
/* We need this one to be constexpr, which means there can't be a warning
about stride not matching the size */
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector3, 0, 3*sizeof(Vector3), 1};
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector3, Containers::StridedArrayView1D<const void>{positionData, 0, -16}};
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector3, Containers::StridedArrayView1D<const void>{positionData, 0, 65000}};
MeshAttributeData{65000};
CORRADE_COMPARE(out.str(),
"Trade::MeshAttributeData: expected stride to be positive and enough to fit VertexFormat::Vector3, got 1\n"
Trade: properly include array size in attribute stride checks.
6 years ago
"Trade::MeshAttributeData: expected stride to be positive and enough to fit VertexFormat::Float[4], got 12\n"
Trade: pack MeshAttributeData internals better. Before it was a 32-byte structure with 3 bytes free (or a 20-byte structure with 3 bytes free), now it's a 24-byte structure with 5 bytes free. Exploiting the fact that strides can't be too high for a GPU anyway (so 2 bytes is enough instead of 8), and vertex count is capped to 32bit by MeshData anyway (so no need for 8 also), saving 10 bytes on a 64-bit build.
6 years ago
"Trade::MeshAttributeData: expected stride to be positive and at most 32k, got -16\n"
"Trade::MeshAttributeData: expected stride to be positive and at most 32k, got 65000\n"
"Trade::MeshAttributeData: at most 32k padding supported, got 65000\n"
);
}
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
void MeshDataTest::constructAttributeWrongDataAccess() {
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
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
Vector2 positionData[3];
MeshAttributeData a{MeshAttribute::Position, Containers::arrayView(positionData)};
MeshAttributeData b{MeshAttribute::Position, VertexFormat::Vector2, 0, 3, sizeof(Vector2)};
CORRADE_VERIFY(!a.isOffsetOnly());
CORRADE_VERIFY(b.isOffsetOnly());
std::ostringstream out;
Error redirectError{&out};
b.data();
CORRADE_COMPARE(out.str(),
"Trade::MeshAttributeData::data(): the attribute is a relative offset, supply a data array\n");
}
Trade: various MSVC workarounds.
6 years ago
constexpr Vector2 ArrayVertexData[3*4]
/* MSVC 2015 needs an explicit initializer. GCC 4.8 *doesn't*. */
#ifdef CORRADE_MSVC2015_COMPATIBILITY
{}
#endif
;
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
void MeshDataTest::constructArrayAttribute() {
Vector2 vertexData[3*4];
Containers::StridedArrayView2D<Vector2> attribute{vertexData, {3, 4}};
MeshAttributeData data{meshAttributeCustom(35), attribute};
CORRADE_VERIFY(!data.isOffsetOnly());
CORRADE_COMPARE(data.name(), meshAttributeCustom(35));
CORRADE_COMPARE(data.format(), VertexFormat::Vector2);
CORRADE_COMPARE(data.arraySize(), 4);
CORRADE_VERIFY(data.data().data() == vertexData);
CORRADE_COMPARE(data.data().size(), 3);
CORRADE_COMPARE(data.data().stride(), sizeof(Vector2)*4);
constexpr Containers::StridedArrayView2D<const Vector2> cattribute{ArrayVertexData, {3, 4}};
constexpr MeshAttributeData cdata{meshAttributeCustom(35), cattribute};
CORRADE_VERIFY(!cdata.isOffsetOnly());
CORRADE_COMPARE(cdata.name(), meshAttributeCustom(35));
CORRADE_COMPARE(cdata.format(), VertexFormat::Vector2);
CORRADE_COMPARE(cdata.arraySize(), 4);
CORRADE_VERIFY(cdata.data().data() == ArrayVertexData);
CORRADE_COMPARE(cdata.data().size(), 3);
CORRADE_COMPARE(cdata.data().stride(), sizeof(Vector2)*4);
}
void MeshDataTest::constructArrayAttributeNonContiguous() {
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
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
Vector2 vertexData[4*3]{};
std::ostringstream out;
Error redirectError{&out};
MeshAttributeData{meshAttributeCustom(35),
Containers::StridedArrayView2D<Vector2>{vertexData,
{4, 3}}.every({1, 2})};
CORRADE_COMPARE(out.str(), "Trade::MeshAttributeData: second view dimension is not contiguous\n");
}
void MeshDataTest::constructArrayAttribute2D() {
char vertexData[3*4*sizeof(Vector2)];
MeshAttributeData data{meshAttributeCustom(35), VertexFormat::Vector2, 4, Containers::StridedArrayView2D<char>{vertexData, {3, 4*sizeof(Vector2)}}};
CORRADE_VERIFY(!data.isOffsetOnly());
CORRADE_COMPARE(data.name(), meshAttributeCustom(35));
CORRADE_COMPARE(data.format(), VertexFormat::Vector2);
CORRADE_COMPARE(data.arraySize(), 4);
CORRADE_VERIFY(data.data().data() == vertexData);
CORRADE_COMPARE(data.data().size(), 3);
CORRADE_COMPARE(data.data().stride(), sizeof(Vector2)*4);
}
void MeshDataTest::constructArrayAttribute2DWrongSize() {
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
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
char vertexData[3*4*sizeof(Vector2)]{};
std::ostringstream out;
Error redirectError{&out};
MeshAttributeData{meshAttributeCustom(35), VertexFormat::Vector2, 3,
Containers::StridedArrayView2D<char>{vertexData,
{3, 4*sizeof(Vector2)}}};
CORRADE_COMPARE(out.str(), "Trade::MeshAttributeData: second view dimension size 32 doesn't match VertexFormat::Vector2 and array size 3\n");
}
void MeshDataTest::constructArrayAttribute2DNonContiguous() {
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
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
char vertexData[4*3*sizeof(Vector2)]{};
std::ostringstream out;
Error redirectError{&out};
MeshAttributeData{meshAttributeCustom(35), VertexFormat::Vector2, 2,
Containers::StridedArrayView2D<char>{vertexData,
{3, sizeof(Vector2)*4}}.every({1, 2})};
CORRADE_COMPARE(out.str(), "Trade::MeshAttributeData: second view dimension is not contiguous\n");
}
void MeshDataTest::constructArrayAttributeTypeErased() {
Vector2 vertexData[3*4];
Containers::StridedArrayView1D<Vector2> attribute{vertexData, 3, 4*sizeof(Vector2)};
MeshAttributeData data{meshAttributeCustom(35), VertexFormat::Vector2, 4, attribute};
CORRADE_VERIFY(!data.isOffsetOnly());
CORRADE_COMPARE(data.name(), meshAttributeCustom(35));
CORRADE_COMPARE(data.format(), VertexFormat::Vector2);
CORRADE_COMPARE(data.arraySize(), 4);
CORRADE_VERIFY(data.data().data() == vertexData);
CORRADE_COMPARE(data.data().size(), 3);
CORRADE_COMPARE(data.data().stride(), sizeof(Vector2)*4);
}
Trade: fix ambiguity when instantiating nullptr array MeshAttributeData.
6 years ago
void MeshDataTest::constructArrayAttributeNullptr() {
MeshAttributeData positions{meshAttributeCustom(35), VertexFormat::Vector2, 4, nullptr};
CORRADE_VERIFY(!positions.isOffsetOnly());
CORRADE_COMPARE(positions.arraySize(), 4);
CORRADE_COMPARE(positions.name(), meshAttributeCustom(35));
CORRADE_COMPARE(positions.format(), VertexFormat::Vector2);
CORRADE_VERIFY(!positions.data().data());
}
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
void MeshDataTest::constructArrayAttributeOffsetOnly() {
MeshAttributeData data{meshAttributeCustom(35), VertexFormat::Vector2, sizeof(Vector2), 3, sizeof(Vector2), 4};
CORRADE_VERIFY(data.isOffsetOnly());
CORRADE_COMPARE(data.name(), meshAttributeCustom(35));
CORRADE_COMPARE(data.format(), VertexFormat::Vector2);
CORRADE_COMPARE(data.arraySize(), 4);
Vector2 vertexData[1 + 3*4];
CORRADE_VERIFY(data.data(vertexData).data() == vertexData + 1);
CORRADE_COMPARE(data.data(vertexData).size(), 3);
CORRADE_COMPARE(data.data(vertexData).stride(), sizeof(Vector2));
constexpr MeshAttributeData cdata{meshAttributeCustom(35), VertexFormat::Vector2, sizeof(Vector2), 3, sizeof(Vector2), 4};
CORRADE_VERIFY(cdata.isOffsetOnly());
CORRADE_COMPARE(cdata.name(), meshAttributeCustom(35));
CORRADE_COMPARE(cdata.format(), VertexFormat::Vector2);
CORRADE_COMPARE(cdata.arraySize(), 4);
}
void MeshDataTest::constructArrayAttributeNotAllowed() {
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
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
Vector2 positionData[3*3];
Containers::ArrayView<Vector2> positions{positionData};
Containers::StridedArrayView2D<Vector2> positions2D{positionData, {3, 3}};
auto positions2Dchar = Containers::arrayCast<2, const char>(positions2D);
/* This is all fine */
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector2, 0, positions};
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector2, 0, 3, 6*sizeof(Vector2), 0};
MeshAttributeData{meshAttributeCustom(35), vertexFormatWrap(0xdead), 0, positions};
MeshAttributeData{meshAttributeCustom(35), positions2D};
MeshAttributeData{meshAttributeCustom(35), VertexFormat::Vector2, 3, positions2Dchar};
MeshAttributeData{meshAttributeCustom(35), VertexFormat::Vector2, 0, 3, 6*sizeof(Vector2), 3};
/* This is not */
std::ostringstream out;
Error redirectError{&out};
Trade: properly include array size in attribute stride checks.
6 years ago
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector2b, 3, Containers::arrayView(positionData)};
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
MeshAttributeData{meshAttributeCustom(35), vertexFormatWrap(0xdead), 3, Containers::arrayView(positionData)};
MeshAttributeData{MeshAttribute::Position, positions2D};
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector2, 3, positions2Dchar};
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector2, 0, 3, 6*sizeof(Vector2), 3};
MeshAttributeData{meshAttributeCustom(35), vertexFormatWrap(0xdead), 0, 3, 6*sizeof(Vector2), 3};
CORRADE_COMPARE(out.str(),
"Trade::MeshAttributeData: Trade::MeshAttribute::Position can't be an array attribute\n"
"Trade::MeshAttributeData: array attributes can't have an implementation-specific format\n"
"Trade::MeshAttributeData: Trade::MeshAttribute::Position can't be an array attribute\n"
"Trade::MeshAttributeData: Trade::MeshAttribute::Position can't be an array attribute\n"
"Trade::MeshAttributeData: Trade::MeshAttribute::Position can't be an array attribute\n"
"Trade::MeshAttributeData: array attributes can't have an implementation-specific format\n");
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void MeshDataTest::construct() {
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
auto&& instanceData = ConstructData[testCaseInstanceId()];
setTestCaseDescription(instanceData.name);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
struct Vertex {
Vector3 position;
Vector3 normal;
Vector2 textureCoordinate;
Short id;
};
Trade: add a convenience MeshData::indexOffset() getter.
6 years ago
Containers::Array<char> indexData{8*sizeof(UnsignedShort)};
auto indexView = Containers::arrayCast<UnsignedShort>(indexData).slice(1, 7);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
indexView[0] = 0;
indexView[1] = 1;
indexView[2] = 2;
indexView[3] = 0;
indexView[4] = 2;
indexView[5] = 1;
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
/* Enough vertex data to fit also the case with large explicit vertex count
(but fill just the first 3, as those are only tested) */
Containers::Array<char> vertexData{17*sizeof(Vertex)};
auto vertexView = Containers::arrayCast<Vertex>(vertexData).prefix(3);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
vertexView[0].position = {0.1f, 0.2f, 0.3f};
vertexView[1].position = {0.4f, 0.5f, 0.6f};
vertexView[2].position = {0.7f, 0.8f, 0.9f};
vertexView[0].normal = Vector3::xAxis();
vertexView[1].normal = Vector3::yAxis();
vertexView[2].normal = Vector3::zAxis();
vertexView[0].textureCoordinate = {0.000f, 0.125f};
vertexView[1].textureCoordinate = {0.250f, 0.375f};
vertexView[2].textureCoordinate = {0.500f, 0.625f};
vertexView[0].id = 15;
vertexView[1].id = -374;
vertexView[2].id = 22;
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
if(instanceData.vertexCount < 3)
vertexView = vertexView.prefix(instanceData.vertexCount);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
int importerState;
MeshIndexData indices{indexView};
MeshAttributeData positions{MeshAttribute::Position,
Containers::StridedArrayView1D<Vector3>{vertexData, &vertexView[0].position, vertexView.size(), sizeof(Vertex)}};
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
/* Using a relative offset */
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
MeshAttributeData normals{MeshAttribute::Normal,
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
VertexFormat::Vector3, offsetof(Vertex, normal),
UnsignedInt(vertexView.size()), sizeof(Vertex)};
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
MeshAttributeData textureCoordinates{MeshAttribute::TextureCoordinates,
Containers::StridedArrayView1D<Vector2>{vertexData, &vertexView[0].textureCoordinate, vertexView.size(), sizeof(Vertex)}};
MeshAttributeData ids{meshAttributeCustom(13),
Containers::StridedArrayView1D<Short>{vertexData, &vertexView[0].id, vertexView.size(), sizeof(Vertex)}};
MeshData data{MeshPrimitive::Triangles,
std::move(indexData), indices,
/* Texture coordinates deliberately twice (though aliased) */
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
std::move(vertexData), {positions, textureCoordinates, normals, textureCoordinates, ids}, instanceData.vertexCount, &importerState};
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
/* Basics */
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
CORRADE_COMPARE(data.indexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
CORRADE_COMPARE(data.vertexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(data.primitive(), MeshPrimitive::Triangles);
Trade: direct access to MeshAttributeData array in MeshData. Again useful for MeshTools algos.
6 years ago
CORRADE_VERIFY(!data.attributeData().empty());
Trade: add a convenience MeshData::indexOffset() getter.
6 years ago
CORRADE_COMPARE(static_cast<const void*>(data.indexData() + 2), indexView.data());
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(static_cast<const void*>(data.vertexData()), vertexView.data());
Trade: add a convenience MeshData::indexOffset() getter.
6 years ago
CORRADE_COMPARE(static_cast<void*>(data.mutableIndexData() + 2), indexView.data());
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
CORRADE_COMPARE(static_cast<void*>(data.mutableVertexData()), vertexView.data());
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(data.importerState(), &importerState);
/* Index access */
CORRADE_VERIFY(data.isIndexed());
CORRADE_COMPARE(data.indexCount(), 6);
CORRADE_COMPARE(data.indexType(), MeshIndexType::UnsignedShort);
Trade: add a convenience MeshData::indexOffset() getter.
6 years ago
CORRADE_COMPARE(data.indexOffset(), 2);
Trade: typeless access to MeshData indices. Like with attributes, it returns a 2D strided view with the second dimension having the same size as the index type.
6 years ago
/* Typeless index access with a cast later */
CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(data.indices())[1]), 1);
CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(data.indices())[3]), 0);
CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(data.indices())[4]), 2);
/* Typed index access */
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(data.indices<UnsignedShort>()[0], 0);
CORRADE_COMPARE(data.indices<UnsignedShort>()[2], 2);
CORRADE_COMPARE(data.indices<UnsignedShort>()[5], 1);
/* Attribute access by ID */
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
CORRADE_COMPARE(data.vertexCount(), instanceData.expectedVertexCount);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(data.attributeCount(), 5);
CORRADE_COMPARE(data.attributeName(0), MeshAttribute::Position);
CORRADE_COMPARE(data.attributeName(1), MeshAttribute::TextureCoordinates);
CORRADE_COMPARE(data.attributeName(2), MeshAttribute::Normal);
CORRADE_COMPARE(data.attributeName(3), MeshAttribute::TextureCoordinates);
CORRADE_COMPARE(data.attributeName(4), meshAttributeCustom(13));
CORRADE_COMPARE(data.attributeFormat(0), VertexFormat::Vector3);
CORRADE_COMPARE(data.attributeFormat(1), VertexFormat::Vector2);
CORRADE_COMPARE(data.attributeFormat(2), VertexFormat::Vector3);
CORRADE_COMPARE(data.attributeFormat(3), VertexFormat::Vector2);
CORRADE_COMPARE(data.attributeFormat(4), VertexFormat::Short);
CORRADE_COMPARE(data.attributeOffset(0), 0);
CORRADE_COMPARE(data.attributeOffset(1), 2*sizeof(Vector3));
CORRADE_COMPARE(data.attributeOffset(2), sizeof(Vector3));
CORRADE_COMPARE(data.attributeOffset(3), 2*sizeof(Vector3));
CORRADE_COMPARE(data.attributeOffset(4), 2*sizeof(Vector3) + sizeof(Vector2));
CORRADE_COMPARE(data.attributeStride(0), sizeof(Vertex));
CORRADE_COMPARE(data.attributeStride(1), sizeof(Vertex));
CORRADE_COMPARE(data.attributeStride(2), sizeof(Vertex));
CORRADE_COMPARE(data.attributeStride(3), sizeof(Vertex));
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
CORRADE_COMPARE(data.attributeArraySize(0), 0);
CORRADE_COMPARE(data.attributeArraySize(1), 0);
CORRADE_COMPARE(data.attributeArraySize(2), 0);
CORRADE_COMPARE(data.attributeArraySize(3), 0);
CORRADE_COMPARE(data.attributeArraySize(4), 0);
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
/* Typeless access by ID with a cast later */
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
CORRADE_COMPARE(data.attribute(0).size()[0], instanceData.expectedVertexCount);
CORRADE_COMPARE(data.mutableAttribute(0).size()[0], instanceData.expectedVertexCount);
if(instanceData.vertexCount) {
CORRADE_COMPARE((Containers::arrayCast<1, const Vector3>(
data.attribute(0))[1]), (Vector3{0.4f, 0.5f, 0.6f}));
CORRADE_COMPARE((Containers::arrayCast<1, const Vector2>(
data.attribute(1))[0]), (Vector2{0.000f, 0.125f}));
CORRADE_COMPARE((Containers::arrayCast<1, const Vector3>(
data.attribute(2))[2]), Vector3::zAxis());
CORRADE_COMPARE((Containers::arrayCast<1, const Vector2>(
data.attribute(3))[1]), (Vector2{0.250f, 0.375f}));
CORRADE_COMPARE((Containers::arrayCast<1, const Short>(
data.attribute(4))[0]), 15);
CORRADE_COMPARE((Containers::arrayCast<1, Vector3>(
data.mutableAttribute(0))[1]), (Vector3{0.4f, 0.5f, 0.6f}));
CORRADE_COMPARE((Containers::arrayCast<1, Vector2>(
data.mutableAttribute(1))[0]), (Vector2{0.000f, 0.125f}));
CORRADE_COMPARE((Containers::arrayCast<1, Vector3>(
data.mutableAttribute(2))[2]), Vector3::zAxis());
CORRADE_COMPARE((Containers::arrayCast<1, Vector2>(
data.mutableAttribute(3))[1]), (Vector2{0.250f, 0.375f}));
CORRADE_COMPARE((Containers::arrayCast<1, Short>(
data.mutableAttribute(4))[0]), 15);
}
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
/* Typed access by ID */
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
CORRADE_COMPARE(data.attribute<Vector3>(0).size(), instanceData.expectedVertexCount);
CORRADE_COMPARE(data.mutableAttribute<Vector3>(0).size(), instanceData.expectedVertexCount);
if(instanceData.vertexCount) {
CORRADE_COMPARE(data.attribute<Vector3>(0)[1], (Vector3{0.4f, 0.5f, 0.6f}));
CORRADE_COMPARE(data.attribute<Vector2>(1)[0], (Vector2{0.000f, 0.125f}));
CORRADE_COMPARE(data.attribute<Vector3>(2)[2], Vector3::zAxis());
CORRADE_COMPARE(data.attribute<Vector2>(3)[1], (Vector2{0.250f, 0.375f}));
CORRADE_COMPARE(data.attribute<Short>(4)[1], -374);
CORRADE_COMPARE(data.mutableAttribute<Vector3>(0)[1], (Vector3{0.4f, 0.5f, 0.6f}));
CORRADE_COMPARE(data.mutableAttribute<Vector2>(1)[0], (Vector2{0.000f, 0.125f}));
CORRADE_COMPARE(data.mutableAttribute<Vector3>(2)[2], Vector3::zAxis());
CORRADE_COMPARE(data.mutableAttribute<Vector2>(3)[1], (Vector2{0.250f, 0.375f}));
CORRADE_COMPARE(data.mutableAttribute<Short>(4)[1], -374);
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
/* Raw attribute data access by ID */
CORRADE_COMPARE(data.attributeData(3).name(), MeshAttribute::TextureCoordinates);
CORRADE_COMPARE(data.attributeData(3).format(), VertexFormat::Vector2);
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
CORRADE_COMPARE(data.attributeData(3).data().size(), instanceData.expectedVertexCount);
if(instanceData.vertexCount)
CORRADE_COMPARE(Containers::arrayCast<const Vector2>(data.attributeData(3).data())[1], (Vector2{0.250f, 0.375f}));
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
/* Attribute access by name */
CORRADE_VERIFY(data.hasAttribute(MeshAttribute::Position));
CORRADE_VERIFY(data.hasAttribute(MeshAttribute::Normal));
CORRADE_VERIFY(data.hasAttribute(MeshAttribute::TextureCoordinates));
CORRADE_VERIFY(data.hasAttribute(meshAttributeCustom(13)));
CORRADE_VERIFY(!data.hasAttribute(MeshAttribute::Color));
CORRADE_VERIFY(!data.hasAttribute(meshAttributeCustom(23)));
CORRADE_COMPARE(data.attributeCount(MeshAttribute::Position), 1);
CORRADE_COMPARE(data.attributeCount(MeshAttribute::Normal), 1);
CORRADE_COMPARE(data.attributeCount(MeshAttribute::TextureCoordinates), 2);
CORRADE_COMPARE(data.attributeCount(meshAttributeCustom(13)), 1);
CORRADE_COMPARE(data.attributeCount(MeshAttribute::Color), 0);
CORRADE_COMPARE(data.attributeCount(meshAttributeCustom(23)), 0);
Trade: added MeshData::attributeId(). Useful for quick localization of named attribs when dealing with attributeData() (for example in MeshTools).
6 years ago
CORRADE_COMPARE(data.attributeId(MeshAttribute::Position), 0);
CORRADE_COMPARE(data.attributeId(MeshAttribute::Normal), 2);
CORRADE_COMPARE(data.attributeId(MeshAttribute::TextureCoordinates), 1);
CORRADE_COMPARE(data.attributeId(MeshAttribute::TextureCoordinates, 1), 3);
CORRADE_COMPARE(data.attributeId(meshAttributeCustom(13)), 4);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(data.attributeFormat(MeshAttribute::Position),
VertexFormat::Vector3);
CORRADE_COMPARE(data.attributeFormat(MeshAttribute::Normal),
VertexFormat::Vector3);
CORRADE_COMPARE(data.attributeFormat(MeshAttribute::TextureCoordinates, 0),
VertexFormat::Vector2);
CORRADE_COMPARE(data.attributeFormat(MeshAttribute::TextureCoordinates, 1),
VertexFormat::Vector2);
CORRADE_COMPARE(data.attributeFormat(meshAttributeCustom(13)),
VertexFormat::Short);
CORRADE_COMPARE(data.attributeOffset(MeshAttribute::Position), 0);
CORRADE_COMPARE(data.attributeOffset(MeshAttribute::Normal), sizeof(Vector3));
CORRADE_COMPARE(data.attributeOffset(MeshAttribute::TextureCoordinates, 0), 2*sizeof(Vector3));
CORRADE_COMPARE(data.attributeOffset(MeshAttribute::TextureCoordinates, 1), 2*sizeof(Vector3)); CORRADE_COMPARE(data.attributeOffset(meshAttributeCustom(13)), 2*sizeof(Vector3) + sizeof(Vector2));
CORRADE_COMPARE(data.attributeStride(MeshAttribute::Position), sizeof(Vertex));
CORRADE_COMPARE(data.attributeStride(MeshAttribute::Normal), sizeof(Vertex));
CORRADE_COMPARE(data.attributeStride(MeshAttribute::TextureCoordinates, 0), sizeof(Vertex));
CORRADE_COMPARE(data.attributeStride(MeshAttribute::TextureCoordinates, 1), sizeof(Vertex));
CORRADE_COMPARE(data.attributeStride(meshAttributeCustom(13)), sizeof(Vertex));
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
CORRADE_COMPARE(data.attributeArraySize(MeshAttribute::Position), 0);
CORRADE_COMPARE(data.attributeArraySize(MeshAttribute::Normal), 0);
CORRADE_COMPARE(data.attributeArraySize(MeshAttribute::TextureCoordinates, 0), 0);
CORRADE_COMPARE(data.attributeArraySize(MeshAttribute::TextureCoordinates, 1), 0);
CORRADE_COMPARE(data.attributeArraySize(meshAttributeCustom(13)), 0);
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
/* Typeless access by name with a cast later */
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
CORRADE_COMPARE(data.attribute(MeshAttribute::Position).size()[0], instanceData.expectedVertexCount);
CORRADE_COMPARE(data.mutableAttribute(MeshAttribute::Position).size()[0], instanceData.expectedVertexCount);
if(instanceData.vertexCount) {
CORRADE_COMPARE((Containers::arrayCast<1, const Vector3>(
data.attribute(MeshAttribute::Position))[1]), (Vector3{0.4f, 0.5f, 0.6f}));
CORRADE_COMPARE((Containers::arrayCast<1, const Vector3>(
data.attribute(MeshAttribute::Normal))[2]), Vector3::zAxis());
CORRADE_COMPARE((Containers::arrayCast<1, const Vector2>(
data.attribute(MeshAttribute::TextureCoordinates, 0))[0]), (Vector2{0.000f, 0.125f}));
CORRADE_COMPARE((Containers::arrayCast<1, const Vector2>(
data.attribute(MeshAttribute::TextureCoordinates, 1))[1]), (Vector2{0.250f, 0.375f}));
CORRADE_COMPARE((Containers::arrayCast<1, const Short>(
data.attribute(meshAttributeCustom(13)))[1]), -374);
CORRADE_COMPARE((Containers::arrayCast<1, const Vector3>(
data.mutableAttribute(MeshAttribute::Position))[1]), (Vector3{0.4f, 0.5f, 0.6f}));
CORRADE_COMPARE((Containers::arrayCast<1, Vector3>(
data.mutableAttribute(MeshAttribute::Normal))[2]), Vector3::zAxis());
CORRADE_COMPARE((Containers::arrayCast<1, Vector2>(
data.mutableAttribute(MeshAttribute::TextureCoordinates, 0))[0]), (Vector2{0.000f, 0.125f}));
CORRADE_COMPARE((Containers::arrayCast<1, Vector2>(
data.mutableAttribute(MeshAttribute::TextureCoordinates, 1))[1]), (Vector2{0.250f, 0.375f}));
CORRADE_COMPARE((Containers::arrayCast<1, Short>(
data.mutableAttribute(meshAttributeCustom(13)))[1]), -374);
}
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
/* Typed access by name */
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
CORRADE_COMPARE(data.attribute(MeshAttribute::Position).size()[0], instanceData.expectedVertexCount);
CORRADE_COMPARE(data.mutableAttribute(MeshAttribute::Position).size()[0], instanceData.expectedVertexCount);
if(instanceData.vertexCount) {
CORRADE_COMPARE(data.attribute<Vector3>(MeshAttribute::Position)[1], (Vector3{0.4f, 0.5f, 0.6f}));
CORRADE_COMPARE(data.attribute<Vector3>(MeshAttribute::Normal)[2], Vector3::zAxis());
CORRADE_COMPARE(data.attribute<Vector2>(MeshAttribute::TextureCoordinates, 0)[0], (Vector2{0.000f, 0.125f}));
CORRADE_COMPARE(data.attribute<Vector2>(MeshAttribute::TextureCoordinates, 1)[1], (Vector2{0.250f, 0.375f}));
CORRADE_COMPARE(data.attribute<Short>(meshAttributeCustom(13))[2], 22);
CORRADE_COMPARE(data.mutableAttribute<Vector3>(MeshAttribute::Position)[1], (Vector3{0.4f, 0.5f, 0.6f}));
CORRADE_COMPARE(data.mutableAttribute<Vector3>(MeshAttribute::Normal)[2], Vector3::zAxis());
CORRADE_COMPARE(data.mutableAttribute<Vector2>(MeshAttribute::TextureCoordinates, 0)[0], (Vector2{0.000f, 0.125f}));
CORRADE_COMPARE(data.mutableAttribute<Vector2>(MeshAttribute::TextureCoordinates, 1)[1], (Vector2{0.250f, 0.375f}));
CORRADE_COMPARE(data.attribute<Short>(meshAttributeCustom(13))[2], 22);
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
Trade: relax index/attribute/vertex count restrictions in MeshData. Allow to make: - an indexed mesh with zero indices - a mesh with non-zero attribute count but zero vertices - a mesh with non-zero vertex count but zero attributes All of these are valid use cases as explained in the tests, and will also make the release*() behavior defined better.
6 years ago
void MeshDataTest::constructZeroIndices() {
/* This is a valid use case because this could be an empty slice of a
well-defined indexed mesh. Explicitly use a non-null zero-sized array
to check the importer is checking size and not pointer. */
Containers::Array<char> vertexData{3*sizeof(Vector3)};
auto vertices = Containers::arrayCast<Vector3>(vertexData);
char i;
Containers::Array<char> indexData{&i, 0, [](char*, std::size_t){}};
auto indices = Containers::arrayCast<UnsignedInt>(indexData);
MeshAttributeData positions{MeshAttribute::Position, vertices};
MeshData data{MeshPrimitive::Triangles,
std::move(indexData), MeshIndexData{indices},
std::move(vertexData), {positions}};
CORRADE_COMPARE(data.indexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
CORRADE_VERIFY(data.isIndexed());
CORRADE_COMPARE(data.indexType(), MeshIndexType::UnsignedInt);
CORRADE_COMPARE(data.indexCount(), 0);
Trade: make creation of non-owning MeshData references easier. While 27f6cc309d4636adb0f65e559de8e5cc109483cb made it easier to create references to attribute-less meshes by avoiding a branch on attributeCount() (and then using a constructor with explicit vertex count), code still had to branch on isIndexed() because indices() could be called only on indexed meshes. This change allows code like Trade::MeshData reference{data.primitive(), {}, data.indexData(), Trade::MeshIndexData{data.indices()}, {}, data.vertexData(), Trade::meshAttributeDataNonOwningArray(data.attributeData()), data.vertexCount()}; which works correctly for all cases and doesn't introduce extra branches and code paths that would need to be tested. While definitely better, I might still give up at some point and introduce some Trade::MeshData::nonOwningImmutableReference() helper for this.
6 years ago
CORRADE_COMPARE(data.indices().size(), (Containers::StridedArrayView2D<std::size_t>::Size{0, 4}));
CORRADE_COMPARE(data.mutableIndices().size(), (Containers::StridedArrayView2D<std::size_t>::Size{0, 4}));
Trade: relax index/attribute/vertex count restrictions in MeshData. Allow to make: - an indexed mesh with zero indices - a mesh with non-zero attribute count but zero vertices - a mesh with non-zero vertex count but zero attributes All of these are valid use cases as explained in the tests, and will also make the release*() behavior defined better.
6 years ago
CORRADE_COMPARE(data.vertexCount(), 3);
}
void MeshDataTest::constructZeroAttributes() {
/* This is a valid use case because e.g. the index/vertex data can be
shared by multiple meshes and this particular one is just a plain
index array */
Containers::Array<char> indexData{3*sizeof(UnsignedInt)};
Containers::Array<char> vertexData{3};
auto indexView = Containers::arrayCast<UnsignedInt>(indexData);
MeshData data{MeshPrimitive::Triangles,
std::move(indexData), MeshIndexData{indexView},
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
std::move(vertexData), {}, 15};
Trade: relax index/attribute/vertex count restrictions in MeshData. Allow to make: - an indexed mesh with zero indices - a mesh with non-zero attribute count but zero vertices - a mesh with non-zero vertex count but zero attributes All of these are valid use cases as explained in the tests, and will also make the release*() behavior defined better.
6 years ago
CORRADE_COMPARE(data.indexCount(), 3);
CORRADE_COMPARE(data.vertexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
CORRADE_COMPARE(data.attributeCount(), 0);
CORRADE_VERIFY(!data.attributeData());
CORRADE_COMPARE(data.vertexData().size(), 3);
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
CORRADE_COMPARE(data.vertexCount(), 15);
Trade: relax index/attribute/vertex count restrictions in MeshData. Allow to make: - an indexed mesh with zero indices - a mesh with non-zero attribute count but zero vertices - a mesh with non-zero vertex count but zero attributes All of these are valid use cases as explained in the tests, and will also make the release*() behavior defined better.
6 years ago
}
void MeshDataTest::constructZeroVertices() {
/* This is a valid use case because this could be an empty slice of a
well-defined indexed mesh */
Containers::Array<char> indexData{3*sizeof(UnsignedInt)};
auto indexView = Containers::arrayCast<UnsignedInt>(indexData);
MeshAttributeData positions{MeshAttribute::Position, VertexFormat::Vector3, nullptr};
MeshData data{MeshPrimitive::Triangles,
std::move(indexData), MeshIndexData{indexView},
nullptr, {positions}};
CORRADE_COMPARE(data.indexCount(), 3);
CORRADE_COMPARE(data.vertexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
CORRADE_COMPARE(data.attributeCount(), 1);
CORRADE_COMPARE(data.attributeName(0), MeshAttribute::Position);
CORRADE_COMPARE(data.attributeFormat(0), VertexFormat::Vector3);
CORRADE_COMPARE(data.attribute<Vector3>(0).size(), 0);
CORRADE_VERIFY(!data.vertexData());
CORRADE_COMPARE(data.vertexCount(), 0);
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void MeshDataTest::constructIndexless() {
Containers::Array<char> vertexData{3*sizeof(Vector2)};
auto vertexView = Containers::arrayCast<Vector2>(vertexData);
vertexView[0] = {0.1f, 0.2f};
vertexView[1] = {0.4f, 0.5f};
vertexView[2] = {0.7f, 0.8f};
int importerState;
MeshAttributeData positions{MeshAttribute::Position, vertexView};
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData data{MeshPrimitive::LineLoop, std::move(vertexData), {positions}, MeshData::ImplicitVertexCount, &importerState};
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
CORRADE_COMPARE(data.indexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
/* These are empty so it doesn't matter, but this is a nice non-restrictive
default */
CORRADE_COMPARE(data.vertexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(data.primitive(), MeshPrimitive::LineLoop);
CORRADE_COMPARE(data.importerState(), &importerState);
Trade: make creation of non-owning MeshData references easier. While 27f6cc309d4636adb0f65e559de8e5cc109483cb made it easier to create references to attribute-less meshes by avoiding a branch on attributeCount() (and then using a constructor with explicit vertex count), code still had to branch on isIndexed() because indices() could be called only on indexed meshes. This change allows code like Trade::MeshData reference{data.primitive(), {}, data.indexData(), Trade::MeshIndexData{data.indices()}, {}, data.vertexData(), Trade::meshAttributeDataNonOwningArray(data.attributeData()), data.vertexCount()}; which works correctly for all cases and doesn't introduce extra branches and code paths that would need to be tested. While definitely better, I might still give up at some point and introduce some Trade::MeshData::nonOwningImmutableReference() helper for this.
6 years ago
/* Access to indexData() and typeless access to (mutable)indices() is
allowed, to allow creation of MeshData instances referencing other
MeshData without having to branch on isIndexed(). */
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_VERIFY(!data.isIndexed());
Trade: make creation of non-owning MeshData references easier. While 27f6cc309d4636adb0f65e559de8e5cc109483cb made it easier to create references to attribute-less meshes by avoiding a branch on attributeCount() (and then using a constructor with explicit vertex count), code still had to branch on isIndexed() because indices() could be called only on indexed meshes. This change allows code like Trade::MeshData reference{data.primitive(), {}, data.indexData(), Trade::MeshIndexData{data.indices()}, {}, data.vertexData(), Trade::meshAttributeDataNonOwningArray(data.attributeData()), data.vertexCount()}; which works correctly for all cases and doesn't introduce extra branches and code paths that would need to be tested. While definitely better, I might still give up at some point and introduce some Trade::MeshData::nonOwningImmutableReference() helper for this.
6 years ago
CORRADE_COMPARE(data.indexData(), nullptr);
CORRADE_COMPARE(data.indices().data(), nullptr);
CORRADE_COMPARE(data.indices().size(), (Containers::StridedArrayView2D<std::size_t>::Size{0, 0}));
CORRADE_COMPARE(data.mutableIndices().data(), nullptr);
CORRADE_COMPARE(data.mutableIndices().size(), (Containers::StridedArrayView2D<std::size_t>::Size{0, 0}));
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(data.vertexCount(), 3);
CORRADE_COMPARE(data.attributeCount(), 1);
CORRADE_COMPARE(data.attributeFormat(MeshAttribute::Position), VertexFormat::Vector2);
CORRADE_COMPARE(data.attribute<Vector2>(MeshAttribute::Position)[1], (Vector2{0.4f, 0.5f}));
}
void MeshDataTest::constructIndexlessZeroVertices() {
MeshAttributeData positions{MeshAttribute::Position, VertexFormat::Vector2, nullptr};
MeshData data{MeshPrimitive::LineLoop, nullptr, {positions}};
CORRADE_COMPARE(data.primitive(), MeshPrimitive::LineLoop);
CORRADE_COMPARE(data.indexData(), nullptr);
CORRADE_COMPARE(data.vertexData(), nullptr);
CORRADE_VERIFY(!data.isIndexed());
CORRADE_COMPARE(data.vertexCount(), 0);
CORRADE_COMPARE(data.attributeCount(), 1);
CORRADE_COMPARE(data.attributeFormat(MeshAttribute::Position), VertexFormat::Vector2);
}
void MeshDataTest::constructAttributeless() {
Containers::Array<char> indexData{6*sizeof(UnsignedInt)};
auto indexView = Containers::arrayCast<UnsignedInt>(indexData);
indexView[0] = 0;
indexView[1] = 1;
indexView[2] = 2;
indexView[3] = 0;
indexView[4] = 2;
indexView[5] = 1;
int importerState;
MeshIndexData indices{indexView};
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData data{MeshPrimitive::TriangleStrip, std::move(indexData), indices, 3, &importerState};
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
/* These are empty so it doesn't matter, but this is a nice non-restrictive
default */
CORRADE_COMPARE(data.indexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
CORRADE_COMPARE(data.vertexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(data.primitive(), MeshPrimitive::TriangleStrip);
Trade: direct access to MeshAttributeData array in MeshData. Again useful for MeshTools algos.
6 years ago
CORRADE_VERIFY(!data.attributeData());
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(data.vertexData(), nullptr);
CORRADE_COMPARE(data.importerState(), &importerState);
CORRADE_VERIFY(data.isIndexed());
CORRADE_COMPARE(data.indexCount(), 6);
CORRADE_COMPARE(data.indexType(), MeshIndexType::UnsignedInt);
CORRADE_COMPARE(data.indices<UnsignedInt>()[0], 0);
CORRADE_COMPARE(data.indices<UnsignedInt>()[2], 2);
CORRADE_COMPARE(data.indices<UnsignedInt>()[5], 1);
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
CORRADE_COMPARE(data.vertexCount(), 3);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(data.attributeCount(), 0);
}
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
void MeshDataTest::constructNotOwned() {
auto&& instanceData = NotOwnedData[testCaseInstanceId()];
setTestCaseDescription(instanceData.name);
UnsignedShort indexData[]{0, 1, 0};
Vector2 vertexData[]{{0.1f, 0.2f}, {0.4f, 0.5f}};
int importerState;
MeshIndexData indices{indexData};
MeshAttributeData positions{MeshAttribute::Position, Containers::arrayView(vertexData)};
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData data{MeshPrimitive::Triangles, instanceData.indexDataFlags, Containers::arrayView(indexData), indices, instanceData.vertexDataFlags, Containers::arrayView(vertexData), {positions}, MeshData::ImplicitVertexCount, &importerState};
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
CORRADE_COMPARE(data.indexDataFlags(), instanceData.indexDataFlags);
CORRADE_COMPARE(data.vertexDataFlags(), instanceData.vertexDataFlags);
CORRADE_COMPARE(data.primitive(), MeshPrimitive::Triangles);
CORRADE_COMPARE(static_cast<const void*>(data.indexData()), +indexData);
CORRADE_COMPARE(static_cast<const void*>(data.vertexData()), +vertexData);
if(instanceData.indexDataFlags & DataFlag::Mutable)
CORRADE_COMPARE(static_cast<const void*>(data.mutableIndexData()), +indexData);
if(instanceData.vertexDataFlags & DataFlag::Mutable)
CORRADE_COMPARE(static_cast<const void*>(data.mutableVertexData()), +vertexData);
CORRADE_COMPARE(data.importerState(), &importerState);
CORRADE_VERIFY(data.isIndexed());
CORRADE_COMPARE(data.indexCount(), 3);
CORRADE_COMPARE(data.indexType(), MeshIndexType::UnsignedShort);
CORRADE_COMPARE(data.indices<UnsignedShort>()[1], 1);
CORRADE_COMPARE(data.indices<UnsignedShort>()[2], 0);
if(instanceData.indexDataFlags & DataFlag::Mutable) {
CORRADE_COMPARE(data.mutableIndices<UnsignedShort>()[1], 1);
CORRADE_COMPARE(data.mutableIndices<UnsignedShort>()[2], 0);
}
CORRADE_COMPARE(data.vertexCount(), 2);
CORRADE_COMPARE(data.attributeCount(), 1);
CORRADE_COMPARE(data.attributeName(0), MeshAttribute::Position);
CORRADE_COMPARE(data.attributeFormat(0), VertexFormat::Vector2);
CORRADE_COMPARE(data.attributeOffset(0), 0);
CORRADE_COMPARE(data.attributeStride(0), sizeof(Vector2));
CORRADE_COMPARE(data.attribute<Vector2>(0)[0], (Vector2{0.1f, 0.2f}));
CORRADE_COMPARE(data.attribute<Vector2>(0)[1], (Vector2{0.4f, 0.5f}));
if(instanceData.vertexDataFlags & DataFlag::Mutable) {
CORRADE_COMPARE(data.mutableAttribute<Vector2>(0)[0], (Vector2{0.1f, 0.2f}));
CORRADE_COMPARE(data.mutableAttribute<Vector2>(0)[1], (Vector2{0.4f, 0.5f}));
}
}
void MeshDataTest::constructIndicesNotOwned() {
auto&& instanceData = SingleNotOwnedData[testCaseInstanceId()];
setTestCaseDescription(instanceData.name);
UnsignedShort indexData[]{0, 1, 0};
Containers::Array<char> vertexData{2*sizeof(Vector2)};
auto vertexView = Containers::arrayCast<Vector2>(vertexData);
vertexView[0] = {0.1f, 0.2f};
vertexView[1] = {0.4f, 0.5f};
int importerState;
MeshIndexData indices{indexData};
MeshAttributeData positions{MeshAttribute::Position, vertexView};
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData data{MeshPrimitive::Triangles, instanceData.dataFlags, Containers::arrayView(indexData), indices, std::move(vertexData), {positions}, MeshData::ImplicitVertexCount, &importerState};
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
CORRADE_COMPARE(data.indexDataFlags(), instanceData.dataFlags);
CORRADE_COMPARE(data.vertexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
CORRADE_COMPARE(data.primitive(), MeshPrimitive::Triangles);
CORRADE_COMPARE(static_cast<const void*>(data.indexData()), +indexData);
CORRADE_COMPARE(static_cast<const void*>(data.vertexData()), vertexView.data());
if(instanceData.dataFlags & DataFlag::Mutable)
CORRADE_COMPARE(static_cast<const void*>(data.mutableIndexData()), +indexData);
CORRADE_COMPARE(static_cast<const void*>(data.mutableVertexData()), vertexView.data());
CORRADE_COMPARE(data.importerState(), &importerState);
CORRADE_VERIFY(data.isIndexed());
CORRADE_COMPARE(data.indexCount(), 3);
CORRADE_COMPARE(data.indexType(), MeshIndexType::UnsignedShort);
CORRADE_COMPARE(data.indices<UnsignedShort>()[1], 1);
CORRADE_COMPARE(data.indices<UnsignedShort>()[2], 0);
if(instanceData.dataFlags & DataFlag::Mutable) {
CORRADE_COMPARE(data.mutableIndices<UnsignedShort>()[1], 1);
CORRADE_COMPARE(data.mutableIndices<UnsignedShort>()[2], 0);
}
CORRADE_COMPARE(data.vertexCount(), 2);
CORRADE_COMPARE(data.attributeCount(), 1);
CORRADE_COMPARE(data.attributeName(0), MeshAttribute::Position);
CORRADE_COMPARE(data.attributeFormat(0), VertexFormat::Vector2);
CORRADE_COMPARE(data.attributeOffset(0), 0);
CORRADE_COMPARE(data.attributeStride(0), sizeof(Vector2));
CORRADE_COMPARE(data.attribute<Vector2>(0)[0], (Vector2{0.1f, 0.2f}));
CORRADE_COMPARE(data.attribute<Vector2>(0)[1], (Vector2{0.4f, 0.5f}));
CORRADE_COMPARE(data.mutableAttribute<Vector2>(0)[0], (Vector2{0.1f, 0.2f}));
CORRADE_COMPARE(data.mutableAttribute<Vector2>(0)[1], (Vector2{0.4f, 0.5f}));
}
void MeshDataTest::constructVerticesNotOwned() {
auto&& instanceData = SingleNotOwnedData[testCaseInstanceId()];
setTestCaseDescription(instanceData.name);
Containers::Array<char> indexData{3*sizeof(UnsignedShort)};
auto indexView = Containers::arrayCast<UnsignedShort>(indexData);
indexView[0] = 0;
indexView[1] = 1;
indexView[2] = 0;
Vector2 vertexData[]{{0.1f, 0.2f}, {0.4f, 0.5f}};
int importerState;
MeshIndexData indices{indexView};
MeshAttributeData positions{MeshAttribute::Position, Containers::arrayView(vertexData)};
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData data{MeshPrimitive::Triangles, std::move(indexData), indices, instanceData.dataFlags, Containers::arrayView(vertexData), {positions}, MeshData::ImplicitVertexCount, &importerState};
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
CORRADE_COMPARE(data.indexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
CORRADE_COMPARE(data.vertexDataFlags(), instanceData.dataFlags);
CORRADE_COMPARE(data.primitive(), MeshPrimitive::Triangles);
CORRADE_COMPARE(static_cast<const void*>(data.indexData()), indexView.data());
CORRADE_COMPARE(static_cast<const void*>(data.vertexData()), +vertexData);
CORRADE_COMPARE(static_cast<const void*>(data.mutableIndexData()), indexView.data());
if(instanceData.dataFlags & DataFlag::Mutable)
CORRADE_COMPARE(static_cast<const void*>(data.mutableVertexData()), +vertexData);
CORRADE_COMPARE(data.importerState(), &importerState);
CORRADE_VERIFY(data.isIndexed());
CORRADE_COMPARE(data.indexCount(), 3);
CORRADE_COMPARE(data.indexType(), MeshIndexType::UnsignedShort);
CORRADE_COMPARE(data.indices<UnsignedShort>()[1], 1);
CORRADE_COMPARE(data.indices<UnsignedShort>()[2], 0);
CORRADE_COMPARE(data.mutableIndices<UnsignedShort>()[1], 1);
CORRADE_COMPARE(data.mutableIndices<UnsignedShort>()[2], 0);
CORRADE_COMPARE(data.vertexCount(), 2);
CORRADE_COMPARE(data.attributeCount(), 1);
CORRADE_COMPARE(data.attributeName(0), MeshAttribute::Position);
CORRADE_COMPARE(data.attributeFormat(0), VertexFormat::Vector2);
CORRADE_COMPARE(data.attributeOffset(0), 0);
CORRADE_COMPARE(data.attributeStride(0), sizeof(Vector2));
CORRADE_COMPARE(data.attribute<Vector2>(0)[0], (Vector2{0.1f, 0.2f}));
CORRADE_COMPARE(data.attribute<Vector2>(0)[1], (Vector2{0.4f, 0.5f}));
if(instanceData.dataFlags & DataFlag::Mutable) {
CORRADE_COMPARE(data.mutableAttribute<Vector2>(0)[0], (Vector2{0.1f, 0.2f}));
CORRADE_COMPARE(data.mutableAttribute<Vector2>(0)[1], (Vector2{0.4f, 0.5f}));
}
}
void MeshDataTest::constructIndexlessNotOwned() {
auto&& instanceData = SingleNotOwnedData[testCaseInstanceId()];
setTestCaseDescription(instanceData.name);
Vector2 vertexData[]{{0.1f, 0.2f}, {0.4f, 0.5f}};
int importerState;
MeshAttributeData positions{MeshAttribute::Position, Containers::arrayView(vertexData)};
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData data{MeshPrimitive::LineLoop, instanceData.dataFlags, vertexData, {positions}, MeshData::ImplicitVertexCount, &importerState};
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
CORRADE_COMPARE(data.indexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
CORRADE_COMPARE(data.vertexDataFlags(), instanceData.dataFlags);
CORRADE_COMPARE(data.primitive(), MeshPrimitive::LineLoop);
CORRADE_COMPARE(data.indexData(), nullptr);
if(instanceData.dataFlags & DataFlag::Mutable)
CORRADE_COMPARE(data.mutableIndexData(), nullptr);
CORRADE_COMPARE(data.importerState(), &importerState);
CORRADE_VERIFY(!data.isIndexed());
CORRADE_COMPARE(data.vertexCount(), 2);
CORRADE_COMPARE(data.attributeCount(), 1);
CORRADE_COMPARE(data.attributeFormat(MeshAttribute::Position), VertexFormat::Vector2);
CORRADE_COMPARE(data.attribute<Vector2>(MeshAttribute::Position)[1], (Vector2{0.4f, 0.5f}));
if(instanceData.dataFlags & DataFlag::Mutable)
CORRADE_COMPARE(data.mutableAttribute<Vector2>(MeshAttribute::Position)[1], (Vector2{0.4f, 0.5f}));
}
void MeshDataTest::constructAttributelessNotOwned() {
auto&& instanceData = SingleNotOwnedData[testCaseInstanceId()];
setTestCaseDescription(instanceData.name);
UnsignedShort indexData[]{0, 1, 0};
int importerState;
MeshIndexData indices{indexData};
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData data{MeshPrimitive::TriangleStrip, instanceData.dataFlags, indexData, indices, 5, &importerState};
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
CORRADE_COMPARE(data.indexDataFlags(), instanceData.dataFlags);
CORRADE_COMPARE(data.vertexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
CORRADE_COMPARE(data.primitive(), MeshPrimitive::TriangleStrip);
Trade: direct access to MeshAttributeData array in MeshData. Again useful for MeshTools algos.
6 years ago
CORRADE_VERIFY(!data.attributeData());
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
CORRADE_COMPARE(data.vertexData(), nullptr);
if(instanceData.dataFlags & DataFlag::Mutable)
CORRADE_COMPARE(data.mutableVertexData(), nullptr);
CORRADE_COMPARE(data.importerState(), &importerState);
CORRADE_VERIFY(data.isIndexed());
CORRADE_COMPARE(data.indexCount(), 3);
CORRADE_COMPARE(data.indexType(), MeshIndexType::UnsignedShort);
CORRADE_COMPARE(data.indices<UnsignedShort>()[0], 0);
CORRADE_COMPARE(data.indices<UnsignedShort>()[1], 1);
CORRADE_COMPARE(data.indices<UnsignedShort>()[2], 0);
if(instanceData.dataFlags & DataFlag::Mutable) {
CORRADE_COMPARE(data.mutableIndices<UnsignedShort>()[0], 0);
CORRADE_COMPARE(data.mutableIndices<UnsignedShort>()[1], 1);
CORRADE_COMPARE(data.mutableIndices<UnsignedShort>()[2], 0);
}
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
CORRADE_COMPARE(data.vertexCount(), 5);
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
CORRADE_COMPARE(data.attributeCount(), 0);
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void MeshDataTest::constructIndexlessAttributeless() {
int importerState;
MeshData data{MeshPrimitive::TriangleStrip, 37, &importerState};
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
/* These are both empty so it doesn't matter, but this is a nice
non-restrictive default */
CORRADE_COMPARE(data.indexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
CORRADE_COMPARE(data.vertexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(data.primitive(), MeshPrimitive::TriangleStrip);
Trade: direct access to MeshAttributeData array in MeshData. Again useful for MeshTools algos.
6 years ago
CORRADE_VERIFY(!data.attributeData());
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(data.indexData(), nullptr);
CORRADE_COMPARE(data.vertexData(), nullptr);
CORRADE_COMPARE(data.importerState(), &importerState);
CORRADE_VERIFY(!data.isIndexed());
CORRADE_COMPARE(data.vertexCount(), 37);
CORRADE_COMPARE(data.attributeCount(), 0);
}
void MeshDataTest::constructIndexlessAttributelessZeroVertices() {
int importerState;
MeshData data{MeshPrimitive::TriangleStrip, 0, &importerState};
CORRADE_COMPARE(data.primitive(), MeshPrimitive::TriangleStrip);
Trade: direct access to MeshAttributeData array in MeshData. Again useful for MeshTools algos.
6 years ago
CORRADE_VERIFY(!data.attributeData());
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(data.indexData(), nullptr);
CORRADE_COMPARE(data.vertexData(), nullptr);
CORRADE_COMPARE(data.importerState(), &importerState);
CORRADE_VERIFY(!data.isIndexed());
CORRADE_COMPARE(data.vertexCount(), 0);
CORRADE_COMPARE(data.attributeCount(), 0);
}
void MeshDataTest::constructIndexDataButNotIndexed() {
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
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::Array<char> indexData{6};
std::ostringstream out;
Error redirectError{&out};
MeshAttributeData positions{MeshAttribute::Position, VertexFormat::Vector2, nullptr};
MeshData{MeshPrimitive::Points, std::move(indexData), MeshIndexData{}, nullptr, {positions}};
CORRADE_COMPARE(out.str(), "Trade::MeshData: indexData passed for a non-indexed mesh\n");
}
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
void MeshDataTest::constructAttributelessImplicitVertexCount() {
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
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
std::ostringstream out;
Error redirectError{&out};
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData{MeshPrimitive::Points, nullptr, {}};
CORRADE_COMPARE(out.str(), "Trade::MeshData: vertex count can't be implicit if there are no attributes\n");
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
void MeshDataTest::constructIndicesNotContained() {
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
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::Array<char> indexData{reinterpret_cast<char*>(0xbadda9), 6, [](char*, std::size_t){}};
Containers::ArrayView<UnsignedShort> indexData2{reinterpret_cast<UnsignedShort*>(0xdead), 3};
MeshIndexData indices{indexData2};
std::ostringstream out;
Error redirectError{&out};
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData{MeshPrimitive::Triangles, std::move(indexData), indices, 1};
MeshData{MeshPrimitive::Triangles, nullptr, indices, 1};
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(out.str(),
"Trade::MeshData: indices [0xdead:0xdeb3] are not contained in passed indexData array [0xbadda9:0xbaddaf]\n"
"Trade::MeshData: indices [0xdead:0xdeb3] are not contained in passed indexData array [0x0:0x0]\n");
}
void MeshDataTest::constructAttributeNotContained() {
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
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::Array<char> vertexData{reinterpret_cast<char*>(0xbadda9), 24, [](char*, std::size_t){}};
Containers::ArrayView<Vector2> vertexData2{reinterpret_cast<Vector2*>(0xdead), 3};
MeshAttributeData positions{MeshAttribute::Position, Containers::arrayCast<Vector2>(vertexData)};
MeshAttributeData positions2{MeshAttribute::Position, Containers::arrayView(vertexData2)};
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
MeshAttributeData positions3{MeshAttribute::Position, VertexFormat::Vector2, 1, 3, 8};
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
/* See implementationSpecificVertexFormatNotContained() below for
implementation-specific formats */
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
/* Here the original positions array is shrunk from 3 items to 2 and the
vertex data too, which should work without asserting -- comparing just
the original view would not pass, which is wrong */
MeshData{MeshPrimitive::Triangles, {}, vertexData.prefix(16), {positions}, 2};
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
std::ostringstream out;
Error redirectError{&out};
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
/* Here the original positions array is extended from 3 items to 4, which
makes it not fit anymore, and thus an assert should hit -- comparing
just the original view would pass, which is wrong */
MeshData{MeshPrimitive::Triangles, {}, vertexData, {positions}, 4};
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
MeshData{MeshPrimitive::Triangles, std::move(vertexData), {positions, positions2}};
MeshData{MeshPrimitive::Triangles, nullptr, {positions}};
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
MeshData{MeshPrimitive::Triangles, Containers::Array<char>{24}, {positions3}};
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(out.str(),
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
"Trade::MeshData: attribute 0 [0xbadda9:0xbaddc9] is not contained in passed vertexData array [0xbadda9:0xbaddc1]\n"
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
"Trade::MeshData: attribute 1 [0xdead:0xdec5] is not contained in passed vertexData array [0xbadda9:0xbaddc1]\n"
Trade: support offset-only MeshAttributeData. Originally this was done in order to make handling of deserialized data much simpler (as for those attributes also need to only contain an offset into some unknown data array), but seems this could be very useful elsewhere as well -- for example when the layout is known beforehand but the actual data not yet -- such as in the Line and Gradient primitives (going to switch them to this in the next commit). What still unfortunately has to be known in advance is the actual vertex count (as supplying it directly to MeshData would mean adding 6 new constructor overloads, and there's enough of those already). Might revisit later.
6 years ago
"Trade::MeshData: attribute 0 [0xbadda9:0xbaddc1] is not contained in passed vertexData array [0x0:0x0]\n"
"Trade::MeshData: offset attribute 0 spans 25 bytes but passed vertexData array has only 24\n");
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
void MeshDataTest::constructInconsitentVertexCount() {
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
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
Containers::Array<char> vertexData{136};
MeshAttributeData positions{MeshAttribute::Position, Containers::arrayCast<Vector2>(vertexData).prefix(3)};
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
MeshAttributeData positions2{MeshAttribute::Position, Containers::arrayCast<Vector2>(vertexData).prefix(2)};
std::ostringstream out;
Error redirectError{&out};
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
/* The explicit vertex count should be ignored for the assertion message,
we only check that all passed attribute arrays have the same vertex
count. However, the actual "containment" of the attribute views is
checked with the explicit vertex count -- see the
constructAttributeNotContained() test above. */
MeshData{MeshPrimitive::Triangles, std::move(vertexData), {positions, positions2}, 17};
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(out.str(),
"Trade::MeshData: attribute 1 has 2 vertices but 3 expected\n");
}
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
void MeshDataTest::constructNotOwnedIndexFlagOwned() {
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
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
const UnsignedShort indexData[]{0, 1, 0};
const Vector2 vertexData[]{{0.1f, 0.2f}, {0.4f, 0.5f}};
MeshIndexData indices{indexData};
MeshAttributeData positions{MeshAttribute::Position, Containers::arrayView(vertexData)};
std::ostringstream out;
Error redirectError{&out};
MeshData data{MeshPrimitive::Triangles, DataFlag::Owned, indexData, indices, {}, vertexData, {positions}};
CORRADE_COMPARE(out.str(),
"Trade::MeshData: can't construct with non-owned index data but Trade::DataFlag::Owned\n");
}
void MeshDataTest::constructNotOwnedVertexFlagOwned() {
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
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
const UnsignedShort indexData[]{0, 1, 0};
const Vector2 vertexData[]{{0.1f, 0.2f}, {0.4f, 0.5f}};
MeshIndexData indices{indexData};
MeshAttributeData positions{MeshAttribute::Position, Containers::arrayView(vertexData)};
std::ostringstream out;
Error redirectError{&out};
MeshData data{MeshPrimitive::Triangles, {}, indexData, indices, DataFlag::Owned, vertexData, {positions}};
CORRADE_COMPARE(out.str(),
"Trade::MeshData: can't construct with non-owned vertex data but Trade::DataFlag::Owned\n");
}
void MeshDataTest::constructIndicesNotOwnedFlagOwned() {
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
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
UnsignedShort indexData[]{0, 1, 0};
Containers::Array<char> vertexData{2*sizeof(Vector2)};
auto vertexView = Containers::arrayCast<Vector2>(vertexData);
vertexView[0] = {0.1f, 0.2f};
vertexView[1] = {0.4f, 0.5f};
MeshIndexData indices{indexData};
MeshAttributeData positions{MeshAttribute::Position, vertexView};
std::ostringstream out;
Error redirectError{&out};
MeshData data{MeshPrimitive::Triangles, DataFlag::Owned, indexData, indices, std::move(vertexData), {positions}};
CORRADE_COMPARE(out.str(),
"Trade::MeshData: can't construct with non-owned index data but Trade::DataFlag::Owned\n");
}
void MeshDataTest::constructVerticesNotOwnedFlagOwned() {
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
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
Containers::Array<char> indexData{3*sizeof(UnsignedShort)};
auto indexView = Containers::arrayCast<UnsignedShort>(indexData);
indexView[0] = 0;
indexView[1] = 1;
indexView[2] = 0;
Vector2 vertexData[]{{0.1f, 0.2f}, {0.4f, 0.5f}};
MeshIndexData indices{indexView};
MeshAttributeData positions{MeshAttribute::Position, Containers::arrayView(vertexData)};
std::ostringstream out;
Error redirectError{&out};
MeshData data{MeshPrimitive::Triangles, std::move(indexData), indices, DataFlag::Owned, vertexData, {positions}};
CORRADE_COMPARE(out.str(),
"Trade::MeshData: can't construct with non-owned vertex data but Trade::DataFlag::Owned\n");
}
void MeshDataTest::constructIndexlessNotOwnedFlagOwned() {
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
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
const Vector2 vertexData[]{{0.1f, 0.2f}, {0.4f, 0.5f}};
MeshAttributeData positions{MeshAttribute::Position, Containers::arrayView(vertexData)};
std::ostringstream out;
Error redirectError{&out};
MeshData data{MeshPrimitive::Triangles, DataFlag::Owned, vertexData, {positions}};
CORRADE_COMPARE(out.str(),
"Trade::MeshData: can't construct with non-owned vertex data but Trade::DataFlag::Owned\n");
}
void MeshDataTest::constructAttributelessNotOwnedFlagOwned() {
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
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
const UnsignedShort indexData[]{0, 1, 0};
MeshIndexData indices{indexData};
std::ostringstream out;
Error redirectError{&out};
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData data{MeshPrimitive::Triangles, DataFlag::Owned, indexData, indices, 2};
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
CORRADE_COMPARE(out.str(),
"Trade::MeshData: can't construct with non-owned index data but Trade::DataFlag::Owned\n");
}
Trade: make it possible to construct a "padding" MeshAttributeData. Will be used in MeshTools algorithms. Also harden the MeshData constructor to reject such instances.
6 years ago
void MeshDataTest::constructInvalidAttributeData() {
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
Trade: make it possible to construct a "padding" MeshAttributeData. Will be used in MeshTools algorithms. Also harden the MeshData constructor to reject such instances.
6 years ago
MeshAttributeData a;
MeshAttributeData b{3};
std::ostringstream out;
Error redirectError{&out};
MeshData{MeshPrimitive::Triangles, nullptr, {a}};
MeshData{MeshPrimitive::Triangles, nullptr, {b}};
CORRADE_COMPARE(out.str(),
"Trade::MeshData: attribute 0 doesn't specify anything\n"
"Trade::MeshData: attribute 0 doesn't specify anything\n");
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void MeshDataTest::constructCopy() {
CORRADE_VERIFY(!(std::is_constructible<MeshData, const MeshData&>{}));
CORRADE_VERIFY(!(std::is_assignable<MeshData, const MeshData&>{}));
}
void MeshDataTest::constructMove() {
Containers::Array<char> indexData{3*sizeof(UnsignedShort)};
auto indexView = Containers::arrayCast<UnsignedShort>(indexData);
indexView[0] = 0;
indexView[1] = 1;
indexView[2] = 0;
Containers::Array<char> vertexData{2*sizeof(Vector2)};
auto vertexView = Containers::arrayCast<Vector2>(vertexData);
vertexView[0] = {0.1f, 0.2f};
vertexView[1] = {0.4f, 0.5f};
int importerState;
MeshIndexData indices{indexView};
MeshAttributeData positions{MeshAttribute::Position, vertexView};
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData a{MeshPrimitive::Triangles, std::move(indexData), indices, std::move(vertexData), {positions}, MeshData::ImplicitVertexCount, &importerState};
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
MeshData b{std::move(a)};
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
CORRADE_COMPARE(b.indexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
CORRADE_COMPARE(b.vertexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(b.primitive(), MeshPrimitive::Triangles);
CORRADE_COMPARE(static_cast<const void*>(b.indexData()), indexView.data());
CORRADE_COMPARE(static_cast<const void*>(b.vertexData()), vertexView.data());
CORRADE_COMPARE(b.importerState(), &importerState);
CORRADE_VERIFY(b.isIndexed());
CORRADE_COMPARE(b.indexCount(), 3);
CORRADE_COMPARE(b.indexType(), MeshIndexType::UnsignedShort);
CORRADE_COMPARE(b.indices<UnsignedShort>()[1], 1);
CORRADE_COMPARE(b.indices<UnsignedShort>()[2], 0);
CORRADE_COMPARE(b.vertexCount(), 2);
CORRADE_COMPARE(b.attributeCount(), 1);
CORRADE_COMPARE(b.attributeName(0), MeshAttribute::Position);
CORRADE_COMPARE(b.attributeFormat(0), VertexFormat::Vector2);
CORRADE_COMPARE(b.attributeOffset(0), 0);
CORRADE_COMPARE(b.attributeStride(0), sizeof(Vector2));
CORRADE_COMPARE(b.attribute<Vector2>(0)[0], (Vector2{0.1f, 0.2f}));
CORRADE_COMPARE(b.attribute<Vector2>(0)[1], (Vector2{0.4f, 0.5f}));
MeshData c{MeshPrimitive::LineLoop, 37};
c = std::move(b);
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
CORRADE_COMPARE(c.indexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
CORRADE_COMPARE(c.vertexDataFlags(), DataFlag::Owned|DataFlag::Mutable);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(c.primitive(), MeshPrimitive::Triangles);
CORRADE_COMPARE(static_cast<const void*>(c.indexData()), indexView.data());
CORRADE_COMPARE(static_cast<const void*>(c.vertexData()), vertexView.data());
CORRADE_COMPARE(c.importerState(), &importerState);
CORRADE_VERIFY(c.isIndexed());
CORRADE_COMPARE(c.indexCount(), 3);
CORRADE_COMPARE(c.indexType(), MeshIndexType::UnsignedShort);
CORRADE_COMPARE(c.indices<UnsignedShort>()[1], 1);
CORRADE_COMPARE(c.indices<UnsignedShort>()[2], 0);
CORRADE_COMPARE(c.vertexCount(), 2);
CORRADE_COMPARE(c.attributeCount(), 1);
CORRADE_COMPARE(c.attributeName(0), MeshAttribute::Position);
CORRADE_COMPARE(c.attributeFormat(0), VertexFormat::Vector2);
CORRADE_COMPARE(c.attributeOffset(0), 0);
CORRADE_COMPARE(c.attributeStride(0), sizeof(Vector2));
CORRADE_COMPARE(c.attribute<Vector2>(0)[0], (Vector2{0.1f, 0.2f}));
CORRADE_COMPARE(c.attribute<Vector2>(0)[1], (Vector2{0.4f, 0.5f}));
CORRADE_VERIFY(std::is_nothrow_move_constructible<MeshData>::value);
CORRADE_VERIFY(std::is_nothrow_move_assignable<MeshData>::value);
}
template<class> struct NameTraits;
#define _c(format) template<> struct NameTraits<format> { \
static const char* name() { return #format; } \
};
_c(Vector2)
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
_c(Vector2h)
_c(Vector2ub)
_c(Vector2b)
_c(Vector2us)
_c(Vector2s)
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
_c(Vector3)
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
_c(Vector3h)
_c(Vector3ub)
_c(Vector3b)
_c(Vector3us)
_c(Vector3s)
Trade: fix tangent retrieval from four-component normalized types. By accident this code path was not tested, and of course it had a bug.
6 years ago
_c(Vector4)
_c(Vector4h)
_c(Vector4b)
_c(Vector4s)
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
_c(Color3)
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
_c(Color3h)
_c(Color3ub)
_c(Color3us)
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
_c(Color4)
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
_c(Color4h)
_c(Color4ub)
_c(Color4us)
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
#undef _c
template<class T> void MeshDataTest::indicesAsArray() {
setTestCaseTemplateName(Math::TypeTraits<T>::name());
Containers::Array<char> indexData{3*sizeof(T)};
auto indexView = Containers::arrayCast<T>(indexData);
indexView[0] = 75;
indexView[1] = 131;
indexView[2] = 240;
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData data{MeshPrimitive::Points, std::move(indexData), MeshIndexData{indexView}, 241};
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE_AS(data.indicesAsArray(),
Containers::arrayView<UnsignedInt>({75, 131, 240}),
TestSuite::Compare::Container);
}
void MeshDataTest::indicesIntoArrayInvalidSize() {
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
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::Array<char> indexData{3*sizeof(UnsignedInt)};
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData data{MeshPrimitive::Points, std::move(indexData), MeshIndexData{Containers::arrayCast<UnsignedInt>(indexData)}, 1};
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
std::ostringstream out;
Error redirectError{&out};
UnsignedInt destination[2];
data.indicesInto(destination);
CORRADE_COMPARE(out.str(),
"Trade::MeshData::indicesInto(): expected a view with 3 elements but got 2\n");
}
template<class T> void MeshDataTest::positions2DAsArray() {
setTestCaseTemplateName(NameTraits<T>::name());
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
typedef typename T::Type U;
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::Array<char> vertexData{3*sizeof(T)};
auto positionsView = Containers::arrayCast<T>(vertexData);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
positionsView[0] = T::pad(Math::Vector2<U>{U(2.0f), U(1.0f)});
positionsView[1] = T::pad(Math::Vector2<U>{U(0.0f), U(-1.0f)});
positionsView[2] = T::pad(Math::Vector2<U>{U(-2.0f), U(3.0f)});
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Position, positionsView}}};
CORRADE_COMPARE_AS(data.positions2DAsArray(),
Containers::arrayView<Vector2>({{2.0f, 1.0f}, {0.0f, -1.0f}, {-2.0f, 3.0f}}),
TestSuite::Compare::Container);
}
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
template<class T> void MeshDataTest::positions2DAsArrayPackedUnsigned() {
setTestCaseTemplateName(NameTraits<T>::name());
Containers::Array<char> vertexData{3*sizeof(T)};
auto positionsView = Containers::arrayCast<T>(vertexData);
positionsView[0] = T::pad(Math::Vector2<typename T::Type>{2, 1});
positionsView[1] = T::pad(Math::Vector2<typename T::Type>{0, 15});
positionsView[2] = T::pad(Math::Vector2<typename T::Type>{22, 3});
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Position, positionsView}}};
CORRADE_COMPARE_AS(data.positions2DAsArray(),
Containers::arrayView<Vector2>({{2.0f, 1.0f}, {0.0f, 15.0f}, {22.0f, 3.0f}}),
TestSuite::Compare::Container);
}
template<class T> void MeshDataTest::positions2DAsArrayPackedSigned() {
setTestCaseTemplateName(NameTraits<T>::name());
Containers::Array<char> vertexData{3*sizeof(T)};
auto positionsView = Containers::arrayCast<T>(vertexData);
positionsView[0] = T::pad(Math::Vector2<typename T::Type>{2, 1});
positionsView[1] = T::pad(Math::Vector2<typename T::Type>{0, -15});
positionsView[2] = T::pad(Math::Vector2<typename T::Type>{-22, 3});
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Position, positionsView}}};
CORRADE_COMPARE_AS(data.positions2DAsArray(),
Containers::arrayView<Vector2>({{2.0f, 1.0f}, {0.0f, -15.0f}, {-22.0f, 3.0f}}),
TestSuite::Compare::Container);
}
template<class T> void MeshDataTest::positions2DAsArrayPackedUnsignedNormalized() {
setTestCaseTemplateName(NameTraits<T>::name());
Containers::Array<char> vertexData{2*sizeof(T)};
auto positionsView = Containers::arrayCast<T>(vertexData);
positionsView[0] = T::pad(Math::Vector2<typename T::Type>{Math::pack<typename T::Type>(1.0f), 0});
positionsView[1] = T::pad(Math::Vector2<typename T::Type>{0, Math::pack<typename T::Type>(1.0f)});
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Position,
/* Assuming the normalized enum is always after the non-normalized */
VertexFormat(UnsignedInt(Implementation::vertexFormatFor<T>()) + 1),
positionsView}}};
CORRADE_COMPARE_AS(data.positions2DAsArray(),
Containers::arrayView<Vector2>({{1.0f, 0.0f}, {0.0f, 1.0f}}),
TestSuite::Compare::Container);
}
template<class T> void MeshDataTest::positions2DAsArrayPackedSignedNormalized() {
setTestCaseTemplateName(NameTraits<T>::name());
Containers::Array<char> vertexData{2*sizeof(T)};
auto positionsView = Containers::arrayCast<T>(vertexData);
positionsView[0] = T::pad(Math::Vector2<typename T::Type>{Math::pack<typename T::Type>(1.0f), 0});
positionsView[1] = T::pad(Math::Vector2<typename T::Type>{0, Math::pack<typename T::Type>(-1.0f)});
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Position,
/* Assuming the normalized enum is always after the non-normalized */
VertexFormat(UnsignedInt(Implementation::vertexFormatFor<T>()) + 1),
positionsView}}};
CORRADE_COMPARE_AS(data.positions2DAsArray(),
Containers::arrayView<Vector2>({{1.0f, 0.0f}, {0.0f, -1.0f}}),
TestSuite::Compare::Container);
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void MeshDataTest::positions2DIntoArrayInvalidSize() {
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
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::Array<char> vertexData{3*sizeof(Vector2)};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Position, Containers::arrayCast<Vector2>(vertexData)}}};
std::ostringstream out;
Error redirectError{&out};
Vector2 destination[2];
data.positions2DInto(destination);
CORRADE_COMPARE(out.str(),
"Trade::MeshData::positions2DInto(): expected a view with 3 elements but got 2\n");
}
template<class T> void MeshDataTest::positions3DAsArray() {
setTestCaseTemplateName(NameTraits<T>::name());
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
typedef typename T::Type U;
Containers::Array<char> vertexData{3*sizeof(T)};
auto positionsView = Containers::arrayCast<T>(vertexData);
/* Needs to be sufficiently representable to have the test work also for
half floats */
positionsView[0] = T::pad(Math::Vector3<U>{U(2.0f), U(1.0f), U(0.75f)});
positionsView[1] = T::pad(Math::Vector3<U>{U(0.0f), U(-1.0f), U(1.25f)});
positionsView[2] = T::pad(Math::Vector3<U>{U(-2.0f), U(3.0f), U(2.5f)});
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Position, positionsView}}};
CORRADE_COMPARE_AS(data.positions3DAsArray(), Containers::arrayView<Vector3>({
Vector3::pad(Math::Vector<T::Size, Float>::pad(Vector3{2.0f, 1.0f, 0.75f})),
Vector3::pad(Math::Vector<T::Size, Float>::pad(Vector3{0.0f, -1.0f, 1.25f})),
Vector3::pad(Math::Vector<T::Size, Float>::pad(Vector3{-2.0f, 3.0f, 2.5f}))
}), TestSuite::Compare::Container);
}
template<class T> void MeshDataTest::positions3DAsArrayPackedUnsigned() {
setTestCaseTemplateName(NameTraits<T>::name());
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::Array<char> vertexData{3*sizeof(T)};
auto positionsView = Containers::arrayCast<T>(vertexData);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
positionsView[0] = T::pad(Math::Vector3<typename T::Type>{2, 1, 135});
positionsView[1] = T::pad(Math::Vector3<typename T::Type>{0, 15, 2});
positionsView[2] = T::pad(Math::Vector3<typename T::Type>{22, 3, 192});
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Position, positionsView}}};
CORRADE_COMPARE_AS(data.positions3DAsArray(), Containers::arrayView<Vector3>({
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
Vector3::pad(Math::Vector<T::Size, Float>::pad(Vector3{2.0f, 1.0f, 135.0f})),
Vector3::pad(Math::Vector<T::Size, Float>::pad(Vector3{0.0f, 15.0f, 2.0f})),
Vector3::pad(Math::Vector<T::Size, Float>::pad(Vector3{22.0f, 3.0f, 192.0f}))
}), TestSuite::Compare::Container);
}
template<class T> void MeshDataTest::positions3DAsArrayPackedSigned() {
setTestCaseTemplateName(NameTraits<T>::name());
Containers::Array<char> vertexData{3*sizeof(T)};
auto positionsView = Containers::arrayCast<T>(vertexData);
positionsView[0] = T::pad(Math::Vector3<typename T::Type>{2, 1, -117});
positionsView[1] = T::pad(Math::Vector3<typename T::Type>{0, -15, 2});
positionsView[2] = T::pad(Math::Vector3<typename T::Type>{-22, 3, 86});
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Position, positionsView}}};
CORRADE_COMPARE_AS(data.positions3DAsArray(), Containers::arrayView<Vector3>({
Vector3::pad(Math::Vector<T::Size, Float>::pad(Vector3{2.0f, 1.0f, -117.0f})),
Vector3::pad(Math::Vector<T::Size, Float>::pad(Vector3{0.0f, -15.0f, 2.0f})),
Vector3::pad(Math::Vector<T::Size, Float>::pad(Vector3{-22.0f, 3.0f, 86.0f}))
}), TestSuite::Compare::Container);
}
template<class T> void MeshDataTest::positions3DAsArrayPackedUnsignedNormalized() {
setTestCaseTemplateName(NameTraits<T>::name());
Containers::Array<char> vertexData{2*sizeof(T)};
auto positionsView = Containers::arrayCast<T>(vertexData);
positionsView[0] = T::pad(Math::Vector3<typename T::Type>{Math::pack<typename T::Type>(1.0f), 0, Math::pack<typename T::Type>(1.0f)});
positionsView[1] = T::pad(Math::Vector3<typename T::Type>{0, Math::pack<typename T::Type>(1.0f), 0});
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Position,
/* Assuming the normalized enum is always after the non-normalized */
VertexFormat(UnsignedInt(Implementation::vertexFormatFor<T>()) + 1),
positionsView}}};
CORRADE_COMPARE_AS(data.positions3DAsArray(), Containers::arrayView<Vector3>({
Vector3::pad(Math::Vector<T::Size, Float>::pad(Vector3{1.0f, 0.0f, 1.0f})),
Vector3::pad(Math::Vector<T::Size, Float>::pad(Vector3{0.0f, 1.0f, 0.0f}))
}), TestSuite::Compare::Container);
}
template<class T> void MeshDataTest::positions3DAsArrayPackedSignedNormalized() {
setTestCaseTemplateName(NameTraits<T>::name());
Containers::Array<char> vertexData{2*sizeof(T)};
auto positionsView = Containers::arrayCast<T>(vertexData);
positionsView[0] = T::pad(Math::Vector3<typename T::Type>{Math::pack<typename T::Type>(1.0f), 0, Math::pack<typename T::Type>(1.0f)});
positionsView[1] = T::pad(Math::Vector3<typename T::Type>{0, Math::pack<typename T::Type>(-1.0f), 0});
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Position,
/* Assuming the normalized enum is always after the non-normalized */
VertexFormat(UnsignedInt(Implementation::vertexFormatFor<T>()) + 1),
positionsView}}};
CORRADE_COMPARE_AS(data.positions3DAsArray(), Containers::arrayView<Vector3>({
Vector3::pad(Math::Vector<T::Size, Float>::pad(Vector3{1.0f, 0.0f, 1.0f})),
Vector3::pad(Math::Vector<T::Size, Float>::pad(Vector3{0.0f, -1.0f, 0.0f}))
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}), TestSuite::Compare::Container);
}
void MeshDataTest::positions3DIntoArrayInvalidSize() {
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
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::Array<char> vertexData{3*sizeof(Vector3)};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Position, Containers::arrayCast<Vector3>(vertexData)}}};
std::ostringstream out;
Error redirectError{&out};
Vector3 destination[2];
data.positions3DInto(destination);
CORRADE_COMPARE(out.str(),
"Trade::MeshData::positions3DInto(): expected a view with 3 elements but got 2\n");
}
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
template<class T> void MeshDataTest::tangentsAsArray() {
setTestCaseTemplateName(NameTraits<T>::name());
typedef typename T::Type U;
Containers::Array<char> vertexData{3*sizeof(T)};
auto tangentView = Containers::arrayCast<T>(vertexData);
/* Needs to be sufficiently representable to have the test work also for
half floats */
Trade: fix tangent retrieval from four-component normalized types. By accident this code path was not tested, and of course it had a bug.
6 years ago
tangentView[0] = T::pad(Math::Vector3<U>{U(2.0f), U(1.0f), U(0.75f)});
tangentView[1] = T::pad(Math::Vector3<U>{U(0.0f), U(-1.0f), U(1.25f)});
tangentView[2] = T::pad(Math::Vector3<U>{U(-2.0f), U(3.0f), U(2.5f)});
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Tangent, tangentView}}};
CORRADE_COMPARE_AS(data.tangentsAsArray(), Containers::arrayView<Vector3>({
{2.0f, 1.0f, 0.75f}, {0.0f, -1.0f, 1.25f}, {-2.0f, 3.0f, 2.5f},
}), TestSuite::Compare::Container);
}
template<class T> void MeshDataTest::tangentsAsArrayPackedSignedNormalized() {
setTestCaseTemplateName(NameTraits<T>::name());
Trade: fix tangent retrieval from four-component normalized types. By accident this code path was not tested, and of course it had a bug.
6 years ago
typedef typename T::Type U;
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
Containers::Array<char> vertexData{2*sizeof(T)};
auto tangentsView = Containers::arrayCast<T>(vertexData);
Trade: fix tangent retrieval from four-component normalized types. By accident this code path was not tested, and of course it had a bug.
6 years ago
tangentsView[0] = T::pad(Math::Vector3<U>{Math::pack<U>(1.0f), 0, Math::pack<U>(1.0f)});
tangentsView[1] = T::pad(Math::Vector3<U>{0, Math::pack<U>(-1.0f), 0});
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Tangent,
/* Assuming the normalized enum is always after the non-normalized */
VertexFormat(UnsignedInt(Implementation::vertexFormatFor<T>()) + 1),
tangentsView}}};
CORRADE_COMPARE_AS(data.tangentsAsArray(), Containers::arrayView<Vector3>({
{1.0f, 0.0f, 1.0f}, {0.0f, -1.0f, 0.0f}
}), TestSuite::Compare::Container);
}
void MeshDataTest::tangentsIntoArrayInvalidSize() {
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
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
Containers::Array<char> vertexData{3*sizeof(Vector3)};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Tangent, Containers::arrayCast<Vector3>(vertexData)}}};
std::ostringstream out;
Error redirectError{&out};
Vector3 destination[2];
data.tangentsInto(destination);
CORRADE_COMPARE(out.str(),
"Trade::MeshData::tangentsInto(): expected a view with 3 elements but got 2\n");
}
template<class T> void MeshDataTest::bitangentSignsAsArray() {
setTestCaseTemplateName(Math::TypeTraits<T>::name());
Containers::Array<char> vertexData{3*sizeof(Math::Vector4<T>)};
auto tangentView = Containers::arrayCast<Math::Vector4<T>>(vertexData);
/* Needs to be sufficiently representable to have the test work also for
half floats */
tangentView[0] = {T(2.0f), T(1.0f), T(0.75f), T(-1.0f)};
tangentView[1] = {T(0.0f), T(-1.0f), T(1.25f), T(1.0f)};
tangentView[2] = {T(-2.0f), T(3.0f), T(2.5f), T(-1.0f)};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Tangent, tangentView}}};
CORRADE_COMPARE_AS(data.bitangentSignsAsArray(), Containers::arrayView<Float>({
-1.0f, 1.0f, -1.0f
}), TestSuite::Compare::Container);
}
template<class T> void MeshDataTest::bitangentSignsAsArrayPackedSignedNormalized() {
setTestCaseTemplateName(Math::TypeTraits<T>::name());
Containers::Array<char> vertexData{2*sizeof(Math::Vector4<T>)};
auto bitangentsView = Containers::arrayCast<Math::Vector4<T>>(vertexData);
bitangentsView[0] = {Math::pack<T>(1.0f), 0, Math::pack<T>(1.0f), Math::pack<T>(-1.0f)};
bitangentsView[1] = {0, Math::pack<T>(-1.0f), 0, Math::pack<T>(1.0f)};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Tangent,
/* Assuming the normalized enum is always after the non-normalized */
VertexFormat(UnsignedInt(Implementation::vertexFormatFor<Math::Vector4<T>>()) + 1),
bitangentsView}}};
CORRADE_COMPARE_AS(data.bitangentSignsAsArray(), Containers::arrayView<Float>({
-1.0f, 1.0f
}), TestSuite::Compare::Container);
}
void MeshDataTest::bitangentSignsAsArrayNotFourComponent() {
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
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
Containers::Array<char> vertexData{3*sizeof(Vector3s)};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Tangent, VertexFormat::Vector3sNormalized, Containers::arrayCast<Vector3s>(vertexData)}}};
std::ostringstream out;
Error redirectError{&out};
Float destination[3];
data.bitangentSignsInto(destination);
CORRADE_COMPARE(out.str(),
"Trade::MeshData::bitangentSignsInto(): expected four-component tangents, but got VertexFormat::Vector3sNormalized\n");
}
void MeshDataTest::bitangentSignsIntoArrayInvalidSize() {
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
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
Containers::Array<char> vertexData{3*sizeof(Vector4)};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Tangent, Containers::arrayCast<Vector4>(vertexData)}}};
std::ostringstream out;
Error redirectError{&out};
Float destination[2];
data.bitangentSignsInto(destination);
CORRADE_COMPARE(out.str(),
"Trade::MeshData::bitangentSignsInto(): expected a view with 3 elements but got 2\n");
}
template<class T> void MeshDataTest::bitangentsAsArray() {
setTestCaseTemplateName(NameTraits<T>::name());
typedef typename T::Type U;
Containers::Array<char> vertexData{3*sizeof(T)};
auto bitangentsView = Containers::arrayCast<T>(vertexData);
/* Needs to be sufficiently representable to have the test work also for
half floats */
bitangentsView[0] = {U(2.0f), U(1.0f), U(0.75f)};
bitangentsView[1] = {U(0.0f), U(-1.0f), U(1.25f)};
bitangentsView[2] = {U(-2.0f), U(3.0f), U(2.5f)};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Bitangent, bitangentsView}}};
CORRADE_COMPARE_AS(data.bitangentsAsArray(), Containers::arrayView<Vector3>({
{2.0f, 1.0f, 0.75f}, {0.0f, -1.0f, 1.25f}, {-2.0f, 3.0f, 2.5f},
}), TestSuite::Compare::Container);
}
template<class T> void MeshDataTest::bitangentsAsArrayPackedSignedNormalized() {
setTestCaseTemplateName(NameTraits<T>::name());
Containers::Array<char> vertexData{2*sizeof(T)};
auto bitangentsView = Containers::arrayCast<T>(vertexData);
bitangentsView[0] = {Math::pack<typename T::Type>(1.0f), 0, Math::pack<typename T::Type>(1.0f)};
bitangentsView[1] = {0, Math::pack<typename T::Type>(-1.0f), 0};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Bitangent,
/* Assuming the normalized enum is always after the non-normalized */
VertexFormat(UnsignedInt(Implementation::vertexFormatFor<T>()) + 1),
bitangentsView}}};
CORRADE_COMPARE_AS(data.bitangentsAsArray(), Containers::arrayView<Vector3>({
{1.0f, 0.0f, 1.0f}, {0.0f, -1.0f, 0.0f}
}), TestSuite::Compare::Container);
}
void MeshDataTest::bitangentsIntoArrayInvalidSize() {
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
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
Containers::Array<char> vertexData{3*sizeof(Vector3)};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Bitangent, Containers::arrayCast<Vector3>(vertexData)}}};
std::ostringstream out;
Error redirectError{&out};
Vector3 destination[2];
data.bitangentsInto(destination);
CORRADE_COMPARE(out.str(),
"Trade::MeshData::bitangentsInto(): expected a view with 3 elements but got 2\n");
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
template<class T> void MeshDataTest::normalsAsArray() {
setTestCaseTemplateName(NameTraits<T>::name());
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
typedef typename T::Type U;
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::Array<char> vertexData{3*sizeof(T)};
auto normalsView = Containers::arrayCast<T>(vertexData);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
/* Needs to be sufficiently representable to have the test work also for
half floats */
normalsView[0] = {U(2.0f), U(1.0f), U(0.75f)};
normalsView[1] = {U(0.0f), U(-1.0f), U(1.25f)};
normalsView[2] = {U(-2.0f), U(3.0f), U(2.5f)};
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Normal, normalsView}}};
CORRADE_COMPARE_AS(data.normalsAsArray(), Containers::arrayView<Vector3>({
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
{2.0f, 1.0f, 0.75f}, {0.0f, -1.0f, 1.25f}, {-2.0f, 3.0f, 2.5f},
}), TestSuite::Compare::Container);
}
template<class T> void MeshDataTest::normalsAsArrayPackedSignedNormalized() {
setTestCaseTemplateName(NameTraits<T>::name());
Containers::Array<char> vertexData{2*sizeof(T)};
auto normalsView = Containers::arrayCast<T>(vertexData);
normalsView[0] = {Math::pack<typename T::Type>(1.0f), 0, Math::pack<typename T::Type>(1.0f)};
normalsView[1] = {0, Math::pack<typename T::Type>(-1.0f), 0};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Normal,
/* Assuming the normalized enum is always after the non-normalized */
VertexFormat(UnsignedInt(Implementation::vertexFormatFor<T>()) + 1),
normalsView}}};
CORRADE_COMPARE_AS(data.normalsAsArray(), Containers::arrayView<Vector3>({
{1.0f, 0.0f, 1.0f}, {0.0f, -1.0f, 0.0f}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}), TestSuite::Compare::Container);
}
void MeshDataTest::normalsIntoArrayInvalidSize() {
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
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::Array<char> vertexData{3*sizeof(Vector3)};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Normal, Containers::arrayCast<Vector3>(vertexData)}}};
std::ostringstream out;
Error redirectError{&out};
Vector3 destination[2];
data.normalsInto(destination);
CORRADE_COMPARE(out.str(),
"Trade::MeshData::normalsInto(): expected a view with 3 elements but got 2\n");
}
template<class T> void MeshDataTest::textureCoordinates2DAsArray() {
setTestCaseTemplateName(NameTraits<T>::name());
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
typedef typename T::Type U;
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::Array<char> vertexData{3*sizeof(T)};
auto textureCoordinatesView = Containers::arrayCast<T>(vertexData);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
textureCoordinatesView[0] = {U(2.0f), U(1.0f)};
textureCoordinatesView[1] = {U(0.0f), U(-1.0f)};
textureCoordinatesView[2] = {U(-2.0f), U(3.0f)};
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::TextureCoordinates, textureCoordinatesView}}};
CORRADE_COMPARE_AS(data.textureCoordinates2DAsArray(), Containers::arrayView<Vector2>({
{2.0f, 1.0f}, {0.0f, -1.0f}, {-2.0f, 3.0f},
}), TestSuite::Compare::Container);
}
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
template<class T> void MeshDataTest::textureCoordinates2DAsArrayPackedUnsigned() {
setTestCaseTemplateName(NameTraits<T>::name());
Containers::Array<char> vertexData{3*sizeof(T)};
auto textureCoordinatesView = Containers::arrayCast<T>(vertexData);
textureCoordinatesView[0] = {2, 1};
textureCoordinatesView[1] = {0, 15};
textureCoordinatesView[2] = {22, 3};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::TextureCoordinates, textureCoordinatesView}}};
CORRADE_COMPARE_AS(data.textureCoordinates2DAsArray(),
Containers::arrayView<Vector2>({{2.0f, 1.0f}, {0.0f, 15.0f}, {22.0f, 3.0f}}),
TestSuite::Compare::Container);
}
template<class T> void MeshDataTest::textureCoordinates2DAsArrayPackedSigned() {
setTestCaseTemplateName(NameTraits<T>::name());
Containers::Array<char> vertexData{3*sizeof(T)};
auto textureCoordinatesView = Containers::arrayCast<T>(vertexData);
textureCoordinatesView[0] = {2, 1};
textureCoordinatesView[1] = {0, -15};
textureCoordinatesView[2] = {-22, 3};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::TextureCoordinates, textureCoordinatesView}}};
CORRADE_COMPARE_AS(data.textureCoordinates2DAsArray(),
Containers::arrayView<Vector2>({{2.0f, 1.0f}, {0.0f, -15.0f}, {-22.0f, 3.0f}}),
TestSuite::Compare::Container);
}
template<class T> void MeshDataTest::textureCoordinates2DAsArrayPackedUnsignedNormalized() {
setTestCaseTemplateName(NameTraits<T>::name());
Containers::Array<char> vertexData{2*sizeof(T)};
auto textureCoordinatesView = Containers::arrayCast<T>(vertexData);
textureCoordinatesView[0] = {Math::pack<typename T::Type>(1.0f), 0};
textureCoordinatesView[1] = {0, Math::pack<typename T::Type>(1.0f)};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::TextureCoordinates,
/* Assuming the normalized enum is always after the non-normalized */
VertexFormat(UnsignedInt(Implementation::vertexFormatFor<T>()) + 1),
textureCoordinatesView}}};
CORRADE_COMPARE_AS(data.textureCoordinates2DAsArray(),
Containers::arrayView<Vector2>({{1.0f, 0.0f}, {0.0f, 1.0f}}),
TestSuite::Compare::Container);
}
template<class T> void MeshDataTest::textureCoordinates2DAsArrayPackedSignedNormalized() {
setTestCaseTemplateName(NameTraits<T>::name());
Containers::Array<char> vertexData{2*sizeof(T)};
auto textureCoordinatesView = Containers::arrayCast<T>(vertexData);
textureCoordinatesView[0] = {Math::pack<typename T::Type>(1.0f), 0};
textureCoordinatesView[1] = {0, Math::pack<typename T::Type>(-1.0f)};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::TextureCoordinates,
/* Assuming the normalized enum is always after the non-normalized */
VertexFormat(UnsignedInt(Implementation::vertexFormatFor<T>()) + 1),
textureCoordinatesView}}};
CORRADE_COMPARE_AS(data.textureCoordinates2DAsArray(),
Containers::arrayView<Vector2>({{1.0f, 0.0f}, {0.0f, -1.0f}}),
TestSuite::Compare::Container);
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void MeshDataTest::textureCoordinates2DIntoArrayInvalidSize() {
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
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::Array<char> vertexData{3*sizeof(Vector2)};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::TextureCoordinates, Containers::arrayCast<Vector2>(vertexData)}}};
std::ostringstream out;
Error redirectError{&out};
Vector2 destination[2];
data.textureCoordinates2DInto(destination);
CORRADE_COMPARE(out.str(),
"Trade::MeshData::textureCoordinates2DInto(): expected a view with 3 elements but got 2\n");
}
template<class T> void MeshDataTest::colorsAsArray() {
setTestCaseTemplateName(NameTraits<T>::name());
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
typedef typename T::Type U;
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::Array<char> vertexData{3*sizeof(T)};
auto colorsView = Containers::arrayCast<T>(vertexData);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
/* Can't use e.g. 0xff3366_rgbf because that's not representable in
half-floats */
colorsView[0] = {U(2.0f), U(1.0f), U(0.75f)};
colorsView[1] = {U(0.0f), U(-1.0f), U(1.25f)};
colorsView[2] = {U(-2.0f), U(3.0f), U(2.5f)};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Color, colorsView}}};
CORRADE_COMPARE_AS(data.colorsAsArray(), Containers::arrayView<Color4>({
{2.0f, 1.0f, 0.75f}, {0.0f, -1.0f, 1.25f}, {-2.0f, 3.0f, 2.5f},
}), TestSuite::Compare::Container);
}
template<class T> void MeshDataTest::colorsAsArrayPackedUnsignedNormalized() {
setTestCaseTemplateName(NameTraits<T>::name());
Containers::Array<char> vertexData{2*sizeof(T)};
auto colorsView = Containers::arrayCast<T>(vertexData);
colorsView[0] = T::pad(Math::Color4<typename T::Type>{Math::pack<typename T::Type>(1.0f), 0, Math::pack<typename T::Type>(1.0f), 0});
colorsView[1] = T::pad(Math::Color4<typename T::Type>{0, Math::pack<typename T::Type>(1.0f), 0, Math::pack<typename T::Type>(1.0f)});
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Color, colorsView}}};
CORRADE_COMPARE_AS(data.colorsAsArray(), Containers::arrayView<Color4>({
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
Color4::pad(Math::Vector<T::Size, Float>::pad(Vector4{1.0f, 0.0f, 1.0f, 0.0f}), 1.0f),
Color4::pad(Math::Vector<T::Size, Float>::pad(Vector4{0.0f, 1.0f, 0.0f, 1.0f}), 1.0f)
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}), TestSuite::Compare::Container);
}
void MeshDataTest::colorsIntoArrayInvalidSize() {
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
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::Array<char> vertexData{3*sizeof(Color4)};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::Color, Containers::arrayCast<Color4>(vertexData)}}};
std::ostringstream out;
Error redirectError{&out};
Color4 destination[2];
data.colorsInto(destination);
CORRADE_COMPARE(out.str(),
"Trade::MeshData::colorsInto(): expected a view with 3 elements but got 2\n");
}
Trade: implement support for object IDs in MeshData.
6 years ago
template<class T> void MeshDataTest::objectIdsAsArray() {
setTestCaseTemplateName(Math::TypeTraits<T>::name());
Containers::Array<char> vertexData{3*sizeof(T)};
auto objectIdsView = Containers::arrayCast<T>(vertexData);
/* Can't use e.g. 0xff3366_rgbf because that's not representable in
half-floats */
objectIdsView[0] = {157};
objectIdsView[1] = {24};
objectIdsView[2] = {1};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::ObjectId, objectIdsView}}};
CORRADE_COMPARE_AS(data.objectIdsAsArray(), Containers::arrayView<UnsignedInt>({
157, 24, 1
}), TestSuite::Compare::Container);
}
void MeshDataTest::objectIdsIntoArrayInvalidSize() {
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
Trade: implement support for object IDs in MeshData.
6 years ago
Containers::Array<char> vertexData{3*sizeof(UnsignedInt)};
MeshData data{MeshPrimitive::Points, std::move(vertexData), {MeshAttributeData{MeshAttribute::ObjectId, Containers::arrayCast<UnsignedInt>(vertexData)}}};
std::ostringstream out;
Error redirectError{&out};
UnsignedInt destination[2];
data.objectIdsInto(destination);
CORRADE_COMPARE(out.str(),
"Trade::MeshData::objectIdsInto(): expected a view with 3 elements but got 2\n");
}
Trade: various MSVC workarounds.
6 years ago
/* MSVC 2015 doesn't like anonymous bitfields in inline structs, so putting the
declaration outside */
struct VertexWithImplementationSpecificData {
Long:64;
long double thing;
};
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
void MeshDataTest::implementationSpecificVertexFormat() {
Trade: various MSVC workarounds.
6 years ago
VertexWithImplementationSpecificData vertexData[] {
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
{456.0l},
{456.0l}
};
/* Constructing should work w/o asserts */
Containers::StridedArrayView1D<long double> attribute{vertexData,
Trade: various MSVC workarounds.
6 years ago
&vertexData[0].thing, 2, sizeof(VertexWithImplementationSpecificData)};
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
MeshData data{MeshPrimitive::TriangleFan, DataFlag::Mutable, vertexData, {
MeshAttributeData{MeshAttribute::Position,
vertexFormatWrap(0xdead1), attribute},
MeshAttributeData{MeshAttribute::Normal,
vertexFormatWrap(0xdead2), attribute},
MeshAttributeData{MeshAttribute::TextureCoordinates,
vertexFormatWrap(0xdead3), attribute},
MeshAttributeData{MeshAttribute::Color,
vertexFormatWrap(0xdead4), attribute}}};
/* Getting typeless attribute should work also */
UnsignedInt format = 0xdead1;
for(MeshAttribute name: {MeshAttribute::Position,
MeshAttribute::Normal,
MeshAttribute::TextureCoordinates,
MeshAttribute::Color}) {
CORRADE_ITERATION(name);
CORRADE_COMPARE(data.attributeFormat(name), vertexFormatWrap(format++));
/* The actual type size is unknown, so this will use the full stride */
Trade: various MSVC workarounds.
6 years ago
CORRADE_COMPARE(data.attribute(name).size()[1], sizeof(VertexWithImplementationSpecificData));
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
CORRADE_COMPARE_AS((Containers::arrayCast<1, const long double>(
data.attribute(name).prefix({2, sizeof(long double)}))),
attribute, TestSuite::Compare::Container);
CORRADE_COMPARE_AS((Containers::arrayCast<1, const long double>(
data.mutableAttribute(name).prefix({2, sizeof(long double)}))),
attribute, TestSuite::Compare::Container);
}
}
void MeshDataTest::implementationSpecificVertexFormatWrongAccess() {
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
Trade: various MSVC workarounds.
6 years ago
VertexWithImplementationSpecificData vertexData[] {
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
{456.0l},
{456.0l}
};
Containers::StridedArrayView1D<long double> attribute{vertexData,
Trade: various MSVC workarounds.
6 years ago
&vertexData[0].thing, 2, sizeof(VertexWithImplementationSpecificData)};
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
MeshData data{MeshPrimitive::TriangleFan, DataFlag::Mutable, vertexData, {
MeshAttributeData{MeshAttribute::Position,
vertexFormatWrap(0xdead1), attribute},
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
MeshAttributeData{MeshAttribute::Tangent,
vertexFormatWrap(0xdead2), attribute},
MeshAttributeData{MeshAttribute::Bitangent,
vertexFormatWrap(0xdead2), attribute},
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
MeshAttributeData{MeshAttribute::Normal,
vertexFormatWrap(0xdead2), attribute},
MeshAttributeData{MeshAttribute::TextureCoordinates,
vertexFormatWrap(0xdead3), attribute},
MeshAttributeData{MeshAttribute::Color,
Trade: implement support for object IDs in MeshData.
6 years ago
vertexFormatWrap(0xdead4), attribute},
MeshAttributeData{MeshAttribute::ObjectId,
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
vertexFormatWrap(0xdead4), attribute}}};
std::ostringstream out;
Error redirectError{&out};
data.attribute<Float>(MeshAttribute::Position);
data.attribute<Float>(MeshAttribute::Normal);
data.attribute<Float>(MeshAttribute::TextureCoordinates);
data.attribute<Float>(MeshAttribute::Color);
data.mutableAttribute<Float>(MeshAttribute::Position);
data.mutableAttribute<Float>(MeshAttribute::Normal);
data.mutableAttribute<Float>(MeshAttribute::TextureCoordinates);
data.mutableAttribute<Float>(MeshAttribute::Color);
data.positions2DAsArray();
data.positions3DAsArray();
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
data.tangentsAsArray();
data.bitangentSignsAsArray();
data.bitangentsAsArray();
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
data.normalsAsArray();
data.textureCoordinates2DAsArray();
data.colorsAsArray();
Trade: implement support for object IDs in MeshData.
6 years ago
data.objectIdsAsArray();
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
CORRADE_COMPARE(out.str(),
"Trade::MeshData::attribute(): can't cast data from an implementation-specific vertex format 0xdead1\n"
"Trade::MeshData::attribute(): can't cast data from an implementation-specific vertex format 0xdead2\n"
"Trade::MeshData::attribute(): can't cast data from an implementation-specific vertex format 0xdead3\n"
"Trade::MeshData::attribute(): can't cast data from an implementation-specific vertex format 0xdead4\n"
"Trade::MeshData::mutableAttribute(): can't cast data from an implementation-specific vertex format 0xdead1\n"
"Trade::MeshData::mutableAttribute(): can't cast data from an implementation-specific vertex format 0xdead2\n"
"Trade::MeshData::mutableAttribute(): can't cast data from an implementation-specific vertex format 0xdead3\n"
"Trade::MeshData::mutableAttribute(): can't cast data from an implementation-specific vertex format 0xdead4\n"
"Trade::MeshData::positions2DInto(): can't extract data out of an implementation-specific vertex format 0xdead1\n"
"Trade::MeshData::positions3DInto(): can't extract data out of an implementation-specific vertex format 0xdead1\n"
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
"Trade::MeshData::tangentsInto(): can't extract data out of an implementation-specific vertex format 0xdead2\n"
"Trade::MeshData::bitangentSignsInto(): can't extract data out of an implementation-specific vertex format 0xdead2\n"
"Trade::MeshData::bitangentsInto(): can't extract data out of an implementation-specific vertex format 0xdead2\n"
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
"Trade::MeshData::normalsInto(): can't extract data out of an implementation-specific vertex format 0xdead2\n"
"Trade::MeshData::textureCoordinatesInto(): can't extract data out of an implementation-specific vertex format 0xdead3\n"
Trade: implement support for object IDs in MeshData.
6 years ago
"Trade::MeshData::colorsInto(): can't extract data out of an implementation-specific vertex format 0xdead4\n"
"Trade::MeshData::objectIdsInto(): can't extract data out of an implementation-specific vertex format 0xdead4\n");
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
}
void MeshDataTest::implementationSpecificVertexFormatNotContained() {
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
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
Containers::Array<char> vertexData{reinterpret_cast<char*>(0xbadda9), 3, [](char*, std::size_t){}};
Containers::ArrayView<char> vertexData2{reinterpret_cast<char*>(0xdead), 3};
MeshAttributeData positions{MeshAttribute::Position, vertexFormatWrap(0x3a), vertexData};
MeshAttributeData positions2{MeshAttribute::Position, vertexFormatWrap(0x3a), vertexData2};
std::ostringstream out;
Error redirectError{&out};
MeshData{MeshPrimitive::Triangles, std::move(vertexData), {positions, positions2}};
CORRADE_COMPARE(out.str(),
/* Assumes size of the type is 0, so the diagnostic is different from
constructAttributeNotContained() */
"Trade::MeshData: attribute 1 [0xdead:0xdeaf] is not contained in passed vertexData array [0xbadda9:0xbaddac]\n");
}
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
void MeshDataTest::arrayAttribute() {
Vector2 vertexData[3*4]{
{1.0f, 2.0f}, {3.0f, 4.0f}, {5.0f, 6.0f}, {7.0f, 8.0f},
{1.1f, 2.2f}, {3.3f, 4.4f}, {5.5f, 6.6f}, {7.7f, 8.8f},
{0.1f, 0.2f}, {0.3f, 0.4f}, {0.5f, 0.6f}, {0.7f, 0.8f},
};
Containers::StridedArrayView2D<Vector2> positions2D{vertexData, {3, 4}};
MeshData data{MeshPrimitive::TriangleFan, DataFlag::Mutable, vertexData, {
MeshAttributeData{meshAttributeCustom(35), positions2D}
}};
CORRADE_COMPARE(data.vertexCount(), 3);
CORRADE_COMPARE(data.attributeArraySize(meshAttributeCustom(35)), 4);
/* Raw access is "as usual" */
auto attribute = Containers::arrayCast<2, const Vector2>(data.attribute(0));
auto attributeByName = Containers::arrayCast<2, const Vector2>(data.attribute(meshAttributeCustom(35)));
auto mutableAttribute = Containers::arrayCast<2, Vector2>(data.mutableAttribute(0));
auto mutableAttributeByName = Containers::arrayCast<2, Vector2>(data.mutableAttribute(meshAttributeCustom(35)));
CORRADE_COMPARE(attribute.size()[0], 3);
CORRADE_COMPARE(attributeByName.size()[0], 3);
CORRADE_COMPARE(mutableAttribute.size()[0], 3);
CORRADE_COMPARE(mutableAttributeByName.size()[0], 3);
for(std::size_t i = 0; i != 3; ++i) {
CORRADE_ITERATION(i);
CORRADE_COMPARE_AS(attribute[i], positions2D[i],
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(attributeByName[i], positions2D[i],
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(mutableAttribute[i], positions2D[i],
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(mutableAttributeByName[i], positions2D[i],
TestSuite::Compare::Container);
}
/* Typed access */
attribute = data.attribute<Vector2[]>(0);
attributeByName = data.attribute<Vector2[]>(meshAttributeCustom(35));
mutableAttribute = data.mutableAttribute<Vector2[]>(0);
mutableAttributeByName = data.mutableAttribute<Vector2[]>(meshAttributeCustom(35));
CORRADE_COMPARE(attribute.size()[0], 3);
CORRADE_COMPARE(attributeByName.size()[0], 3);
CORRADE_COMPARE(mutableAttribute.size()[0], 3);
CORRADE_COMPARE(mutableAttributeByName.size()[0], 3);
for(std::size_t i = 0; i != 3; ++i) {
CORRADE_ITERATION(i);
CORRADE_COMPARE_AS(attribute[i], positions2D[i],
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(attributeByName[i], positions2D[i],
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(mutableAttribute[i], positions2D[i],
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(mutableAttributeByName[i], positions2D[i],
TestSuite::Compare::Container);
}
}
void MeshDataTest::arrayAttributeWrongAccess() {
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
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
Vector2 vertexData[3*4]{
{1.0f, 2.0f}, {3.0f, 4.0f}, {5.0f, 6.0f}, {7.0f, 8.0f},
{1.1f, 2.2f}, {3.3f, 4.4f}, {5.5f, 6.6f}, {7.7f, 8.8f},
{0.1f, 0.2f}, {0.3f, 0.4f}, {0.5f, 0.6f}, {0.7f, 0.8f},
};
Containers::StridedArrayView1D<Vector2> positions{vertexData, 3, 4*sizeof(Vector2)};
Containers::StridedArrayView2D<Vector2> positions2D{vertexData, {3, 4}};
MeshData data{MeshPrimitive::TriangleFan, DataFlag::Mutable, vertexData, {
MeshAttributeData{MeshAttribute::Position, positions},
MeshAttributeData{meshAttributeCustom(35), positions2D}
}};
std::ostringstream out;
Error redirectError{&out};
data.attribute<Vector2[]>(0);
data.attribute<Vector2>(1);
data.mutableAttribute<Vector2[]>(0);
data.mutableAttribute<Vector2>(1);
data.attribute<Vector2[]>(MeshAttribute::Position);
data.attribute<Vector2>(meshAttributeCustom(35));
data.mutableAttribute<Vector2[]>(MeshAttribute::Position);
data.mutableAttribute<Vector2>(meshAttributeCustom(35));
CORRADE_COMPARE(out.str(),
"Trade::MeshData::attribute(): use T[] to access an array attribute\n"
"Trade::MeshData::attribute(): use T[] to access an array attribute\n"
"Trade::MeshData::mutableAttribute(): use T[] to access an array attribute\n"
"Trade::MeshData::mutableAttribute(): use T[] to access an array attribute\n"
"Trade::MeshData::attribute(): use T[] to access an array attribute\n"
"Trade::MeshData::attribute(): use T[] to access an array attribute\n"
"Trade::MeshData::mutableAttribute(): use T[] to access an array attribute\n"
"Trade::MeshData::mutableAttribute(): use T[] to access an array attribute\n");
}
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
void MeshDataTest::mutableAccessNotAllowed() {
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
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
const UnsignedShort indexData[]{0, 1, 0};
const Vector2 vertexData[]{{0.1f, 0.2f}, {0.4f, 0.5f}};
MeshIndexData indices{indexData};
MeshAttributeData positions{MeshAttribute::Position, Containers::arrayView(vertexData)};
MeshData data{MeshPrimitive::Triangles, {}, indexData, indices, {}, vertexData, {positions}};
CORRADE_COMPARE(data.indexDataFlags(), DataFlags{});
CORRADE_COMPARE(data.vertexDataFlags(), DataFlags{});
std::ostringstream out;
Error redirectError{&out};
data.mutableIndexData();
data.mutableVertexData();
Trade: typeless access to MeshData indices. Like with attributes, it returns a 2D strided view with the second dimension having the same size as the index type.
6 years ago
data.mutableIndices();
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
data.mutableIndices<UnsignedShort>();
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
data.mutableAttribute(0);
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
data.mutableAttribute<Vector2>(0);
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
data.mutableAttribute(MeshAttribute::Position);
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
data.mutableAttribute<Vector2>(MeshAttribute::Position);
CORRADE_COMPARE(out.str(),
"Trade::MeshData::mutableIndexData(): index data not mutable\n"
"Trade::MeshData::mutableVertexData(): vertex data not mutable\n"
"Trade::MeshData::mutableIndices(): index data not mutable\n"
Trade: typeless access to MeshData indices. Like with attributes, it returns a 2D strided view with the second dimension having the same size as the index type.
6 years ago
"Trade::MeshData::mutableIndices(): index data not mutable\n"
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
"Trade::MeshData::mutableAttribute(): vertex data not mutable\n"
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
"Trade::MeshData::mutableAttribute(): vertex data not mutable\n"
"Trade::MeshData::mutableAttribute(): vertex data not mutable\n"
Trade: implement mutable data access in MeshData. Turns out the design wasn't so simple after all. AnimationData and ImageData classes will follow with similar changes.
7 years ago
"Trade::MeshData::mutableAttribute(): vertex data not mutable\n");
}
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
void MeshDataTest::indicesNotIndexed() {
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
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
MeshData data{MeshPrimitive::Triangles, 37};
std::ostringstream out;
Error redirectError{&out};
data.indexCount();
data.indexType();
Trade: add a convenience MeshData::indexOffset() getter.
6 years ago
data.indexOffset();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
data.indices<UnsignedInt>();
Trade: make creation of non-owning MeshData references easier. While 27f6cc309d4636adb0f65e559de8e5cc109483cb made it easier to create references to attribute-less meshes by avoiding a branch on attributeCount() (and then using a constructor with explicit vertex count), code still had to branch on isIndexed() because indices() could be called only on indexed meshes. This change allows code like Trade::MeshData reference{data.primitive(), {}, data.indexData(), Trade::MeshIndexData{data.indices()}, {}, data.vertexData(), Trade::meshAttributeDataNonOwningArray(data.attributeData()), data.vertexCount()}; which works correctly for all cases and doesn't introduce extra branches and code paths that would need to be tested. While definitely better, I might still give up at some point and introduce some Trade::MeshData::nonOwningImmutableReference() helper for this.
6 years ago
data.mutableIndices<UnsignedShort>();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
data.indicesAsArray();
UnsignedInt a[1];
data.indicesInto(a);
CORRADE_COMPARE(out.str(),
"Trade::MeshData::indexCount(): the mesh is not indexed\n"
"Trade::MeshData::indexType(): the mesh is not indexed\n"
Trade: add a convenience MeshData::indexOffset() getter.
6 years ago
"Trade::MeshData::indexOffset(): the mesh is not indexed\n"
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
"Trade::MeshData::indices(): the mesh is not indexed\n"
Trade: make creation of non-owning MeshData references easier. While 27f6cc309d4636adb0f65e559de8e5cc109483cb made it easier to create references to attribute-less meshes by avoiding a branch on attributeCount() (and then using a constructor with explicit vertex count), code still had to branch on isIndexed() because indices() could be called only on indexed meshes. This change allows code like Trade::MeshData reference{data.primitive(), {}, data.indexData(), Trade::MeshIndexData{data.indices()}, {}, data.vertexData(), Trade::meshAttributeDataNonOwningArray(data.attributeData()), data.vertexCount()}; which works correctly for all cases and doesn't introduce extra branches and code paths that would need to be tested. While definitely better, I might still give up at some point and introduce some Trade::MeshData::nonOwningImmutableReference() helper for this.
6 years ago
"Trade::MeshData::mutableIndices(): the mesh is not indexed\n"
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
"Trade::MeshData::indicesAsArray(): the mesh is not indexed\n"
"Trade::MeshData::indicesInto(): the mesh is not indexed\n");
}
void MeshDataTest::indicesWrongType() {
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
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::Array<char> indexData{sizeof(UnsignedShort)};
auto indexView = Containers::arrayCast<UnsignedShort>(indexData);
indexView[0] = 57616;
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData data{MeshPrimitive::Points, std::move(indexData), MeshIndexData{indexView}, 57617};
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
std::ostringstream out;
Error redirectError{&out};
data.indices<UnsignedByte>();
CORRADE_COMPARE(out.str(), "Trade::MeshData::indices(): improper type requested for MeshIndexType::UnsignedShort\n");
}
void MeshDataTest::attributeNotFound() {
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
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
MeshAttributeData colors1{MeshAttribute::Color, VertexFormat::Vector3, nullptr};
MeshAttributeData colors2{MeshAttribute::Color, VertexFormat::Vector4, nullptr};
MeshData data{MeshPrimitive::Points, nullptr, {colors1, colors2}};
std::ostringstream out;
Error redirectError{&out};
data.attributeName(2);
data.attributeFormat(2);
data.attributeOffset(2);
data.attributeStride(2);
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
data.attributeArraySize(2);
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
data.attribute(2);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
data.attribute<Vector2>(2);
Trade: added MeshData::attributeId(). Useful for quick localization of named attribs when dealing with attributeData() (for example in MeshTools).
6 years ago
data.attributeId(MeshAttribute::Position);
data.attributeId(MeshAttribute::Color, 2);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
data.attributeFormat(MeshAttribute::Position);
data.attributeFormat(MeshAttribute::Color, 2);
data.attributeOffset(MeshAttribute::Position);
data.attributeOffset(MeshAttribute::Color, 2);
data.attributeStride(MeshAttribute::Position);
data.attributeStride(MeshAttribute::Color, 2);
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
data.attributeArraySize(MeshAttribute::Position);
data.attributeArraySize(MeshAttribute::Color, 2);
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
data.attribute(MeshAttribute::Position);
data.attribute(MeshAttribute::Color, 2);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
data.attribute<Vector2>(MeshAttribute::Position);
data.attribute<Vector2>(MeshAttribute::Color, 2);
data.positions2DAsArray();
data.positions3DAsArray();
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
data.tangentsAsArray();
data.bitangentSignsAsArray();
data.bitangentsAsArray();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
data.normalsAsArray();
data.textureCoordinates2DAsArray();
data.colorsAsArray(2);
Trade: implement support for object IDs in MeshData.
6 years ago
data.objectIdsAsArray();
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(out.str(),
"Trade::MeshData::attributeName(): index 2 out of range for 2 attributes\n"
"Trade::MeshData::attributeFormat(): index 2 out of range for 2 attributes\n"
"Trade::MeshData::attributeOffset(): index 2 out of range for 2 attributes\n"
"Trade::MeshData::attributeStride(): index 2 out of range for 2 attributes\n"
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
"Trade::MeshData::attributeArraySize(): index 2 out of range for 2 attributes\n"
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
"Trade::MeshData::attribute(): index 2 out of range for 2 attributes\n"
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
"Trade::MeshData::attribute(): index 2 out of range for 2 attributes\n"
Trade: added MeshData::attributeId(). Useful for quick localization of named attribs when dealing with attributeData() (for example in MeshTools).
6 years ago
"Trade::MeshData::attributeId(): index 0 out of range for 0 Trade::MeshAttribute::Position attributes\n"
"Trade::MeshData::attributeId(): index 2 out of range for 2 Trade::MeshAttribute::Color attributes\n"
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
"Trade::MeshData::attributeFormat(): index 0 out of range for 0 Trade::MeshAttribute::Position attributes\n"
"Trade::MeshData::attributeFormat(): index 2 out of range for 2 Trade::MeshAttribute::Color attributes\n"
"Trade::MeshData::attributeOffset(): index 0 out of range for 0 Trade::MeshAttribute::Position attributes\n"
"Trade::MeshData::attributeOffset(): index 2 out of range for 2 Trade::MeshAttribute::Color attributes\n"
"Trade::MeshData::attributeStride(): index 0 out of range for 0 Trade::MeshAttribute::Position attributes\n"
"Trade::MeshData::attributeStride(): index 2 out of range for 2 Trade::MeshAttribute::Color attributes\n"
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
"Trade::MeshData::attributeArraySize(): index 0 out of range for 0 Trade::MeshAttribute::Position attributes\n"
"Trade::MeshData::attributeArraySize(): index 2 out of range for 2 Trade::MeshAttribute::Color attributes\n"
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
"Trade::MeshData::attribute(): index 0 out of range for 0 Trade::MeshAttribute::Position attributes\n"
"Trade::MeshData::attribute(): index 2 out of range for 2 Trade::MeshAttribute::Color attributes\n"
Trade: typeless access to MeshData attributes. Similarly to ImageData::pixels() which return a strided array view of one dimension more.
6 years ago
"Trade::MeshData::attribute(): index 0 out of range for 0 Trade::MeshAttribute::Position attributes\n"
"Trade::MeshData::attribute(): index 2 out of range for 2 Trade::MeshAttribute::Color attributes\n"
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
"Trade::MeshData::positions2DInto(): index 0 out of range for 0 position attributes\n"
"Trade::MeshData::positions3DInto(): index 0 out of range for 0 position attributes\n"
Trade: implement support for tangents and bitangents in MeshData. Originally wanted to offload this to someone else, but then realized I need those for generic vertex attribute definitions, which I need for instancing, which I need now. So here it is, at the bottom of the dependency chain.
6 years ago
"Trade::MeshData::tangentsInto(): index 0 out of range for 0 tangent attributes\n"
"Trade::MeshData::bitangentSignsInto(): index 0 out of range for 0 tangent attributes\n"
"Trade::MeshData::bitangentsInto(): index 0 out of range for 0 bitangent attributes\n"
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
"Trade::MeshData::normalsInto(): index 0 out of range for 0 normal attributes\n"
"Trade::MeshData::textureCoordinates2DInto(): index 0 out of range for 0 texture coordinate attributes\n"
Trade: implement support for object IDs in MeshData.
6 years ago
"Trade::MeshData::colorsInto(): index 2 out of range for 2 color attributes\n"
"Trade::MeshData::objectIdsInto(): index 0 out of range for 0 object ID attributes\n");
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
void MeshDataTest::attributeWrongType() {
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
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
MeshAttributeData positions{MeshAttribute::Position, VertexFormat::Vector3, nullptr};
MeshData data{MeshPrimitive::Points, nullptr, {positions}};
std::ostringstream out;
Error redirectError{&out};
data.attribute<Vector4>(MeshAttribute::Position);
CORRADE_COMPARE(out.str(), "Trade::MeshData::attribute(): improper type requested for Trade::MeshAttribute::Position of format VertexFormat::Vector3\n");
}
void MeshDataTest::releaseIndexData() {
Trade: make MeshData::release*() less brutal, add releaseAttributeData(). It only resets count of released thing to zero, not going all nuclear. Otherwise it wouldn't be possible to release attribute data and then vertex data as releasing one would wipe the other.
6 years ago
Containers::Array<char> indexData{23};
auto indexView = Containers::arrayCast<UnsignedShort>(indexData.slice(6, 12));
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Trade: allow specifying explicit vertex count on MeshData construction. Until now, except for an attribute-less index-less mesh, the vertex count was only implicitly taken from passed attributes, but it was severely limiting: - There was no way to set vertex count for an attribute-less indexed mesh, which didn't make sense - All code that made non-owning MeshData instances referencing another MeshData had to explicitly handle the attribute-less corner case to avoid vertex count getting lost - Offset-only attributes couldn't be used to specify static layout of meshes with dynamic vertex count, causing unnecessary extra allocations especially in the Primitives library.
6 years ago
MeshData data{MeshPrimitive::TriangleStrip, std::move(indexData), MeshIndexData{indexView}, 10};
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_VERIFY(data.isIndexed());
Trade: make MeshData::release*() less brutal, add releaseAttributeData(). It only resets count of released thing to zero, not going all nuclear. Otherwise it wouldn't be possible to release attribute data and then vertex data as releasing one would wipe the other.
6 years ago
CORRADE_COMPARE(data.indexCount(), 3);
CORRADE_COMPARE(data.indexOffset(), 6);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::Array<char> released = data.releaseIndexData();
Trade: make MeshData::release*() less brutal, add releaseAttributeData(). It only resets count of released thing to zero, not going all nuclear. Otherwise it wouldn't be possible to release attribute data and then vertex data as releasing one would wipe the other.
6 years ago
CORRADE_COMPARE(static_cast<void*>(released.data() + 6), indexView.data());
/* This is not null as we still need the value for calculating offsets */
CORRADE_COMPARE(static_cast<const void*>(data.indexData()), released.data());
CORRADE_COMPARE(data.indexData().size(), 0);
CORRADE_VERIFY(data.isIndexed());
CORRADE_COMPARE(data.indexCount(), 0);
CORRADE_COMPARE(data.indexType(), MeshIndexType::UnsignedShort);
CORRADE_COMPARE(data.indexOffset(), 6);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
Trade: make MeshData::release*() less brutal, add releaseAttributeData(). It only resets count of released thing to zero, not going all nuclear. Otherwise it wouldn't be possible to release attribute data and then vertex data as releasing one would wipe the other.
6 years ago
void MeshDataTest::releaseAttributeData() {
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
Containers::Array<char> vertexData{16};
auto vertexView = Containers::arrayCast<Vector2>(vertexData);
MeshAttributeData positions{MeshAttribute::Position, vertexView};
MeshData data{MeshPrimitive::LineLoop, std::move(vertexData), {positions, positions}};
CORRADE_COMPARE(data.attributeCount(), 2);
Trade: make MeshData::release*() less brutal, add releaseAttributeData(). It only resets count of released thing to zero, not going all nuclear. Otherwise it wouldn't be possible to release attribute data and then vertex data as releasing one would wipe the other.
6 years ago
Containers::Array<MeshAttributeData> released = data.releaseAttributeData();
CORRADE_COMPARE(released.size(), 2);
CORRADE_COMPARE(static_cast<const void*>(released[0].data().data()), vertexView.data());
CORRADE_COMPARE(released[0].data().size(), 2);
/* Unlike the other two, this is null as we don't need the value for
calculating anything */
CORRADE_COMPARE(static_cast<const void*>(data.attributeData()), nullptr);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
CORRADE_COMPARE(data.attributeCount(), 0);
Trade: make MeshData::release*() less brutal, add releaseAttributeData(). It only resets count of released thing to zero, not going all nuclear. Otherwise it wouldn't be possible to release attribute data and then vertex data as releasing one would wipe the other.
6 years ago
CORRADE_COMPARE(static_cast<const void*>(data.vertexData()), vertexView);
CORRADE_COMPARE(data.vertexCount(), 2);
}
void MeshDataTest::releaseVertexData() {
Containers::Array<char> vertexData{80};
auto vertexView = Containers::arrayCast<Vector2>(vertexData.slice(48, 72));
MeshAttributeData positions{MeshAttribute::Position, vertexView};
MeshData data{MeshPrimitive::LineLoop, std::move(vertexData), {positions, positions}};
CORRADE_COMPARE(data.attributeCount(), 2);
CORRADE_COMPARE(data.vertexCount(), 3);
CORRADE_COMPARE(data.attributeOffset(0), 48);
Containers::Array<char> released = data.releaseVertexData();
CORRADE_VERIFY(data.attributeData());
CORRADE_COMPARE(data.attributeCount(), 2);
CORRADE_COMPARE(static_cast<const void*>(static_cast<const char*>(data.attribute(0).data())), vertexView.data());
CORRADE_COMPARE(static_cast<const void*>(static_cast<const char*>(data.mutableAttribute(0).data())), vertexView.data());
/* Returned views should be patched to have zero size (but not the direct
access, there it stays as it's an internal API really) */
CORRADE_COMPARE(data.attribute(0).size()[0], 0);
CORRADE_COMPARE(data.mutableAttribute(0).size()[0], 0);
CORRADE_COMPARE(data.attributeData()[0].data().size(), 3);
CORRADE_COMPARE(static_cast<void*>(released.data() + 48), vertexView.data());
/* This is not null as we still need the value for calculating offsets */
CORRADE_COMPARE(static_cast<const void*>(data.vertexData()), released.data());
CORRADE_COMPARE(data.vertexCount(), 0);
CORRADE_COMPARE(data.attributeOffset(0), 48);
Trade: a reworked MeshData class. With API analogous to the (relatively) new AnimationData -- with one buffer containing all index data and one buffer containing all vertex data, both meant to be uploaded as-is to the GPU. This will eventually replace MeshData2D and MeshData3D, backwards compatibility and wiring up to other APIs will be done in follow-up commits.
7 years ago
}
}}}}
CORRADE_TEST_MAIN(Magnum::Trade::Test::MeshDataTest)