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

4066 lines
190 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.
Updated copyright year.
6 years ago
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019,
Updated copyright year.
4 years ago
2020, 2021, 2022 Vladimír Vondruš <mosra@centrum.cz>
doc: updated credits and changelog.
4 years ago
Copyright © 2020 Jonathan Hale <squareys@googlemail.com>
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
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>
Trade: add MeshData::findAttributeId().
4 years ago
#include <Corrade/Containers/Optional.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 <Corrade/TestSuite/Tester.h>
#include <Corrade/TestSuite/Compare/Container.h>
Trade: support zero and negative strides in mesh attribute data. This is not something the classic GPU vertex pipeline can handle (except maybe Vulkan, which can handle zero strides for instanced attributes?), but useful for other scenarios. This means existing code needs to be aware of and handle the new corner case.
4 years ago
#include <Corrade/Utility/Algorithms.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 <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();
Packed debug output for enums used by Trade. Again not publicly documented because I don't like the naming and I don't have the full behavior and interactions figured out yet -- i.e., an array of VertexFormats would be printed with Debug::packed as a long string of characters without any whitespace. Not good, thus this feature probably needs to be split in two, with this being named "compact" or something else.
4 years ago
void debugAttributeNamePacked();
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 strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
void constructIndexContiguous();
void constructIndexStrided();
void constructIndexStridedWrongStride();
void constructIndexTypeErasedContiguous();
Trade: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
void constructIndexTypeErasedContiguousImplementationSpecificFormat();
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
void constructIndexTypeErasedContiguousWrongSize();
void constructIndexTypeErasedStrided();
Trade: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
void constructIndexTypeErasedStridedImplementationSpecificFormat();
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
void constructIndexTypeErasedStridedWrongStride();
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();
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
void constructIndex2DWrongStride();
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 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();
Trade: accidentally missed a test for empty MeshAttributeData.
6 years ago
void constructAttributeDefault();
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 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: implement support for Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
void constructAttributeOnlyArrayAllowed();
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();
Trade: allow array attributes to have implementation-specific formats. I'm not sure why this restriction was there as nothing was preventing them from being used. The attribute is only accessible through the typeless attribute(), which gives back `Containers::StridedArrayView2D<const char>` with second dimension size being set to the full stride. And there it doesn't matter if the format is an array or not. This will be useful for joint IDs and weights, for example doing crazy things like packing the IDs into an array of 8 4-bit numbers, saving half the memory compared to the smallest builtin representation using UnsignedByte[8].
4 years ago
void constructArrayAttributeImplementationSpecificFormat();
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
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: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
void constructImplementationSpecificIndexType();
Trade: move MeshData impl-specific vert format tests closer to the rest. Because this way I wasn't even aware these got tested and so I didn't extend them for zero/negative strides. Now they got proper treatment.
4 years ago
void constructImplementationSpecificVertexFormat();
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
void constructSpecialIndexStrides();
Trade: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
void constructSpecialIndexStridesImplementationSpecificIndexType();
Trade: support zero and negative strides in mesh attribute data. This is not something the classic GPU vertex pipeline can handle (except maybe Vulkan, which can handle zero strides for instanced attributes?), but useful for other scenarios. This means existing code needs to be aware of and handle the new corner case.
4 years ago
void constructSpecialAttributeStrides();
void constructSpecialAttributeStridesImplementationSpecificVertexFormat();
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 support for Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
void constructDifferentJointIdWeightCount();
void constructInconsistentJointIdWeightArraySizes();
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 Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
template<class T> void jointIdsAsArray();
void jointIdsIntoArrayInvalidSizeStride();
template<class T> void weightsAsArray();
template<class T> void weightsAsArrayPackedUnsignedNormalized();
void weightsIntoArrayInvalidSizeStride();
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: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
void implementationSpecificIndexTypeWrongAccess();
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
void implementationSpecificVertexFormatWrongAccess();
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();
Trade: move a test case to where it fits better.
5 years ago
void attributeWrongArrayAccess();
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 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,
Packed debug output for enums used by Trade. Again not publicly documented because I don't like the naming and I don't have the full behavior and interactions figured out yet -- i.e., an array of VertexFormats would be printed with Debug::packed as a long string of characters without any whitespace. Not good, thus this feature probably needs to be split in two, with this being named "compact" or something else.
4 years ago
&MeshDataTest::debugAttributeNamePacked,
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 strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
&MeshDataTest::constructIndexContiguous,
&MeshDataTest::constructIndexStrided,
&MeshDataTest::constructIndexStridedWrongStride,
&MeshDataTest::constructIndexTypeErasedContiguous,
Trade: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
&MeshDataTest::constructIndexTypeErasedContiguousImplementationSpecificFormat,
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
&MeshDataTest::constructIndexTypeErasedContiguousWrongSize,
&MeshDataTest::constructIndexTypeErasedStrided,
Trade: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
&MeshDataTest::constructIndexTypeErasedStridedImplementationSpecificFormat,
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
&MeshDataTest::constructIndexTypeErasedStridedWrongStride,
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,
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
&MeshDataTest::constructIndex2DWrongStride,
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::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,
Trade: accidentally missed a test for empty MeshAttributeData.
6 years ago
&MeshDataTest::constructAttributeDefault,
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::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: implement support for Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
&MeshDataTest::constructAttributeOnlyArrayAllowed,
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 array attributes to have implementation-specific formats. I'm not sure why this restriction was there as nothing was preventing them from being used. The attribute is only accessible through the typeless attribute(), which gives back `Containers::StridedArrayView2D<const char>` with second dimension size being set to the full stride. And there it doesn't matter if the format is an array or not. This will be useful for joint IDs and weights, for example doing crazy things like packing the IDs into an array of 8 4-bit numbers, saving half the memory compared to the smallest builtin representation using UnsignedByte[8].
4 years ago
&MeshDataTest::constructArrayAttributeImplementationSpecificFormat,
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: support zero and negative strides in mesh attribute data. This is not something the classic GPU vertex pipeline can handle (except maybe Vulkan, which can handle zero strides for instanced attributes?), but useful for other scenarios. This means existing code needs to be aware of and handle the new corner case.
4 years ago
&MeshDataTest::constructIndexlessAttributelessZeroVertices,
Trade: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
&MeshDataTest::constructImplementationSpecificIndexType,
Trade: move MeshData impl-specific vert format tests closer to the rest. Because this way I wasn't even aware these got tested and so I didn't extend them for zero/negative strides. Now they got proper treatment.
4 years ago
&MeshDataTest::constructImplementationSpecificVertexFormat,
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
&MeshDataTest::constructSpecialIndexStrides,
Trade: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
&MeshDataTest::constructSpecialIndexStridesImplementationSpecificIndexType,
Trade: support zero and negative strides in mesh attribute data. This is not something the classic GPU vertex pipeline can handle (except maybe Vulkan, which can handle zero strides for instanced attributes?), but useful for other scenarios. This means existing code needs to be aware of and handle the new corner case.
4 years ago
&MeshDataTest::constructSpecialAttributeStrides,
&MeshDataTest::constructSpecialAttributeStridesImplementationSpecificVertexFormat});
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 support for Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
&MeshDataTest::constructDifferentJointIdWeightCount,
&MeshDataTest::constructInconsistentJointIdWeightArraySizes,
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 Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
&MeshDataTest::jointIdsAsArray<UnsignedInt>,
&MeshDataTest::jointIdsAsArray<UnsignedByte>,
&MeshDataTest::jointIdsAsArray<UnsignedShort>,
&MeshDataTest::jointIdsIntoArrayInvalidSizeStride,
&MeshDataTest::weightsAsArray<Float>,
&MeshDataTest::weightsAsArray<Half>,
&MeshDataTest::weightsAsArrayPackedUnsignedNormalized<UnsignedByte>,
&MeshDataTest::weightsAsArrayPackedUnsignedNormalized<UnsignedShort>,
&MeshDataTest::weightsIntoArrayInvalidSizeStride,
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: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
&MeshDataTest::implementationSpecificIndexTypeWrongAccess,
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
&MeshDataTest::implementationSpecificVertexFormatWrongAccess,
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,
Trade: move a test case to where it fits better.
5 years ago
&MeshDataTest::attributeWrongArrayAccess,
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::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)));
Trade: drop {MeshAttribute,SceneField}::Custom. I realized those are too annoying when writing a glTF exporter which contains a lot of switches over enums. And as further shown by the diff, those were only inflicting additional pain in *all* switch statements, nothing else, no other added value. And everywhere else the helpers are the designated way to deal with those, so there's no point in having an explicit enum value denoting start of a "custom range". It wasn't even any convenient to have it in the enum, as the extra effort needed for casting actually made it *exactly* the same length as if I'd just use a separately-defined constant.
4 years ago
CORRADE_VERIFY(isMeshAttributeCustom(MeshAttribute(Implementation::MeshAttributeCustom)));
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(isMeshAttributeCustom(MeshAttribute(65535)));
CORRADE_COMPARE(UnsignedShort(meshAttributeCustom(0)), 32768);
CORRADE_COMPARE(UnsignedShort(meshAttributeCustom(8290)), 41058);
CORRADE_COMPARE(UnsignedShort(meshAttributeCustom(32767)), 65535);
Trade: drop {MeshAttribute,SceneField}::Custom. I realized those are too annoying when writing a glTF exporter which contains a lot of switches over enums. And as further shown by the diff, those were only inflicting additional pain in *all* switch statements, nothing else, no other added value. And everywhere else the helpers are the designated way to deal with those, so there's no point in having an explicit enum value denoting start of a "custom range". It wasn't even any convenient to have it in the enum, as the extra effort needed for casting actually made it *exactly* the same length as if I'd just use a separately-defined constant.
4 years ago
CORRADE_COMPARE(meshAttributeCustom(MeshAttribute(Implementation::MeshAttributeCustom)), 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(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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
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
std::ostringstream out;
Error redirectError{&out};
meshAttributeCustom(32768);
CORRADE_COMPARE(out.str(), "Trade::meshAttributeCustom(): index 32768 too large\n");
}
void MeshDataTest::customAttributeNameNotCustom() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
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
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");
}
Packed debug output for enums used by Trade. Again not publicly documented because I don't like the naming and I don't have the full behavior and interactions figured out yet -- i.e., an array of VertexFormats would be printed with Debug::packed as a long string of characters without any whitespace. Not good, thus this feature probably needs to be split in two, with this being named "compact" or something else.
4 years ago
void MeshDataTest::debugAttributeNamePacked() {
std::ostringstream out;
/* Last is not packed, ones before should not make any flags persistent */
Debug{&out} << Debug::packed << MeshAttribute::Position << Debug::packed << meshAttributeCustom(73) << Debug::packed << MeshAttribute(0x73) << MeshAttribute::Normal;
CORRADE_COMPARE(out.str(), "Position Custom(73) 0x73 Trade::MeshAttribute::Normal\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
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: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
void MeshDataTest::constructIndexContiguous() {
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 UnsignedByte indexData[]{25, 132, 3};
MeshIndexData indices{indexData};
CORRADE_COMPARE(indices.type(), MeshIndexType::UnsignedByte);
CORRADE_COMPARE(indices.data().data(), indexData);
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
CORRADE_COMPARE(indices.data().size(), 3);
CORRADE_COMPARE(indices.data().stride(), 1);
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();
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
constexpr Containers::StridedArrayView1D<const void> data = cindices.data();
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(type, MeshIndexType::UnsignedByte);
CORRADE_COMPARE(data.data(), IndexBytes);
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
CORRADE_COMPARE(data.size(), 3);
CORRADE_COMPARE(data.stride(), 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
} {
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: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
CORRADE_COMPARE(indices.data().size(), 3);
CORRADE_COMPARE(indices.data().stride(), 2);
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();
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
constexpr Containers::StridedArrayView1D<const void> data = cindices.data();
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(type, MeshIndexType::UnsignedShort);
CORRADE_COMPARE(data.data(), IndexShorts);
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
CORRADE_COMPARE(data.size(), 3);
CORRADE_COMPARE(data.stride(), 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
} {
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: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
CORRADE_COMPARE(indices.data().size(), 3);
CORRADE_COMPARE(indices.data().stride(), 4);
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();
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
constexpr Containers::StridedArrayView1D<const void> data = cindices.data();
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(type, MeshIndexType::UnsignedInt);
CORRADE_COMPARE(data.data(), IndexInts);
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
CORRADE_COMPARE(data.size(), 3);
CORRADE_COMPARE(data.stride(), 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
}
}
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
constexpr struct IndexStruct {
UnsignedByte byteIndex;
UnsignedShort shortIndex;
UnsignedInt intIndex;
} IndexStructData[3]{
{25, 2575, 2110122},
{132, 13224, 132257},
{3, 3, 3}
};
void MeshDataTest::constructIndexStrided() {
const IndexStruct data[3]{
{25, 2575, 2110122},
{132, 13224, 132257},
{3, 3, 3}
};
Containers::StridedArrayView1D<const IndexStruct> view = data;
{
MeshIndexData indices{view.slice(&IndexStruct::byteIndex)};
CORRADE_COMPARE(indices.type(), MeshIndexType::UnsignedByte);
CORRADE_COMPARE(indices.data().data(), &data[0].byteIndex);
CORRADE_COMPARE(indices.data().size(), 3);
CORRADE_COMPARE(indices.data().stride(), sizeof(IndexStruct));
constexpr MeshIndexData cindices{Containers::stridedArrayView(IndexStructData, &IndexStructData[0].byteIndex, 3, sizeof(IndexStruct))};
Fix various variable shadowing warnings.
4 years ago
constexpr MeshIndexType ctype = cindices.type();
constexpr Containers::StridedArrayView1D<const void> cdata = cindices.data();
CORRADE_COMPARE(ctype, MeshIndexType::UnsignedByte);
CORRADE_COMPARE(cdata.data(), &IndexStructData[0].byteIndex);
CORRADE_COMPARE(cdata.size(), 3);
CORRADE_COMPARE(cdata.stride(), sizeof(IndexStruct));
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
} {
MeshIndexData indices{view.slice(&IndexStruct::shortIndex)};
CORRADE_COMPARE(indices.type(), MeshIndexType::UnsignedShort);
CORRADE_COMPARE(indices.data().data(), &data[0].shortIndex);
CORRADE_COMPARE(indices.data().size(), 3);
CORRADE_COMPARE(indices.data().stride(), sizeof(IndexStruct));
constexpr MeshIndexData cindices{Containers::stridedArrayView(IndexStructData, &IndexStructData[0].shortIndex, 3, sizeof(IndexStruct))};
Fix various variable shadowing warnings.
4 years ago
constexpr MeshIndexType ctype = cindices.type();
constexpr Containers::StridedArrayView1D<const void> cdata = cindices.data();
CORRADE_COMPARE(ctype, MeshIndexType::UnsignedShort);
CORRADE_COMPARE(cdata.data(), &IndexStructData[0].shortIndex);
CORRADE_COMPARE(cdata.size(), 3);
CORRADE_COMPARE(cdata.stride(), sizeof(IndexStruct));
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
} {
MeshIndexData indices{view.slice(&IndexStruct::intIndex)};
CORRADE_COMPARE(indices.type(), MeshIndexType::UnsignedInt);
CORRADE_COMPARE(indices.data().data(), &data[0].intIndex);
CORRADE_COMPARE(indices.data().size(), 3);
CORRADE_COMPARE(indices.data().stride(), sizeof(IndexStruct));
constexpr MeshIndexData cindices{Containers::stridedArrayView(IndexStructData, &IndexStructData[0].intIndex, 3, sizeof(IndexStruct))};
Fix various variable shadowing warnings.
4 years ago
constexpr MeshIndexType ctype = cindices.type();
constexpr Containers::StridedArrayView1D<const void> cdata = cindices.data();
CORRADE_COMPARE(ctype, MeshIndexType::UnsignedInt);
CORRADE_COMPARE(cdata.data(), &IndexStructData[0].intIndex);
CORRADE_COMPARE(cdata.size(), 3);
CORRADE_COMPARE(cdata.stride(), sizeof(IndexStruct));
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
}
}
void MeshDataTest::constructIndexStridedWrongStride() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
char toomuch[2*(32768 + 1)];
/* These should be fine */
MeshIndexData{Containers::StridedArrayView1D<UnsignedByte>{Containers::arrayCast<UnsignedByte>(toomuch), 2, 32767}};
MeshIndexData{Containers::StridedArrayView1D<UnsignedByte>{Containers::arrayCast<UnsignedByte>(toomuch), 2, 32768}.flipped<0>()};
std::ostringstream out;
Error redirectError{&out};
MeshIndexData{Containers::StridedArrayView1D<UnsignedByte>{Containers::arrayCast<UnsignedByte>(toomuch), 2, 32768}};
MeshIndexData{Containers::StridedArrayView1D<UnsignedByte>{Containers::arrayCast<UnsignedByte>(toomuch), 2, 32769}.flipped<0>()};
CORRADE_COMPARE(out.str(),
"Trade::MeshIndexData: expected stride to fit into 16 bits but got 32768\n"
"Trade::MeshIndexData: expected stride to fit into 16 bits but got -32769\n");
}
void MeshDataTest::constructIndexTypeErasedContiguous() {
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);
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
CORRADE_COMPARE(indices.data().data(), indexData);
CORRADE_COMPARE(indices.data().size(), 3);
CORRADE_COMPARE(indices.data().stride(), 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
}
Trade: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
void MeshDataTest::constructIndexTypeErasedContiguousImplementationSpecificFormat() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
const char indexData[3*2]{};
std::ostringstream out;
Error redirectError{&out};
MeshIndexData{meshIndexTypeWrap(0xcaca), indexData};
CORRADE_COMPARE(out.str(), "Trade::MeshIndexData: can't create index data from a contiguous view and an implementation-specific type 0xcaca, pass a strided view instead\n");
}
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
void MeshDataTest::constructIndexTypeErasedContiguousWrongSize() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 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 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: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
constexpr const char IndexData[3*4]{};
void MeshDataTest::constructIndexTypeErasedStrided() {
const char indexData[3*4]{};
MeshIndexData indices{MeshIndexType::UnsignedShort, {indexData, 3, 4}};
CORRADE_COMPARE(indices.type(), MeshIndexType::UnsignedShort);
CORRADE_VERIFY(indices.data().data() == indexData);
CORRADE_COMPARE(indices.data().size(), 3);
CORRADE_COMPARE(indices.data().stride(), 4);
constexpr MeshIndexData cindices{MeshIndexType::UnsignedShort, {IndexData, 3, 4}};
constexpr MeshIndexType type = cindices.type();
constexpr Containers::StridedArrayView1D<const void> data = cindices.data();
CORRADE_COMPARE(type, MeshIndexType::UnsignedShort);
CORRADE_COMPARE(data.data(), IndexData);
CORRADE_COMPARE(data.size(), 3);
CORRADE_COMPARE(data.stride(), 4);
}
Trade: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
void MeshDataTest::constructIndexTypeErasedStridedImplementationSpecificFormat() {
const char indexData[3*2]{};
MeshIndexData indices{meshIndexTypeWrap(0xcaca), Containers::StridedArrayView1D<const char>{indexData, 3, 2}};
CORRADE_COMPARE(indices.type(), meshIndexTypeWrap(0xcaca));
CORRADE_COMPARE(indices.data().data(), indexData);
CORRADE_COMPARE(indices.data().size(), 3);
CORRADE_COMPARE(indices.data().stride(), 2);
}
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
void MeshDataTest::constructIndexTypeErasedStridedWrongStride() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
char toomuch[2*(32768 + 1)]{};
/* These should be fine */
MeshIndexData{MeshIndexType::UnsignedByte, Containers::StridedArrayView1D<const void>{toomuch, 2, 32767}};
MeshIndexData{MeshIndexType::UnsignedByte, Containers::StridedArrayView1D<UnsignedByte>{Containers::arrayCast<UnsignedByte>(toomuch), 2, 32768}.flipped<0>()};
std::ostringstream out;
Error redirectError{&out};
MeshIndexData{MeshIndexType::UnsignedByte, Containers::StridedArrayView1D<const void>{toomuch, 2, 32768}};
MeshIndexData{MeshIndexType::UnsignedByte, Containers::StridedArrayView1D<UnsignedByte>{Containers::arrayCast<UnsignedByte>(toomuch), 2, 32769}.flipped<0>()};
CORRADE_COMPARE(out.str(),
"Trade::MeshIndexData: expected stride to fit into 16 bits but got 32768\n"
"Trade::MeshIndexData: expected stride to fit into 16 bits but got -32769\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() {
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
const IndexStruct data[3]{
{25, 2575, 2110122},
{132, 13224, 132257},
{3, 3, 3}
};
Containers::StridedArrayView1D<const IndexStruct> view = data;
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: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
MeshIndexData indices{Containers::arrayCast<2, const char>(view.slice(&IndexStruct::byteIndex))};
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
CORRADE_COMPARE(indices.type(), MeshIndexType::UnsignedByte);
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
CORRADE_COMPARE(indices.data().data(), &data[0].byteIndex);
CORRADE_COMPARE(indices.data().size(), 3);
CORRADE_COMPARE(indices.data().stride(), sizeof(IndexStruct));
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: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
MeshIndexData indices{Containers::arrayCast<2, const char>(view.slice(&IndexStruct::shortIndex))};
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
CORRADE_COMPARE(indices.type(), MeshIndexType::UnsignedShort);
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
CORRADE_COMPARE(indices.data().data(), &data[0].shortIndex);
CORRADE_COMPARE(indices.data().size(), 3);
CORRADE_COMPARE(indices.data().stride(), sizeof(IndexStruct));
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: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
MeshIndexData indices{Containers::arrayCast<2, const char>(view.slice(&IndexStruct::intIndex))};
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
CORRADE_COMPARE(indices.type(), MeshIndexType::UnsignedInt);
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
CORRADE_COMPARE(indices.data().data(), &data[0].intIndex);
CORRADE_COMPARE(indices.data().size(), 3);
CORRADE_COMPARE(indices.data().stride(), sizeof(IndexStruct));
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: 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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
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");
}
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
void MeshDataTest::constructIndex2DWrongStride() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
char toomuch[2*(32768 + 1)];
/* These should be fine */
MeshIndexData{Containers::StridedArrayView2D<char>{toomuch, {2, 1}, {32767, 1}}};
MeshIndexData{Containers::StridedArrayView2D<char>{toomuch, {2, 1}, {32768, 1}}.flipped<0>()};
std::ostringstream out;
Error redirectError{&out};
MeshIndexData{Containers::StridedArrayView2D<char>{toomuch, {2, 1}, {32768, 1}}};
MeshIndexData{Containers::StridedArrayView2D<char>{toomuch, {2, 1}, {32769, 1}}.flipped<0>()};
CORRADE_COMPARE(out.str(),
"Trade::MeshIndexData: expected stride to fit into 16 bits but got 32768\n"
"Trade::MeshIndexData: expected stride to fit into 16 bits but got -32769\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::constructIndex2DNonContiguous() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
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]{};
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
/* This should be fine */
MeshIndexData{Containers::StridedArrayView2D<const char>{data, {3, 2}, {4, 1}}};
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
std::ostringstream out;
Error redirectError{&out};
MeshIndexData{Containers::StridedArrayView2D<const char>{data, {3, 2}, {4, 2}}};
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
CORRADE_COMPARE(out.str(), "Trade::MeshIndexData: second view dimension is not contiguous\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::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: minor.
5 years ago
/* This is allowed too for simplicity, the parameter has to be large enough
tho */
char someArray[3*sizeof(Vector2)];
CORRADE_VERIFY(positions.data(someArray).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
}
Trade: accidentally missed a test for empty MeshAttributeData.
6 years ago
void MeshDataTest::constructAttributeDefault() {
MeshAttributeData data;
CORRADE_COMPARE(data.name(), MeshAttribute{});
CORRADE_COMPARE(data.format(), VertexFormat{});
constexpr MeshAttributeData cdata;
CORRADE_COMPARE(cdata.name(), MeshAttribute{});
CORRADE_COMPARE(cdata.format(), VertexFormat{});
}
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: doc++
5 years ago
/* Verifying it doesn't hit any assertion about disallowed type for given
attribute */
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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
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]{};
Trade: don't do an unnecessary cast for a MeshAttributeData view. Same as previous commit, would cause ambiguity with an upcoming StridedArrayView "updimensioning" constructor.
3 years ago
MeshAttributeData positions{MeshAttribute::Position, VertexFormat::Vector3, 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 */
Trade: minor cleanup in a test.
4 years ago
MeshAttributeData a{MeshAttribute::Position, vertexFormatWrap(0x3a), positions};
CORRADE_COMPARE(a.name(), MeshAttribute::Position);
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 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
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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
Trade: support zero and negative strides in mesh attribute data. This is not something the classic GPU vertex pipeline can handle (except maybe Vulkan, which can handle zero strides for instanced attributes?), but useful for other scenarios. This means existing code needs to be aware of and handle the new corner case.
4 years ago
char toomuch[2*(32768 + sizeof(Vector2))];
/* These should be fine */
MeshAttributeData{MeshAttribute::Position, Containers::StridedArrayView1D<Vector2>{Containers::arrayCast<Vector2>(toomuch), 2, 32767}};
MeshAttributeData{MeshAttribute::Position, Containers::StridedArrayView1D<Vector2>{Containers::arrayCast<Vector2>(toomuch), 2, 32768}.flipped<0>()};
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector2, 0, 1, 32767};
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector2, 65536, 1, -32768};
MeshAttributeData{32767};
MeshAttributeData{-32768};
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
std::ostringstream out;
Error redirectError{&out};
Trade: support zero and negative strides in mesh attribute data. This is not something the classic GPU vertex pipeline can handle (except maybe Vulkan, which can handle zero strides for instanced attributes?), but useful for other scenarios. This means existing code needs to be aware of and handle the new corner case.
4 years ago
MeshAttributeData{MeshAttribute::Position, Containers::StridedArrayView1D<Vector2>{Containers::arrayCast<Vector2>(toomuch), 2, 32768}};
MeshAttributeData{MeshAttribute::Position, Containers::StridedArrayView1D<Vector2>{Containers::arrayCast<Vector2>(toomuch), 2, 32769}.flipped<0>()};
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector2, 0, 1, 32768};
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector2, 65536, 1, -32769};
MeshAttributeData{32768};
MeshAttributeData{-32769};
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
CORRADE_COMPARE(out.str(),
Trade: support zero and negative strides in mesh attribute data. This is not something the classic GPU vertex pipeline can handle (except maybe Vulkan, which can handle zero strides for instanced attributes?), but useful for other scenarios. This means existing code needs to be aware of and handle the new corner case.
4 years ago
"Trade::MeshAttributeData: expected stride to fit into 16 bits but got 32768\n"
"Trade::MeshAttributeData: expected stride to fit into 16 bits but got -32769\n"
"Trade::MeshAttributeData: expected stride to fit into 16 bits but got 32768\n"
"Trade::MeshAttributeData: expected stride to fit into 16 bits but got -32769\n"
"Trade::MeshAttributeData: expected padding to fit into 16 bits but got 32768\n"
"Trade::MeshAttributeData: expected padding to fit into 16 bits but got -32769\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: implement support for Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
void MeshDataTest::constructAttributeOnlyArrayAllowed() {
CORRADE_SKIP_IF_NO_ASSERT();
Vector2 data[3];
/* These should be fine */
MeshAttributeData{MeshAttribute::Weights, VertexFormat::Float, data, 2};
MeshAttributeData{meshAttributeCustom(25), VertexFormat::Vector2, data};
MeshAttributeData{meshAttributeCustom(25), VertexFormat::Float, data, 2};
std::ostringstream out;
Error redirectError{&out};
MeshAttributeData{MeshAttribute::Weights, VertexFormat::Float, data};
CORRADE_COMPARE(out.str(),
"Trade::MeshAttributeData: Trade::MeshAttribute::Weights has to be an array attribute\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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 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
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());
Trade: use consistent naming in an assert message.
5 years ago
a.data(positionData); /* This is fine, no asserts */
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
std::ostringstream out;
Error redirectError{&out};
b.data();
CORRADE_COMPARE(out.str(),
Trade: use consistent naming in an assert message.
5 years ago
"Trade::MeshAttributeData::data(): the attribute is offset-only, supply a data array\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: 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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
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)];
Trade: unify array MeshAttributeData constructors. The array size is always last, defaulting to 0. This makes it consistent with the offset-only constructor and removes two unnecessary overloads. It's a breaking change, but I don't think array attributes have many users yet -- and better to do this now than later. In any case, sorry about breaking your code.
6 years ago
MeshAttributeData data{meshAttributeCustom(35), VertexFormat::Vector2, Containers::StridedArrayView2D<char>{vertexData, {3, 4*sizeof(Vector2)}}, 4};
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
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};
Trade: unify array MeshAttributeData constructors. The array size is always last, defaulting to 0. This makes it consistent with the offset-only constructor and removes two unnecessary overloads. It's a breaking change, but I don't think array attributes have many users yet -- and better to do this now than later. In any case, sorry about breaking your code.
6 years ago
MeshAttributeData{meshAttributeCustom(35), VertexFormat::Vector2,
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
Containers::StridedArrayView2D<char>{vertexData,
Trade: unify array MeshAttributeData constructors. The array size is always last, defaulting to 0. This makes it consistent with the offset-only constructor and removes two unnecessary overloads. It's a breaking change, but I don't think array attributes have many users yet -- and better to do this now than later. In any case, sorry about breaking your code.
6 years ago
{3, 4*sizeof(Vector2)}}, 3};
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
CORRADE_COMPARE(out.str(), "Trade::MeshAttributeData: second view dimension size 32 doesn't match VertexFormat::Vector2 and array size 3\n");
}
void MeshDataTest::constructArrayAttribute2DNonContiguous() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
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};
Trade: unify array MeshAttributeData constructors. The array size is always last, defaulting to 0. This makes it consistent with the offset-only constructor and removes two unnecessary overloads. It's a breaking change, but I don't think array attributes have many users yet -- and better to do this now than later. In any case, sorry about breaking your code.
6 years ago
MeshAttributeData{meshAttributeCustom(35), VertexFormat::Vector2,
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
Containers::StridedArrayView2D<char>{vertexData,
Trade: unify array MeshAttributeData constructors. The array size is always last, defaulting to 0. This makes it consistent with the offset-only constructor and removes two unnecessary overloads. It's a breaking change, but I don't think array attributes have many users yet -- and better to do this now than later. In any case, sorry about breaking your code.
6 years ago
{3, sizeof(Vector2)*4}}.every({1, 2}), 2};
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
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)};
Trade: don't do an unnecessary cast for a MeshAttributeData view. Same as previous commit, would cause ambiguity with an upcoming StridedArrayView "updimensioning" constructor.
3 years ago
MeshAttributeData data{meshAttributeCustom(35), VertexFormat::Vector2, attribute, 4};
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
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() {
Trade: unify array MeshAttributeData constructors. The array size is always last, defaulting to 0. This makes it consistent with the offset-only constructor and removes two unnecessary overloads. It's a breaking change, but I don't think array attributes have many users yet -- and better to do this now than later. In any case, sorry about breaking your code.
6 years ago
MeshAttributeData positions{meshAttributeCustom(35), VertexFormat::Vector2, nullptr, 4};
Trade: fix ambiguity when instantiating nullptr array MeshAttributeData.
6 years ago
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);
}
Trade: allow array attributes to have implementation-specific formats. I'm not sure why this restriction was there as nothing was preventing them from being used. The attribute is only accessible through the typeless attribute(), which gives back `Containers::StridedArrayView2D<const char>` with second dimension size being set to the full stride. And there it doesn't matter if the format is an array or not. This will be useful for joint IDs and weights, for example doing crazy things like packing the IDs into an array of 8 4-bit numbers, saving half the memory compared to the smallest builtin representation using UnsignedByte[8].
4 years ago
void MeshDataTest::constructArrayAttributeImplementationSpecificFormat() {
Vector2 positions[]{{1.0f, 0.3f}, {0.5f, 0.7f}};
/* This should not fire any asserts */
MeshAttributeData a{meshAttributeCustom(35), vertexFormatWrap(0x3a), positions, 2};
CORRADE_COMPARE(a.name(), meshAttributeCustom(35));
CORRADE_COMPARE(a.format(), vertexFormatWrap(0x3a));
CORRADE_COMPARE(a.arraySize(), 2);
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 array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
void MeshDataTest::constructArrayAttributeNotAllowed() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
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 */
Trade: unify array MeshAttributeData constructors. The array size is always last, defaulting to 0. This makes it consistent with the offset-only constructor and removes two unnecessary overloads. It's a breaking change, but I don't think array attributes have many users yet -- and better to do this now than later. In any case, sorry about breaking your code.
6 years ago
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector2, positions, 0};
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector2, 0, 3, 6*sizeof(Vector2), 0};
Trade: unify array MeshAttributeData constructors. The array size is always last, defaulting to 0. This makes it consistent with the offset-only constructor and removes two unnecessary overloads. It's a breaking change, but I don't think array attributes have many users yet -- and better to do this now than later. In any case, sorry about breaking your code.
6 years ago
MeshAttributeData{meshAttributeCustom(35), vertexFormatWrap(0xdead), positions, 0};
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
MeshAttributeData{meshAttributeCustom(35), positions2D};
Trade: unify array MeshAttributeData constructors. The array size is always last, defaulting to 0. This makes it consistent with the offset-only constructor and removes two unnecessary overloads. It's a breaking change, but I don't think array attributes have many users yet -- and better to do this now than later. In any case, sorry about breaking your code.
6 years ago
MeshAttributeData{meshAttributeCustom(35), VertexFormat::Vector2, positions2Dchar, 3};
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
MeshAttributeData{meshAttributeCustom(35), VertexFormat::Vector2, 0, 3, 6*sizeof(Vector2), 3};
Trade: allow array attributes to have implementation-specific formats. I'm not sure why this restriction was there as nothing was preventing them from being used. The attribute is only accessible through the typeless attribute(), which gives back `Containers::StridedArrayView2D<const char>` with second dimension size being set to the full stride. And there it doesn't matter if the format is an array or not. This will be useful for joint IDs and weights, for example doing crazy things like packing the IDs into an array of 8 4-bit numbers, saving half the memory compared to the smallest builtin representation using UnsignedByte[8].
4 years ago
MeshAttributeData{meshAttributeCustom(35), vertexFormatWrap(0xdead), positions, 3};
MeshAttributeData{meshAttributeCustom(35), vertexFormatWrap(0xdead), 0, 3, 6*sizeof(Vector2), 3};
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
/* This is not */
std::ostringstream out;
Error redirectError{&out};
Trade: minor cleanup in a test.
4 years ago
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector2b, positions, 3};
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
MeshAttributeData{MeshAttribute::Position, positions2D};
Trade: unify array MeshAttributeData constructors. The array size is always last, defaulting to 0. This makes it consistent with the offset-only constructor and removes two unnecessary overloads. It's a breaking change, but I don't think array attributes have many users yet -- and better to do this now than later. In any case, sorry about breaking your code.
6 years ago
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector2, positions2Dchar, 3};
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
6 years ago
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector2, 0, 3, 6*sizeof(Vector2), 3};
CORRADE_COMPARE(out.str(),
"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: allow array attributes to have implementation-specific formats. I'm not sure why this restriction was there as nothing was preventing them from being used. The attribute is only accessible through the typeless attribute(), which gives back `Containers::StridedArrayView2D<const char>` with second dimension size being set to the full stride. And there it doesn't matter if the format is an array or not. This will be useful for joint IDs and weights, for example doing crazy things like packing the IDs into an array of 8 4-bit numbers, saving half the memory compared to the smallest builtin representation using UnsignedByte[8].
4 years ago
"Trade::MeshAttributeData: Trade::MeshAttribute::Position can't be an array attribute\n");
Trade: support array attributes in MeshData. The last major bit needed for meshlet support.
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
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;
Trade: merge MeshData array attribute tests with the main test. Because otherwise we don't properly test all cases. Case in point -- attributeData(UnsignedInt) wasn't correctly propagating the array size, causing the new tests to fail. Fix in the next commit.
5 years ago
Short id[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
};
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)};
Trade: use the fancy StridedArrayView slicing in MeshDataTest. Stone age APIs used here again, I can't fathom how I could live without member slicing for so long. This also fixes an OOB access which trips up the new ArrayView assertions -- accessing element 0 in the constructor isn't a good thing to do if there's no data at all.
3 years ago
auto vertexView = stridedArrayView(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};
Trade: merge MeshData array attribute tests with the main test. Because otherwise we don't properly test all cases. Case in point -- attributeData(UnsignedInt) wasn't correctly propagating the array size, causing the new tests to fail. Fix in the next commit.
5 years ago
vertexView[0].id[0] = 15;
vertexView[0].id[1] = 74;
vertexView[1].id[0] = -374;
vertexView[1].id[1] = 2;
vertexView[2].id[0] = 22;
vertexView[2].id[1] = -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
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,
Trade: use the fancy StridedArrayView slicing in MeshDataTest. Stone age APIs used here again, I can't fathom how I could live without member slicing for so long. This also fixes an OOB access which trips up the new ArrayView assertions -- accessing element 0 in the constructor isn't a good thing to do if there's no data at all.
3 years ago
vertexView.slice(&Vertex::position)};
Trade: merge MeshData array attribute tests with the main test. Because otherwise we don't properly test all cases. Case in point -- attributeData(UnsignedInt) wasn't correctly propagating the array size, causing the new tests to fail. Fix in the next commit.
5 years ago
/* Offset-only */
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,
Trade: use the fancy StridedArrayView slicing in MeshDataTest. Stone age APIs used here again, I can't fathom how I could live without member slicing for so long. This also fixes an OOB access which trips up the new ArrayView assertions -- accessing element 0 in the constructor isn't a good thing to do if there's no data at all.
3 years ago
vertexView.slice(&Vertex::textureCoordinate)};
Trade: merge MeshData array attribute tests with the main test. Because otherwise we don't properly test all cases. Case in point -- attributeData(UnsignedInt) wasn't correctly propagating the array size, causing the new tests to fail. Fix in the next commit.
5 years ago
/* Custom & array */
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 ids{meshAttributeCustom(13),
Trade: use the fancy StridedArrayView slicing in MeshDataTest. Stone age APIs used here again, I can't fathom how I could live without member slicing for so long. This also fixes an OOB access which trips up the new ArrayView assertions -- accessing element 0 in the constructor isn't a good thing to do if there's no data at all.
3 years ago
Containers::arrayCast<2, Short>(vertexView.slice(&Vertex::id))};
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,
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);
Adapt to Corrade changes.
4 years ago
CORRADE_VERIFY(!data.attributeData().isEmpty());
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));
Trade: add MeshData::attributeId() for inverse ID mapping. A helper for knowing e.g. which texture coordinate set is given texture coordinate attribute.
4 years ago
CORRADE_COMPARE(data.attributeId(0), 0);
CORRADE_COMPARE(data.attributeId(1), 0);
CORRADE_COMPARE(data.attributeId(2), 0);
CORRADE_COMPARE(data.attributeId(3), 1);
CORRADE_COMPARE(data.attributeId(4), 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.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);
Trade: merge MeshData array attribute tests with the main test. Because otherwise we don't properly test all cases. Case in point -- attributeData(UnsignedInt) wasn't correctly propagating the array size, causing the new tests to fail. Fix in the next commit.
5 years ago
CORRADE_COMPARE(data.attributeArraySize(4), 2);
/* Raw attribute data access by ID */
CORRADE_COMPARE(data.attributeData(1).name(), MeshAttribute::TextureCoordinates);
CORRADE_COMPARE(data.attributeData(1).format(), VertexFormat::Vector2);
CORRADE_COMPARE(data.attributeData(1).data().size(), instanceData.expectedVertexCount);
CORRADE_COMPARE(data.attributeData(1).arraySize(), 0);
if(instanceData.vertexCount)
CORRADE_COMPARE(Containers::arrayCast<const Vector2>(data.attributeData(1).data())[1], (Vector2{0.250f, 0.375f}));
/* Offset-only */
CORRADE_COMPARE(data.attributeData(2).name(), MeshAttribute::Normal);
CORRADE_COMPARE(data.attributeData(2).format(), VertexFormat::Vector3);
CORRADE_COMPARE(data.attributeData(2).data().size(), instanceData.expectedVertexCount);
CORRADE_COMPARE(data.attributeData(2).arraySize(), 0);
if(instanceData.vertexCount)
CORRADE_COMPARE(Containers::arrayCast<const Vector3>(data.attributeData(2).data())[1], Vector3::yAxis());
/* Array */
CORRADE_COMPARE(data.attributeData(4).name(), meshAttributeCustom(13));
CORRADE_COMPARE(data.attributeData(4).format(), VertexFormat::Short);
CORRADE_COMPARE(data.attributeData(4).data().size(), instanceData.expectedVertexCount);
CORRADE_COMPARE(data.attributeData(4).arraySize(), 2);
if(instanceData.vertexCount) {
CORRADE_COMPARE((Containers::arrayCast<2, const Short>(data.attributeData(4).data(), 2))[1][0], -374);
CORRADE_COMPARE((Containers::arrayCast<2, const Short>(data.attributeData(4).data(), 2))[1][1], 2);
}
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}));
Trade: merge MeshData array attribute tests with the main test. Because otherwise we don't properly test all cases. Case in point -- attributeData(UnsignedInt) wasn't correctly propagating the array size, causing the new tests to fail. Fix in the next commit.
5 years ago
/* Array */
CORRADE_COMPARE((Containers::arrayCast<2, const Short>(
data.attribute(4))[0])[0], 15);
CORRADE_COMPARE((Containers::arrayCast<2, const Short>(
data.attribute(4))[0])[1], 74);
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((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}));
Trade: merge MeshData array attribute tests with the main test. Because otherwise we don't properly test all cases. Case in point -- attributeData(UnsignedInt) wasn't correctly propagating the array size, causing the new tests to fail. Fix in the next commit.
5 years ago
/* Array */
CORRADE_COMPARE((Containers::arrayCast<2, Short>(
data.mutableAttribute(4))[0])[0], 15);
CORRADE_COMPARE((Containers::arrayCast<2, Short>(
data.mutableAttribute(4))[0])[1], 74);
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: 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}));
Trade: merge MeshData array attribute tests with the main test. Because otherwise we don't properly test all cases. Case in point -- attributeData(UnsignedInt) wasn't correctly propagating the array size, causing the new tests to fail. Fix in the next commit.
5 years ago
/* Array */
CORRADE_COMPARE(data.attribute<Short[]>(4)[1][0], -374);
CORRADE_COMPARE(data.attribute<Short[]>(4)[1][1], 2);
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.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}));
Trade: merge MeshData array attribute tests with the main test. Because otherwise we don't properly test all cases. Case in point -- attributeData(UnsignedInt) wasn't correctly propagating the array size, causing the new tests to fail. Fix in the next commit.
5 years ago
/* Array */
CORRADE_COMPARE(data.mutableAttribute<Short[]>(4)[1][0], -374);
CORRADE_COMPARE(data.mutableAttribute<Short[]>(4)[1][1], 2);
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: 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: add MeshData::findAttributeId().
4 years ago
CORRADE_COMPARE(data.findAttributeId(MeshAttribute::Position), 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);
Trade: add MeshData::findAttributeId().
4 years ago
CORRADE_COMPARE(data.findAttributeId(MeshAttribute::Normal), 2);
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::Normal), 2);
Trade: add MeshData::findAttributeId().
4 years ago
CORRADE_COMPARE(data.findAttributeId(MeshAttribute::TextureCoordinates), 1);
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::TextureCoordinates), 1);
Trade: add MeshData::findAttributeId().
4 years ago
CORRADE_COMPARE(data.findAttributeId(MeshAttribute::TextureCoordinates, 1), 3);
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::TextureCoordinates, 1), 3);
Trade: add MeshData::findAttributeId().
4 years ago
CORRADE_COMPARE(data.findAttributeId(meshAttributeCustom(13)), 4);
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(meshAttributeCustom(13)), 4);
Trade: add MeshData::findAttributeId().
4 years ago
CORRADE_COMPARE(data.findAttributeId(MeshAttribute::Color), Containers::NullOpt);
CORRADE_COMPARE(data.findAttributeId(MeshAttribute::TextureCoordinates, 2), Containers::NullOpt);
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);
Trade: merge MeshData array attribute tests with the main test. Because otherwise we don't properly test all cases. Case in point -- attributeData(UnsignedInt) wasn't correctly propagating the array size, causing the new tests to fail. Fix in the next commit.
5 years ago
CORRADE_COMPARE(data.attributeArraySize(meshAttributeCustom(13)), 2);
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}));
Trade: merge MeshData array attribute tests with the main test. Because otherwise we don't properly test all cases. Case in point -- attributeData(UnsignedInt) wasn't correctly propagating the array size, causing the new tests to fail. Fix in the next commit.
5 years ago
/* Array */
CORRADE_COMPARE((Containers::arrayCast<2, const Short>(
data.attribute(meshAttributeCustom(13)))[1])[0], -374);
CORRADE_COMPARE((Containers::arrayCast<2, const Short>(
data.attribute(meshAttributeCustom(13)))[1])[1], 2);
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((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}));
Trade: merge MeshData array attribute tests with the main test. Because otherwise we don't properly test all cases. Case in point -- attributeData(UnsignedInt) wasn't correctly propagating the array size, causing the new tests to fail. Fix in the next commit.
5 years ago
/* Array */
CORRADE_COMPARE((Containers::arrayCast<2, Short>(
data.mutableAttribute(meshAttributeCustom(13)))[1])[0], -374);
CORRADE_COMPARE((Containers::arrayCast<2, Short>(
data.mutableAttribute(meshAttributeCustom(13)))[1])[1], 2);
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: 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}));
Trade: merge MeshData array attribute tests with the main test. Because otherwise we don't properly test all cases. Case in point -- attributeData(UnsignedInt) wasn't correctly propagating the array size, causing the new tests to fail. Fix in the next commit.
5 years ago
/* Array */
CORRADE_COMPARE(data.attribute<Short[]>(meshAttributeCustom(13))[2][0], 22);
CORRADE_COMPARE(data.attribute<Short[]>(meshAttributeCustom(13))[2][1], -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.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}));
Trade: merge MeshData array attribute tests with the main test. Because otherwise we don't properly test all cases. Case in point -- attributeData(UnsignedInt) wasn't correctly propagating the array size, causing the new tests to fail. Fix in the next commit.
5 years ago
/* Array */
Trade: accidentally didn't test MeshData::mutableAttribute<T[]>().
4 years ago
CORRADE_COMPARE(data.mutableAttribute<Short[]>(meshAttributeCustom(13))[2][0], 22);
CORRADE_COMPARE(data.mutableAttribute<Short[]>(meshAttributeCustom(13))[2][1], -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
}
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);
Use the new, shorter Containers::Size / Stride typedefs.
4 years ago
CORRADE_COMPARE(data.indices().size(), (Containers::Size2D{0, 4}));
CORRADE_COMPARE(data.mutableIndices().size(), (Containers::Size2D{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());
Test: don't compare char* pointers. It's dangerous, as in case of failure it will attempt to print them as strings. Plus now with latest de-std-string-ification of TestSuite it causes the compilation to fail due to an ambigupus overload. This should eventually be catched and disallowed directly by the Tester class.
4 years ago
CORRADE_COMPARE(data.indexData(), static_cast<const void*>(nullptr));
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().data(), nullptr);
Use the new, shorter Containers::Size / Stride typedefs.
4 years ago
CORRADE_COMPARE(data.indices().size(), (Containers::Size2D{0, 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.mutableIndices().data(), nullptr);
Use the new, shorter Containers::Size / Stride typedefs.
4 years ago
CORRADE_COMPARE(data.mutableIndices().size(), (Containers::Size2D{0, 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
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);
Test: don't compare char* pointers. It's dangerous, as in case of failure it will attempt to print them as strings. Plus now with latest de-std-string-ification of TestSuite it causes the compilation to fail due to an ambigupus overload. This should eventually be catched and disallowed directly by the Tester class.
4 years ago
CORRADE_COMPARE(data.indexData(), static_cast<const void*>(nullptr));
CORRADE_COMPARE(data.vertexData(), static_cast<const void*>(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_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());
Test: don't compare char* pointers. It's dangerous, as in case of failure it will attempt to print them as strings. Plus now with latest de-std-string-ification of TestSuite it causes the compilation to fail due to an ambigupus overload. This should eventually be catched and disallowed directly by the Tester class.
4 years ago
CORRADE_COMPARE(data.vertexData(), static_cast<const void*>(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.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);
Test: don't compare char* pointers. It's dangerous, as in case of failure it will attempt to print them as strings. Plus now with latest de-std-string-ification of TestSuite it causes the compilation to fail due to an ambigupus overload. This should eventually be catched and disallowed directly by the Tester class.
4 years ago
CORRADE_COMPARE(data.indexData(), static_cast<const void*>(nullptr));
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
if(instanceData.dataFlags & DataFlag::Mutable)
Test: don't compare char* pointers. It's dangerous, as in case of failure it will attempt to print them as strings. Plus now with latest de-std-string-ification of TestSuite it causes the compilation to fail due to an ambigupus overload. This should eventually be catched and disallowed directly by the Tester class.
4 years ago
CORRADE_COMPARE(data.mutableIndexData(), static_cast<void*>(nullptr));
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.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());
Test: don't compare char* pointers. It's dangerous, as in case of failure it will attempt to print them as strings. Plus now with latest de-std-string-ification of TestSuite it causes the compilation to fail due to an ambigupus overload. This should eventually be catched and disallowed directly by the Tester class.
4 years ago
CORRADE_COMPARE(data.vertexData(), static_cast<const void*>(nullptr));
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
if(instanceData.dataFlags & DataFlag::Mutable)
Test: don't compare char ArrayViews to nullptr. Because, when it fails, it'd attempt to print them as strings, inevitably leading to a crash or garbage in the terminal. Moreover, with the upcoming fix that makes StringView *actually* convertible from an ArrayView, it would become ambiguous.
3 years ago
CORRADE_COMPARE(data.mutableVertexData(), static_cast<const void*>(nullptr));
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.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() {
GCC 11, your fancy new warnings are NOT helpful.
5 years ago
int state{}; /* GCC 11 complains that "maybe uninitialized" w/o the {} */
MeshData data{MeshPrimitive::TriangleStrip, 37, &state};
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());
Test: don't compare char* pointers. It's dangerous, as in case of failure it will attempt to print them as strings. Plus now with latest de-std-string-ification of TestSuite it causes the compilation to fail due to an ambigupus overload. This should eventually be catched and disallowed directly by the Tester class.
4 years ago
CORRADE_COMPARE(data.indexData(), static_cast<const void*>(nullptr));
CORRADE_COMPARE(data.vertexData(), static_cast<const void*>(nullptr));
GCC 11, your fancy new warnings are NOT helpful.
5 years ago
CORRADE_COMPARE(data.importerState(), &state);
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());
CORRADE_COMPARE(data.vertexCount(), 37);
CORRADE_COMPARE(data.attributeCount(), 0);
}
void MeshDataTest::constructIndexlessAttributelessZeroVertices() {
GCC 11, your fancy new warnings are NOT helpful.
5 years ago
int state{}; /* GCC 11 complains that "maybe uninitialized" w/o the {} */
MeshData data{MeshPrimitive::TriangleStrip, 0, &state};
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());
Test: don't compare char* pointers. It's dangerous, as in case of failure it will attempt to print them as strings. Plus now with latest de-std-string-ification of TestSuite it causes the compilation to fail due to an ambigupus overload. This should eventually be catched and disallowed directly by the Tester class.
4 years ago
CORRADE_COMPARE(data.indexData(), static_cast<const void*>(nullptr));
CORRADE_COMPARE(data.vertexData(), static_cast<const void*>(nullptr));
GCC 11, your fancy new warnings are NOT helpful.
5 years ago
CORRADE_COMPARE(data.importerState(), &state);
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());
CORRADE_COMPARE(data.vertexCount(), 0);
CORRADE_COMPARE(data.attributeCount(), 0);
}
Trade: move MeshData impl-specific vert format tests closer to the rest. Because this way I wasn't even aware these got tested and so I didn't extend them for zero/negative strides. Now they got proper treatment.
4 years ago
/* MSVC 2015 doesn't like anonymous bitfields in inline structs, so putting the
declaration outside */
struct VertexWithImplementationSpecificData {
Long:64;
Trade: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
/* Using some definitely not a vertex format to test there's no weird
compile-time assertion preventing this */
Trade: move MeshData impl-specific vert format tests closer to the rest. Because this way I wasn't even aware these got tested and so I didn't extend them for zero/negative strides. Now they got proper treatment.
4 years ago
long double thing;
};
Trade: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
void MeshDataTest::constructImplementationSpecificIndexType() {
/* Using some definitely not an index type to test there's no weird
compile-time assertion preventing this. Also using a strided view to
have the same case as with implementation-specific vertex formats
below -- for an implementation-specific type it's always strided,
anyway. */
VertexWithImplementationSpecificData indexData[]{{12.3l}, {34.5l}, {45.6l}};
/* Constructing should work w/o asserts */
Containers::StridedArrayView1D<long double> indices{indexData,
&indexData[0].thing, 3, sizeof(VertexWithImplementationSpecificData)};
MeshData data{MeshPrimitive::Triangles, DataFlag::Mutable, indexData,
MeshIndexData{meshIndexTypeWrap(0xcaca), indices}, 1};
/* Getting typeless indices should work also */
CORRADE_COMPARE(data.indexType(), meshIndexTypeWrap(0xcaca));
CORRADE_COMPARE(data.indexCount(), 3);
CORRADE_COMPARE(data.indexStride(), sizeof(VertexWithImplementationSpecificData));
/* The actual type size is unknown, so this will use the full stride */
CORRADE_COMPARE(data.indices().size()[1], sizeof(VertexWithImplementationSpecificData));
CORRADE_COMPARE_AS((Containers::arrayCast<1, const long double>(
data.indices().prefix({3, sizeof(long double)}))),
indices, TestSuite::Compare::Container);
CORRADE_COMPARE_AS((Containers::arrayCast<1, const long double>(
data.mutableIndices().prefix({3, sizeof(long double)}))),
indices, TestSuite::Compare::Container);
}
Trade: move MeshData impl-specific vert format tests closer to the rest. Because this way I wasn't even aware these got tested and so I didn't extend them for zero/negative strides. Now they got proper treatment.
4 years ago
void MeshDataTest::constructImplementationSpecificVertexFormat() {
VertexWithImplementationSpecificData vertexData[] {
{456.0l},
{456.0l}
};
/* Constructing should work w/o asserts */
Containers::StridedArrayView1D<long double> attribute{vertexData,
&vertexData[0].thing, 2, sizeof(VertexWithImplementationSpecificData)};
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,
Trade: allow array attributes to have implementation-specific formats. I'm not sure why this restriction was there as nothing was preventing them from being used. The attribute is only accessible through the typeless attribute(), which gives back `Containers::StridedArrayView2D<const char>` with second dimension size being set to the full stride. And there it doesn't matter if the format is an array or not. This will be useful for joint IDs and weights, for example doing crazy things like packing the IDs into an array of 8 4-bit numbers, saving half the memory compared to the smallest builtin representation using UnsignedByte[8].
4 years ago
vertexFormatWrap(0xdead4), attribute},
MeshAttributeData{meshAttributeCustom(35),
vertexFormatWrap(0xdead5), attribute, 27}}};
Trade: move MeshData impl-specific vert format tests closer to the rest. Because this way I wasn't even aware these got tested and so I didn't extend them for zero/negative strides. Now they got proper treatment.
4 years ago
/* Getting typeless attribute should work also */
UnsignedInt format = 0xdead1;
for(MeshAttribute name: {MeshAttribute::Position,
MeshAttribute::Normal,
MeshAttribute::TextureCoordinates,
Trade: allow array attributes to have implementation-specific formats. I'm not sure why this restriction was there as nothing was preventing them from being used. The attribute is only accessible through the typeless attribute(), which gives back `Containers::StridedArrayView2D<const char>` with second dimension size being set to the full stride. And there it doesn't matter if the format is an array or not. This will be useful for joint IDs and weights, for example doing crazy things like packing the IDs into an array of 8 4-bit numbers, saving half the memory compared to the smallest builtin representation using UnsignedByte[8].
4 years ago
MeshAttribute::Color,
meshAttributeCustom(35)}) {
Trade: move MeshData impl-specific vert format tests closer to the rest. Because this way I wasn't even aware these got tested and so I didn't extend them for zero/negative strides. Now they got proper treatment.
4 years ago
CORRADE_ITERATION(name);
CORRADE_COMPARE(data.attributeFormat(name), vertexFormatWrap(format++));
/* The actual type size is unknown, so this will use the full stride */
CORRADE_COMPARE(data.attribute(name).size()[1], sizeof(VertexWithImplementationSpecificData));
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);
}
}
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
void MeshDataTest::constructSpecialIndexStrides() {
/* Every second index */
{
Containers::Array<char> indexData{sizeof(UnsignedShort)*8};
Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
Utility::copy({1, 0, 2, 0, 3, 0, 4, 0}, indices);
MeshData mesh{MeshPrimitive::Points, std::move(indexData), MeshIndexData{indices.every(2)}, 1};
CORRADE_COMPARE(mesh.indexStride(), 4);
/* Type-erased access with a cast later */
CORRADE_COMPARE_AS((Containers::arrayCast<1, const UnsignedShort>(mesh.indices())),
Containers::arrayView<UnsignedShort>({1, 2, 3, 4}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS((Containers::arrayCast<1, UnsignedShort>(mesh.mutableIndices())),
Containers::stridedArrayView<UnsignedShort>({1, 2, 3, 4}),
TestSuite::Compare::Container);
/* Typed access */
CORRADE_COMPARE_AS(mesh.indices<UnsignedShort>(),
Containers::arrayView<UnsignedShort>({1, 2, 3, 4}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(mesh.mutableIndices<UnsignedShort>(),
Containers::stridedArrayView<UnsignedShort>({1, 2, 3, 4}),
TestSuite::Compare::Container);
/* Convenience accessor. This uses the indicesInto() internally so it
verifies both. */
CORRADE_COMPARE_AS(mesh.indicesAsArray(),
Containers::arrayView<UnsignedInt>({1, 2, 3, 4}),
TestSuite::Compare::Container);
/* Zero stride. Not sure how useful like this. */
} {
Containers::Array<char> indexData{sizeof(UnsignedShort)};
Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
indices[0] = 15;
MeshData mesh{MeshPrimitive::Points, std::move(indexData), MeshIndexData{indices.broadcasted<0>(4)}, 1};
CORRADE_COMPARE(mesh.indexStride(), 0);
/* Type-erased access with a cast later */
CORRADE_COMPARE_AS((Containers::arrayCast<1, const UnsignedShort>(mesh.indices())),
Containers::arrayView<UnsignedShort>({15, 15, 15, 15}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS((Containers::arrayCast<1, UnsignedShort>(mesh.mutableIndices())),
Containers::stridedArrayView<UnsignedShort>({15, 15, 15, 15}),
TestSuite::Compare::Container);
/* Typed access */
CORRADE_COMPARE_AS(mesh.indices<UnsignedShort>(),
Containers::arrayView<UnsignedShort>({15, 15, 15, 15}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(mesh.mutableIndices<UnsignedShort>(),
Containers::stridedArrayView<UnsignedShort>({15, 15, 15, 15}),
TestSuite::Compare::Container);
/* The convenience accessor should work as well, as it consumes output
of the type-erased one */
CORRADE_COMPARE_AS(mesh.indicesAsArray(),
Containers::arrayView<UnsignedInt>({15, 15, 15, 15}),
TestSuite::Compare::Container);
/* Negative stride */
} {
Containers::Array<char> indexData{sizeof(UnsignedShort)*4};
Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
Utility::copy({1, 2, 3, 4}, indices);
MeshData mesh{MeshPrimitive::Points, std::move(indexData), MeshIndexData{indices.flipped<0>()}, 1};
CORRADE_COMPARE(mesh.indexStride(), -2);
/* Type-erased access with a cast later */
CORRADE_COMPARE_AS((Containers::arrayCast<1, const UnsignedShort>(mesh.indices())),
Containers::arrayView<UnsignedShort>({4, 3, 2, 1}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS((Containers::arrayCast<1, UnsignedShort>(mesh.mutableIndices())),
Containers::stridedArrayView<UnsignedShort>({4, 3, 2, 1}),
TestSuite::Compare::Container);
/* Typed access */
CORRADE_COMPARE_AS(mesh.indices<UnsignedShort>(),
Containers::arrayView<UnsignedShort>({4, 3, 2, 1}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(mesh.mutableIndices<UnsignedShort>(),
Containers::stridedArrayView<UnsignedShort>({4, 3, 2, 1}),
TestSuite::Compare::Container);
/* The convenience accessor should work as well, as it consumes output
of the type-erased one */
CORRADE_COMPARE_AS(mesh.indicesAsArray(),
Containers::arrayView<UnsignedInt>({4, 3, 2, 1}),
TestSuite::Compare::Container);
}
}
Trade: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
void MeshDataTest::constructSpecialIndexStridesImplementationSpecificIndexType() {
/* Same as constructSpecialIndexStrides() except for custom index types,
which causes the indices() to return the full stride in second
dimension */
/* Every second index */
{
Containers::Array<char> indexData{sizeof(UnsignedShort)*8};
Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
Utility::copy({1, 0, 2, 0, 3, 0, 4, 0}, indices);
MeshData mesh{MeshPrimitive::Points, std::move(indexData), MeshIndexData{meshIndexTypeWrap(0xcaca), indices.every(2)}, 1};
CORRADE_COMPARE(mesh.indexStride(), 4);
/* Type-erased access with a cast later. The size is the whole stride,
so we need to take just the prefix we want. */
CORRADE_COMPARE_AS((Containers::arrayCast<1, const UnsignedShort>(mesh.indices().prefix({mesh.indexCount(), 2}))),
Containers::arrayView<UnsignedShort>({1, 2, 3, 4}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS((Containers::arrayCast<1, UnsignedShort>(mesh.mutableIndices().prefix({mesh.indexCount(), 2}))),
Containers::stridedArrayView<UnsignedShort>({1, 2, 3, 4}),
TestSuite::Compare::Container);
/* Typed access and convenience accessors won't work here due to the
implementation-specific format */
/* Zero stride. The element size is zero as well, meaning there's no way to
access anything except for directly interpreting the data pointer. Which
is actually as desired for implementation-specific index types. */
} {
Containers::Array<char> indexData{sizeof(UnsignedShort)};
Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
indices[0] = 15;
MeshData mesh{MeshPrimitive::Points, std::move(indexData), MeshIndexData{meshIndexTypeWrap(0xcaca), indices.broadcasted<0>(4)}, 1};
CORRADE_COMPARE(mesh.indexStride(), 0);
Use the new, shorter Containers::Size / Stride typedefs.
4 years ago
CORRADE_COMPARE(mesh.indices().size(), (Containers::Size2D{4, 0}));
CORRADE_COMPARE(mesh.mutableIndices().size(), (Containers::Size2D{4, 0}));
CORRADE_COMPARE(mesh.indices().stride(), (Containers::Stride2D{0, 1}));
CORRADE_COMPARE(mesh.mutableIndices().stride(), (Containers::Stride2D{0, 1}));
Trade: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
CORRADE_COMPARE(*reinterpret_cast<const UnsignedShort*>(mesh.indices().data()), 15);
CORRADE_COMPARE(*reinterpret_cast<UnsignedShort*>(mesh.mutableIndices().data()), 15);
/* Typed access and convenience accessors won't work here due to the
implementation-specific format */
/* Negative stride */
} {
Containers::Array<char> indexData{sizeof(UnsignedShort)*4};
Containers::StridedArrayView1D<UnsignedShort> indices = Containers::arrayCast<UnsignedShort>(indexData);
Utility::copy({1, 2, 3, 4}, indices);
MeshData mesh{MeshPrimitive::Points, std::move(indexData), MeshIndexData{meshIndexTypeWrap(0xcaca), indices.flipped<0>()}, 1};
CORRADE_COMPARE(mesh.indexStride(), -2);
/* Type-erased access with a cast later */
CORRADE_COMPARE_AS((Containers::arrayCast<1, const UnsignedShort>(mesh.indices())),
Containers::arrayView<UnsignedShort>({4, 3, 2, 1}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS((Containers::arrayCast<1, UnsignedShort>(mesh.mutableIndices())),
Containers::stridedArrayView<UnsignedShort>({4, 3, 2, 1}),
TestSuite::Compare::Container);
/* Typed access and convenience accessors won't work here due to the
implementation-specific format */
}
}
Trade: support zero and negative strides in mesh attribute data. This is not something the classic GPU vertex pipeline can handle (except maybe Vulkan, which can handle zero strides for instanced attributes?), but useful for other scenarios. This means existing code needs to be aware of and handle the new corner case.
4 years ago
void MeshDataTest::constructSpecialAttributeStrides() {
Containers::Array<char> vertexData{sizeof(UnsignedShort)*5};
Containers::StridedArrayView1D<UnsignedShort> vertices = Containers::arrayCast<UnsignedShort>(vertexData);
Utility::copy({15, 1, 2, 3, 4}, vertices);
MeshData mesh{MeshPrimitive::Points, std::move(vertexData), {
MeshAttributeData{MeshAttribute::ObjectId, vertices.prefix(1).broadcasted<0>(4)},
Adapt to Corrade changes.
4 years ago
MeshAttributeData{MeshAttribute::ObjectId, vertices.exceptPrefix(1).flipped<0>()},
Trade: support zero and negative strides in mesh attribute data. This is not something the classic GPU vertex pipeline can handle (except maybe Vulkan, which can handle zero strides for instanced attributes?), but useful for other scenarios. This means existing code needs to be aware of and handle the new corner case.
4 years ago
}};
CORRADE_COMPARE(mesh.attributeStride(0), 0);
CORRADE_COMPARE(mesh.attributeStride(1), -2);
/* Type-erased access with a cast later */
CORRADE_COMPARE_AS((Containers::arrayCast<1, const UnsignedShort>(mesh.attribute(0))),
Containers::arrayView<UnsignedShort>({15, 15, 15, 15}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS((Containers::arrayCast<1, UnsignedShort>(mesh.mutableAttribute(0))),
Containers::stridedArrayView<UnsignedShort>({15, 15, 15, 15}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS((Containers::arrayCast<1, const UnsignedShort>(mesh.attribute(1))),
Containers::arrayView<UnsignedShort>({4, 3, 2, 1}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS((Containers::arrayCast<1, UnsignedShort>(mesh.mutableAttribute(1))),
Containers::stridedArrayView<UnsignedShort>({4, 3, 2, 1}),
TestSuite::Compare::Container);
/* Typed access */
CORRADE_COMPARE_AS(mesh.attribute<UnsignedShort>(0),
Containers::arrayView<UnsignedShort>({15, 15, 15, 15}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(mesh.mutableAttribute<UnsignedShort>(0),
Containers::stridedArrayView<UnsignedShort>({15, 15, 15, 15}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(mesh.attribute<UnsignedShort>(1),
Containers::arrayView<UnsignedShort>({4, 3, 2, 1}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(mesh.mutableAttribute<UnsignedShort>(1),
Containers::stridedArrayView<UnsignedShort>({4, 3, 2, 1}),
TestSuite::Compare::Container);
/* All convenience accessors should work well also as they consume the
output of the type-erased one. But just to be sure, test at least
one. */
CORRADE_COMPARE_AS(mesh.objectIdsAsArray(0),
Containers::arrayView<UnsignedInt>({15, 15, 15, 15}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(mesh.objectIdsAsArray(1),
Containers::arrayView<UnsignedInt>({4, 3, 2, 1}),
TestSuite::Compare::Container);
}
void MeshDataTest::constructSpecialAttributeStridesImplementationSpecificVertexFormat() {
/* Same as constructSpecialAttributeStrides() except for custom vertex
formats, which causes the attribute() to return the full stride in
second dimension */
Containers::Array<char> vertexData{sizeof(UnsignedShort)*5};
Containers::StridedArrayView1D<UnsignedShort> vertices = Containers::arrayCast<UnsignedShort>(vertexData);
Utility::copy({15, 1, 2, 3, 4}, vertices);
MeshData mesh{MeshPrimitive::Points, std::move(vertexData), {
MeshAttributeData{MeshAttribute::ObjectId, vertexFormatWrap(0xdead), vertices.prefix(1).broadcasted<0>(4)},
Adapt to Corrade changes.
4 years ago
MeshAttributeData{MeshAttribute::ObjectId, vertexFormatWrap(0xdead), vertices.exceptPrefix(1).flipped<0>()}
Trade: support zero and negative strides in mesh attribute data. This is not something the classic GPU vertex pipeline can handle (except maybe Vulkan, which can handle zero strides for instanced attributes?), but useful for other scenarios. This means existing code needs to be aware of and handle the new corner case.
4 years ago
}};
CORRADE_COMPARE(mesh.attributeStride(0), 0);
CORRADE_COMPARE(mesh.attributeStride(1), -2);
/* Type-erased access with a cast later. For the zero-stride attribute the
element size is zero as well, meaning there's no way to access anything
except for directly interpreting the data pointer. Which is actually as
desired for implementation-specific vertex formats. */
Use the new, shorter Containers::Size / Stride typedefs.
4 years ago
CORRADE_COMPARE(mesh.attribute(0).size(), (Containers::Size2D{4, 0}));
CORRADE_COMPARE(mesh.mutableAttribute(0).size(), (Containers::Size2D{4, 0}));
CORRADE_COMPARE(mesh.attribute(0).stride(), (Containers::Stride2D{0, 1}));
CORRADE_COMPARE(mesh.mutableAttribute(0).stride(), (Containers::Stride2D{0, 1}));
Trade: support zero and negative strides in mesh attribute data. This is not something the classic GPU vertex pipeline can handle (except maybe Vulkan, which can handle zero strides for instanced attributes?), but useful for other scenarios. This means existing code needs to be aware of and handle the new corner case.
4 years ago
CORRADE_COMPARE(*reinterpret_cast<const UnsignedShort*>(mesh.attribute(0).data()), 15);
CORRADE_COMPARE(*reinterpret_cast<UnsignedShort*>(mesh.mutableAttribute(0).data()), 15);
CORRADE_COMPARE_AS((Containers::arrayCast<1, const UnsignedShort>(mesh.attribute(1))),
Containers::arrayView<UnsignedShort>({4, 3, 2, 1}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS((Containers::arrayCast<1, UnsignedShort>(mesh.mutableAttribute(1))),
Containers::stridedArrayView<UnsignedShort>({4, 3, 2, 1}),
TestSuite::Compare::Container);
/* Typed access and convenience accessors won't work here due to the
implementation-specific format */
}
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::constructIndexDataButNotIndexed() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
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
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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
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
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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
Trade: further clean up MeshData/SceneData view containment tests. No need to have redundant cases there just because the order was weird.
4 years ago
const Containers::Array<char> indexData{reinterpret_cast<char*>(0xbadda9), 3*sizeof(UnsignedShort), [](char*, std::size_t){}};
Containers::Array<char> sameIndexDataButMovable{reinterpret_cast<char*>(0xbadda9), 3*sizeof(UnsignedShort), [](char*, std::size_t){}};
Trade: improve tests for MeshData index/attribute view range checks. Found a bug with attribute array size not being taken into account. It triggers now.
5 years ago
Containers::ArrayView<UnsignedShort> indexDataSlightlyOut{reinterpret_cast<UnsignedShort*>(0xbaddaa), 3};
Containers::ArrayView<UnsignedShort> indexDataOut{reinterpret_cast<UnsignedShort*>(0xdead), 3};
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
Containers::StridedArrayView1D<UnsignedShort> indexDataStridedOut{{reinterpret_cast<UnsignedShort*>(0xbadda9), 6}, 3, 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
Trade: further clean up MeshData/SceneData view containment tests. No need to have redundant cases there just because the order was weird.
4 years ago
/* "Obviously good" case */
MeshData{MeshPrimitive::Triangles, {}, indexData, MeshIndexData{Containers::arrayCast<UnsignedShort>(indexData)}, 1};
Trade: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
/* An implementation-specific index type has a size assumed to be 0, so
even though the last element starts at 0xbaddaf it's fine */
MeshData{MeshPrimitive::Triangles, {}, indexData, MeshIndexData{meshIndexTypeWrap(0xcaca), Containers::StridedArrayView1D<UnsignedShort>{reinterpret_cast<UnsignedShort*>(0xbadda9 + sizeof(UnsignedShort)), 3}}, 1};
/* This has both stride and size zero, so it's treated as both starting and
ending at 0xbaddaf */
MeshData{MeshPrimitive::Triangles, {}, indexData, MeshIndexData{meshIndexTypeWrap(0xcaca), Containers::StridedArrayView1D<UnsignedShort>{{reinterpret_cast<UnsignedShort*>(0xbaddaf), 1}, 1}.broadcasted<0>(3)}, 1};
Trade: further clean up MeshData/SceneData view containment tests. No need to have redundant cases there just because the order was weird.
4 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
std::ostringstream out;
Error redirectError{&out};
Trade: further clean up MeshData/SceneData view containment tests. No need to have redundant cases there just because the order was weird.
4 years ago
/* Basic "obviously wrong" case with owned index data */
MeshData{MeshPrimitive::Triangles, std::move(sameIndexDataButMovable), MeshIndexData{indexDataOut}, 1};
/* A "slightly off" view that exceeds the original by one byte */
Trade: improve tests for MeshData index/attribute view range checks. Found a bug with attribute array size not being taken into account. It triggers now.
5 years ago
MeshData{MeshPrimitive::Triangles, {}, indexData, MeshIndexData{indexDataSlightlyOut}, 1};
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
/* A strided index array which would pass if stride wasn't taken into
account */
MeshData{MeshPrimitive::Triangles, {}, indexData, MeshIndexData{indexDataStridedOut}, 1};
Trade: improve tests for MeshData index/attribute view range checks. Found a bug with attribute array size not being taken into account. It triggers now.
5 years ago
/* Empty view which however begins outside */
MeshData{MeshPrimitive::Triangles, {}, indexData, MeshIndexData{indexDataSlightlyOut.slice(3, 3)}, 1};
/* If we have no data at all, it doesn't try to dereference them but still
checks properly */
MeshData{MeshPrimitive::Triangles, nullptr, MeshIndexData{indexDataOut}, 1};
Trade: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
/* An implementation-specific index type has a size assumed to be 0, but
even then this exceeds the data by one byte */
MeshData{MeshPrimitive::Triangles, {}, indexData, MeshIndexData{meshIndexTypeWrap(0xcaca), Containers::StridedArrayView1D<UnsignedShort>{reinterpret_cast<UnsignedShort*>(0xbadda9 + sizeof(UnsignedShort) + 1), 3}}, 1};
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
/* And the final boss, negative strides. Only caught if the element size
gets properly added to the larger offset, not just the "end". */
MeshData{MeshPrimitive::Triangles, {}, indexData, MeshIndexData{stridedArrayView(indexDataSlightlyOut).flipped<0>()}, 1};
Trade: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
/* In this case the implementation-specific type is treated as having a
zero size, and the stride is zero as well, but since it starts one byte
after, it's wrong */
MeshData{MeshPrimitive::Triangles, {}, indexData, MeshIndexData{meshIndexTypeWrap(0xcaca), Containers::StridedArrayView1D<UnsignedShort>{{reinterpret_cast<UnsignedShort*>(0xbaddaf + 1), 1}, 1}.broadcasted<0>(3)}, 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: improve tests for MeshData index/attribute view range checks. Found a bug with attribute array size not being taken into account. It triggers now.
5 years ago
"Trade::MeshData: indices [0xdead:0xdeb3] are not contained in passed indexData array [0xbadda9:0xbaddaf]\n"
Trade: further clean up MeshData/SceneData view containment tests. No need to have redundant cases there just because the order was weird.
4 years ago
"Trade::MeshData: indices [0xbaddaa:0xbaddb0] are not contained in passed indexData array [0xbadda9:0xbaddaf]\n"
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
"Trade::MeshData: indices [0xbadda9:0xbaddb3] are not contained in passed indexData array [0xbadda9:0xbaddaf]\n"
Trade: improve tests for MeshData index/attribute view range checks. Found a bug with attribute array size not being taken into account. It triggers now.
5 years ago
/* This scenario is invalid, just have it here for the record */
"Trade::MeshData: indexData passed for a non-indexed mesh\n"
Trade: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
"Trade::MeshData: indices [0xdead:0xdeb3] are not contained in passed indexData array [0x0:0x0]\n"
Trade: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
"Trade::MeshData: indices [0xbaddac:0xbaddb0] are not contained in passed indexData array [0xbadda9:0xbaddaf]\n"
"Trade::MeshData: indices [0xbaddaa:0xbaddb0] are not contained in passed indexData array [0xbadda9:0xbaddaf]\n"
"Trade::MeshData: indices [0xbaddb0:0xbaddb0] are not contained in passed indexData array [0xbadda9:0xbaddaf]\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::constructAttributeNotContained() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
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: further clean up MeshData/SceneData view containment tests. No need to have redundant cases there just because the order was weird.
4 years ago
const Containers::Array<char> vertexData{reinterpret_cast<char*>(0xbadda9), 3*sizeof(Vector2), [](char*, std::size_t){}};
Containers::Array<char> sameVertexDataButMovable{reinterpret_cast<char*>(0xbadda9), 3*sizeof(Vector2), [](char*, std::size_t){}};
Trade: improve tests for MeshData index/attribute view range checks. Found a bug with attribute array size not being taken into account. It triggers now.
5 years ago
Containers::ArrayView<Vector2> vertexDataIn{reinterpret_cast<Vector2*>(0xbadda9), 3};
Trade: support zero and negative strides in mesh attribute data. This is not something the classic GPU vertex pipeline can handle (except maybe Vulkan, which can handle zero strides for instanced attributes?), but useful for other scenarios. This means existing code needs to be aware of and handle the new corner case.
4 years ago
Containers::ArrayView<Vector2> vertexDataSlightlyOut{reinterpret_cast<Vector2*>(0xbaddaa), 3};
Trade: improve tests for MeshData index/attribute view range checks. Found a bug with attribute array size not being taken into account. It triggers now.
5 years ago
Containers::ArrayView<Vector2> vertexDataOut{reinterpret_cast<Vector2*>(0xdead), 3};
MeshAttributeData{MeshAttribute::Position, Containers::arrayCast<Vector2>(vertexData)};
Trade: further clean up MeshData/SceneData view containment tests. No need to have redundant cases there just because the order was weird.
4 years ago
/* "Obviously good" case */
MeshData{MeshPrimitive::Triangles, {}, vertexData, {
MeshAttributeData{MeshAttribute::Position, vertexDataIn}
}};
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 */
Trade: improve tests for MeshData index/attribute view range checks. Found a bug with attribute array size not being taken into account. It triggers now.
5 years ago
MeshData{MeshPrimitive::Triangles, {}, vertexData.prefix(16), {
Trade: further clean up MeshData/SceneData view containment tests. No need to have redundant cases there just because the order was weird.
4 years ago
MeshAttributeData{MeshAttribute::Position, vertexDataIn}
Trade: improve tests for MeshData index/attribute view range checks. Found a bug with attribute array size not being taken into account. It triggers now.
5 years ago
}, 2};
Trade: move MeshData impl-specific vert format tests closer to the rest. Because this way I wasn't even aware these got tested and so I didn't extend them for zero/negative strides. Now they got proper treatment.
4 years ago
/* An implementation-specific vertex format has a size assumed to be 0, so
even though the last element starts at 0xbaddc1 it's fine */
MeshData{MeshPrimitive::Triangles, {}, vertexData, {
MeshAttributeData{MeshAttribute::Position, vertexFormatWrap(0xcaca), Containers::ArrayView<Vector2>{reinterpret_cast<Vector2*>(0xbadda9 + sizeof(Vector2)), 3}}
}};
/* This has both stride and size zero, so it's treated as both starting and
ending at 0xbaddc1 */
MeshData{MeshPrimitive::Triangles, {}, vertexData, {
MeshAttributeData{MeshAttribute::Position, vertexFormatWrap(0xcaca), Containers::StridedArrayView1D<Vector2>{{reinterpret_cast<Vector2*>(0xbaddc1), 1}, 1}.broadcasted<0>(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
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: further clean up MeshData/SceneData view containment tests. No need to have redundant cases there just because the order was weird.
4 years ago
/* Basic "obviously wrong" case with owned vertex data */
MeshData{MeshPrimitive::Triangles, std::move(sameVertexDataButMovable), {
/* This is here to test that not just the first attribute gets checked
and that the message shows proper ID */
MeshAttributeData{MeshAttribute::Position, vertexDataIn},
MeshAttributeData{MeshAttribute::Position, Containers::arrayView(vertexDataOut)}
}};
/* A "slightly off" view that exceeds the original by one byte */
MeshData{MeshPrimitive::Triangles, {}, vertexData, {
MeshAttributeData{MeshAttribute::Position, vertexDataSlightlyOut}
}};
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 */
Trade: improve tests for MeshData index/attribute view range checks. Found a bug with attribute array size not being taken into account. It triggers now.
5 years ago
MeshData{MeshPrimitive::Triangles, {}, vertexData, {
MeshAttributeData{MeshAttribute::Position, vertexDataIn}
}, 4};
/* Spanning 20 bytes originally, 25 when vertex count is changed to 5. If
array size wouldn't be taken into account, it would span only 16 / 21,
which fits into the vertex data size and thus wouldn't fail */
MeshData{MeshPrimitive::Triangles, {}, vertexData, {
Trade: support zero and negative strides in mesh attribute data. This is not something the classic GPU vertex pipeline can handle (except maybe Vulkan, which can handle zero strides for instanced attributes?), but useful for other scenarios. This means existing code needs to be aware of and handle the new corner case.
4 years ago
MeshAttributeData{meshAttributeCustom(37), Containers::StridedArrayView2D<const UnsignedByte>{Containers::arrayCast<const UnsignedByte>(vertexData), {4, 5}, {5, 1}}}
Trade: improve tests for MeshData index/attribute view range checks. Found a bug with attribute array size not being taken into account. It triggers now.
5 years ago
}, 5};
/* And if we have no data at all, it doesn't try to dereference them but
still checks properly */
MeshData{MeshPrimitive::Triangles, nullptr, {
MeshAttributeData{MeshAttribute::Position, vertexDataIn}
}};
Trade: support zero and negative strides in mesh attribute data. This is not something the classic GPU vertex pipeline can handle (except maybe Vulkan, which can handle zero strides for instanced attributes?), but useful for other scenarios. This means existing code needs to be aware of and handle the new corner case.
4 years ago
/* Offset-only attributes with a different message */
Trade: improve tests for MeshData index/attribute view range checks. Found a bug with attribute array size not being taken into account. It triggers now.
5 years ago
MeshData{MeshPrimitive::Triangles, Containers::Array<char>{24}, {
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector2, 1, 3, 8}
}};
/* This again spans 21 bytes if array size isn't taken into account, and 25
if it is */
MeshData{MeshPrimitive::Triangles, Containers::Array<char>{24}, {
MeshAttributeData{meshAttributeCustom(37), VertexFormat::UnsignedByte, 0, 5, 5, 5}
}};
Trade: move MeshData impl-specific vert format tests closer to the rest. Because this way I wasn't even aware these got tested and so I didn't extend them for zero/negative strides. Now they got proper treatment.
4 years ago
/* An implementation-specific vertex format has a size assumed to be 0, but
even then this exceeds the data by one byte */
MeshData{MeshPrimitive::Triangles, {}, vertexData, {
MeshAttributeData{MeshAttribute::Position, vertexFormatWrap(0xcaca), Containers::ArrayView<Vector2>{reinterpret_cast<Vector2*>(0xbadda9 + sizeof(Vector2) + 1), 3}}
}};
Trade: support zero and negative strides in mesh attribute data. This is not something the classic GPU vertex pipeline can handle (except maybe Vulkan, which can handle zero strides for instanced attributes?), but useful for other scenarios. This means existing code needs to be aware of and handle the new corner case.
4 years ago
/* And the final boss, negative strides. Both only caught if the element
size gets properly added to the larger offset, not just the "end". */
MeshData{MeshPrimitive::Triangles, {}, vertexData, {
MeshAttributeData{MeshAttribute::Position, stridedArrayView(vertexDataSlightlyOut).flipped<0>()}
}};
MeshData{MeshPrimitive::Triangles, Containers::Array<char>{24}, {
MeshAttributeData{meshAttributeCustom(37), VertexFormat::UnsignedByte, 24, 3, -8}
}};
Trade: move MeshData impl-specific vert format tests closer to the rest. Because this way I wasn't even aware these got tested and so I didn't extend them for zero/negative strides. Now they got proper treatment.
4 years ago
/* In this case the implementation-specific format is treated as having a
zero size, and the stride is zero as well, but since it starts one byte
after, it's wrong */
MeshData{MeshPrimitive::Triangles, {}, vertexData, {
MeshAttributeData{MeshAttribute::Position, vertexFormatWrap(0xcaca), Containers::StridedArrayView1D<Vector2>{{reinterpret_cast<Vector2*>(0xbaddc1 + 1), 1}, 1}.broadcasted<0>(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(out.str(),
Trade: further clean up MeshData/SceneData view containment tests. No need to have redundant cases there just because the order was weird.
4 years ago
"Trade::MeshData: attribute 1 [0xdead:0xdec5] is not contained in passed vertexData array [0xbadda9:0xbaddc1]\n"
"Trade::MeshData: attribute 0 [0xbaddaa:0xbaddc2] is not contained in passed vertexData array [0xbadda9:0xbaddc1]\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
"Trade::MeshData: attribute 0 [0xbadda9:0xbaddc9] is not contained in passed vertexData array [0xbadda9:0xbaddc1]\n"
Trade: improve tests for MeshData index/attribute view range checks. Found a bug with attribute array size not being taken into account. It triggers now.
5 years ago
"Trade::MeshData: attribute 0 [0xbadda9:0xbaddc2] 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: support zero and negative strides in mesh attribute data. This is not something the classic GPU vertex pipeline can handle (except maybe Vulkan, which can handle zero strides for instanced attributes?), but useful for other scenarios. This means existing code needs to be aware of and handle the new corner case.
4 years ago
"Trade::MeshData: offset-only attribute 0 spans 25 bytes but passed vertexData array has only 24\n"
Trade: improve tests for MeshData index/attribute view range checks. Found a bug with attribute array size not being taken into account. It triggers now.
5 years ago
"Trade::MeshData: offset-only attribute 0 spans 25 bytes but passed vertexData array has only 24\n"
Trade: support zero and negative strides in mesh attribute data. This is not something the classic GPU vertex pipeline can handle (except maybe Vulkan, which can handle zero strides for instanced attributes?), but useful for other scenarios. This means existing code needs to be aware of and handle the new corner case.
4 years ago
Trade: move MeshData impl-specific vert format tests closer to the rest. Because this way I wasn't even aware these got tested and so I didn't extend them for zero/negative strides. Now they got proper treatment.
4 years ago
"Trade::MeshData: attribute 0 [0xbaddb2:0xbaddc2] is not contained in passed vertexData array [0xbadda9:0xbaddc1]\n"
Trade: support zero and negative strides in mesh attribute data. This is not something the classic GPU vertex pipeline can handle (except maybe Vulkan, which can handle zero strides for instanced attributes?), but useful for other scenarios. This means existing code needs to be aware of and handle the new corner case.
4 years ago
"Trade::MeshData: attribute 0 [0xbaddaa:0xbaddc2] is not contained in passed vertexData array [0xbadda9:0xbaddc1]\n"
"Trade::MeshData: offset-only attribute 0 spans 25 bytes but passed vertexData array has only 24\n"
Trade: move MeshData impl-specific vert format tests closer to the rest. Because this way I wasn't even aware these got tested and so I didn't extend them for zero/negative strides. Now they got proper treatment.
4 years ago
"Trade::MeshData: attribute 0 [0xbaddc2:0xbaddc2] is not contained in passed vertexData array [0xbadda9:0xbaddc1]\n"
Trade: support zero and negative strides in mesh attribute data. This is not something the classic GPU vertex pipeline can handle (except maybe Vulkan, which can handle zero strides for instanced attributes?), but useful for other scenarios. This means existing code needs to be aware of and handle the new corner case.
4 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
}
void MeshDataTest::constructInconsitentVertexCount() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
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
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 support for Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
void MeshDataTest::constructDifferentJointIdWeightCount() {
CORRADE_SKIP_IF_NO_ASSERT();
struct Vertex {
/* Weights required to be here by the constructor */
Float weights[2];
UnsignedByte jointIds[2];
UnsignedShort secondaryJointIds[4];
} vertices[3]{};
auto view = Containers::stridedArrayView(vertices);
std::ostringstream out;
Error redirectError{&out};
MeshData{MeshPrimitive::Points, {}, vertices, {
/* Weights required to be here by the constructor */
MeshAttributeData{MeshAttribute::Weights, VertexFormat::Float,
view.slice(&Vertex::weights), 2},
MeshAttributeData{MeshAttribute::JointIds, VertexFormat::UnsignedByte,
view.slice(&Vertex::jointIds), 2},
MeshAttributeData{MeshAttribute::JointIds, VertexFormat::UnsignedShort,
view.slice(&Vertex::secondaryJointIds), 4}
}};
CORRADE_COMPARE(out.str(), "Trade::MeshData: expected 2 weight attributes to match joint IDs but got 1\n");
}
void MeshDataTest::constructInconsistentJointIdWeightArraySizes() {
CORRADE_SKIP_IF_NO_ASSERT();
struct Vertex {
/* Weights required to be here by the constructor */
Float weights[2];
UnsignedByte jointIds[2];
Trade: attempt to resuscitate GCC 4.8 that died on this test. ../src/Magnum/Trade/Test/MeshDataTest.cpp:2470:19: internal compiler error: in gimplify_init_constructor, at gimplify.c:4271
4 years ago
UnsignedShort secondaryWeights[3]; /* Half together with {} makes GCC 4.8 crash */
Trade: implement support for Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
UnsignedShort secondaryJointIds[4];
} vertices[3]{};
auto view = Containers::stridedArrayView(vertices);
std::ostringstream out;
Error redirectError{&out};
MeshData{MeshPrimitive::Points, {}, vertices, {
/* Weights required to be here by the constructor */
MeshAttributeData{MeshAttribute::Weights, VertexFormat::Float,
view.slice(&Vertex::weights), 2},
MeshAttributeData{MeshAttribute::JointIds, VertexFormat::UnsignedByte,
view.slice(&Vertex::jointIds), 2},
MeshAttributeData{MeshAttribute::Weights, VertexFormat::Half,
view.slice(&Vertex::secondaryWeights), 3},
MeshAttributeData{MeshAttribute::JointIds, VertexFormat::UnsignedShort,
view.slice(&Vertex::secondaryJointIds), 4}
}};
CORRADE_COMPARE(out.str(), "Trade::MeshData: expected 4 array items for weight attribute 1 to match joint IDs but got 3\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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 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
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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 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
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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 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
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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 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
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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 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
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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 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
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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
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
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() {
Test: use shorter std::is_copy_{constructible,assignable} everywhere. I wonder why I didn't do this from the beginning, back in 2010 or so.
5 years ago
CORRADE_VERIFY(!std::is_copy_constructible<MeshData>{});
CORRADE_VERIFY(!std::is_copy_assignable<MeshData>{});
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::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; } \
};
Trade: implement support for Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
/* Scalars are in Math::TypeTraits already */
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(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());
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
T indices[]{75, 131, 240};
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: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
MeshData data{MeshPrimitive::Points, {}, indices, MeshIndexData{indices}, 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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
UnsignedInt indices[3]{};
MeshData data{MeshPrimitive::Points, {}, indices, MeshIndexData{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
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: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
/* Testing also that it picks the correct attribute */
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
struct Vertex {
Vector2 otherPosition;
UnsignedShort objectId;
T position;
} vertices[]{
{{}, 0, T::pad(Math::Vector2<TT>{TT(2.0f), TT(1.0f)})},
{{}, 0, T::pad(Math::Vector2<TT>{TT(0.0f), TT(-1.0f)})},
{{}, 0, T::pad(Math::Vector2<TT>{TT(-2.0f), TT(3.0f)})}
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
};
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
auto view = Containers::stridedArrayView(vertices);
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: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
MeshData data{MeshPrimitive::Points, {}, vertices, {
MeshAttributeData{MeshAttribute::Position, view.slice(&Vertex::otherPosition)},
MeshAttributeData{MeshAttribute::ObjectId, view.slice(&Vertex::objectId)},
MeshAttributeData{MeshAttribute::Position, view.slice(&Vertex::position)}
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
}};
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
CORRADE_COMPARE_AS(data.positions2DAsArray(1), Containers::arrayView<Vector2>({
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
{2.0f, 1.0f}, {0.0f, -1.0f}, {-2.0f, 3.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
}
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());
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
T positions[]{
T::pad(Math::Vector2<TT>{2, 1}),
T::pad(Math::Vector2<TT>{0, 15}),
T::pad(Math::Vector2<TT>{22, 3})
};
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
MeshData data{MeshPrimitive::Points, {}, positions, {
MeshAttributeData{MeshAttribute::Position, Containers::arrayView(positions)}
}};
CORRADE_COMPARE_AS(data.positions2DAsArray(), Containers::arrayView<Vector2>({
{2.0f, 1.0f}, {0.0f, 15.0f}, {22.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::positions2DAsArrayPackedSigned() {
setTestCaseTemplateName(NameTraits<T>::name());
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
T positions[]{
T::pad(Math::Vector2<TT>{2, 1}),
T::pad(Math::Vector2<TT>{0, -15}),
T::pad(Math::Vector2<TT>{-22, 3})
};
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
MeshData data{MeshPrimitive::Points, {}, positions, {
MeshAttributeData{MeshAttribute::Position, Containers::arrayView(positions)}
}};
CORRADE_COMPARE_AS(data.positions2DAsArray(), Containers::arrayView<Vector2>({
{2.0f, 1.0f}, {0.0f, -15.0f}, {-22.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::positions2DAsArrayPackedUnsignedNormalized() {
setTestCaseTemplateName(NameTraits<T>::name());
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
T positions[]{
T::pad(Math::Vector2<TT>{Math::pack<TT>(1.0f), 0}),
T::pad(Math::Vector2<TT>{0, Math::pack<TT>(1.0f)})
};
MeshData data{MeshPrimitive::Points, {}, positions, {
MeshAttributeData{MeshAttribute::Position,
Trade: use the vertexFormat() helper instead of assuming enum order. Probably also something that got made only after this test was written.
4 years ago
vertexFormat(Implementation::vertexFormatFor<T>(), T::Size, true),
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
Containers::arrayView(positions)}
}};
CORRADE_COMPARE_AS(data.positions2DAsArray(), Containers::arrayView<Vector2>({
{1.0f, 0.0f}, {0.0f, 1.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::positions2DAsArrayPackedSignedNormalized() {
setTestCaseTemplateName(NameTraits<T>::name());
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
T positions[]{
T::pad(Math::Vector2<TT>{Math::pack<TT>(1.0f), 0}),
T::pad(Math::Vector2<TT>{0, Math::pack<TT>(-1.0f)})
};
MeshData data{MeshPrimitive::Points, {}, positions, {
MeshAttributeData{MeshAttribute::Position,
Trade: use the vertexFormat() helper instead of assuming enum order. Probably also something that got made only after this test was written.
4 years ago
vertexFormat(Implementation::vertexFormatFor<T>(), T::Size, true),
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
Containers::arrayView(positions)}
}};
CORRADE_COMPARE_AS(data.positions2DAsArray(), Containers::arrayView<Vector2>({
{1.0f, 0.0f}, {0.0f, -1.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
}
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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
Vector2 positions[3]{};
MeshData data{MeshPrimitive::Points, {}, positions, {
MeshAttributeData{MeshAttribute::Position, Containers::arrayView(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
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
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
/* Testing also that it picks the correct attribute. Needs to be
sufficiently representable to have the test work also for half
floats. */
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
struct Vertex {
Vector3 otherPosition;
UnsignedShort objectId;
T position;
} vertices[]{
{{}, 0, T::pad(Math::Vector3<TT>{TT(2.0f), TT(1.0f), TT(0.75f)})},
{{}, 0, T::pad(Math::Vector3<TT>{TT(0.0f), TT(-1.0f), TT(1.25f)})},
{{}, 0, T::pad(Math::Vector3<TT>{TT(-2.0f), TT(3.0f), TT(2.5f)})}
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
};
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
auto view = Containers::stridedArrayView(vertices);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
MeshData data{MeshPrimitive::Points, {}, vertices, {
MeshAttributeData{MeshAttribute::Position, view.slice(&Vertex::otherPosition)},
MeshAttributeData{MeshAttribute::ObjectId, view.slice(&Vertex::objectId)},
MeshAttributeData{MeshAttribute::Position, view.slice(&Vertex::position)}
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
}};
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
CORRADE_COMPARE_AS(data.positions3DAsArray(1), 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, 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
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
T positions[]{
T::pad(Math::Vector3<TT>{2, 1, 135}),
T::pad(Math::Vector3<TT>{0, 15, 2}),
T::pad(Math::Vector3<TT>{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
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
MeshData data{MeshPrimitive::Points, {}, positions, {
MeshAttributeData{MeshAttribute::Position, Containers::arrayView(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
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());
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
T positions[]{
T::pad(Math::Vector3<TT>{2, 1, -117}),
T::pad(Math::Vector3<TT>{0, -15, 2}),
T::pad(Math::Vector3<TT>{-22, 3, 86})
};
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
MeshData data{MeshPrimitive::Points, {}, positions, {
MeshAttributeData{MeshAttribute::Position, Containers::arrayView(positions)}
}};
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
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());
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
T positions[]{
T::pad(Math::Vector3<TT>{Math::pack<TT>(1.0f), 0, Math::pack<TT>(1.0f)}),
T::pad(Math::Vector3<TT>{0, Math::pack<TT>(1.0f), 0})
};
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
MeshData data{MeshPrimitive::Points, {}, positions, {
MeshAttributeData{MeshAttribute::Position,
Trade: use the vertexFormat() helper instead of assuming enum order. Probably also something that got made only after this test was written.
4 years ago
vertexFormat(Implementation::vertexFormatFor<T>(), T::Size, true),
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
Containers::arrayView(positions)}
}};
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
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());
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
T positions[]{
T::pad(Math::Vector3<TT>{Math::pack<TT>(1.0f), 0, Math::pack<TT>(1.0f)}),
T::pad(Math::Vector3<TT>{0, Math::pack<TT>(-1.0f), 0})
};
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
MeshData data{MeshPrimitive::Points, {}, positions, {
MeshAttributeData{MeshAttribute::Position,
Trade: use the vertexFormat() helper instead of assuming enum order. Probably also something that got made only after this test was written.
4 years ago
vertexFormat(Implementation::vertexFormatFor<T>(), T::Size, true),
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
Containers::arrayView(positions)}
}};
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
Vector3 positions[3]{};
MeshData data{MeshPrimitive::Points, {}, positions, {
MeshAttributeData{MeshAttribute::Position, Containers::arrayView(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
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());
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
/* Testing also that it picks the correct attribute. Needs to be
sufficiently representable to have the test work also for half
floats. */
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
struct Vertex {
Vector3 otherTangent;
UnsignedShort objectId;
T tangent;
} vertices[]{
{{}, 0, T::pad(Math::Vector3<TT>{TT(2.0f), TT(1.0f), TT(0.75f)})},
{{}, 0, T::pad(Math::Vector3<TT>{TT(0.0f), TT(-1.0f), TT(1.25f)})},
{{}, 0, T::pad(Math::Vector3<TT>{TT(-2.0f), TT(3.0f), TT(2.5f)})}
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
};
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
auto view = Containers::stridedArrayView(vertices);
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: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
MeshData data{MeshPrimitive::Points, {}, vertices, {
MeshAttributeData{MeshAttribute::Tangent, view.slice(&Vertex::otherTangent)},
MeshAttributeData{MeshAttribute::ObjectId, view.slice(&Vertex::objectId)},
MeshAttributeData{MeshAttribute::Tangent, view.slice(&Vertex::tangent)}
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
}};
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
CORRADE_COMPARE_AS(data.tangentsAsArray(1), Containers::arrayView<Vector3>({
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
{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: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
T tangents[]{
T::pad(Math::Vector3<TT>{Math::pack<TT>(1.0f), 0, Math::pack<TT>(1.0f)}),
T::pad(Math::Vector3<TT>{0, Math::pack<TT>(-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
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
MeshData data{MeshPrimitive::Points, {}, tangents, {
MeshAttributeData{MeshAttribute::Tangent,
Trade: use the vertexFormat() helper instead of assuming enum order. Probably also something that got made only after this test was written.
4 years ago
vertexFormat(Implementation::vertexFormatFor<T>(), T::Size, true),
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
Containers::arrayView(tangents)}
}};
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
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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
Vector3 tangents[3]{};
MeshData data{MeshPrimitive::Points, {}, tangents, {
MeshAttributeData{MeshAttribute::Tangent, Containers::arrayView(tangents)}
}};
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
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());
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
/* Testing also that it picks the correct attribute. Needs to be
sufficiently representable to have the test work also for half
floats. */
struct Vertex {
Vector3 otherTangent;
UnsignedShort objectId;
Math::Vector4<T> tangent;
} vertices[]{
{{}, 0, {T(2.0f), T(1.0f), T(0.75f), T(-1.0f)}},
{{}, 0, {T(0.0f), T(-1.0f), T(1.25f), T(1.0f)}},
{{}, 0, {T(-2.0f), T(3.0f), T(2.5f), T(-1.0f)}}
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
};
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
auto view = Containers::stridedArrayView(vertices);
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: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
MeshData data{MeshPrimitive::Points, {}, vertices, {
MeshAttributeData{MeshAttribute::Tangent, view.slice(&Vertex::otherTangent)},
MeshAttributeData{MeshAttribute::ObjectId, view.slice(&Vertex::objectId)},
MeshAttributeData{MeshAttribute::Tangent, view.slice(&Vertex::tangent)}
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
}};
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
CORRADE_COMPARE_AS(data.bitangentSignsAsArray(1), Containers::arrayView<Float>({
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
-1.0f, 1.0f, -1.0f
}), TestSuite::Compare::Container);
}
template<class T> void MeshDataTest::bitangentSignsAsArrayPackedSignedNormalized() {
setTestCaseTemplateName(Math::TypeTraits<T>::name());
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
Math::Vector4<T> tangents[]{
{Math::pack<T>(1.0f), 0, Math::pack<T>(1.0f), Math::pack<T>(-1.0f)},
{0, Math::pack<T>(-1.0f), 0, Math::pack<T>(1.0f)}
};
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: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
MeshData data{MeshPrimitive::Points, {}, tangents, {
MeshAttributeData{MeshAttribute::Tangent,
Trade: use the vertexFormat() helper instead of assuming enum order. Probably also something that got made only after this test was written.
4 years ago
vertexFormat(Implementation::vertexFormatFor<T>(), 4, true),
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
Containers::arrayView(tangents)}
}};
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
CORRADE_COMPARE_AS(data.bitangentSignsAsArray(), Containers::arrayView<Float>({
-1.0f, 1.0f
}), TestSuite::Compare::Container);
}
void MeshDataTest::bitangentSignsAsArrayNotFourComponent() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
Vector3s tangents[3]{};
MeshData data{MeshPrimitive::Points, {}, tangents, {
MeshAttributeData{MeshAttribute::Tangent, VertexFormat::Vector3sNormalized, Containers::arrayView(tangents)}
}};
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
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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
Vector4 tangents[3]{};
MeshData data{MeshPrimitive::Points, {}, tangents, {
MeshAttributeData{MeshAttribute::Tangent, Containers::arrayView(tangents)}
}};
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
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());
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
/* Testing also that it picks the correct attribute. Needs to be
sufficiently representable to have the test work also for half
floats. */
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
struct Vertex {
Vector3 otherBitangent;
UnsignedShort objectId;
T bitangent;
} vertices[]{
{{}, 0, {TT(2.0f), TT(1.0f), TT(0.75f)}},
{{}, 0, {TT(0.0f), TT(-1.0f), TT(1.25f)}},
{{}, 0, {TT(-2.0f), TT(3.0f), TT(2.5f)}}
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
};
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
auto view = Containers::stridedArrayView(vertices);
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: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
MeshData data{MeshPrimitive::Points, {}, vertices, {
MeshAttributeData{MeshAttribute::Bitangent, view.slice(&Vertex::otherBitangent)},
MeshAttributeData{MeshAttribute::ObjectId, view.slice(&Vertex::objectId)},
MeshAttributeData{MeshAttribute::Bitangent, view.slice(&Vertex::bitangent)}
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
}};
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
CORRADE_COMPARE_AS(data.bitangentsAsArray(1), Containers::arrayView<Vector3>({
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
{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());
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
T bitangents[]{
{Math::pack<TT>(1.0f), 0, Math::pack<TT>(1.0f)},
{0, Math::pack<TT>(-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
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
MeshData data{MeshPrimitive::Points, {}, bitangents, {
MeshAttributeData{MeshAttribute::Bitangent,
Trade: use the vertexFormat() helper instead of assuming enum order. Probably also something that got made only after this test was written.
4 years ago
vertexFormat(Implementation::vertexFormatFor<T>(), T::Size, true),
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
Containers::arrayView(bitangents)}
}};
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
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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
Vector3 bitangents[3]{};
MeshData data{MeshPrimitive::Points, {}, bitangents, {
MeshAttributeData{MeshAttribute::Bitangent, Containers::arrayView(bitangents)}
}};
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
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: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
/* Testing also that it picks the correct attribute. Needs to be
sufficiently representable to have the test work also for half
floats. */
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
struct Vertex {
Vector3 otherNormal;
UnsignedShort objectId;
T normal;
} vertices[]{
{{}, 0, {TT(2.0f), TT(1.0f), TT(0.75f)}},
{{}, 0, {TT(0.0f), TT(-1.0f), TT(1.25f)}},
{{}, 0, {TT(-2.0f), TT(3.0f), TT(2.5f)}}
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
};
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
auto view = Containers::stridedArrayView(vertices);
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: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
MeshData data{MeshPrimitive::Points, {}, vertices, {
MeshAttributeData{MeshAttribute::Normal, view.slice(&Vertex::otherNormal)},
MeshAttributeData{MeshAttribute::ObjectId, view.slice(&Vertex::objectId)},
MeshAttributeData{MeshAttribute::Normal, view.slice(&Vertex::normal)}
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
}};
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
CORRADE_COMPARE_AS(data.normalsAsArray(1), 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());
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
T normals[]{
{Math::pack<TT>(1.0f), 0, Math::pack<TT>(1.0f)},
{0, Math::pack<TT>(-1.0f), 0}
};
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
MeshData data{MeshPrimitive::Points, {}, normals, {
MeshAttributeData{MeshAttribute::Normal,
Trade: use the vertexFormat() helper instead of assuming enum order. Probably also something that got made only after this test was written.
4 years ago
vertexFormat(Implementation::vertexFormatFor<T>(), T::Size, true),
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
Containers::arrayView(normals)}
}};
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
Vector3 normals[3]{};
MeshData data{MeshPrimitive::Points, {}, normals, {
MeshAttributeData{MeshAttribute::Normal, Containers::arrayView(normals)}
}};
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};
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: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
/* Testing also that it picks the correct attribute. Needs to be
sufficiently representable to have the test work also for half
floats. */
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
struct Vertex {
Vector2 otherTextureCoordinate;
UnsignedShort objectId;
T textureCoordinate;
} vertices[]{
{{}, 0, {TT(2.0f), TT(1.0f)}},
{{}, 0, {TT(0.0f), TT(-1.0f)}},
{{}, 0, {TT(-2.0f), TT(3.0f)}}
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
};
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
auto view = Containers::stridedArrayView(vertices);
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: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
MeshData data{MeshPrimitive::Points, {}, vertices, {
MeshAttributeData{MeshAttribute::TextureCoordinates, view.slice(&Vertex::otherTextureCoordinate)},
MeshAttributeData{MeshAttribute::ObjectId, view.slice(&Vertex::objectId)},
MeshAttributeData{MeshAttribute::TextureCoordinates, view.slice(&Vertex::textureCoordinate)}
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
}};
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
CORRADE_COMPARE_AS(data.textureCoordinates2DAsArray(1), Containers::arrayView<Vector2>({
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
{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());
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
T textureCoordinates[]{
{2, 1},
{0, 15},
{22, 3}
};
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
MeshData data{MeshPrimitive::Points, {}, textureCoordinates, {
MeshAttributeData{MeshAttribute::TextureCoordinates, Containers::arrayView(textureCoordinates)}
}};
CORRADE_COMPARE_AS(data.textureCoordinates2DAsArray(), Containers::arrayView<Vector2>({
{2.0f, 1.0f}, {0.0f, 15.0f}, {22.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::textureCoordinates2DAsArrayPackedSigned() {
setTestCaseTemplateName(NameTraits<T>::name());
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
T textureCoordinates[]{
{2, 1},
{0, -15},
{-22, 3}
};
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
MeshData data{MeshPrimitive::Points, {}, textureCoordinates, {
MeshAttributeData{MeshAttribute::TextureCoordinates, Containers::arrayView(textureCoordinates)}
}};
CORRADE_COMPARE_AS(data.textureCoordinates2DAsArray(), Containers::arrayView<Vector2>({
{2.0f, 1.0f}, {0.0f, -15.0f}, {-22.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::textureCoordinates2DAsArrayPackedUnsignedNormalized() {
setTestCaseTemplateName(NameTraits<T>::name());
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
T textureCoordinates[]{
{Math::pack<TT>(1.0f), 0},
{0, Math::pack<TT>(1.0f)}
};
MeshData data{MeshPrimitive::Points, {}, textureCoordinates, {
MeshAttributeData{MeshAttribute::TextureCoordinates,
Trade: use the vertexFormat() helper instead of assuming enum order. Probably also something that got made only after this test was written.
4 years ago
vertexFormat(Implementation::vertexFormatFor<T>(), T::Size, true),
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
Containers::arrayView(textureCoordinates)}
}};
CORRADE_COMPARE_AS(data.textureCoordinates2DAsArray(), Containers::arrayView<Vector2>({
{1.0f, 0.0f}, {0.0f, 1.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::textureCoordinates2DAsArrayPackedSignedNormalized() {
setTestCaseTemplateName(NameTraits<T>::name());
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
T textureCoordinates[]{
{Math::pack<TT>(1.0f), 0},
{0, Math::pack<TT>(-1.0f)}
};
MeshData data{MeshPrimitive::Points, {}, textureCoordinates, {
MeshAttributeData{MeshAttribute::TextureCoordinates,
Trade: use the vertexFormat() helper instead of assuming enum order. Probably also something that got made only after this test was written.
4 years ago
vertexFormat(Implementation::vertexFormatFor<T>(), T::Size, true),
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
Containers::arrayView(textureCoordinates)}
}};
CORRADE_COMPARE_AS(data.textureCoordinates2DAsArray(), Containers::arrayView<Vector2>({
{1.0f, 0.0f}, {0.0f, -1.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
}
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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
Vector2 textureCoordinates[3];
MeshData data{MeshPrimitive::Points, {}, textureCoordinates, {
MeshAttributeData{MeshAttribute::TextureCoordinates, Containers::arrayView(textureCoordinates)}
}};
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};
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: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
/* Testing also that it picks the correct attribute. Can't use e.g.
0xff3366_rgbf because that's not representable in half-floats. */
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
struct Vertex {
Color4 otherColor;
UnsignedShort objectId;
T color;
} vertices[]{
{{}, 0, {TT(2.0f), TT(1.0f), TT(0.75f)}},
{{}, 0, {TT(0.0f), TT(-1.0f), TT(1.25f)}},
{{}, 0, {TT(-2.0f), TT(3.0f), TT(2.5f)}}
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
};
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
auto view = Containers::stridedArrayView(vertices);
Trade: support packed attributes in MeshData. This was a LONG unexpected detour... I mean, I expected it, but not so soon.
6 years ago
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
MeshData data{MeshPrimitive::Points, {}, vertices, {
MeshAttributeData{MeshAttribute::Color, view.slice(&Vertex::otherColor)},
MeshAttributeData{MeshAttribute::ObjectId, view.slice(&Vertex::objectId)},
MeshAttributeData{MeshAttribute::Color, view.slice(&Vertex::color)}
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
}};
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
CORRADE_COMPARE_AS(data.colorsAsArray(1), 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
{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());
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
typedef typename T::Type TT;
T colors[]{
T::pad(Math::Color4<TT>{Math::pack<TT>(1.0f), 0, Math::pack<TT>(1.0f), 0}),
T::pad(Math::Color4<TT>{0, Math::pack<TT>(1.0f), 0, Math::pack<TT>(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
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
MeshData data{MeshPrimitive::Points, {}, colors, {
MeshAttributeData{MeshAttribute::Color, Containers::arrayView(colors)}
}};
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.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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
Color4 colors[3]{};
MeshData data{MeshPrimitive::Points, {}, colors, {
MeshAttributeData{MeshAttribute::Color, Containers::arrayView(colors)}
}};
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};
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 Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
template<class T> void MeshDataTest::jointIdsAsArray() {
setTestCaseTemplateName(Math::TypeTraits<T>::name());
/* Testing also that it picks the correct attribute. Needs to be
sufficiently representable to have the test work also for half
floats. */
struct Vertex {
/* Weights required to be here by the constructor */
Float otherWeights[3];
Float weights[5];
UnsignedInt otherJointIds[3];
UnsignedShort objectId;
T jointIds[5];
} vertices[]{
{{}, {}, {},
0,
{T(0), T(3), T(20), T(1), T(7)}},
{{}, {}, {},
0,
{T(9), T(1), T(15), T(2), T(3)}},
{{}, {}, {},
0,
{T(25), T(7), T(0), T(2), T(1)}},
};
auto view = Containers::stridedArrayView(vertices);
MeshData data{MeshPrimitive::Points, {}, vertices, {
/* Weights required to be here by the constructor */
MeshAttributeData{MeshAttribute::Weights, VertexFormat::Float,
view.slice(&Vertex::otherWeights), 3},
MeshAttributeData{MeshAttribute::Weights, VertexFormat::Float,
view.slice(&Vertex::weights), 5},
MeshAttributeData{MeshAttribute::JointIds,
Implementation::vertexFormatFor<T>(),
view.slice(&Vertex::otherJointIds), 3},
MeshAttributeData{MeshAttribute::ObjectId, view.slice(&Vertex::objectId)},
MeshAttributeData{MeshAttribute::JointIds,
Implementation::vertexFormatFor<T>(),
view.slice(&Vertex::jointIds), 5},
}};
CORRADE_COMPARE_AS(data.jointIdsAsArray(1), (Containers::arrayView<UnsignedInt>({
0, 3, 20, 1, 7,
9, 1, 15, 2, 3,
25, 7, 0, 2, 1
})), TestSuite::Compare::Container);
}
void MeshDataTest::jointIdsIntoArrayInvalidSizeStride() {
CORRADE_SKIP_IF_NO_ASSERT();
struct Vertex {
/* Weights required to be here by the constructor */
Float weights[2];
UnsignedByte jointIds[2];
} vertices[3]{};
auto view = Containers::stridedArrayView(vertices);
MeshData data{MeshPrimitive::Points, {}, vertices, {
/* Weights required to be here by the constructor */
MeshAttributeData{MeshAttribute::Weights, VertexFormat::Float,
view.slice(&Vertex::weights), 2},
MeshAttributeData{MeshAttribute::JointIds, VertexFormat::UnsignedByte,
view.slice(&Vertex::jointIds), 2}
}};
std::ostringstream out;
Error redirectError{&out};
UnsignedInt jointIds1[3*3];
UnsignedInt jointIds2[2*2];
UnsignedInt jointIds3[3*4];
data.jointIdsInto(Containers::StridedArrayView2D<UnsignedInt>{jointIds1, {3, 3}});
data.jointIdsInto(Containers::StridedArrayView2D<UnsignedInt>{jointIds2, {2, 2}});
data.jointIdsInto(Containers::StridedArrayView2D<UnsignedInt>{jointIds3, {3, 4}}.every({1, 2}));
CORRADE_COMPARE(out.str(),
"Trade::MeshData::jointIdsInto(): expected a view with {3, 2} elements but got {3, 3}\n"
"Trade::MeshData::jointIdsInto(): expected a view with {3, 2} elements but got {2, 2}\n"
"Trade::MeshData::jointIdsInto(): second view dimension is not contiguous\n");
}
template<class T> void MeshDataTest::weightsAsArray() {
setTestCaseTemplateName(Math::TypeTraits<T>::name());
/* Testing also that it picks the correct attribute. Needs to be
sufficiently representable to have the test work also for half
floats. */
struct Vertex {
/* Joint IDs required to be here by the constructor */
UnsignedInt otherJointIds[3];
UnsignedInt jointIds[5];
Float otherWeights[3];
UnsignedShort objectId;
T weights[5];
} vertices[]{
{{}, {}, {},
0,
{T(2.0f), T(1.0f), T(0.75f), T(3.0f), T(1.75f)}},
{{}, {}, {},
0,
{T(0.0f), T(-1.0f), T(1.25f), T(1.0f), T(2.25f)}},
{{}, {}, {},
0,
{T(-2.0f), T(3.0f), T(2.5f), T(2.5f), T(0.25f)}},
};
auto view = Containers::stridedArrayView(vertices);
MeshData data{MeshPrimitive::Points, {}, vertices, {
/* Joint IDs required to be here by the constructor */
MeshAttributeData{MeshAttribute::JointIds, VertexFormat::UnsignedInt,
view.slice(&Vertex::otherJointIds), 3},
MeshAttributeData{MeshAttribute::JointIds, VertexFormat::UnsignedInt,
view.slice(&Vertex::jointIds), 5},
MeshAttributeData{MeshAttribute::Weights,
Implementation::vertexFormatFor<T>(),
view.slice(&Vertex::otherWeights), 3},
MeshAttributeData{MeshAttribute::ObjectId, view.slice(&Vertex::objectId)},
MeshAttributeData{MeshAttribute::Weights,
Implementation::vertexFormatFor<T>(),
view.slice(&Vertex::weights), 5}
}};
CORRADE_COMPARE_AS(data.weightsAsArray(1), (Containers::arrayView<Float>({
2.0f, 1.0f, 0.75f, 3.0f, 1.75f,
0.0f, -1.0f, 1.25f, 1.0f, 2.25f,
-2.0f, 3.0f, 2.5f, 2.5f, 0.25f,
})), TestSuite::Compare::Container);
}
template<class T> void MeshDataTest::weightsAsArrayPackedUnsignedNormalized() {
setTestCaseTemplateName(Math::TypeTraits<T>::name());
struct Vertex {
/* Joint IDs required to be here by the constructor */
UnsignedByte jointIds[2];
T weights[2];
} vertices[2]{
{{}, {Math::pack<T>(1.0f), Math::pack<T>(0.8f)}},
{{}, {0, Math::pack<T>(0.4f)}}
};
auto view = Containers::stridedArrayView(vertices);
MeshData data{MeshPrimitive::Points, {}, vertices, {
/* Joint IDs required to be here by the constructor */
MeshAttributeData{MeshAttribute::JointIds, VertexFormat::UnsignedByte,
view.slice(&Vertex::jointIds), 2},
MeshAttributeData{MeshAttribute::Weights,
vertexFormat(Implementation::vertexFormatFor<T>(), 1, true),
view.slice(&Vertex::weights), 2}
}};
CORRADE_COMPARE_AS(data.weightsAsArray(), (Containers::arrayView<Float>({
1.0f, 0.8f,
0.0f, 0.4f
})), TestSuite::Compare::Container);
}
void MeshDataTest::weightsIntoArrayInvalidSizeStride() {
CORRADE_SKIP_IF_NO_ASSERT();
struct Vertex {
/* Joint IDs required to be here by the constructor */
UnsignedInt jointIds[2];
Trade: attempt to resuscitate GCC 4.8 that died on this test. ../src/Magnum/Trade/Test/MeshDataTest.cpp:2470:19: internal compiler error: in gimplify_init_constructor, at gimplify.c:4271
4 years ago
UnsignedShort weights[2]; /* Half together with {} makes GCC 4.8 crash */
Trade: implement support for Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
} vertices[3]{};
auto view = Containers::stridedArrayView(vertices);
MeshData data{MeshPrimitive::Points, {}, vertices, {
/* Joint IDs required to be here by the constructor */
MeshAttributeData{MeshAttribute::JointIds, VertexFormat::UnsignedInt,
view.slice(&Vertex::jointIds), 2},
MeshAttributeData{MeshAttribute::Weights, VertexFormat::Half,
view.slice(&Vertex::weights), 2}
}};
std::ostringstream out;
Error redirectError{&out};
Float weights1[3*3];
Float weights2[2*2];
Float weights3[3*4];
data.weightsInto(Containers::StridedArrayView2D<Float>{weights1, {3, 3}});
data.weightsInto(Containers::StridedArrayView2D<Float>{weights2, {2, 2}});
data.weightsInto(Containers::StridedArrayView2D<Float>{weights3, {3, 4}}.every({1, 2}));
CORRADE_COMPARE(out.str(),
"Trade::MeshData::weightsInto(): expected a view with {3, 2} elements but got {3, 3}\n"
"Trade::MeshData::weightsInto(): expected a view with {3, 2} elements but got {2, 2}\n"
"Trade::MeshData::weightsInto(): second view dimension is not contiguous\n");
}
Trade: implement support for object IDs in MeshData.
6 years ago
template<class T> void MeshDataTest::objectIdsAsArray() {
setTestCaseTemplateName(Math::TypeTraits<T>::name());
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
/* Testing also that it picks the correct attribute */
struct Vertex {
UnsignedByte otherObjectId;
Vector2 position;
T objectId;
} vertices[]{
{0, {}, 157},
{0, {}, 24},
{0, {}, 1}
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
};
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
auto view = Containers::stridedArrayView(vertices);
Trade: implement support for object IDs in MeshData.
6 years ago
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
MeshData data{MeshPrimitive::Points, {}, vertices, {
MeshAttributeData{MeshAttribute::ObjectId, view.slice(&Vertex::otherObjectId)},
MeshAttributeData{MeshAttribute::Position, view.slice(&Vertex::position)},
MeshAttributeData{MeshAttribute::ObjectId, view.slice(&Vertex::objectId)}
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
}};
Trade: test that MeshData::*AsArray() APIs pick the right attribute. Instead of always testing with exactly one attribute. Now the test cases are back to the original verbosity, but doing something actually useful.
4 years ago
CORRADE_COMPARE_AS(data.objectIdsAsArray(1), Containers::arrayView<UnsignedInt>({
Trade: implement support for object IDs in MeshData.
6 years ago
157, 24, 1
}), TestSuite::Compare::Container);
}
void MeshDataTest::objectIdsIntoArrayInvalidSize() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
Trade: clean up MeshData::*AsArray() test cases. A lot of pain went into creating owned mesh data even though it was completely unnecessary in retrospect. Originally I thought "let's not use any advanced feature" but the verbosity is just not worth it. In the recent-ish SceneData tests I went with non-owned data already, and it was much simpler. It's a learning process even for using my own APIs, huh.
4 years ago
UnsignedInt objectIds[3]{};
MeshData data{MeshPrimitive::Points, {}, objectIds, {
MeshAttributeData{MeshAttribute::ObjectId, Containers::arrayView(objectIds)}
}};
Trade: implement support for object IDs in MeshData.
6 years ago
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: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
void MeshDataTest::implementationSpecificIndexTypeWrongAccess() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: support implementation-specific index types in MeshData. This mirrors what's done already for implementation-specific vertex formats, thus: * Ability to construct the classes without tripping up when trying to check for type size in various asserts * Providing a zero-size type-erased access in indices() and mutableIndices() * Disallowing typed and convenience access
4 years ago
VertexWithImplementationSpecificData indexData[3];
Containers::StridedArrayView1D<long double> indices{indexData,
&indexData[0].thing, 3, sizeof(VertexWithImplementationSpecificData)};
MeshData data{MeshPrimitive::Triangles, DataFlag::Mutable, indexData,
MeshIndexData{meshIndexTypeWrap(0xcaca), indices}, 1};
std::ostringstream out;
Error redirectError{&out};
data.indices<UnsignedInt>();
data.mutableIndices<UnsignedInt>();
data.indicesAsArray();
CORRADE_COMPARE(out.str(),
"Trade::MeshData::indices(): can't cast data from an implementation-specific index type 0xcaca\n"
"Trade::MeshData::mutableIndices(): can't cast data from an implementation-specific index type 0xcaca\n"
"Trade::MeshData::indicesInto(): can't extract data out of an implementation-specific index type 0xcaca\n");
}
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
void MeshDataTest::implementationSpecificVertexFormatWrongAccess() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
Trade: minor test cleanup.
4 years ago
VertexWithImplementationSpecificData vertexData[2];
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
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,
Trade: use unique identifiers in assertion tests. Otherwise it could just pick whatever format from the set, which isn't desired.
4 years ago
vertexFormatWrap(0xdead3), attribute},
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
MeshAttributeData{MeshAttribute::Normal,
Trade: use unique identifiers in assertion tests. Otherwise it could just pick whatever format from the set, which isn't desired.
4 years ago
vertexFormatWrap(0xdead4), attribute},
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
MeshAttributeData{MeshAttribute::TextureCoordinates,
Trade: use unique identifiers in assertion tests. Otherwise it could just pick whatever format from the set, which isn't desired.
4 years ago
vertexFormatWrap(0xdead5), attribute},
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
MeshAttributeData{MeshAttribute::Color,
Trade: use unique identifiers in assertion tests. Otherwise it could just pick whatever format from the set, which isn't desired.
4 years ago
vertexFormatWrap(0xdead6), attribute},
Trade: implement support for Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
MeshAttributeData{MeshAttribute::JointIds,
vertexFormatWrap(0xdead7), attribute, 2},
MeshAttributeData{MeshAttribute::Weights,
vertexFormatWrap(0xdead8), attribute, 2},
Trade: implement support for object IDs in MeshData.
6 years ago
MeshAttributeData{MeshAttribute::ObjectId,
Trade: implement support for Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
vertexFormatWrap(0xdead9), attribute}}};
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
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 Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
data.jointIdsAsArray();
data.weightsAsArray();
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 0xdead4\n"
Trade: use unique identifiers in assertion tests. Otherwise it could just pick whatever format from the set, which isn't desired.
4 years ago
"Trade::MeshData::attribute(): can't cast data from an implementation-specific vertex format 0xdead5\n"
"Trade::MeshData::attribute(): can't cast data from an implementation-specific vertex format 0xdead6\n"
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
"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 0xdead4\n"
Trade: use unique identifiers in assertion tests. Otherwise it could just pick whatever format from the set, which isn't desired.
4 years ago
"Trade::MeshData::mutableAttribute(): can't cast data from an implementation-specific vertex format 0xdead5\n"
"Trade::MeshData::mutableAttribute(): can't cast data from an implementation-specific vertex format 0xdead6\n"
Trade: handle implementation-specific vertex formats in MeshData.
6 years ago
"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: use unique identifiers in assertion tests. Otherwise it could just pick whatever format from the set, which isn't desired.
4 years ago
"Trade::MeshData::bitangentsInto(): can't extract data out of an implementation-specific vertex format 0xdead3\n"
"Trade::MeshData::normalsInto(): can't extract data out of an implementation-specific vertex format 0xdead4\n"
"Trade::MeshData::textureCoordinatesInto(): can't extract data out of an implementation-specific vertex format 0xdead5\n"
"Trade::MeshData::colorsInto(): can't extract data out of an implementation-specific vertex format 0xdead6\n"
Trade: implement support for Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
"Trade::MeshData::jointIdsInto(): can't extract data out of an implementation-specific vertex format 0xdead7\n"
"Trade::MeshData::weightsInto(): can't extract data out of an implementation-specific vertex format 0xdead8\n"
"Trade::MeshData::objectIdsInto(): can't extract data out of an implementation-specific vertex format 0xdead9\n");
Trade: handle implementation-specific vertex formats in MeshData.
6 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
void MeshDataTest::mutableAccessNotAllowed() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
Trade: minor test cleanup.
4 years ago
const UnsignedShort indexData[3]{};
const Vector2 vertexData[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
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: test all MeshData mutable/array attribute assertion variants.
5 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);
Trade: test all MeshData mutable/array attribute assertion variants.
5 years ago
data.mutableAttribute<Vector2[]>(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
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: test all MeshData mutable/array attribute assertion variants.
5 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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
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
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: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
data.indexStride();
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: support strided index buffers in MeshData. Also not something the classic GPU vertex pipeline can handle, but useful for other scenarios. Subsequently a support for array indices will be added, allowing to directly represent for example OBJ files, where each attribute has its own index buffer.
4 years ago
"Trade::MeshData::indexStride(): 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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
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
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>();
Trade: test all MeshData mutable/array attribute assertion variants.
5 years ago
data.mutableIndices<UnsignedByte>();
CORRADE_COMPARE(out.str(),
Trade: improve MeshData type mismatch assertions. We *do* know what type the user requested, so why not print it as well. And for the array access the message was especially lazy.
5 years ago
"Trade::MeshData::indices(): indices are MeshIndexType::UnsignedShort but requested MeshIndexType::UnsignedByte\n"
"Trade::MeshData::mutableIndices(): indices are MeshIndexType::UnsignedShort but requested MeshIndexType::UnsignedByte\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::attributeNotFound() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
6 years ago
Trade: implement support for Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
MeshData data{MeshPrimitive::Points, nullptr, {
MeshAttributeData{MeshAttribute::Color, VertexFormat::Vector3, nullptr},
MeshAttributeData{MeshAttribute::Weights, VertexFormat::UnsignedByteNormalized, nullptr, 3},
MeshAttributeData{MeshAttribute::JointIds, VertexFormat::UnsignedByte, nullptr, 3},
MeshAttributeData{MeshAttribute::Color, VertexFormat::Vector4, nullptr},
MeshAttributeData{MeshAttribute::Weights, VertexFormat::Float, nullptr, 6},
MeshAttributeData{MeshAttribute::JointIds, VertexFormat::UnsignedShort, nullptr, 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: add MeshData::findAttributeId().
4 years ago
/* This is fine */
CORRADE_COMPARE(data.attributeCount(MeshAttribute::Position), 0);
CORRADE_COMPARE(data.findAttributeId(MeshAttribute::Position), Containers::NullOpt);
CORRADE_COMPARE(data.findAttributeId(MeshAttribute::Color, 2), Containers::NullOpt);
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: implement support for Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
data.attributeData(6);
data.attributeName(6);
data.attributeId(6);
data.attributeFormat(6);
data.attributeOffset(6);
data.attributeStride(6);
data.attributeArraySize(6);
data.attribute(6);
data.attribute<Vector2>(6);
data.attribute<Vector2[]>(6);
data.mutableAttribute(6);
data.mutableAttribute<Vector2>(6);
data.mutableAttribute<Vector2[]>(6);
Trade: test all MeshData mutable/array attribute assertion variants.
5 years ago
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);
Trade: test all MeshData mutable/array attribute assertion variants.
5 years ago
data.attribute<Vector2[]>(MeshAttribute::Position);
data.attribute<Vector2[]>(MeshAttribute::Color, 2);
data.mutableAttribute(MeshAttribute::Position);
data.mutableAttribute(MeshAttribute::Color, 2);
data.mutableAttribute<Vector2>(MeshAttribute::Position);
data.mutableAttribute<Vector2>(MeshAttribute::Color, 2);
data.mutableAttribute<Vector2[]>(MeshAttribute::Position);
data.mutableAttribute<Vector2[]>(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.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 Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
/* jointIdsAsArray() and weightsAsArray() have their own assert in order to
fetch array size, have to test also Into() for these */
data.jointIdsAsArray(2);
data.jointIdsInto(nullptr, 2);
data.weightsAsArray(2);
data.weightsInto(nullptr, 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: implement support for Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
"Trade::MeshData::attributeData(): index 6 out of range for 6 attributes\n"
"Trade::MeshData::attributeName(): index 6 out of range for 6 attributes\n"
"Trade::MeshData::attributeId(): index 6 out of range for 6 attributes\n"
"Trade::MeshData::attributeFormat(): index 6 out of range for 6 attributes\n"
"Trade::MeshData::attributeOffset(): index 6 out of range for 6 attributes\n"
"Trade::MeshData::attributeStride(): index 6 out of range for 6 attributes\n"
"Trade::MeshData::attributeArraySize(): index 6 out of range for 6 attributes\n"
"Trade::MeshData::attribute(): index 6 out of range for 6 attributes\n"
"Trade::MeshData::attribute(): index 6 out of range for 6 attributes\n"
"Trade::MeshData::attribute(): index 6 out of range for 6 attributes\n"
"Trade::MeshData::mutableAttribute(): index 6 out of range for 6 attributes\n"
"Trade::MeshData::mutableAttribute(): index 6 out of range for 6 attributes\n"
"Trade::MeshData::mutableAttribute(): index 6 out of range for 6 attributes\n"
Trade: test all MeshData mutable/array attribute assertion variants.
5 years ago
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: test all MeshData mutable/array attribute assertion variants.
5 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::MeshData::mutableAttribute(): index 0 out of range for 0 Trade::MeshAttribute::Position attributes\n"
"Trade::MeshData::mutableAttribute(): index 2 out of range for 2 Trade::MeshAttribute::Color attributes\n"
"Trade::MeshData::mutableAttribute(): index 0 out of range for 0 Trade::MeshAttribute::Position attributes\n"
"Trade::MeshData::mutableAttribute(): index 2 out of range for 2 Trade::MeshAttribute::Color attributes\n"
"Trade::MeshData::mutableAttribute(): index 0 out of range for 0 Trade::MeshAttribute::Position attributes\n"
"Trade::MeshData::mutableAttribute(): 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: implement support for Weights & JointIds in MeshData. This is the first builtin array attribute, with one of the objectives being an ability to support an arbitrary count of per-vertex weights in a single contiguous attribute without the complexity of having to go through several four-component attributes. On the shader side it still needs to get cut into at most four components per attribute, but there's no reason for such limitation to get propagated here as well. Co-authored-by: Vladimír Vondruš <mosra@centrum.cz>
4 years ago
"Trade::MeshData::jointIdsAsArray(): index 2 out of range for 2 joint ID attributes\n"
"Trade::MeshData::jointIdsInto(): index 2 out of range for 2 joint ID attributes\n"
"Trade::MeshData::weightsAsArray(): index 2 out of range for 2 weight attributes\n"
"Trade::MeshData::weightsInto(): index 2 out of range for 2 weight attributes\n"
Trade: implement support for object IDs in MeshData.
6 years ago
"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() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Make this compile and test cleanly with CORRADE_NO_ASSERT defined.
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
MeshAttributeData positions{MeshAttribute::Position, VertexFormat::Vector3, nullptr};
MeshData data{MeshPrimitive::Points, nullptr, {positions}};
std::ostringstream out;
Error redirectError{&out};
data.attribute<Vector4>(MeshAttribute::Position);
Trade: test all MeshData mutable/array attribute assertion variants.
5 years ago
data.attribute<Vector4[]>(MeshAttribute::Position);
data.mutableAttribute<Vector4>(MeshAttribute::Position);
data.mutableAttribute<Vector4[]>(MeshAttribute::Position);
CORRADE_COMPARE(out.str(),
Trade: improve MeshData type mismatch assertions. We *do* know what type the user requested, so why not print it as well. And for the array access the message was especially lazy.
5 years ago
"Trade::MeshData::attribute(): Trade::MeshAttribute::Position is VertexFormat::Vector3 but requested a type equivalent to VertexFormat::Vector4\n"
"Trade::MeshData::attribute(): Trade::MeshAttribute::Position is VertexFormat::Vector3 but requested a type equivalent to VertexFormat::Vector4\n"
"Trade::MeshData::mutableAttribute(): Trade::MeshAttribute::Position is VertexFormat::Vector3 but requested a type equivalent to VertexFormat::Vector4\n"
"Trade::MeshData::mutableAttribute(): Trade::MeshAttribute::Position is VertexFormat::Vector3 but requested a type equivalent to VertexFormat::Vector4\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: move a test case to where it fits better.
5 years ago
void MeshDataTest::attributeWrongArrayAccess() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: move a test case to where it fits better.
5 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(): Trade::MeshAttribute::Position is not an array attribute, can't use T[] to access it\n"
"Trade::MeshData::attribute(): Trade::MeshAttribute::Custom(35) is an array attribute, use T[] to access it\n"
"Trade::MeshData::mutableAttribute(): Trade::MeshAttribute::Position is not an array attribute, can't use T[] to access it\n"
"Trade::MeshData::mutableAttribute(): Trade::MeshAttribute::Custom(35) is an array attribute, use T[] to access it\n"
"Trade::MeshData::attribute(): Trade::MeshAttribute::Position is not an array attribute, can't use T[] to access it\n"
"Trade::MeshData::attribute(): Trade::MeshAttribute::Custom(35) is an array attribute, use T[] to access it\n"
"Trade::MeshData::mutableAttribute(): Trade::MeshAttribute::Position is not an array attribute, can't use T[] to access it\n"
"Trade::MeshData::mutableAttribute(): Trade::MeshAttribute::Custom(35) is an array attribute, use T[] to access it\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::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)