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

7562 lines
379 KiB
Raw Normal View History Unescape

Trade: test construction and assignments of the container classes.
10 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>
Trade: test construction and assignments of the container classes.
10 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.
*/
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
/* Including first to verify the StridedBitArrayView include is not needed */
#include "Magnum/Trade/SceneData.h"
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#include <sstream>
#include <Corrade/Containers/ArrayTuple.h>
Trade: convenience per-object field access in SceneData.
5 years ago
#include <Corrade/Containers/Optional.h>
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
#include <Corrade/Containers/Pair.h>
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
#include <Corrade/Containers/StridedBitArrayView.h>
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
#include <Corrade/Containers/StringIterable.h>
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
#include <Corrade/Containers/Triple.h>
Trade: test construction and assignments of the container classes.
10 years ago
#include <Corrade/TestSuite/Tester.h>
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#include <Corrade/TestSuite/Compare/Container.h>
Trade: use Utility::copy() instead of painstakingly filling test data.
3 years ago
#include <Corrade/Utility/Algorithms.h>
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/FormatStl.h>
Trade: test construction and assignments of the container classes.
10 years ago
#include "Magnum/Magnum.h"
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#include "Magnum/Math/Half.h"
#include "Magnum/Math/DualComplex.h"
#include "Magnum/Math/DualQuaternion.h"
#include "Magnum/Math/Range.h"
Trade: test construction and assignments of the container classes.
10 years ago
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
#include <vector>
#include <Corrade/Containers/GrowableArray.h>
#endif
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
namespace Magnum { namespace Trade { namespace Test { namespace {
Trade: test construction and assignments of the container classes.
10 years ago
struct SceneDataTest: TestSuite::Tester {
explicit SceneDataTest();
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
void mappingTypeSizeAlignment();
void mappingTypeSizeAlignmentInvalid();
void debugMappingType();
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 debugMappingTypePacked();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void customFieldName();
void customFieldNameTooLarge();
void customFieldNameNotCustom();
void debugFieldName();
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 debugFieldNamePacked();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: add scene{Object,Field}TypeAlignment(). Support utilities needed for SceneTools that will operate on arbitrary SceneData (adding/removing fields, objects...) without having to know what each field means and how it needs to be treated. Honestly the same would make sense for the VertexFormat enum as well. But not now, later.
5 years ago
void fieldTypeSizeAlignment();
void fieldTypeSizeAlignmentInvalid();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void debugFieldType();
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 debugFieldTypePacked();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
void debugFieldFlag();
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 debugFieldFlagPacked();
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
void debugFieldFlags();
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 debugFieldFlagsPacked();
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
void debugFieldFlagsSupersets();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void constructField();
void constructFieldDefault();
void constructFieldCustom();
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void constructFieldBit();
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
void constructFieldString();
void constructFieldStringNegativeStride();
void constructFieldStringNegativeOffset();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void constructFieldTypeErased();
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void constructFieldTypeErasedBit();
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
void constructFieldTypeErasedString();
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
void constructFieldTypeErased2D();
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void constructFieldTypeErased2DBit();
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
void constructFieldTypeErased2DString();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void constructFieldNonOwningArray();
void constructFieldOffsetOnly();
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void constructFieldOffsetOnlyBit();
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
void constructFieldOffsetOnlyString();
void constructFieldOffsetOnlyStringNegativeStride();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void constructFieldArray();
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void constructFieldArrayBit();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void constructFieldArrayTypeErased();
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void constructFieldArrayTypeErasedBit();
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
/* no constructFieldArrayTypeErasedString(), strings can't be arrays */
void constructFieldArrayTypeErased2D();
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void constructFieldArrayTypeErased2DBit();
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
/* no constructFieldArrayTypeErased2DString(), strings can't be arrays */
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void constructFieldArrayOffsetOnly();
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void constructFieldArrayOffsetOnlyBit();
/* no constructFieldArrayOffsetOnlyString(), strings can't be arrays */
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void constructFieldWrongType();
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void constructFieldWrongTypeBit();
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
void constructFieldWrongTypeString();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void constructFieldInconsistentViewSize();
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
void constructFieldTooLargeMappingStride();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void constructFieldTooLargeFieldStride();
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
void constructFieldFlagNotAllowed();
Trade: rename a test case for clarity.
3 years ago
void constructFieldWrongOffsetOnlyDataAccess();
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void constructFieldWrongBitDataAccess();
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
void constructFieldWrongStringDataAccess();
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
void constructFieldTypeErased2DWrongSize();
void constructFieldTypeErased2DNonContiguous();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void constructFieldArrayNonContiguous();
void constructFieldArrayNotAllowed();
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
void constructFieldArrayTypeErased2DWrongSize();
void constructFieldArrayTypeErased2DNonContiguous();
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void constructFieldBitTooLargeBitOffset();
void constructFieldBitTooLargeSize();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: test construction and assignments of the container classes.
10 years ago
void construct();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void constructZeroFields();
void constructZeroObjects();
void constructNotOwned();
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void constructBit();
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
template<class T> void constructString();
Trade: move a test case to a better place. It'll be together with a test case for special bit strides, so it should be after the place where to put constructBit().
3 years ago
void constructSpecialStrides();
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void constructSpecialStridesBit();
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
void constructDeprecated();
void constructDeprecatedBoth2DAnd3D();
#endif
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void constructDuplicateField();
void constructDuplicateCustomField();
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
void constructInconsistentMappingType();
void constructMappingDataNotContained();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void constructFieldDataNotContained();
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void constructBitFieldDataNotContained();
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
void constructStringDataNotContained();
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
void constructMappingTypeTooSmall();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void constructNotOwnedFlagOwned();
void constructMismatchedTRSViews();
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
template<class T> void constructMismatchedTRSDimensionality();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void constructMismatchedMeshMaterialView();
Trade: SceneField::Skin now requires a transformation to be present. Even an empty field, it's there just to disambiguate whether the skin is 2D or 3D.
5 years ago
void constructAmbiguousSkinDimensions();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: test construction and assignments of the container classes.
10 years ago
void constructCopy();
void constructMove();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
void findFieldId();
template<class T> void findFieldObjectOffset();
void findFieldObjectOffsetInvalidOffset();
void fieldObjectOffsetNotFound();
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
template<class T> void mappingAsArrayByIndex();
template<class T> void mappingAsArrayByName();
void mappingIntoArrayByIndex();
void mappingIntoArrayByName();
void mappingIntoArrayInvalidSizeOrOffset();
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
template<class T> void parentsAsArray();
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
void parentsIntoArray();
void parentsIntoArrayInvalidSizeOrOffset();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
template<class T> void transformations2DAsArray();
Trade: SceneData TRS components can each have different type, test that.
5 years ago
template<class T, class U, class V> void transformations2DAsArrayTRS();
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
void transformations2DAsArrayBut3DType();
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
void transformations2DIntoArray();
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
void transformations2DTRSIntoArray();
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
void transformations2DIntoArrayTRS();
void transformations2DIntoArrayInvalidSizeOrOffset();
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
void transformations2DIntoArrayInvalidSizeOrOffsetTRS();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
template<class T> void transformations3DAsArray();
Trade: SceneData TRS components can each have different type, test that.
5 years ago
template<class T, class U, class V> void transformations3DAsArrayTRS();
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
void transformations3DAsArrayBut2DType();
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
void transformations3DIntoArray();
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
void transformations3DTRSIntoArray();
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
void transformations3DIntoArrayTRS();
void transformations3DIntoArrayInvalidSizeOrOffset();
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
void transformations3DIntoArrayInvalidSizeOrOffsetTRS();
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
template<class T, class U> void meshesMaterialsAsArray();
void meshesMaterialsIntoArray();
void meshesMaterialsIntoArrayInvalidSizeOrOffset();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
template<class T> void lightsAsArray();
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
void lightsIntoArray();
void lightsIntoArrayInvalidSizeOrOffset();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
template<class T> void camerasAsArray();
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
void camerasIntoArray();
void camerasIntoArrayInvalidSizeOrOffset();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
template<class T> void skinsAsArray();
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
void skinsIntoArray();
void skinsIntoArrayInvalidSizeOrOffset();
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
template<class T> void importerStateAsArray();
void importerStateIntoArray();
void importerStateIntoArrayInvalidSizeOrOffset();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void mutableAccessNotAllowed();
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
void mappingNotFound();
void mappingWrongType();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void fieldNotFound();
void fieldWrongType();
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
void fieldWrongPointerType();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void fieldWrongArrayAccess();
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
void parentFor();
Trade: test SceneData::{parentFor,childrenFor}() with trivial parents. Hmm, doesn't look right. A bug somewhere!
5 years ago
void parentForTrivialParent();
Trade: add a parentFor() object-oriented accessor as well. For a lack of better API right now, this will be used to check if an object belongs to a certain scene. In the future, when BitArray is a thing, there will be a dedicated field with a mask telling which objects belong to the scene and which not, with a fallback that goes through all field object mappings and collects objects that have at least one field.
5 years ago
void childrenFor();
Trade: test SceneData::{parentFor,childrenFor}() with trivial parents. Hmm, doesn't look right. A bug somewhere!
5 years ago
void childrenForTrivialParent();
Trade: convenience per-object field access in SceneData.
5 years ago
void transformation2DFor();
void transformation2DForTRS();
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
void transformation2DForBut3DType();
Trade: convenience per-object field access in SceneData.
5 years ago
void transformation3DFor();
void transformation3DForTRS();
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
void transformation3DForBut2DType();
Trade: convenience per-object field access in SceneData.
5 years ago
void meshesMaterialsFor();
void lightsFor();
void camerasFor();
void skinsFor();
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
void importerStateFor();
Trade: convenience per-object field access in SceneData.
5 years ago
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
void childrenDeprecated();
#endif
Trade: convenience per-object field access in SceneData.
5 years ago
void fieldForFieldMissing();
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
void findFieldObjectOffsetInvalidObject();
Trade: convenience per-object field access in SceneData.
5 years ago
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void releaseFieldData();
void releaseData();
};
const struct {
const char* name;
DataFlags dataFlags;
} NotOwnedData[]{
{"", {}},
{"mutable", DataFlag::Mutable}
Trade: test construction and assignments of the container classes.
10 years ago
};
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
const struct {
const char* name;
SceneFieldFlags flags;
UnsignedInt mapping[5];
UnsignedInt object;
UnsignedInt offset;
Containers::Optional<std::size_t> expected;
} FindFieldObjectOffsetData[]{
{"", {},
{4, 2, 1, 0, 2}, 2, 0, 1},
{"not found", {},
{4, 2, 1, 0, 2}, 3, 0, Containers::NullOpt},
{"offset", {},
{4, 2, 1, 0, 2}, 2, 2, 4},
{"offset, not found", {},
{4, 2, 1, 0, 2}, 2, 5, Containers::NullOpt},
{"ordered", SceneFieldFlag::OrderedMapping,
{1, 3, 4, 4, 5}, 4, 0, 2},
{"ordered, not found", SceneFieldFlag::OrderedMapping,
/* It *is* there but the binary search expects an ordered range and thus
should not even see it */
{1, 3, 4, 4, 2}, 2, 0, Containers::NullOpt},
{"ordered, not found, too small", SceneFieldFlag::OrderedMapping,
{1, 3, 4, 4, 5}, 0, 0, Containers::NullOpt},
{"ordered, not found, too large", SceneFieldFlag::OrderedMapping,
{1, 3, 4, 4, 5}, 6, 0, Containers::NullOpt},
{"ordered, offset", SceneFieldFlag::OrderedMapping,
{1, 3, 4, 4, 5}, 4, 3, 3},
{"ordered, offset, not found", SceneFieldFlag::OrderedMapping,
{1, 3, 4, 4, 5}, 4, 4, Containers::NullOpt},
{"implicit", SceneFieldFlag::ImplicitMapping,
/* Not there but the assumption is that the ID matches the offset */
{5, 5, 5, 5, 5}, 3, 0, 3},
{"implicit, not found", SceneFieldFlag::ImplicitMapping,
/* Is there but the assumption is that the ID matches the offset, which
is out of bounds */
{5, 5, 5, 5, 5}, 5, 0, Containers::NullOpt},
{"implicit, offset", SceneFieldFlag::ImplicitMapping,
/* Not there but the assumption is that the ID matches the offset;
verifying that the offset is properly accounted for */
{5, 5, 5, 5, 5}, 3, 3, 3},
{"implicit, offset, not found, less than offset", SceneFieldFlag::ImplicitMapping,
/* Cerifying that the offset is properly accounted for -- it's never
found if offset > id */
{5, 5, 5, 5, 5}, 3, 4, Containers::NullOpt},
{"implicit, offset, not found, out of bounds", SceneFieldFlag::ImplicitMapping,
{5, 5, 5, 5, 5}, 5, 4, Containers::NullOpt}
};
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
const struct {
const char* name;
std::size_t offset;
std::size_t size;
std::size_t expectedSize;
} IntoArrayOffsetData[]{
{"whole", 0, 3, 3},
{"one element in the middle", 1, 1, 1},
{"suffix to a larger array", 2, 10, 1},
{"offset at the end", 3, 10, 0}
};
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
const struct {
const char* name;
std::size_t offset;
std::size_t size;
std::size_t expectedSize;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
bool mapping, field;
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
} IntoArrayOffset1Data[]{
{"whole", 0, 3, 3, true, true},
{"one element in the middle", 1, 1, 1, true, true},
{"suffix to a larger array", 2, 10, 1, true, true},
{"offset at the end", 3, 10, 0, true, true},
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
{"only mapping", 0, 3, 3, true, false},
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
{"only field", 0, 3, 3, false, true},
{"neither", 0, 3, 0, false, false}
};
const struct {
const char* name;
std::size_t offset;
std::size_t size;
std::size_t expectedSize;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
bool mapping, field1, field2;
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
} IntoArrayOffset2Data[]{
{"whole", 0, 3, 3, true, true, true},
{"one element in the middle", 1, 1, 1, true, true, true},
{"suffix to a larger array", 2, 10, 1, true, true, true},
{"offset at the end", 3, 10, 0, true, true, true},
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
{"only mapping", 0, 3, 3, true, false, false},
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
{"only fields", 0, 3, 3, false, true, true},
{"only first field", 0, 3, 3, false, true, false},
{"only second field", 0, 3, 3, false, false, true},
{"none", 0, 3, 0, false, false, false}
};
const struct {
const char* name;
std::size_t offset;
std::size_t size;
std::size_t expectedSize;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
bool mapping, field1, field2, field3;
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
} IntoArrayOffset3Data[]{
{"whole", 0, 3, 3, true, true, true, true},
{"one element in the middle", 1, 1, 1, true, true, true, true},
{"suffix to a larger array", 2, 10, 1, true, true, true, true},
{"offset at the end", 3, 10, 0, true, true, true, true},
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
{"only mapping", 0, 3, 3, true, false, false, true},
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
{"only fields", 0, 3, 3, false, true, true, true},
{"only first field", 0, 3, 3, false, true, false, false},
{"only second field", 0, 3, 3, false, false, true, false},
{"only third field", 0, 3, 3, false, false, false, true},
{"none", 0, 3, 0, false, false, false, false}
};
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
const struct {
const char* name;
std::ptrdiff_t stride;
std::size_t offset, bitOffset, arrayBitOffset;
UnsignedByte expectedBits;
UnsignedByte expectedArrayBits[2];
} ConstructSpecialStridesBitData[]{
{"negative stride", -2*8, 3*2, 3, 5,
0x0d /* 0b1101 */,
{0x03 /* 0b0011 */, 0x0d /* 0b1101 */}},
{"zero stride, all ones", 0, 0, 3, 5,
0x0f, {0x00, 0x0f}},
/* No change for the array, as it exhibits both values */
{"zero stride, all zeros", 0, 0, 2, 5,
0x00, {0x00, 0x0f}},
};
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
const struct {
const char* name;
bool is2D;
bool is3D;
Trade: warn in deprecated SceneData::children*D() if there's no parent. Even though this API is deprecated and thus not meant to be used, most existing code is still using the previous APIs and relying on the backwards compatibiity interfaces. And I wasted quite some time debugging why the scene looks like empty.
5 years ago
bool skipParent;
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
} ChildrenDeprecatedData[]{
Trade: warn in deprecated SceneData::children*D() if there's no parent. Even though this API is deprecated and thus not meant to be used, most existing code is still using the previous APIs and relying on the backwards compatibiity interfaces. And I wasted quite some time debugging why the scene looks like empty.
5 years ago
{"2D", true, false, false},
{"2D with no parent", true, false, true},
{"3D", false, true, false},
{"3D with no parent", false, true, true},
{"neither", false, false, false},
{"neither with no parent", false, false, true}
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
};
#endif
Trade: test construction and assignments of the container classes.
10 years ago
SceneDataTest::SceneDataTest() {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
addTests({&SceneDataTest::mappingTypeSizeAlignment,
&SceneDataTest::mappingTypeSizeAlignmentInvalid,
&SceneDataTest::debugMappingType,
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
&SceneDataTest::debugMappingTypePacked,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::customFieldName,
&SceneDataTest::customFieldNameTooLarge,
&SceneDataTest::customFieldNameNotCustom,
&SceneDataTest::debugFieldName,
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
&SceneDataTest::debugFieldNamePacked,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: add scene{Object,Field}TypeAlignment(). Support utilities needed for SceneTools that will operate on arbitrary SceneData (adding/removing fields, objects...) without having to know what each field means and how it needs to be treated. Honestly the same would make sense for the VertexFormat enum as well. But not now, later.
5 years ago
&SceneDataTest::fieldTypeSizeAlignment,
&SceneDataTest::fieldTypeSizeAlignmentInvalid,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::debugFieldType,
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
&SceneDataTest::debugFieldTypePacked,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
&SceneDataTest::debugFieldFlag,
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
&SceneDataTest::debugFieldFlagPacked,
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
&SceneDataTest::debugFieldFlags,
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
&SceneDataTest::debugFieldFlagsPacked,
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
&SceneDataTest::debugFieldFlagsSupersets,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::constructField,
&SceneDataTest::constructFieldDefault,
&SceneDataTest::constructFieldCustom,
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
&SceneDataTest::constructFieldBit,
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
&SceneDataTest::constructFieldString,
&SceneDataTest::constructFieldStringNegativeStride,
&SceneDataTest::constructFieldStringNegativeOffset,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::constructFieldTypeErased,
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
&SceneDataTest::constructFieldTypeErasedBit,
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
&SceneDataTest::constructFieldTypeErasedString,
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
&SceneDataTest::constructFieldTypeErased2D,
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
&SceneDataTest::constructFieldTypeErased2DBit,
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
&SceneDataTest::constructFieldTypeErased2DString,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::constructFieldNonOwningArray,
&SceneDataTest::constructFieldOffsetOnly,
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
&SceneDataTest::constructFieldOffsetOnlyBit,
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
&SceneDataTest::constructFieldOffsetOnlyString,
&SceneDataTest::constructFieldOffsetOnlyStringNegativeStride,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::constructFieldArray,
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
&SceneDataTest::constructFieldArrayBit,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::constructFieldArrayTypeErased,
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
&SceneDataTest::constructFieldArrayTypeErasedBit,
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
&SceneDataTest::constructFieldArrayTypeErased2D,
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
&SceneDataTest::constructFieldArrayTypeErased2DBit,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::constructFieldArrayOffsetOnly,
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
&SceneDataTest::constructFieldArrayOffsetOnlyBit,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::constructFieldWrongType,
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
&SceneDataTest::constructFieldWrongTypeBit,
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
&SceneDataTest::constructFieldWrongTypeString,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::constructFieldInconsistentViewSize,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
&SceneDataTest::constructFieldTooLargeMappingStride,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::constructFieldTooLargeFieldStride,
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
&SceneDataTest::constructFieldFlagNotAllowed,
Trade: rename a test case for clarity.
3 years ago
&SceneDataTest::constructFieldWrongOffsetOnlyDataAccess,
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
&SceneDataTest::constructFieldWrongBitDataAccess,
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
&SceneDataTest::constructFieldWrongStringDataAccess,
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
&SceneDataTest::constructFieldTypeErased2DWrongSize,
&SceneDataTest::constructFieldTypeErased2DNonContiguous,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::constructFieldArrayNonContiguous,
&SceneDataTest::constructFieldArrayNotAllowed,
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
&SceneDataTest::constructFieldArrayTypeErased2DWrongSize,
&SceneDataTest::constructFieldArrayTypeErased2DNonContiguous,
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
&SceneDataTest::constructFieldBitTooLargeBitOffset,
&SceneDataTest::constructFieldBitTooLargeSize,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::construct,
&SceneDataTest::constructZeroFields,
Trade: move a test case to a better place. It'll be together with a test case for special bit strides, so it should be after the place where to put constructBit().
3 years ago
&SceneDataTest::constructZeroObjects});
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
addInstancedTests({&SceneDataTest::constructNotOwned},
Containers::arraySize(NotOwnedData));
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
addTests({&SceneDataTest::constructBit,
&SceneDataTest::constructString<UnsignedByte>,
Trade: move a test case to a better place. It'll be together with a test case for special bit strides, so it should be after the place where to put constructBit().
3 years ago
&SceneDataTest::constructString<UnsignedShort>,
&SceneDataTest::constructString<UnsignedInt>,
&SceneDataTest::constructString<UnsignedLong>,
&SceneDataTest::constructSpecialStrides});
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
addInstancedTests({&SceneDataTest::constructSpecialStridesBit},
Containers::arraySize(ConstructSpecialStridesBitData));
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
addInstancedTests({&SceneDataTest::constructDeprecated},
Containers::arraySize(ChildrenDeprecatedData));
addTests({&SceneDataTest::constructDeprecatedBoth2DAnd3D});
#endif
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
addTests({&SceneDataTest::constructDuplicateField,
&SceneDataTest::constructDuplicateCustomField,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
&SceneDataTest::constructInconsistentMappingType,
&SceneDataTest::constructMappingDataNotContained,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::constructFieldDataNotContained,
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
&SceneDataTest::constructBitFieldDataNotContained,
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
&SceneDataTest::constructStringDataNotContained,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
&SceneDataTest::constructMappingTypeTooSmall,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::constructNotOwnedFlagOwned,
&SceneDataTest::constructMismatchedTRSViews,
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
&SceneDataTest::constructMismatchedTRSDimensionality<Float>,
&SceneDataTest::constructMismatchedTRSDimensionality<Double>,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::constructMismatchedMeshMaterialView,
Trade: SceneField::Skin now requires a transformation to be present. Even an empty field, it's there just to disambiguate whether the skin is 2D or 3D.
5 years ago
&SceneDataTest::constructAmbiguousSkinDimensions,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: test construction and assignments of the container classes.
10 years ago
&SceneDataTest::constructCopy,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::constructMove,
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
&SceneDataTest::findFieldId});
addInstancedTests<SceneDataTest>({
&SceneDataTest::findFieldObjectOffset<UnsignedByte>,
&SceneDataTest::findFieldObjectOffset<UnsignedShort>,
&SceneDataTest::findFieldObjectOffset<UnsignedInt>,
&SceneDataTest::findFieldObjectOffset<UnsignedLong>
}, Containers::arraySize(FindFieldObjectOffsetData));
addTests({&SceneDataTest::findFieldObjectOffsetInvalidOffset,
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
&SceneDataTest::fieldObjectOffsetNotFound,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
&SceneDataTest::mappingAsArrayByIndex<UnsignedByte>,
&SceneDataTest::mappingAsArrayByIndex<UnsignedShort>,
&SceneDataTest::mappingAsArrayByIndex<UnsignedInt>,
&SceneDataTest::mappingAsArrayByIndex<UnsignedLong>,
&SceneDataTest::mappingAsArrayByName<UnsignedByte>,
&SceneDataTest::mappingAsArrayByName<UnsignedShort>,
&SceneDataTest::mappingAsArrayByName<UnsignedInt>,
&SceneDataTest::mappingAsArrayByName<UnsignedLong>});
addInstancedTests({&SceneDataTest::mappingIntoArrayByIndex,
&SceneDataTest::mappingIntoArrayByName},
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
Containers::arraySize(IntoArrayOffsetData));
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
addTests({&SceneDataTest::mappingIntoArrayInvalidSizeOrOffset,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::parentsAsArray<Byte>,
&SceneDataTest::parentsAsArray<Short>,
&SceneDataTest::parentsAsArray<Int>,
Trade: drop assertions for 64-bit object/parent values from SceneData. This has to be solved on a more systematic level, perhaps even by switching all types to be 64-bit. In the following commit all *AsArray() and *Int() functions will output the object IDs as well, meaning this would need to be handled in each and every API, which is a huge maintenance burden. As it's very unlikely that there actually will *ever* be >4G objects, one possible option would be to introduce some "object ID hash" field that would provide (contiguous?) remapping of the object ID to 32-bit values, and the Into() and AsArray() accessors would return this remapping instead of the original. But then again it'd cause issues with for example animation references that would still reference the original 64-bit value.
5 years ago
&SceneDataTest::parentsAsArray<Long>});
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
addInstancedTests({&SceneDataTest::parentsIntoArray},
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Containers::arraySize(IntoArrayOffset1Data));
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
addTests({&SceneDataTest::parentsIntoArrayInvalidSizeOrOffset,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::transformations2DAsArray<Matrix3>,
&SceneDataTest::transformations2DAsArray<Matrix3d>,
Trade: allow SceneField::Transformation to be a 3x2 or a 4x3 matrix. Another thought I had was about allowing a 2x2 / 3x3 matrix to be used for rotation, but there's the ambiguity with it possibly containing scaling / shear / whatever, which would then cause EXPLODING HEADACHES when converting to quaternions / complex numbers.
5 years ago
&SceneDataTest::transformations2DAsArray<Matrix3x2>,
&SceneDataTest::transformations2DAsArray<Matrix3x2d>,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::transformations2DAsArray<DualComplex>,
&SceneDataTest::transformations2DAsArray<DualComplexd>,
Trade: SceneData TRS components can each have different type, test that.
5 years ago
&SceneDataTest::transformations2DAsArrayTRS<Float, Float, Double>,
&SceneDataTest::transformations2DAsArrayTRS<Double, Double, Float>,
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
&SceneDataTest::transformations2DAsArrayBut3DType});
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
addInstancedTests({&SceneDataTest::transformations2DIntoArray,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
&SceneDataTest::transformations2DTRSIntoArray},
Containers::arraySize(IntoArrayOffset1Data));
addInstancedTests({&SceneDataTest::transformations2DIntoArrayTRS},
Containers::arraySize(IntoArrayOffset3Data));
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
addTests({&SceneDataTest::transformations2DIntoArrayInvalidSizeOrOffset,
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
&SceneDataTest::transformations2DIntoArrayInvalidSizeOrOffsetTRS,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::transformations3DAsArray<Matrix4>,
&SceneDataTest::transformations3DAsArray<Matrix4d>,
Trade: allow SceneField::Transformation to be a 3x2 or a 4x3 matrix. Another thought I had was about allowing a 2x2 / 3x3 matrix to be used for rotation, but there's the ambiguity with it possibly containing scaling / shear / whatever, which would then cause EXPLODING HEADACHES when converting to quaternions / complex numbers.
5 years ago
&SceneDataTest::transformations3DAsArray<Matrix4x3>,
&SceneDataTest::transformations3DAsArray<Matrix4x3d>,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::transformations3DAsArray<DualQuaternion>,
&SceneDataTest::transformations3DAsArray<DualQuaterniond>,
Trade: SceneData TRS components can each have different type, test that.
5 years ago
&SceneDataTest::transformations3DAsArrayTRS<Float, Double, Double>,
&SceneDataTest::transformations3DAsArrayTRS<Double, Float, Float>,
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
&SceneDataTest::transformations3DAsArrayBut2DType});
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
addInstancedTests({&SceneDataTest::transformations3DIntoArray,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
&SceneDataTest::transformations3DTRSIntoArray},
Containers::arraySize(IntoArrayOffset1Data));
addInstancedTests({&SceneDataTest::transformations3DIntoArrayTRS},
Containers::arraySize(IntoArrayOffset3Data));
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
addTests({&SceneDataTest::transformations3DIntoArrayInvalidSizeOrOffset,
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
&SceneDataTest::transformations3DIntoArrayInvalidSizeOrOffsetTRS,
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
&SceneDataTest::meshesMaterialsAsArray<UnsignedByte, Int>,
&SceneDataTest::meshesMaterialsAsArray<UnsignedShort, Byte>,
&SceneDataTest::meshesMaterialsAsArray<UnsignedInt, Short>});
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
addInstancedTests({&SceneDataTest::meshesMaterialsIntoArray},
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Containers::arraySize(IntoArrayOffset2Data));
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
addTests({&SceneDataTest::meshesMaterialsIntoArrayInvalidSizeOrOffset,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::lightsAsArray<UnsignedByte>,
&SceneDataTest::lightsAsArray<UnsignedShort>,
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
&SceneDataTest::lightsAsArray<UnsignedInt>});
addInstancedTests({&SceneDataTest::lightsIntoArray},
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Containers::arraySize(IntoArrayOffset1Data));
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
addTests({&SceneDataTest::lightsIntoArrayInvalidSizeOrOffset,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::camerasAsArray<UnsignedByte>,
&SceneDataTest::camerasAsArray<UnsignedShort>,
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
&SceneDataTest::camerasAsArray<UnsignedInt>});
addInstancedTests({&SceneDataTest::camerasIntoArray},
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Containers::arraySize(IntoArrayOffset1Data));
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
addTests({&SceneDataTest::camerasIntoArrayInvalidSizeOrOffset,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::skinsAsArray<UnsignedByte>,
&SceneDataTest::skinsAsArray<UnsignedShort>,
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
&SceneDataTest::skinsAsArray<UnsignedInt>});
addInstancedTests({&SceneDataTest::skinsIntoArray},
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Containers::arraySize(IntoArrayOffset1Data));
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
addTests({&SceneDataTest::skinsIntoArrayInvalidSizeOrOffset,
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
&SceneDataTest::importerStateAsArray<const void*>,
&SceneDataTest::importerStateAsArray<void*>});
addInstancedTests({&SceneDataTest::importerStateIntoArray},
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Containers::arraySize(IntoArrayOffset1Data));
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
addTests({&SceneDataTest::importerStateIntoArrayInvalidSizeOrOffset,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::mutableAccessNotAllowed,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
&SceneDataTest::mappingNotFound,
&SceneDataTest::mappingWrongType,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::fieldNotFound,
&SceneDataTest::fieldWrongType,
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
&SceneDataTest::fieldWrongPointerType,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::fieldWrongArrayAccess,
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
&SceneDataTest::parentFor,
Trade: test SceneData::{parentFor,childrenFor}() with trivial parents. Hmm, doesn't look right. A bug somewhere!
5 years ago
&SceneDataTest::parentForTrivialParent,
Trade: add a parentFor() object-oriented accessor as well. For a lack of better API right now, this will be used to check if an object belongs to a certain scene. In the future, when BitArray is a thing, there will be a dedicated field with a mask telling which objects belong to the scene and which not, with a fallback that goes through all field object mappings and collects objects that have at least one field.
5 years ago
&SceneDataTest::childrenFor,
Trade: test SceneData::{parentFor,childrenFor}() with trivial parents. Hmm, doesn't look right. A bug somewhere!
5 years ago
&SceneDataTest::childrenForTrivialParent,
Trade: convenience per-object field access in SceneData.
5 years ago
&SceneDataTest::transformation2DFor,
&SceneDataTest::transformation2DForTRS,
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
&SceneDataTest::transformation2DForBut3DType,
Trade: convenience per-object field access in SceneData.
5 years ago
&SceneDataTest::transformation3DFor,
&SceneDataTest::transformation3DForTRS,
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
&SceneDataTest::transformation3DForBut2DType,
Trade: convenience per-object field access in SceneData.
5 years ago
&SceneDataTest::meshesMaterialsFor,
&SceneDataTest::lightsFor,
&SceneDataTest::camerasFor,
&SceneDataTest::skinsFor,
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
&SceneDataTest::importerStateFor});
#ifdef MAGNUM_BUILD_DEPRECATED
addInstancedTests({&SceneDataTest::childrenDeprecated},
Containers::arraySize(ChildrenDeprecatedData));
#endif
Trade: convenience per-object field access in SceneData.
5 years ago
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
addTests({&SceneDataTest::fieldForFieldMissing,
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
&SceneDataTest::findFieldObjectOffsetInvalidObject,
Trade: convenience per-object field access in SceneData.
5 years ago
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
&SceneDataTest::releaseFieldData,
&SceneDataTest::releaseData});
}
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
using namespace Containers::Literals;
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
using namespace Math::Literals;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
void SceneDataTest::mappingTypeSizeAlignment() {
CORRADE_COMPARE(sceneMappingTypeSize(SceneMappingType::UnsignedByte), 1);
CORRADE_COMPARE(sceneMappingTypeAlignment(SceneMappingType::UnsignedByte), 1);
CORRADE_COMPARE(sceneMappingTypeSize(SceneMappingType::UnsignedShort), 2);
CORRADE_COMPARE(sceneMappingTypeAlignment(SceneMappingType::UnsignedShort), 2);
CORRADE_COMPARE(sceneMappingTypeSize(SceneMappingType::UnsignedInt), 4);
CORRADE_COMPARE(sceneMappingTypeAlignment(SceneMappingType::UnsignedInt), 4);
CORRADE_COMPARE(sceneMappingTypeSize(SceneMappingType::UnsignedLong), 8);
CORRADE_COMPARE(sceneMappingTypeAlignment(SceneMappingType::UnsignedLong), 8);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
void SceneDataTest::mappingTypeSizeAlignmentInvalid() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
sceneMappingTypeSize(SceneMappingType{});
sceneMappingTypeAlignment(SceneMappingType{});
sceneMappingTypeSize(SceneMappingType(0x73));
sceneMappingTypeAlignment(SceneMappingType(0x73));
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::sceneMappingTypeSize(): invalid type Trade::SceneMappingType(0x0)\n"
"Trade::sceneMappingTypeAlignment(): invalid type Trade::SceneMappingType(0x0)\n"
"Trade::sceneMappingTypeSize(): invalid type Trade::SceneMappingType(0x73)\n"
"Trade::sceneMappingTypeAlignment(): invalid type Trade::SceneMappingType(0x73)\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
void SceneDataTest::debugMappingType() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
std::ostringstream out;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Debug{&out} << SceneMappingType::UnsignedLong << SceneMappingType(0x73);
CORRADE_COMPARE(out.str(), "Trade::SceneMappingType::UnsignedLong Trade::SceneMappingType(0x73)\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
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 SceneDataTest::debugMappingTypePacked() {
std::ostringstream out;
/* Last is not packed, ones before should not make any flags persistent */
Debug{&out} << Debug::packed << SceneMappingType::UnsignedLong << Debug::packed << SceneMappingType(0x73) << SceneMappingType::UnsignedInt;
CORRADE_COMPARE(out.str(), "UnsignedLong 0x73 Trade::SceneMappingType::UnsignedInt\n");
}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void SceneDataTest::customFieldName() {
CORRADE_VERIFY(!isSceneFieldCustom(SceneField::Rotation));
CORRADE_VERIFY(!isSceneFieldCustom(SceneField(0x0fffffffu)));
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(isSceneFieldCustom(SceneField(Implementation::SceneFieldCustom)));
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_VERIFY(isSceneFieldCustom(SceneField(0x80000000u)));
CORRADE_COMPARE(UnsignedInt(sceneFieldCustom(0)), 0x80000000u);
CORRADE_COMPARE(UnsignedInt(sceneFieldCustom(0xabcd)), 0x8000abcdu);
CORRADE_COMPARE(UnsignedInt(sceneFieldCustom(0x7fffffff)), 0xffffffffu);
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(sceneFieldCustom(SceneField(Implementation::SceneFieldCustom)), 0);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(sceneFieldCustom(SceneField(0x8000abcdu)), 0xabcd);
CORRADE_COMPARE(sceneFieldCustom(SceneField(0xffffffffu)), 0x7fffffffu);
constexpr bool is = isSceneFieldCustom(SceneField(0x8000abcdu));
CORRADE_VERIFY(is);
constexpr SceneField a = sceneFieldCustom(0xabcd);
CORRADE_COMPARE(UnsignedInt(a), 0x8000abcdu);
constexpr UnsignedInt b = sceneFieldCustom(a);
CORRADE_COMPARE(b, 0xabcd);
}
void SceneDataTest::customFieldNameTooLarge() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
std::ostringstream out;
Error redirectError{&out};
sceneFieldCustom(1u << 31);
CORRADE_COMPARE(out.str(), "Trade::sceneFieldCustom(): index 2147483648 too large\n");
}
void SceneDataTest::customFieldNameNotCustom() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
std::ostringstream out;
Error redirectError{&out};
sceneFieldCustom(SceneField::Transformation);
CORRADE_COMPARE(out.str(), "Trade::sceneFieldCustom(): Trade::SceneField::Transformation is not custom\n");
}
void SceneDataTest::debugFieldName() {
std::ostringstream out;
Debug{&out} << SceneField::Transformation << sceneFieldCustom(73) << SceneField(0xdeadda7);
CORRADE_COMPARE(out.str(), "Trade::SceneField::Transformation Trade::SceneField::Custom(73) Trade::SceneField(0xdeadda7)\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 SceneDataTest::debugFieldNamePacked() {
std::ostringstream out;
/* Last is not packed, ones before should not make any flags persistent */
Debug{&out} << Debug::packed << SceneField::Transformation << Debug::packed << sceneFieldCustom(73) << Debug::packed << SceneField(0xdeadda7) << SceneField::Parent;
CORRADE_COMPARE(out.str(), "Transformation Custom(73) 0xdeadda7 Trade::SceneField::Parent\n");
}
Trade: add scene{Object,Field}TypeAlignment(). Support utilities needed for SceneTools that will operate on arbitrary SceneData (adding/removing fields, objects...) without having to know what each field means and how it needs to be treated. Honestly the same would make sense for the VertexFormat enum as well. But not now, later.
5 years ago
void SceneDataTest::fieldTypeSizeAlignment() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* Test at least one of every size */
CORRADE_COMPARE(sceneFieldTypeSize(SceneFieldType::Byte), sizeof(Byte));
CORRADE_COMPARE(sceneFieldTypeSize(SceneFieldType::Degh), sizeof(Degh));
CORRADE_COMPARE(sceneFieldTypeSize(SceneFieldType::Vector3ub), sizeof(Vector3ub));
CORRADE_COMPARE(sceneFieldTypeSize(SceneFieldType::Range1Dh), sizeof(Range1Dh));
CORRADE_COMPARE(sceneFieldTypeSize(SceneFieldType::Vector3s), sizeof(Vector3s));
CORRADE_COMPARE(sceneFieldTypeSize(SceneFieldType::Long), sizeof(Long));
CORRADE_COMPARE(sceneFieldTypeSize(SceneFieldType::Matrix3x2h), sizeof(Matrix3x2h));
CORRADE_COMPARE(sceneFieldTypeSize(SceneFieldType::Matrix4x2h), sizeof(Matrix4x2h));
CORRADE_COMPARE(sceneFieldTypeSize(SceneFieldType::Matrix3x3h), sizeof(Matrix3x3h));
CORRADE_COMPARE(sceneFieldTypeSize(SceneFieldType::Range3Di), sizeof(Range3Di));
CORRADE_COMPARE(sceneFieldTypeSize(SceneFieldType::DualQuaternion), sizeof(DualQuaternion));
CORRADE_COMPARE(sceneFieldTypeSize(SceneFieldType::Matrix3x3), sizeof(Matrix3x3));
CORRADE_COMPARE(sceneFieldTypeSize(SceneFieldType::Matrix3x2d), sizeof(Matrix3x2d));
CORRADE_COMPARE(sceneFieldTypeSize(SceneFieldType::DualQuaterniond), sizeof(DualQuaterniond));
CORRADE_COMPARE(sceneFieldTypeSize(SceneFieldType::Matrix3x3d), sizeof(Matrix3x3d));
CORRADE_COMPARE(sceneFieldTypeSize(SceneFieldType::Matrix3x4d), sizeof(Matrix3x4d));
CORRADE_COMPARE(sceneFieldTypeSize(SceneFieldType::Matrix4x4d), sizeof(Matrix4x4d));
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
CORRADE_COMPARE(sceneFieldTypeSize(SceneFieldType::Pointer), sizeof(const void*));
Trade: add scene{Object,Field}TypeAlignment(). Support utilities needed for SceneTools that will operate on arbitrary SceneData (adding/removing fields, objects...) without having to know what each field means and how it needs to be treated. Honestly the same would make sense for the VertexFormat enum as well. But not now, later.
5 years ago
/* Test at least one of every alignment */
CORRADE_COMPARE(sceneFieldTypeAlignment(SceneFieldType::Vector3ub), alignof(UnsignedByte));
CORRADE_COMPARE(sceneFieldTypeAlignment(SceneFieldType::Matrix3x3h), alignof(Half));
CORRADE_COMPARE(sceneFieldTypeAlignment(SceneFieldType::Range3Di), alignof(UnsignedInt));
Trade: adapt test to insane alignof(double) == 4 on Android x86.
4 years ago
/* alignof(Double) is 4 on Android x86, which is stupid, so hardcode 8 */
CORRADE_COMPARE(sceneFieldTypeAlignment(SceneFieldType::DualComplexd), 8);
Trade: add scene{Object,Field}TypeAlignment(). Support utilities needed for SceneTools that will operate on arbitrary SceneData (adding/removing fields, objects...) without having to know what each field means and how it needs to be treated. Honestly the same would make sense for the VertexFormat enum as well. But not now, later.
5 years ago
CORRADE_COMPARE(sceneFieldTypeAlignment(SceneFieldType::Pointer), alignof(const void*));
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: add scene{Object,Field}TypeAlignment(). Support utilities needed for SceneTools that will operate on arbitrary SceneData (adding/removing fields, objects...) without having to know what each field means and how it needs to be treated. Honestly the same would make sense for the VertexFormat enum as well. But not now, later.
5 years ago
void SceneDataTest::fieldTypeSizeAlignmentInvalid() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
std::ostringstream out;
Error redirectError{&out};
sceneFieldTypeSize(SceneFieldType{});
Trade: add scene{Object,Field}TypeAlignment(). Support utilities needed for SceneTools that will operate on arbitrary SceneData (adding/removing fields, objects...) without having to know what each field means and how it needs to be treated. Honestly the same would make sense for the VertexFormat enum as well. But not now, later.
5 years ago
sceneFieldTypeAlignment(SceneFieldType{});
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
sceneFieldTypeSize(SceneFieldType(0xdead));
Trade: add scene{Object,Field}TypeAlignment(). Support utilities needed for SceneTools that will operate on arbitrary SceneData (adding/removing fields, objects...) without having to know what each field means and how it needs to be treated. Honestly the same would make sense for the VertexFormat enum as well. But not now, later.
5 years ago
sceneFieldTypeAlignment(SceneFieldType(0xdead));
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
sceneFieldTypeSize(SceneFieldType::Bit);
sceneFieldTypeAlignment(SceneFieldType::Bit);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
"Trade::sceneFieldTypeSize(): invalid type Trade::SceneFieldType(0x0)\n"
Trade: add scene{Object,Field}TypeAlignment(). Support utilities needed for SceneTools that will operate on arbitrary SceneData (adding/removing fields, objects...) without having to know what each field means and how it needs to be treated. Honestly the same would make sense for the VertexFormat enum as well. But not now, later.
5 years ago
"Trade::sceneFieldTypeAlignment(): invalid type Trade::SceneFieldType(0x0)\n"
"Trade::sceneFieldTypeSize(): invalid type Trade::SceneFieldType(0xdead)\n"
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
"Trade::sceneFieldTypeAlignment(): invalid type Trade::SceneFieldType(0xdead)\n"
"Trade::sceneFieldTypeSize(): can't use with Trade::SceneFieldType::Bit\n"
"Trade::sceneFieldTypeAlignment(): can't use with Trade::SceneFieldType::Bit\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
void SceneDataTest::debugFieldType() {
std::ostringstream out;
Debug{&out} << SceneFieldType::Matrix3x4h << SceneFieldType(0xdead);
CORRADE_COMPARE(out.str(), "Trade::SceneFieldType::Matrix3x4h Trade::SceneFieldType(0xdead)\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 SceneDataTest::debugFieldTypePacked() {
std::ostringstream out;
/* Last is not packed, ones before should not make any flags persistent */
Debug{&out} << Debug::packed << SceneFieldType::Matrix3x4h << Debug::packed << SceneFieldType(0xdead) << SceneFieldType::Float;
CORRADE_COMPARE(out.str(), "Matrix3x4h 0xdead Trade::SceneFieldType::Float\n");
}
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
void SceneDataTest::debugFieldFlag() {
std::ostringstream out;
Debug(&out) << SceneFieldFlag::OffsetOnly << SceneFieldFlag(0xbe);
CORRADE_COMPARE(out.str(), "Trade::SceneFieldFlag::OffsetOnly Trade::SceneFieldFlag(0xbe)\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 SceneDataTest::debugFieldFlagPacked() {
std::ostringstream out;
/* Last is not packed, ones before should not make any flags persistent */
Debug(&out) << Debug::packed << SceneFieldFlag::OffsetOnly << Debug::packed << SceneFieldFlag(0xbe) << SceneFieldFlag::ImplicitMapping;
CORRADE_COMPARE(out.str(), "OffsetOnly 0xbe Trade::SceneFieldFlag::ImplicitMapping\n");
}
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
void SceneDataTest::debugFieldFlags() {
std::ostringstream out;
Debug{&out} << (SceneFieldFlag::OffsetOnly|SceneFieldFlag(0xe0)) << SceneFieldFlags{};
CORRADE_COMPARE(out.str(), "Trade::SceneFieldFlag::OffsetOnly|Trade::SceneFieldFlag(0xe0) Trade::SceneFieldFlags{}\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 SceneDataTest::debugFieldFlagsPacked() {
std::ostringstream out;
/* Last is not packed, ones before should not make any flags persistent */
Debug{&out} << Debug::packed << (SceneFieldFlag::OffsetOnly|SceneFieldFlag(0xe0)) << Debug::packed << SceneFieldFlags{} << (SceneFieldFlag::OffsetOnly|SceneFieldFlag::ImplicitMapping);
CORRADE_COMPARE(out.str(), "OffsetOnly|0xe0 {} Trade::SceneFieldFlag::OffsetOnly|Trade::SceneFieldFlag::ImplicitMapping\n");
}
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
void SceneDataTest::debugFieldFlagsSupersets() {
/* ImplicitMapping is a superset of OrderedMapping, so only one should be
printed */
{
std::ostringstream out;
Debug{&out} << (SceneFieldFlag::ImplicitMapping|SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(out.str(), "Trade::SceneFieldFlag::ImplicitMapping\n");
}
}
Trade: properly test all constexpr SceneFieldData constructors.
3 years ago
constexpr UnsignedShort RotationMapping2D[3]{};
Trade: fix build on GCC 4.8, but don't break MSVC at the same time. UHHHHHH
3 years ago
constexpr Complexd RotationField2D[3]
/* Can't use {} because GCC 4.8 then complains that "array must be
initialized with a brace-enclosed initializer". OTOH, can't use this
without {} because MSVC then thinks it's not a constant expression. */
#if !defined(CORRADE_TARGET_GCC) || defined(CORRADE_TARGET_CLANG) || __GNUC__ >= 5
{}
#endif
;
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void SceneDataTest::constructField() {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
const UnsignedShort rotationMappingData[3]{};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
const Complexd rotationFieldData[3];
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
SceneFieldData rotations{SceneField::Rotation, Containers::arrayView(rotationMappingData), Containers::arrayView(rotationFieldData), SceneFieldFlag::OrderedMapping};
CORRADE_COMPARE(rotations.flags(), SceneFieldFlag::OrderedMapping);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(rotations.name(), SceneField::Rotation);
CORRADE_COMPARE(rotations.size(), 3);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(rotations.mappingType(), SceneMappingType::UnsignedShort);
CORRADE_COMPARE(rotations.mappingData().size(), 3);
CORRADE_COMPARE(rotations.mappingData().stride(), sizeof(UnsignedShort));
Trade: compare data pointers instead of just testing equality. Better diagnostic output.
3 years ago
CORRADE_COMPARE(rotations.mappingData().data(), rotationMappingData);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(rotations.fieldType(), SceneFieldType::Complexd);
CORRADE_COMPARE(rotations.fieldArraySize(), 0);
CORRADE_COMPARE(rotations.fieldData().size(), 3);
CORRADE_COMPARE(rotations.fieldData().stride(), sizeof(Complexd));
Trade: compare data pointers instead of just testing equality. Better diagnostic output.
3 years ago
CORRADE_COMPARE(rotations.fieldData().data(), rotationFieldData);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* This is allowed too for simplicity, the parameter has to be large enough
tho */
char someArray[3*sizeof(Complexd)];
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(rotations.mappingData(someArray).size(), 3);
CORRADE_COMPARE(rotations.mappingData(someArray).stride(), sizeof(UnsignedShort));
Trade: compare data pointers instead of just testing equality. Better diagnostic output.
3 years ago
CORRADE_COMPARE(rotations.mappingData(someArray).data(), rotationMappingData);
CORRADE_COMPARE(rotations.fieldData(someArray).size(), 3);
CORRADE_COMPARE(rotations.fieldData(someArray).stride(), sizeof(Complexd));
CORRADE_COMPARE(rotations.fieldData(someArray).data(), rotationFieldData);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
constexpr SceneFieldData crotations{SceneField::Rotation, Containers::arrayView(RotationMapping2D), Containers::arrayView(RotationField2D), SceneFieldFlag::ImplicitMapping};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
constexpr SceneField name = crotations.name();
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
constexpr SceneFieldFlags flags = crotations.flags();
Trade: properly test all constexpr SceneFieldData constructors.
3 years ago
constexpr std::size_t size = crotations.size();
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
constexpr SceneMappingType mappingType = crotations.mappingType();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(name, SceneField::Rotation);
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
CORRADE_COMPARE(flags, SceneFieldFlag::ImplicitMapping);
Trade: properly test all constexpr SceneFieldData constructors.
3 years ago
CORRADE_COMPARE(size, 3);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(mappingType, SceneMappingType::UnsignedShort);
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
/* These are not marked constexpr because it'd work only partially, not for
Trade: the SceneFieldData string constructors can't be constexpr. Apparently I forgot to actually test these -- in order to fit the string data pointer without making SceneFieldData too large, it'đ stored as an offset from fieldData. And that's something not expressible in a constexpr context. Thus the only way to create a constexpr string field is by using the offset-only constructor (which is now appropriately tested). This change at least allowed me to move the constructor to the cpp file, saving on header size and using more lightweight assertions.
3 years ago
string fields (tested in constructFieldOffsetOnlyString()) */
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
CORRADE_COMPARE(crotations.fieldType(), SceneFieldType::Complexd);
CORRADE_COMPARE(crotations.fieldArraySize(), 0);
Trade: deinline SceneFieldData::*Data() accessors. These APIs are mostly just for debugging purposes, not widely used, so it doesn't make sense to have them as constexpr in the header. (Plus the returned void view is useless in a constexpr context anyway.) This header size is getting out of hand, so every stripped bit counts. Also now that they're no longer constexpr, I can go back to using regular assertions. The reinterpret_cast<> wasn't needed either.
3 years ago
/* These are deliberately not constexpr to save header size a bit --
compared to SceneField APIs they get used very little and it's mostly
useless in a constexpr context anyway */
CORRADE_COMPARE(crotations.mappingData().size(), 3);
CORRADE_COMPARE(crotations.mappingData().stride(), sizeof(UnsignedShort));
CORRADE_COMPARE(crotations.mappingData().data(), RotationMapping2D);
CORRADE_COMPARE(crotations.fieldData().size(), 3);
CORRADE_COMPARE(crotations.fieldData().stride(), sizeof(Complexd));
CORRADE_COMPARE(crotations.fieldData().data(), RotationField2D);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
void SceneDataTest::constructFieldDefault() {
SceneFieldData data;
CORRADE_COMPARE(data.name(), SceneField{});
CORRADE_COMPARE(data.fieldType(), SceneFieldType{});
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(data.mappingType(), SceneMappingType{});
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
constexpr SceneFieldData cdata;
CORRADE_COMPARE(cdata.name(), SceneField{});
CORRADE_COMPARE(cdata.fieldType(), SceneFieldType{});
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(cdata.mappingType(), SceneMappingType{});
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
void SceneDataTest::constructFieldCustom() {
/* Verifying it doesn't hit any assertion about disallowed type for given
attribute */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
const UnsignedByte rangeMappingData[3]{};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
const Range2Dh rangeFieldData[3];
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData ranges{sceneFieldCustom(13), Containers::arrayView(rangeMappingData), Containers::arrayView(rangeFieldData)};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(ranges.name(), sceneFieldCustom(13));
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(ranges.mappingType(), SceneMappingType::UnsignedByte);
CORRADE_VERIFY(ranges.mappingData().data() == rangeMappingData);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(ranges.fieldType(), SceneFieldType::Range2Dh);
CORRADE_VERIFY(ranges.fieldData().data() == rangeFieldData);
}
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
constexpr UnsignedShort HiddenMapping[8]{};
constexpr char HiddenField[5]{};
void SceneDataTest::constructFieldBit() {
const UnsignedShort hiddenMappingData[8]{};
const char hiddenFieldData[5]{};
SceneFieldData hidden{sceneFieldCustom(773), Containers::arrayView(hiddenMappingData), Containers::StridedBitArrayView1D{Containers::BitArrayView{hiddenFieldData + 1, 5, 24}, 8, 3}, SceneFieldFlag::OrderedMapping};
CORRADE_COMPARE(hidden.flags(), SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(hidden.name(), sceneFieldCustom(773));
CORRADE_COMPARE(hidden.size(), 8);
CORRADE_COMPARE(hidden.mappingType(), SceneMappingType::UnsignedShort);
CORRADE_COMPARE(hidden.mappingData().size(), 8);
CORRADE_COMPARE(hidden.mappingData().stride(), sizeof(UnsignedShort));
CORRADE_COMPARE(hidden.mappingData().data(), hiddenMappingData);
CORRADE_COMPARE(hidden.fieldType(), SceneFieldType::Bit);
CORRADE_COMPARE(hidden.fieldArraySize(), 0);
CORRADE_COMPARE(hidden.fieldBitData().data(), hiddenFieldData + 1);
CORRADE_COMPARE(hidden.fieldBitData().offset(), 5);
CORRADE_COMPARE(hidden.fieldBitData().size(), (Containers::Size2D{8, 1}));
CORRADE_COMPARE(hidden.fieldBitData().stride(), (Containers::Stride2D{3, 1}));
/* This is allowed too for simplicity, the parameter has to be large enough
tho */
char someArray[8*2];
CORRADE_COMPARE(hidden.mappingType(), SceneMappingType::UnsignedShort);
CORRADE_COMPARE(hidden.mappingData(someArray).size(), 8);
CORRADE_COMPARE(hidden.mappingData(someArray).stride(), sizeof(UnsignedShort));
CORRADE_COMPARE(hidden.mappingData(someArray).data(), hiddenMappingData);
CORRADE_COMPARE(hidden.fieldType(), SceneFieldType::Bit);
CORRADE_COMPARE(hidden.fieldArraySize(), 0);
CORRADE_COMPARE(hidden.fieldBitData(someArray).data(), hiddenFieldData + 1);
CORRADE_COMPARE(hidden.fieldBitData(someArray).offset(), 5);
CORRADE_COMPARE(hidden.fieldBitData(someArray).size(), (Containers::Size2D{8, 1}));
CORRADE_COMPARE(hidden.fieldBitData(someArray).stride(), (Containers::Stride2D{3, 1}));
constexpr SceneFieldData chidden{sceneFieldCustom(773), Containers::arrayView(HiddenMapping), Containers::StridedBitArrayView1D{Containers::BitArrayView{HiddenField + 1, 5, 24}, 8, 3}, SceneFieldFlag::ImplicitMapping};
constexpr SceneField name = chidden.name();
constexpr SceneFieldFlags flags = chidden.flags();
constexpr std::size_t size = chidden.size();
constexpr SceneMappingType mappingType = chidden.mappingType();
CORRADE_COMPARE(name, sceneFieldCustom(773));
CORRADE_COMPARE(flags, SceneFieldFlag::ImplicitMapping);
CORRADE_COMPARE(size, 8);
CORRADE_COMPARE(mappingType, SceneMappingType::UnsignedShort);
/* These are not marked constexpr because it'd work only partially, not for
string fields (tested in constructFieldOffsetOnlyString()) */
CORRADE_COMPARE(chidden.fieldType(), SceneFieldType::Bit);
CORRADE_COMPARE(chidden.fieldArraySize(), 0);
/* These are deliberately not constexpr to save header size a bit --
compared to SceneField APIs they get used very little and it's mostly
useless in a constexpr context anyway */
CORRADE_COMPARE(chidden.mappingData(someArray).size(), 8);
CORRADE_COMPARE(chidden.mappingData(someArray).stride(), sizeof(UnsignedShort));
CORRADE_COMPARE(chidden.mappingData(someArray).data(), HiddenMapping);
CORRADE_COMPARE(chidden.fieldBitData(someArray).data(), HiddenField + 1);
CORRADE_COMPARE(chidden.fieldBitData(someArray).offset(), 5);
CORRADE_COMPARE(chidden.fieldBitData(someArray).size(), (Containers::Size2D{8, 1}));
CORRADE_COMPARE(chidden.fieldBitData(someArray).stride(), (Containers::Stride2D{3, 1}));
}
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
void SceneDataTest::constructFieldString() {
const UnsignedLong nameMappingData[3]{};
/* The string data is after the field data so the stored offset is
positive. Needs to be put into a struct as otherwise the compiler may
reorder it however it wants. Negative offset is tested in
constructFieldStringNegativeOffset() below. */
const struct {
Containers::Pair<UnsignedShort, UnsignedShort> nameField[3];
char nameString[15];
} data{};
CORRADE_VERIFY(static_cast<const void*>(data.nameString) > static_cast<const void*>(data.nameField));
SceneFieldData names{sceneFieldCustom(25), Containers::arrayView(nameMappingData), data.nameString, SceneFieldType::StringRange16, Containers::arrayView(data.nameField), SceneFieldFlag::OrderedMapping};
CORRADE_COMPARE(names.flags(), SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(names.name(), sceneFieldCustom(25));
CORRADE_COMPARE(names.size(), 3);
CORRADE_COMPARE(names.mappingType(), SceneMappingType::UnsignedLong);
CORRADE_COMPARE(names.mappingData().size(), 3);
CORRADE_COMPARE(names.mappingData().stride(), sizeof(UnsignedLong));
CORRADE_COMPARE(names.mappingData().data(), nameMappingData);
CORRADE_COMPARE(names.fieldType(), SceneFieldType::StringRange16);
CORRADE_COMPARE(names.fieldArraySize(), 0);
CORRADE_COMPARE(names.fieldData().size(), 3);
CORRADE_COMPARE(names.fieldData().stride(), sizeof(Containers::Pair<UnsignedShort, UnsignedShort>));
CORRADE_COMPARE(names.fieldData().data(), data.nameField);
CORRADE_COMPARE(names.stringData(), static_cast<const void*>(data.nameString));
/* This is allowed too for simplicity, the parameter has to be large enough
tho */
char someArray[3*sizeof(UnsignedLong)];
CORRADE_COMPARE(names.mappingData(someArray).size(), 3);
CORRADE_COMPARE(names.mappingData(someArray).stride(), sizeof(UnsignedLong));
CORRADE_VERIFY(names.mappingData(someArray).data() == nameMappingData);
CORRADE_COMPARE(names.fieldData(someArray).size(), 3);
CORRADE_COMPARE(names.fieldData(someArray).stride(), sizeof(Containers::Pair<UnsignedShort, UnsignedShort>));
CORRADE_COMPARE(names.fieldData(someArray).data(), data.nameField);
CORRADE_COMPARE(names.stringData(someArray), static_cast<const void*>(data.nameString));
Trade: the SceneFieldData string constructors can't be constexpr. Apparently I forgot to actually test these -- in order to fit the string data pointer without making SceneFieldData too large, it'đ stored as an offset from fieldData. And that's something not expressible in a constexpr context. Thus the only way to create a constexpr string field is by using the offset-only constructor (which is now appropriately tested). This change at least allowed me to move the constructor to the cpp file, saving on header size and using more lightweight assertions.
3 years ago
/* Construction of a string field is not constexpr due to arithmetic on two
(differently cast) pointers */
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
}
void SceneDataTest::constructFieldStringNegativeStride() {
const UnsignedLong nameMappingData[3]{};
/* The string data is after the field data so the stored offset is
positive. Needs to be put into a struct as otherwise the compiler may
reorder it however it wants. Negative offset is tested in
constructFieldStringNegativeOffset() below. */
const struct {
UnsignedInt nameField[3];
char nameString[15];
} data{};
CORRADE_VERIFY(static_cast<const void*>(data.nameString) > static_cast<const void*>(data.nameField));
SceneFieldData names{sceneFieldCustom(25), Containers::arrayView(nameMappingData), data.nameString, SceneFieldType::StringRangeNullTerminated32, Containers::stridedArrayView(data.nameField).flipped<0>(), SceneFieldFlag::OrderedMapping};
/* NullTerminatedString added implicitly for this type */
CORRADE_COMPARE(names.flags(), SceneFieldFlag::OrderedMapping|SceneFieldFlag::NullTerminatedString);
/* Testing only the properties related to the stride/offset unpack */
CORRADE_COMPARE(names.fieldData().size(), 3);
Trade: C++, are you telling me that I can't do `-sizeof(foo)`?? This language is just amazing. What the hell.
3 years ago
/* Uhh C++ WHAT THE HELL? "error C4146: unary minus operator applied to
unsigned type, result still unsigned" */
CORRADE_COMPARE(names.fieldData().stride(), -std::ptrdiff_t(sizeof(UnsignedInt)));
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
CORRADE_COMPARE(names.fieldData().data(), data.nameField + 2);
CORRADE_COMPARE(names.stringData(), static_cast<const void*>(data.nameString));
/* This is a separate code path, but should do the same */
char someArray[3*sizeof(UnsignedLong)];
CORRADE_COMPARE(names.fieldData(someArray).size(), 3);
Trade: C++, are you telling me that I can't do `-sizeof(foo)`?? This language is just amazing. What the hell.
3 years ago
/* Uhh C++ WHAT THE HELL? "error C4146: unary minus operator applied to
unsigned type, result still unsigned" */
CORRADE_COMPARE(names.fieldData(someArray).stride(), -std::ptrdiff_t(sizeof(UnsignedInt)));
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
CORRADE_COMPARE(names.fieldData(someArray).data(), data.nameField + 2);
CORRADE_COMPARE(names.stringData(someArray), static_cast<const void*>(data.nameString));
}
void SceneDataTest::constructFieldStringNegativeOffset() {
const UnsignedLong nameMappingData[3]{};
/* Compared to constructFieldString(), the string data is before the field
data so the stored offset is negative. Needd to be put into a struct as
otherwise the compiler may reorder it however it wants. */
const struct {
char nameString[15];
Containers::Pair<UnsignedShort, UnsignedShort> nameField[3];
} data{};
CORRADE_VERIFY(static_cast<const void*>(data.nameString) < static_cast<const void*>(data.nameField));
SceneFieldData names{sceneFieldCustom(25), Containers::arrayView(nameMappingData), data.nameString, SceneFieldType::StringRange16, Containers::arrayView(data.nameField), SceneFieldFlag::NullTerminatedString|SceneFieldFlag::OrderedMapping};
/* Testing only the properties related to the stride/offset unpack */
CORRADE_COMPARE(names.fieldData().size(), 3);
CORRADE_COMPARE(names.fieldData().stride(), sizeof(Containers::Pair<UnsignedShort, UnsignedShort>));
CORRADE_COMPARE(names.fieldData().data(), data.nameField);
CORRADE_COMPARE(names.stringData(), static_cast<const void*>(data.nameString));
/* This is a separate code path, but should do the same */
char someArray[3*sizeof(UnsignedLong)];
CORRADE_COMPARE(names.fieldData(someArray).size(), 3);
CORRADE_COMPARE(names.fieldData(someArray).stride(), sizeof(Containers::Pair<UnsignedShort, UnsignedShort>));
CORRADE_COMPARE(names.fieldData(someArray).data(), data.nameField);
CORRADE_COMPARE(names.stringData(someArray), static_cast<const void*>(data.nameString));
}
Trade: properly test all constexpr SceneFieldData constructors.
3 years ago
constexpr char ScalingMappingData[3*sizeof(UnsignedLong)]{};
constexpr char ScalingFieldData[3*sizeof(Vector3)]{};
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
void SceneDataTest::constructFieldTypeErased() {
const UnsignedLong scalingMappingData[3]{};
const Vector3 scalingFieldData[3];
SceneFieldData scalings{SceneField::Scaling, SceneMappingType::UnsignedLong, Containers::arrayCast<const char>(Containers::stridedArrayView(scalingMappingData)), SceneFieldType::Vector3, Containers::arrayCast<const char>(Containers::stridedArrayView(scalingFieldData)), SceneFieldFlag::OrderedMapping};
CORRADE_COMPARE(scalings.flags(), SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(scalings.name(), SceneField::Scaling);
CORRADE_COMPARE(scalings.size(), 3);
CORRADE_COMPARE(scalings.mappingType(), SceneMappingType::UnsignedLong);
CORRADE_COMPARE(scalings.mappingData().size(), 3);
CORRADE_COMPARE(scalings.mappingData().stride(), sizeof(UnsignedLong));
CORRADE_COMPARE(scalings.mappingData().data(), scalingMappingData);
CORRADE_COMPARE(scalings.fieldType(), SceneFieldType::Vector3);
CORRADE_COMPARE(scalings.fieldArraySize(), 0);
CORRADE_COMPARE(scalings.fieldData().size(), 3);
CORRADE_COMPARE(scalings.fieldData().stride(), sizeof(Vector3));
CORRADE_COMPARE(scalings.fieldData().data(), scalingFieldData);
Trade: properly test all constexpr SceneFieldData constructors.
3 years ago
constexpr SceneFieldData cscalings{SceneField::Scaling, SceneMappingType::UnsignedLong, Containers::StridedArrayView1D<const void>{ScalingMappingData, 3, sizeof(UnsignedLong)}, SceneFieldType::Vector3, Containers::StridedArrayView1D<const void>{ScalingFieldData, 3, sizeof(Vector3)}, SceneFieldFlag::OrderedMapping};
constexpr SceneField name = cscalings.name();
constexpr SceneFieldFlags flags = cscalings.flags();
constexpr std::size_t size = cscalings.size();
constexpr SceneMappingType mappingType = cscalings.mappingType();
CORRADE_COMPARE(name, SceneField::Scaling);
CORRADE_COMPARE(flags, SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(size, 3);
CORRADE_COMPARE(mappingType, SceneMappingType::UnsignedLong);
/* These are not marked constexpr because it'd work only partially, not for
string fields (tested in constructFieldTypeErasedString()) */
CORRADE_COMPARE(cscalings.fieldType(), SceneFieldType::Vector3);
CORRADE_COMPARE(cscalings.fieldArraySize(), 0);
/* These are deliberately not constexpr to save header size a bit --
compared to SceneField APIs they get used very little and it's mostly
useless in a constexpr context anyway */
CORRADE_COMPARE(cscalings.mappingType(), SceneMappingType::UnsignedLong);
CORRADE_COMPARE(cscalings.mappingData().size(), 3);
CORRADE_COMPARE(cscalings.mappingData().stride(), sizeof(UnsignedLong));
CORRADE_COMPARE(cscalings.mappingData().data(), ScalingMappingData);
CORRADE_COMPARE(cscalings.fieldData().size(), 3);
CORRADE_COMPARE(cscalings.fieldData().stride(), sizeof(Vector3));
CORRADE_COMPARE(cscalings.fieldData().data(), ScalingFieldData);
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
}
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void SceneDataTest::constructFieldTypeErasedBit() {
const UnsignedShort hiddenMappingData[8]{};
const char hiddenFieldData[5]{};
SceneFieldData hidden{sceneFieldCustom(773), SceneMappingType::UnsignedShort, Containers::arrayCast<const char>(Containers::stridedArrayView(hiddenMappingData)), Containers::StridedBitArrayView1D{Containers::BitArrayView{hiddenFieldData + 1, 5, 24}, 8, 3}, SceneFieldFlag::OrderedMapping};
CORRADE_COMPARE(hidden.flags(), SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(hidden.name(), sceneFieldCustom(773));
CORRADE_COMPARE(hidden.size(), 8);
CORRADE_COMPARE(hidden.mappingType(), SceneMappingType::UnsignedShort);
CORRADE_COMPARE(hidden.mappingData().size(), 8);
CORRADE_COMPARE(hidden.mappingData().stride(), sizeof(UnsignedShort));
CORRADE_COMPARE(hidden.mappingData().data(), hiddenMappingData);
CORRADE_COMPARE(hidden.fieldType(), SceneFieldType::Bit);
CORRADE_COMPARE(hidden.fieldArraySize(), 0);
CORRADE_COMPARE(hidden.fieldBitData().data(), hiddenFieldData + 1);
CORRADE_COMPARE(hidden.fieldBitData().offset(), 5);
CORRADE_COMPARE(hidden.fieldBitData().size(), (Containers::Size2D{8, 1}));
CORRADE_COMPARE(hidden.fieldBitData().stride(), (Containers::Stride2D{3, 1}));
constexpr SceneFieldData chidden{sceneFieldCustom(773), SceneMappingType::UnsignedShort, Containers::StridedArrayView1D<const void>{HiddenMapping, 8, sizeof(UnsignedShort)}, Containers::StridedBitArrayView1D{Containers::BitArrayView{HiddenField + 1, 5, 24}, 8, 3}, SceneFieldFlag::ImplicitMapping};
constexpr SceneField name = chidden.name();
constexpr SceneFieldFlags flags = chidden.flags();
constexpr std::size_t size = chidden.size();
constexpr SceneMappingType mappingType = chidden.mappingType();
CORRADE_COMPARE(name, sceneFieldCustom(773));
CORRADE_COMPARE(flags, SceneFieldFlag::ImplicitMapping);
CORRADE_COMPARE(size, 8);
CORRADE_COMPARE(mappingType, SceneMappingType::UnsignedShort);
/* These are not marked constexpr because it'd work only partially, not for
string fields (tested in constructFieldOffsetOnlyString()) */
CORRADE_COMPARE(chidden.mappingData().size(), 8);
CORRADE_COMPARE(chidden.mappingData().stride(), sizeof(UnsignedShort));
CORRADE_COMPARE(chidden.mappingData().data(), HiddenMapping);
/* These are deliberately not constexpr to save header size a bit --
compared to SceneField APIs they get used very little and it's mostly
useless in a constexpr context anyway */
CORRADE_COMPARE(chidden.fieldType(), SceneFieldType::Bit);
CORRADE_COMPARE(chidden.fieldArraySize(), 0);
CORRADE_COMPARE(chidden.fieldBitData().data(), HiddenField + 1);
CORRADE_COMPARE(chidden.fieldBitData().offset(), 5);
CORRADE_COMPARE(chidden.fieldBitData().size(), (Containers::Size2D{8, 1}));
CORRADE_COMPARE(chidden.fieldBitData().stride(), (Containers::Stride2D{3, 1}));
}
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
void SceneDataTest::constructFieldTypeErasedString() {
const UnsignedLong nameMappingData[3]{};
const char nameStringData[15]{};
const Containers::Pair<UnsignedShort, UnsignedShort> nameFieldData[3]{};
SceneFieldData names{sceneFieldCustom(25), SceneMappingType::UnsignedLong, Containers::arrayCast<const char>(Containers::stridedArrayView(nameMappingData)), nameStringData, SceneFieldType::StringRange16, Containers::arrayCast<const char>(Containers::stridedArrayView(nameFieldData)), SceneFieldFlag::NullTerminatedString|SceneFieldFlag::OrderedMapping};
CORRADE_COMPARE(names.flags(), SceneFieldFlag::OrderedMapping|SceneFieldFlag::NullTerminatedString);
CORRADE_COMPARE(names.name(), sceneFieldCustom(25));
CORRADE_COMPARE(names.size(), 3);
CORRADE_COMPARE(names.mappingType(), SceneMappingType::UnsignedLong);
CORRADE_COMPARE(names.mappingData().size(), 3);
CORRADE_COMPARE(names.mappingData().stride(), sizeof(UnsignedLong));
CORRADE_COMPARE(names.mappingData().data(), nameMappingData);
CORRADE_COMPARE(names.fieldType(), SceneFieldType::StringRange16);
CORRADE_COMPARE(names.fieldArraySize(), 0);
CORRADE_COMPARE(names.fieldData().size(), 3);
CORRADE_COMPARE(names.fieldData().stride(), sizeof(UnsignedShort)*2);
CORRADE_COMPARE(names.fieldData().data(), nameFieldData);
CORRADE_COMPARE(names.stringData(), static_cast<const void*>(nameStringData));
Trade: the SceneFieldData string constructors can't be constexpr. Apparently I forgot to actually test these -- in order to fit the string data pointer without making SceneFieldData too large, it'đ stored as an offset from fieldData. And that's something not expressible in a constexpr context. Thus the only way to create a constexpr string field is by using the offset-only constructor (which is now appropriately tested). This change at least allowed me to move the constructor to the cpp file, saving on header size and using more lightweight assertions.
3 years ago
/* Construction of a string field is not constexpr due to arithmetic on two
(differently cast) pointers */
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
}
void SceneDataTest::constructFieldTypeErased2D() {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
char rotationMappingData[6*sizeof(UnsignedShort)];
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
char rotationFieldData[6*sizeof(Complexd)];
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
auto rotationMappingView = Containers::StridedArrayView2D<char>{rotationMappingData, {6, sizeof(UnsignedShort)}}.every(2);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
auto rotationFieldView = Containers::StridedArrayView2D<char>{rotationFieldData, {6, sizeof(Complexd)}}.every(2);
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
SceneFieldData rotations{SceneField::Rotation, rotationMappingView, SceneFieldType::Complexd, rotationFieldView, SceneFieldFlag::ImplicitMapping};
CORRADE_COMPARE(rotations.flags(), SceneFieldFlag::ImplicitMapping);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(rotations.name(), SceneField::Rotation);
CORRADE_COMPARE(rotations.size(), 3);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(rotations.mappingType(), SceneMappingType::UnsignedShort);
CORRADE_COMPARE(rotations.mappingData().size(), 3);
CORRADE_COMPARE(rotations.mappingData().stride(), 2*sizeof(UnsignedShort));
CORRADE_COMPARE(rotations.mappingData().data(), rotationMappingView.data());
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(rotations.fieldType(), SceneFieldType::Complexd);
CORRADE_COMPARE(rotations.fieldArraySize(), 0);
CORRADE_COMPARE(rotations.fieldData().size(), 3);
CORRADE_COMPARE(rotations.fieldData().stride(), 2*sizeof(Complexd));
CORRADE_COMPARE(rotations.fieldData().data(), rotationFieldView.data());
Trade: properly test all constexpr SceneFieldData constructors.
3 years ago
/* 2D type-erased construction is not constexpr due to branching to select
a corresponding SceneMappingType */
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void SceneDataTest::constructFieldTypeErased2DBit() {
char hiddenMappingData[16*sizeof(UnsignedShort)]{};
char hiddenFieldData[5]{};
auto hiddenMappingView = Containers::StridedArrayView2D<char>{hiddenMappingData, {16, sizeof(UnsignedShort)}}.every(2);
/* No type-erased 2D view for the bit field data -- the 2D view constructor
is the array constructor which is tested in constructFieldArrayBit() */
SceneFieldData hidden{sceneFieldCustom(773), hiddenMappingView, Containers::StridedBitArrayView1D{Containers::BitArrayView{hiddenFieldData + 1, 5, 24}, 8, 3}, SceneFieldFlag::OrderedMapping};
CORRADE_COMPARE(hidden.flags(), SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(hidden.name(), sceneFieldCustom(773));
CORRADE_COMPARE(hidden.size(), 8);
CORRADE_COMPARE(hidden.mappingType(), SceneMappingType::UnsignedShort);
CORRADE_COMPARE(hidden.mappingData().size(), 8);
CORRADE_COMPARE(hidden.mappingData().stride(), 2*sizeof(UnsignedShort));
CORRADE_COMPARE(hidden.mappingData().data(), hiddenMappingData);
CORRADE_COMPARE(hidden.fieldType(), SceneFieldType::Bit);
CORRADE_COMPARE(hidden.fieldArraySize(), 0);
CORRADE_COMPARE(hidden.fieldBitData().data(), hiddenFieldData + 1);
CORRADE_COMPARE(hidden.fieldBitData().offset(), 5);
CORRADE_COMPARE(hidden.fieldBitData().size(), (Containers::Size2D{8, 1}));
CORRADE_COMPARE(hidden.fieldBitData().stride(), (Containers::Stride2D{3, 1}));
/* 2D type-erased construction is not constexpr due to branching to select
a corresponding SceneMappingType */
}
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
void SceneDataTest::constructFieldTypeErased2DString() {
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
char nameMappingData[6*sizeof(UnsignedLong)]{};
char nameFieldData[6*sizeof(Containers::Pair<UnsignedShort, UnsignedShort>)]{};
auto nameMappingView = Containers::StridedArrayView2D<char>{nameMappingData, {6, sizeof(UnsignedLong)}}.every(2);
auto nameFieldView = Containers::StridedArrayView2D<char>{nameFieldData, {6, sizeof(Containers::Pair<UnsignedShort, UnsignedShort>)}}.every(2);
const char nameStringData[15]{};
SceneFieldData names{sceneFieldCustom(25), nameMappingView, nameStringData, SceneFieldType::StringRange16, nameFieldView, SceneFieldFlag::NullTerminatedString|SceneFieldFlag::OrderedMapping};
CORRADE_COMPARE(names.flags(), SceneFieldFlag::OrderedMapping|SceneFieldFlag::NullTerminatedString);
CORRADE_COMPARE(names.name(), sceneFieldCustom(25));
CORRADE_COMPARE(names.size(), 3);
CORRADE_COMPARE(names.mappingType(), SceneMappingType::UnsignedLong);
CORRADE_COMPARE(names.mappingData().size(), 3);
CORRADE_COMPARE(names.mappingData().stride(), 2*sizeof(UnsignedLong));
CORRADE_COMPARE(names.mappingData().data(), nameMappingView.data());
CORRADE_COMPARE(names.fieldType(), SceneFieldType::StringRange16);
CORRADE_COMPARE(names.fieldArraySize(), 0);
CORRADE_COMPARE(names.fieldData().size(), 3);
CORRADE_COMPARE(names.fieldData().stride(), 2*sizeof(UnsignedShort)*2);
CORRADE_COMPARE(names.fieldData().data(), nameFieldView.data());
CORRADE_COMPARE(names.stringData(), static_cast<const void*>(nameStringData));
Trade: properly test all constexpr SceneFieldData constructors.
3 years ago
/* 2D type-erased construction is not constexpr due to branching to select
a corresponding SceneMappingType */
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void SceneDataTest::constructFieldNonOwningArray() {
const SceneFieldData data[3];
Containers::Array<SceneFieldData> array = sceneFieldDataNonOwningArray(data);
CORRADE_COMPARE(array.size(), 3);
CORRADE_COMPARE(static_cast<const void*>(array.data()), data);
}
void SceneDataTest::constructFieldOffsetOnly() {
struct Data {
Byte parent;
UnsignedShort object;
Vector2 translation;
} data[] {
{0, 2, {2.0f, 3.0f}},
{0, 15, {67.0f, -1.1f}}
};
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
SceneFieldData a{SceneField::Translation, 2, SceneMappingType::UnsignedShort, offsetof(Data, object), sizeof(Data), SceneFieldType::Vector2, offsetof(Data, translation), sizeof(Data), SceneFieldFlag::ImplicitMapping};
CORRADE_COMPARE(a.flags(), SceneFieldFlag::OffsetOnly|SceneFieldFlag::ImplicitMapping);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(a.name(), SceneField::Translation);
CORRADE_COMPARE(a.size(), 2);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(a.mappingType(), SceneMappingType::UnsignedShort);
CORRADE_COMPARE(a.mappingData(data).size(), 2);
CORRADE_COMPARE(a.mappingData(data).stride(), sizeof(Data));
CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedShort>(a.mappingData(data)),
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Containers::arrayView<UnsignedShort>({2, 15}),
TestSuite::Compare::Container);
CORRADE_COMPARE(a.fieldType(), SceneFieldType::Vector2);
CORRADE_COMPARE(a.fieldArraySize(), 0);
CORRADE_COMPARE(a.fieldData(data).size(), 2);
CORRADE_COMPARE(a.fieldData(data).stride(), sizeof(Data));
CORRADE_COMPARE_AS(Containers::arrayCast<const Vector2>(a.fieldData(data)),
Containers::arrayView<Vector2>({{2.0f, 3.0f}, {67.0f, -1.1f}}),
TestSuite::Compare::Container);
Trade: properly test all constexpr SceneFieldData constructors.
3 years ago
constexpr SceneFieldData ca{SceneField::Translation, 2, SceneMappingType::UnsignedShort, offsetof(Data, object), sizeof(Data), SceneFieldType::Vector2, offsetof(Data, translation), sizeof(Data), SceneFieldFlag::ImplicitMapping};
constexpr SceneField name = ca.name();
constexpr SceneFieldFlags flags = ca.flags();
constexpr std::size_t size = ca.size();
constexpr SceneMappingType mappingType = ca.mappingType();
CORRADE_COMPARE(name, SceneField::Translation);
CORRADE_COMPARE(flags, SceneFieldFlag::OffsetOnly|SceneFieldFlag::ImplicitMapping);
CORRADE_COMPARE(size, 2);
CORRADE_COMPARE(mappingType, SceneMappingType::UnsignedShort);
/* These are not marked constexpr because it'd work only partially, not for
string fields (tested in constructFieldOffsetOnlyString()) */
CORRADE_COMPARE(ca.fieldType(), SceneFieldType::Vector2);
CORRADE_COMPARE(ca.fieldArraySize(), 0);
/* These are deliberately not constexpr to save header size a bit --
compared to SceneField APIs they get used very little and it's mostly
useless in a constexpr context anyway */
CORRADE_COMPARE(ca.mappingData(data).size(), 2);
CORRADE_COMPARE(ca.mappingData(data).stride(), sizeof(Data));
CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedShort>(ca.mappingData(data)),
Containers::arrayView<UnsignedShort>({2, 15}),
TestSuite::Compare::Container);
CORRADE_COMPARE(ca.fieldData(data).size(), 2);
CORRADE_COMPARE(ca.fieldData(data).stride(), sizeof(Data));
CORRADE_COMPARE_AS(Containers::arrayCast<const Vector2>(ca.fieldData(data)),
Containers::arrayView<Vector2>({{2.0f, 3.0f}, {67.0f, -1.1f}}),
TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void SceneDataTest::constructFieldOffsetOnlyBit() {
struct Data {
Byte parent;
UnsignedInt object;
char yesInFifthBit;
} data[]{
{0, 2, '\x10'},
{0, 15, '\xef'},
{0, 22, '\x10'}
};
SceneFieldData a{sceneFieldCustom(773), 3, SceneMappingType::UnsignedInt, offsetof(Data, object), sizeof(Data), offsetof(Data, yesInFifthBit), 4, sizeof(Data)*8, SceneFieldFlag::OrderedMapping};
CORRADE_COMPARE(a.flags(), SceneFieldFlag::OffsetOnly|SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(a.name(), sceneFieldCustom(773));
CORRADE_COMPARE(a.size(), 3);
CORRADE_COMPARE(a.mappingType(), SceneMappingType::UnsignedInt);
CORRADE_COMPARE(a.mappingData(data).size(), 3);
CORRADE_COMPARE(a.mappingData(data).stride(), sizeof(Data));
CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedInt>(a.mappingData(data)),
Containers::arrayView<UnsignedInt>({2, 15, 22}),
TestSuite::Compare::Container);
CORRADE_COMPARE(a.fieldType(), SceneFieldType::Bit);
CORRADE_COMPARE(a.fieldArraySize(), 0);
CORRADE_COMPARE(a.fieldBitData(data).data(), &data[0].yesInFifthBit);
CORRADE_COMPARE(a.fieldBitData(data).offset(), 4);
CORRADE_COMPARE(a.fieldBitData(data).size(), (Containers::Size2D{3, 1}));
CORRADE_COMPARE(a.fieldBitData(data).stride(), (Containers::Stride2D{sizeof(Data)*8, 1}));
CORRADE_COMPARE_AS((a.fieldBitData(data).transposed<0, 1>())[0],
Containers::stridedArrayView({true, false, true}).sliceBit(0),
TestSuite::Compare::Container);
constexpr SceneFieldData ca{sceneFieldCustom(773), 3, SceneMappingType::UnsignedInt, offsetof(Data, object), sizeof(Data), offsetof(Data, yesInFifthBit), 4, sizeof(Data)*8, SceneFieldFlag::OrderedMapping};
constexpr SceneField name = ca.name();
constexpr SceneFieldFlags flags = ca.flags();
constexpr std::size_t size = ca.size();
constexpr SceneMappingType mappingType = ca.mappingType();
CORRADE_COMPARE(name, sceneFieldCustom(773));
CORRADE_COMPARE(flags, SceneFieldFlag::OffsetOnly|SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(size, 3);
CORRADE_COMPARE(mappingType, SceneMappingType::UnsignedInt);
/* These are not marked constexpr because it'd work only partially, not for
string fields (tested in constructFieldOffsetOnlyString()) */
CORRADE_COMPARE(ca.fieldType(), SceneFieldType::Bit);
CORRADE_COMPARE(ca.fieldArraySize(), 0);
/* These are deliberately not constexpr to save header size a bit --
compared to SceneField APIs they get used very little and it's mostly
useless in a constexpr context anyway */
CORRADE_COMPARE(ca.mappingData(data).size(), 3);
CORRADE_COMPARE(ca.mappingData(data).stride(), sizeof(Data));
CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedInt>(ca.mappingData(data)),
Containers::arrayView<UnsignedInt>({2, 15, 22}),
TestSuite::Compare::Container);
CORRADE_COMPARE(ca.fieldBitData(data).offset(), 4);
CORRADE_COMPARE(ca.fieldBitData(data).size(), (Containers::Size2D{3, 1}));
CORRADE_COMPARE(ca.fieldBitData(data).stride(), (Containers::Stride2D{sizeof(Data)*8, 1}));
CORRADE_COMPARE_AS((ca.fieldBitData(data).transposed<0, 1>())[0],
Containers::stridedArrayView({true, false, true}).sliceBit(0),
TestSuite::Compare::Container);
}
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
void SceneDataTest::constructFieldOffsetOnlyString() {
const char string[] = "NAMES:eyehandnoseleg";
struct Data {
Byte parent;
UnsignedLong object;
Containers::Pair<UnsignedByte, UnsignedByte> nameRange;
} data[]{
{0, 2, {3, 4}},
{0, 15, {11, 3}}
};
SceneFieldData a{sceneFieldCustom(36), 2, SceneMappingType::UnsignedLong, offsetof(Data, object), sizeof(Data), 6, SceneFieldType::StringRange8, offsetof(Data, nameRange), sizeof(Data), SceneFieldFlag::OrderedMapping};
CORRADE_COMPARE(a.flags(), SceneFieldFlag::OffsetOnly|SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(a.name(), sceneFieldCustom(36));
CORRADE_COMPARE(a.size(), 2);
CORRADE_COMPARE(a.mappingType(), SceneMappingType::UnsignedLong);
CORRADE_COMPARE(a.mappingData(data).size(), 2);
CORRADE_COMPARE(a.mappingData(data).stride(), sizeof(Data));
CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedLong>(a.mappingData(data)),
Containers::arrayView<UnsignedLong>({2, 15}),
TestSuite::Compare::Container);
CORRADE_COMPARE(a.fieldType(), SceneFieldType::StringRange8);
CORRADE_COMPARE(a.fieldArraySize(), 0);
CORRADE_COMPARE(a.fieldData(data).size(), 2);
CORRADE_COMPARE(a.fieldData(data).stride(), sizeof(Data));
auto fieldData = Containers::arrayCast<const Containers::Pair<UnsignedByte, UnsignedByte>>(a.fieldData(data));
CORRADE_COMPARE_AS(fieldData, (Containers::arrayView<Containers::Pair<UnsignedByte, UnsignedByte>>({
{3, 4}, {11, 3}
})), TestSuite::Compare::Container);
CORRADE_COMPARE(a.stringData(string), "eyehandnoseleg"_s);
CORRADE_COMPARE((Containers::StringView{a.stringData(string) + fieldData[0].first(), fieldData[0].second()}), "hand");
CORRADE_COMPARE((Containers::StringView{a.stringData(string) + fieldData[1].first(), fieldData[1].second()}), "leg");
Trade: the SceneFieldData string constructors can't be constexpr. Apparently I forgot to actually test these -- in order to fit the string data pointer without making SceneFieldData too large, it'đ stored as an offset from fieldData. And that's something not expressible in a constexpr context. Thus the only way to create a constexpr string field is by using the offset-only constructor (which is now appropriately tested). This change at least allowed me to move the constructor to the cpp file, saving on header size and using more lightweight assertions.
3 years ago
constexpr SceneFieldData ca{sceneFieldCustom(36), 2, SceneMappingType::UnsignedLong, offsetof(Data, object), sizeof(Data), 6, SceneFieldType::StringRange8, offsetof(Data, nameRange), sizeof(Data), SceneFieldFlag::OrderedMapping};
constexpr SceneField name = ca.name();
constexpr SceneFieldFlags flags = ca.flags();
constexpr std::size_t size = ca.size();
constexpr SceneMappingType mappingType = ca.mappingType();
CORRADE_COMPARE(name, sceneFieldCustom(36));
CORRADE_COMPARE(flags, SceneFieldFlag::OffsetOnly|SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(size, 2);
CORRADE_COMPARE(mappingType, SceneMappingType::UnsignedLong);
/* These are not marked constexpr because it wouldn't work for string
fields due to the type/size stored in an union */
CORRADE_COMPARE(ca.fieldType(), SceneFieldType::StringRange8);
CORRADE_COMPARE(ca.fieldArraySize(), 0);
/* These are deliberately not constexpr to save header size a bit --
compared to SceneField APIs they get used very little and it's mostly
useless in a constexpr context anyway */
CORRADE_COMPARE(ca.mappingData(data).size(), 2);
CORRADE_COMPARE(ca.mappingData(data).stride(), sizeof(Data));
CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedLong>(ca.mappingData(data)),
Containers::arrayView<UnsignedLong>({2, 15}),
TestSuite::Compare::Container);
CORRADE_COMPARE(ca.fieldData(data).size(), 2);
CORRADE_COMPARE(ca.fieldData(data).stride(), sizeof(Data));
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
}
void SceneDataTest::constructFieldOffsetOnlyStringNegativeStride() {
const char string[] = "NAMES:eye\0hand\0nose\0leg";
struct Data {
UnsignedLong object;
UnsignedShort nameRange;
} data[]{
{2, 4},
{15, 14}
};
SceneFieldData a{sceneFieldCustom(36), 2, SceneMappingType::UnsignedLong, offsetof(Data, object), sizeof(Data), 6, SceneFieldType::StringRangeNullTerminated16, offsetof(Data, nameRange) + sizeof(Data), -std::ptrdiff_t(sizeof(Data)), SceneFieldFlag::OrderedMapping};
/* NullTerminatedString added implicitly for this type */
CORRADE_COMPARE(a.flags(), SceneFieldFlag::OffsetOnly|SceneFieldFlag::OrderedMapping|SceneFieldFlag::NullTerminatedString);
CORRADE_COMPARE(a.fieldType(), SceneFieldType::StringRangeNullTerminated16);
CORRADE_COMPARE(a.fieldArraySize(), 0);
CORRADE_COMPARE(a.fieldData(data).size(), 2);
Trade: C++, are you telling me that I can't do `-sizeof(foo)`?? This language is just amazing. What the hell.
3 years ago
/* Uhh C++ WHAT THE HELL? "error C4146: unary minus operator applied to
unsigned type, result still unsigned" */
CORRADE_COMPARE(a.fieldData(data).stride(), -std::ptrdiff_t(sizeof(Data)));
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
/* Order flipped compared to constructFieldOffsetOnlyString() */
auto fieldData = Containers::arrayCast<const UnsignedShort>(a.fieldData(data));
CORRADE_COMPARE_AS(fieldData, Containers::arrayView<UnsignedShort>({
14, 4,
}), TestSuite::Compare::Container);
CORRADE_COMPARE(a.stringData(string), "eye"_s); /* after \0 it's lost */
CORRADE_COMPARE(a.stringData(string) + fieldData[0], "leg"_s);
CORRADE_COMPARE(a.stringData(string) + fieldData[1], "hand"_s);
}
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
constexpr UnsignedByte ArrayOffsetMappingData[3]{};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
constexpr Int ArrayOffsetFieldData[3*4]{};
void SceneDataTest::constructFieldArray() {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedByte offsetMappingData[3];
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Int offsetFieldData[3*4];
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
SceneFieldData data{sceneFieldCustom(34), Containers::arrayView(offsetMappingData), Containers::StridedArrayView2D<Int>{offsetFieldData, {3, 4}}, SceneFieldFlag::ImplicitMapping};
CORRADE_COMPARE(data.flags(), SceneFieldFlag::ImplicitMapping);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(data.name(), sceneFieldCustom(34));
CORRADE_COMPARE(data.size(), 3);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(data.mappingType(), SceneMappingType::UnsignedByte);
CORRADE_COMPARE(data.mappingData().size(), 3);
CORRADE_COMPARE(data.mappingData().stride(), sizeof(UnsignedByte));
CORRADE_VERIFY(data.mappingData().data() == offsetMappingData);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(data.fieldType(), SceneFieldType::Int);
CORRADE_COMPARE(data.fieldArraySize(), 4);
CORRADE_COMPARE(data.fieldData().size(), 3);
CORRADE_COMPARE(data.fieldData().stride(), 4*sizeof(Int));
CORRADE_VERIFY(data.fieldData().data() == offsetFieldData);
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
constexpr SceneFieldData cdata{sceneFieldCustom(34), Containers::arrayView(ArrayOffsetMappingData), Containers::StridedArrayView2D<const Int>{ArrayOffsetFieldData, {3, 4}}, SceneFieldFlag::OrderedMapping};
Trade: properly test all constexpr SceneFieldData constructors.
3 years ago
constexpr SceneField name = cdata.name();
constexpr SceneFieldFlags flags = cdata.flags();
constexpr std::size_t size = cdata.size();
constexpr SceneMappingType mappingType = cdata.mappingType();
CORRADE_COMPARE(name, sceneFieldCustom(34));
CORRADE_COMPARE(flags, SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(size, 3);
CORRADE_COMPARE(mappingType, SceneMappingType::UnsignedByte);
/* These are not marked constexpr because it'd work only partially, not for
string fields (tested in constructFieldOffsetOnlyString()) */
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(cdata.fieldType(), SceneFieldType::Int);
CORRADE_COMPARE(cdata.fieldArraySize(), 4);
Trade: properly test all constexpr SceneFieldData constructors.
3 years ago
/* These are deliberately not constexpr to save header size a bit --
compared to SceneField APIs they get used very little and it's mostly
useless in a constexpr context anyway */
CORRADE_COMPARE(cdata.mappingData().size(), 3);
CORRADE_COMPARE(cdata.mappingData().stride(), sizeof(UnsignedByte));
CORRADE_COMPARE(cdata.mappingData().data(), ArrayOffsetMappingData);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(cdata.fieldData().size(), 3);
CORRADE_COMPARE(cdata.fieldData().stride(), 4*sizeof(Int));
Trade: properly test all constexpr SceneFieldData constructors.
3 years ago
CORRADE_COMPARE(cdata.fieldData().data(), ArrayOffsetFieldData);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
constexpr UnsignedLong ArrayHiddenMapping[3]{};
constexpr char ArrayHiddenField[5]{};
void SceneDataTest::constructFieldArrayBit() {
const UnsignedLong hiddenMappingData[3]{};
const char hiddenFieldData[5]{};
SceneFieldData data{sceneFieldCustom(773), Containers::arrayView(hiddenMappingData), Containers::StridedBitArrayView2D{Containers::BitArrayView{hiddenFieldData + 1, 5, 24}, {3, 4}, {8, 1}}, SceneFieldFlag::OrderedMapping};
CORRADE_COMPARE(data.flags(), SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(data.name(), sceneFieldCustom(773));
CORRADE_COMPARE(data.size(), 3);
CORRADE_COMPARE(data.mappingType(), SceneMappingType::UnsignedLong);
CORRADE_COMPARE(data.mappingData().size(), 3);
CORRADE_COMPARE(data.mappingData().stride(), sizeof(UnsignedLong));
CORRADE_COMPARE(data.mappingData().data(), hiddenMappingData);
CORRADE_COMPARE(data.fieldType(), SceneFieldType::Bit);
CORRADE_COMPARE(data.fieldArraySize(), 4);
CORRADE_COMPARE(data.fieldBitData().data(), hiddenFieldData + 1);
CORRADE_COMPARE(data.fieldBitData().offset(), 5);
CORRADE_COMPARE(data.fieldBitData().size(), (Containers::Size2D{3, 4}));
CORRADE_COMPARE(data.fieldBitData().stride(), (Containers::Stride2D{8, 1}));
constexpr SceneFieldData cdata{sceneFieldCustom(773), Containers::arrayView(ArrayHiddenMapping), Containers::StridedBitArrayView2D{Containers::BitArrayView{ArrayHiddenField + 1, 5, 24}, {3, 4}, {8, 1}}, SceneFieldFlag::OrderedMapping};
constexpr SceneField name = cdata.name();
constexpr SceneFieldFlags flags = cdata.flags();
constexpr std::size_t size = cdata.size();
constexpr SceneMappingType mappingType = cdata.mappingType();
CORRADE_COMPARE(name, sceneFieldCustom(773));
CORRADE_COMPARE(flags, SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(size, 3);
CORRADE_COMPARE(mappingType, SceneMappingType::UnsignedLong);
/* These are not marked constexpr because it'd work only partially, not for
string fields (tested in constructFieldOffsetOnlyString()) */
CORRADE_COMPARE(cdata.fieldType(), SceneFieldType::Bit);
CORRADE_COMPARE(cdata.fieldArraySize(), 4);
/* These are deliberately not constexpr to save header size a bit --
compared to SceneField APIs they get used very little and it's mostly
useless in a constexpr context anyway */
CORRADE_COMPARE(cdata.mappingData().size(), 3);
CORRADE_COMPARE(cdata.mappingData().stride(), sizeof(UnsignedLong));
CORRADE_COMPARE(cdata.mappingData().data(), ArrayHiddenMapping);
CORRADE_COMPARE(cdata.fieldBitData().data(), ArrayHiddenField + 1);
CORRADE_COMPARE(cdata.fieldBitData().offset(), 5);
CORRADE_COMPARE(cdata.fieldBitData().size(), (Containers::Size2D{3, 4}));
CORRADE_COMPARE(cdata.fieldBitData().stride(), (Containers::Stride2D{8, 1}));
}
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
void SceneDataTest::constructFieldArrayTypeErased() {
UnsignedByte offsetMappingData[3];
Int offsetFieldData[3*4];
Containers::StridedArrayView1D<Int> offset{offsetFieldData, 3, 4*sizeof(Int)};
SceneFieldData data{sceneFieldCustom(34), SceneMappingType::UnsignedByte, Containers::arrayCast<const char>(Containers::stridedArrayView(offsetMappingData)), SceneFieldType::Int, Containers::arrayCast<const char>(offset), 4, SceneFieldFlag::OrderedMapping};
CORRADE_COMPARE(data.flags(), SceneFieldFlag::OrderedMapping);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(data.name(), sceneFieldCustom(34));
CORRADE_COMPARE(data.size(), 3);
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
CORRADE_COMPARE(data.fieldType(), SceneFieldType::Int);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(data.mappingType(), SceneMappingType::UnsignedByte);
CORRADE_COMPARE(data.mappingData().size(), 3);
CORRADE_COMPARE(data.mappingData().stride(), sizeof(UnsignedByte));
CORRADE_VERIFY(data.mappingData().data() == offsetMappingData);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(data.fieldArraySize(), 4);
CORRADE_COMPARE(data.fieldData().size(), 3);
CORRADE_COMPARE(data.fieldData().stride(), 4*sizeof(Int));
CORRADE_VERIFY(data.fieldData().data() == offsetFieldData);
Trade: properly test all constexpr SceneFieldData constructors.
3 years ago
constexpr SceneFieldData cdata{sceneFieldCustom(34), SceneMappingType::UnsignedByte, Containers::StridedArrayView1D<const void>{ArrayOffsetMappingData}, SceneFieldType::Int, Containers::StridedArrayView1D<const void>{ArrayOffsetFieldData, 3, 4*sizeof(Int)}, 4, SceneFieldFlag::OrderedMapping};
constexpr SceneField name = cdata.name();
constexpr SceneFieldFlags flags = cdata.flags();
constexpr std::size_t size = cdata.size();
constexpr SceneMappingType mappingType = cdata.mappingType();
CORRADE_COMPARE(name, sceneFieldCustom(34));
CORRADE_COMPARE(flags, SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(size, 3);
CORRADE_COMPARE(mappingType, SceneMappingType::UnsignedByte);
/* These are not marked constexpr because it'd work only partially, not for
string fields (tested in constructFieldOffsetOnlyString()) */
CORRADE_COMPARE(cdata.fieldType(), SceneFieldType::Int);
CORRADE_COMPARE(cdata.fieldArraySize(), 4);
/* These are deliberately not constexpr to save header size a bit --
compared to SceneField APIs they get used very little and it's mostly
useless in a constexpr context anyway */
CORRADE_COMPARE(cdata.mappingData().size(), 3);
CORRADE_COMPARE(cdata.mappingData().stride(), sizeof(UnsignedByte));
CORRADE_COMPARE(cdata.mappingData().data(), ArrayOffsetMappingData);
CORRADE_COMPARE(cdata.fieldData().size(), 3);
CORRADE_COMPARE(cdata.fieldData().stride(), 4*sizeof(Int));
CORRADE_COMPARE(cdata.fieldData().data(), ArrayOffsetFieldData);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void SceneDataTest::constructFieldArrayTypeErasedBit() {
const UnsignedLong hiddenMappingData[3]{};
const char hiddenFieldData[5]{};
SceneFieldData data{sceneFieldCustom(773), SceneMappingType::UnsignedLong, Containers::arrayCast<const char>(Containers::stridedArrayView(hiddenMappingData)), Containers::StridedBitArrayView2D{Containers::BitArrayView{hiddenFieldData + 1, 5, 24}, {3, 4}, {8, 1}}, SceneFieldFlag::OrderedMapping};
CORRADE_COMPARE(data.flags(), SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(data.name(), sceneFieldCustom(773));
CORRADE_COMPARE(data.size(), 3);
CORRADE_COMPARE(data.mappingType(), SceneMappingType::UnsignedLong);
CORRADE_COMPARE(data.mappingData().size(), 3);
CORRADE_COMPARE(data.mappingData().stride(), sizeof(UnsignedLong));
CORRADE_COMPARE(data.mappingData().data(), hiddenMappingData);
CORRADE_COMPARE(data.fieldType(), SceneFieldType::Bit);
CORRADE_COMPARE(data.fieldArraySize(), 4);
CORRADE_COMPARE(data.fieldBitData().data(), hiddenFieldData + 1);
CORRADE_COMPARE(data.fieldBitData().offset(), 5);
CORRADE_COMPARE(data.fieldBitData().size(), (Containers::Size2D{3, 4}));
CORRADE_COMPARE(data.fieldBitData().stride(), (Containers::Stride2D{8, 1}));
constexpr SceneFieldData cdata{sceneFieldCustom(773), SceneMappingType::UnsignedLong, Containers::StridedArrayView1D<const void>{ArrayHiddenMapping}, Containers::StridedBitArrayView2D{Containers::BitArrayView{ArrayHiddenField + 1, 5, 24}, {3, 4}, {8, 1}}, SceneFieldFlag::OrderedMapping};
constexpr SceneField name = cdata.name();
constexpr SceneFieldFlags flags = cdata.flags();
constexpr std::size_t size = cdata.size();
constexpr SceneMappingType mappingType = cdata.mappingType();
CORRADE_COMPARE(name, sceneFieldCustom(773));
CORRADE_COMPARE(flags, SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(size, 3);
CORRADE_COMPARE(mappingType, SceneMappingType::UnsignedLong);
/* These are not marked constexpr because it'd work only partially, not for
string fields (tested in constructFieldOffsetOnlyString()) */
CORRADE_COMPARE(cdata.fieldType(), SceneFieldType::Bit);
CORRADE_COMPARE(cdata.fieldArraySize(), 4);
/* These are deliberately not constexpr to save header size a bit --
compared to SceneField APIs they get used very little and it's mostly
useless in a constexpr context anyway */
CORRADE_COMPARE(cdata.mappingData().size(), 3);
CORRADE_COMPARE(cdata.mappingData().stride(), sizeof(UnsignedLong));
CORRADE_COMPARE(cdata.mappingData().data(), ArrayHiddenMapping);
CORRADE_COMPARE(cdata.fieldBitData().data(), ArrayHiddenField + 1);
CORRADE_COMPARE(cdata.fieldBitData().offset(), 5);
CORRADE_COMPARE(cdata.fieldBitData().size(), (Containers::Size2D{3, 4}));
CORRADE_COMPARE(cdata.fieldBitData().stride(), (Containers::Stride2D{8, 1}));
}
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
void SceneDataTest::constructFieldArrayTypeErased2D() {
char offsetMappingData[3*sizeof(UnsignedByte)];
char offsetFieldData[3*4*sizeof(Int)];
SceneFieldData data{sceneFieldCustom(34), Containers::StridedArrayView2D<char>{offsetMappingData, {3, sizeof(UnsignedByte)}}, SceneFieldType::Int, Containers::StridedArrayView2D<char>{offsetFieldData, {3, 4*sizeof(Int)}}, 4, SceneFieldFlag::ImplicitMapping};
CORRADE_COMPARE(data.flags(), SceneFieldFlag::ImplicitMapping);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(data.name(), sceneFieldCustom(34));
CORRADE_COMPARE(data.size(), 3);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(data.mappingType(), SceneMappingType::UnsignedByte);
CORRADE_COMPARE(data.mappingData().size(), 3);
CORRADE_COMPARE(data.mappingData().stride(), sizeof(UnsignedByte));
CORRADE_VERIFY(data.mappingData().data() == offsetMappingData);
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
CORRADE_COMPARE(data.fieldType(), SceneFieldType::Int);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(data.fieldArraySize(), 4);
CORRADE_COMPARE(data.fieldData().size(), 3);
CORRADE_COMPARE(data.fieldData().stride(), 4*sizeof(Int));
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_VERIFY(data.fieldData().data() == offsetFieldData);
Trade: properly test all constexpr SceneFieldData constructors.
3 years ago
/* 2D type-erased construction is not constexpr due to branching to select
a corresponding SceneMappingType */
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void SceneDataTest::constructFieldArrayTypeErased2DBit() {
char hiddenMappingData[3*sizeof(UnsignedLong)]{};
char hiddenFieldData[5]{};
SceneFieldData data{sceneFieldCustom(773), Containers::StridedArrayView2D<const char>{hiddenMappingData, {3, sizeof(UnsignedLong)}}, Containers::StridedBitArrayView2D{Containers::BitArrayView{hiddenFieldData + 1, 5, 24}, {3, 4}, {8, 1}}, SceneFieldFlag::OrderedMapping};
CORRADE_COMPARE(data.flags(), SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(data.name(), sceneFieldCustom(773));
CORRADE_COMPARE(data.size(), 3);
CORRADE_COMPARE(data.mappingType(), SceneMappingType::UnsignedLong);
CORRADE_COMPARE(data.mappingData().size(), 3);
CORRADE_COMPARE(data.mappingData().stride(), sizeof(UnsignedLong));
CORRADE_COMPARE(data.mappingData().data(), hiddenMappingData);
CORRADE_COMPARE(data.fieldType(), SceneFieldType::Bit);
CORRADE_COMPARE(data.fieldArraySize(), 4);
CORRADE_COMPARE(data.fieldBitData().data(), hiddenFieldData + 1);
CORRADE_COMPARE(data.fieldBitData().offset(), 5);
CORRADE_COMPARE(data.fieldBitData().size(), (Containers::Size2D{3, 4}));
CORRADE_COMPARE(data.fieldBitData().stride(), (Containers::Stride2D{8, 1}));
/* 2D type-erased construction is not constexpr due to branching to select
a corresponding SceneMappingType */
}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void SceneDataTest::constructFieldArrayOffsetOnly() {
struct Data {
Byte parent;
UnsignedByte object;
Trade: properly test all constexpr SceneFieldData constructors.
3 years ago
Int offset[2];
} data[]{
{0, 2, {0, 1}},
{0, 15, {2, 3}},
{0, 22, {4, 5}}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
};
Trade: properly test all constexpr SceneFieldData constructors.
3 years ago
SceneFieldData a{sceneFieldCustom(34), 3, SceneMappingType::UnsignedByte, offsetof(Data, object), sizeof(Data), SceneFieldType::Int, offsetof(Data, offset), sizeof(Data), 2, SceneFieldFlag::ImplicitMapping};
CORRADE_COMPARE(a.flags(), SceneFieldFlag::OffsetOnly|SceneFieldFlag::ImplicitMapping);
CORRADE_COMPARE(a.name(), sceneFieldCustom(34));
CORRADE_COMPARE(a.size(), 3);
CORRADE_COMPARE(a.mappingType(), SceneMappingType::UnsignedByte);
CORRADE_COMPARE(a.mappingData(data).size(), 3);
CORRADE_COMPARE(a.mappingData(data).stride(), sizeof(Data));
CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedByte>(a.mappingData(data)),
Containers::arrayView<UnsignedByte>({2, 15, 22}),
TestSuite::Compare::Container);
CORRADE_COMPARE(a.fieldType(), SceneFieldType::Int);
CORRADE_COMPARE(a.fieldArraySize(), 2);
CORRADE_COMPARE(a.fieldData(data).size(), 3);
CORRADE_COMPARE(a.fieldData(data).stride(), sizeof(Data));
CORRADE_COMPARE_AS((Containers::arrayCast<2, const Int>(a.fieldData(data), 2).transposed<0, 1>())[0],
Containers::arrayView({0, 2, 4}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS((Containers::arrayCast<2, const Int>(a.fieldData(data), 2).transposed<0, 1>())[1],
Containers::arrayView({1, 3, 5}),
TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: properly test all constexpr SceneFieldData constructors.
3 years ago
constexpr SceneFieldData ca{sceneFieldCustom(34), 3, SceneMappingType::UnsignedByte, offsetof(Data, object), sizeof(Data), SceneFieldType::Int, offsetof(Data, offset), sizeof(Data), 2, SceneFieldFlag::OrderedMapping};
constexpr SceneField name = ca.name();
constexpr SceneFieldFlags flags = ca.flags();
constexpr std::size_t size = ca.size();
constexpr SceneMappingType mappingType = ca.mappingType();
CORRADE_COMPARE(name, sceneFieldCustom(34));
CORRADE_COMPARE(flags, SceneFieldFlag::OffsetOnly|SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(size, 3);
CORRADE_COMPARE(mappingType, SceneMappingType::UnsignedByte);
/* These are not marked constexpr because it'd work only partially, not for
string fields (tested in constructFieldOffsetOnlyString()) */
CORRADE_COMPARE(ca.fieldType(), SceneFieldType::Int);
CORRADE_COMPARE(ca.fieldArraySize(), 2);
/* These are deliberately not constexpr to save header size a bit --
compared to SceneField APIs they get used very little and it's mostly
useless in a constexpr context anyway */
CORRADE_COMPARE(ca.mappingData(data).size(), 3);
CORRADE_COMPARE(ca.mappingData(data).stride(), sizeof(Data));
CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedByte>(ca.mappingData(data)),
Containers::arrayView<UnsignedByte>({2, 15, 22}),
TestSuite::Compare::Container);
CORRADE_COMPARE(ca.fieldData(data).size(), 3);
CORRADE_COMPARE(ca.fieldData(data).stride(), sizeof(Data));
CORRADE_COMPARE_AS((Containers::arrayCast<2, const Int>(ca.fieldData(data), 2).transposed<0, 1>())[0],
Containers::arrayView({0, 2, 4}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS((Containers::arrayCast<2, const Int>(ca.fieldData(data), 2).transposed<0, 1>())[1],
Containers::arrayView({1, 3, 5}),
TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void SceneDataTest::constructFieldArrayOffsetOnlyBit() {
struct Data {
Byte parent;
UnsignedInt object;
char yesNoInUpperBits;
} data[]{
{0, 2, '\x80'},
{0, 15, '\x7f'},
{0, 22, '\x80'}
};
SceneFieldData a{sceneFieldCustom(773), 3, SceneMappingType::UnsignedInt, offsetof(Data, object), sizeof(Data), offsetof(Data, yesNoInUpperBits), 6, sizeof(Data)*8, 2, SceneFieldFlag::OrderedMapping};
CORRADE_COMPARE(a.flags(), SceneFieldFlag::OffsetOnly|SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(a.name(), sceneFieldCustom(773));
CORRADE_COMPARE(a.size(), 3);
CORRADE_COMPARE(a.mappingType(), SceneMappingType::UnsignedInt);
CORRADE_COMPARE(a.mappingData(data).size(), 3);
CORRADE_COMPARE(a.mappingData(data).stride(), sizeof(Data));
CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedInt>(a.mappingData(data)),
Containers::arrayView<UnsignedInt>({2, 15, 22}),
TestSuite::Compare::Container);
CORRADE_COMPARE(a.fieldType(), SceneFieldType::Bit);
CORRADE_COMPARE(a.fieldArraySize(), 2);
CORRADE_COMPARE(a.fieldBitData(data).offset(), 6);
CORRADE_COMPARE(a.fieldBitData(data).size(), (Containers::Size2D{3, 2}));
CORRADE_COMPARE(a.fieldBitData(data).stride(), (Containers::Stride2D{sizeof(Data)*8, 1}));
CORRADE_COMPARE_AS((a.fieldBitData(data).transposed<0, 1>())[0],
Containers::stridedArrayView({false, true, false}).sliceBit(0),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS((a.fieldBitData(data).transposed<0, 1>())[1],
Containers::stridedArrayView({true, false, true}).sliceBit(0),
TestSuite::Compare::Container);
constexpr SceneFieldData ca{sceneFieldCustom(773), 3, SceneMappingType::UnsignedInt, offsetof(Data, object), sizeof(Data), offsetof(Data, yesNoInUpperBits), 6, sizeof(Data)*8, 2, SceneFieldFlag::OrderedMapping};
constexpr SceneField name = ca.name();
constexpr SceneFieldFlags flags = ca.flags();
constexpr std::size_t size = ca.size();
constexpr SceneMappingType mappingType = ca.mappingType();
CORRADE_COMPARE(name, sceneFieldCustom(773));
CORRADE_COMPARE(flags, SceneFieldFlag::OffsetOnly|SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(size, 3);
CORRADE_COMPARE(mappingType, SceneMappingType::UnsignedInt);
/* These are not marked constexpr because it'd work only partially, not for
string fields (tested in constructFieldOffsetOnlyString()) */
CORRADE_COMPARE(ca.fieldType(), SceneFieldType::Bit);
CORRADE_COMPARE(ca.fieldArraySize(), 2);
/* These are deliberately not constexpr to save header size a bit --
compared to SceneField APIs they get used very little and it's mostly
useless in a constexpr context anyway */
CORRADE_COMPARE(ca.mappingData(data).size(), 3);
CORRADE_COMPARE(ca.mappingData(data).stride(), sizeof(Data));
CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedInt>(ca.mappingData(data)),
Containers::arrayView<UnsignedInt>({2, 15, 22}),
TestSuite::Compare::Container);
CORRADE_COMPARE(ca.fieldBitData(data).offset(), 6);
CORRADE_COMPARE(ca.fieldBitData(data).size(), (Containers::Size2D{3, 2}));
CORRADE_COMPARE(ca.fieldBitData(data).stride(), (Containers::Stride2D{sizeof(Data)*8, 1}));
CORRADE_COMPARE_AS((ca.fieldBitData(data).transposed<0, 1>())[0],
Containers::stridedArrayView({false, true, false}).sliceBit(0),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS((ca.fieldBitData(data).transposed<0, 1>())[1],
Containers::stridedArrayView({true, false, true}).sliceBit(0),
TestSuite::Compare::Container);
}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void SceneDataTest::constructFieldInconsistentViewSize() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
const UnsignedShort mappingData[3]{};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
const Complexd rotationFieldData[2];
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
const char hiddenFieldData[1]{};
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
const char helloStringData[5]{};
const UnsignedLong helloOffsetsData[2]{};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
std::ostringstream out;
Error redirectError{&out};
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
SceneFieldData{SceneField::Rotation, Containers::arrayView(mappingData), Containers::arrayView(rotationFieldData)};
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
SceneFieldData{sceneFieldCustom(773), Containers::arrayView(mappingData), Containers::BitArrayView{hiddenFieldData, 0, 2}};
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
SceneFieldData{sceneFieldCustom(32), Containers::arrayView(mappingData), helloStringData, SceneFieldType::StringOffset64, Containers::arrayView(helloOffsetsData)};
CORRADE_COMPARE(out.str(),
"Trade::SceneFieldData: expected Trade::SceneField::Rotation mapping and field view to have the same size but got 3 and 2\n"
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
"Trade::SceneFieldData: expected Trade::SceneField::Custom(773) mapping and field view to have the same size but got 3 and 2\n"
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
"Trade::SceneFieldData: expected Trade::SceneField::Custom(32) mapping and field view to have the same size but got 3 and 2\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
void SceneDataTest::constructFieldWrongType() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
const UnsignedShort rotationMappingData[3]{};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
const Quaternion rotationFieldData[3];
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Transformation, Containers::arrayView(rotationMappingData), Containers::arrayView(rotationFieldData)};
SceneFieldData{SceneField::Transformation, 3, SceneMappingType::UnsignedShort, 0, sizeof(UnsignedShort), SceneFieldType::Quaternion, 0, sizeof(Quaternion)};
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
/** @todo test also builtin bit and string fields with non-string types
once there are any */
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
"Trade::SceneFieldData: Trade::SceneFieldType::Quaternion is not a valid type for Trade::SceneField::Transformation\n"
"Trade::SceneFieldData: Trade::SceneFieldType::Quaternion is not a valid type for Trade::SceneField::Transformation\n");
}
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void SceneDataTest::constructFieldWrongTypeBit() {
CORRADE_SKIP_IF_NO_ASSERT();
const UnsignedShort hiddenMappingData[3]{};
const bool hiddenFieldData[3]{};
std::ostringstream out;
Error redirectError{&out};
/* Non-bit constructors with SceneFieldType::Bit. Only type-erased, 2D and
offset-only construction, the regular and array constructor from typed
views have SceneFieldType implicit. */
SceneFieldData{sceneFieldCustom(773), SceneMappingType::UnsignedShort, Containers::arrayView(hiddenMappingData), SceneFieldType::Bit, Containers::arrayView(hiddenFieldData)};
SceneFieldData{sceneFieldCustom(773), Containers::arrayCast<2, const char>(Containers::arrayView(hiddenMappingData)), SceneFieldType::Bit, Containers::arrayCast<2, const char>(Containers::arrayView(hiddenFieldData))};
SceneFieldData{sceneFieldCustom(773), 3, SceneMappingType::UnsignedShort, 0, 2, SceneFieldType::Bit, 0, 1};
CORRADE_COMPARE(out.str(),
"Trade::SceneFieldData: use a bit constructor for Trade::SceneFieldType::Bit\n"
"Trade::SceneFieldData: use a bit constructor for Trade::SceneFieldType::Bit\n"
"Trade::SceneFieldData: use a bit constructor for Trade::SceneFieldType::Bit\n");
}
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
void SceneDataTest::constructFieldWrongTypeString() {
CORRADE_SKIP_IF_NO_ASSERT();
const UnsignedShort mappingData[3]{};
const Complexd rotationFieldData[3];
const char helloStringData[5]{};
const UnsignedLong helloFieldData[3]{};
std::ostringstream out;
Error redirectError{&out};
/* Non-string constructors with a string SceneFieldType. Only type-erased,
2D and offset-only construction, the regular and array constructor from
typed views have SceneFieldType implicit. */
SceneFieldData{sceneFieldCustom(32), SceneMappingType::UnsignedShort, Containers::arrayView(mappingData), SceneFieldType::StringOffset64, Containers::arrayView(helloFieldData)};
SceneFieldData{sceneFieldCustom(32), Containers::arrayCast<2, const char>(Containers::arrayView(mappingData)), SceneFieldType::StringOffset64, Containers::arrayCast<2, const char>(Containers::arrayView(helloFieldData))};
SceneFieldData{sceneFieldCustom(32), 3, SceneMappingType::UnsignedShort, 0, 2, SceneFieldType::StringRange16, 0, 8};
/* String constructors with a non-string SceneFieldType. */
SceneFieldData{SceneField::Rotation, SceneMappingType::UnsignedShort, Containers::arrayView(mappingData), nullptr, SceneFieldType::Complexd, Containers::arrayView(rotationFieldData)};
SceneFieldData{SceneField::Rotation, Containers::arrayCast<2, const char>(Containers::arrayView(mappingData)), helloStringData, SceneFieldType::Complexd, Containers::arrayCast<2, const char>(Containers::arrayView(rotationFieldData))};
SceneFieldData{SceneField::Rotation, Containers::arrayView(mappingData), helloStringData, SceneFieldType::Complexd, Containers::arrayView(rotationFieldData)};
SceneFieldData{SceneField::Rotation, 3, SceneMappingType::UnsignedLong, 0, 8, 0, SceneFieldType::Quaternion, 0, 16};
CORRADE_COMPARE(out.str(),
"Trade::SceneFieldData: use a string constructor for Trade::SceneFieldType::StringOffset64\n"
"Trade::SceneFieldData: use a string constructor for Trade::SceneFieldType::StringOffset64\n"
"Trade::SceneFieldData: use a string constructor for Trade::SceneFieldType::StringRange16\n"
"Trade::SceneFieldData: can't use a string constructor for Trade::SceneFieldType::Complexd\n"
"Trade::SceneFieldData: can't use a string constructor for Trade::SceneFieldType::Complexd\n"
"Trade::SceneFieldData: can't use a string constructor for Trade::SceneFieldType::Complexd\n"
"Trade::SceneFieldData: can't use a string constructor for Trade::SceneFieldType::Quaternion\n");
}
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
void SceneDataTest::constructFieldTooLargeMappingStride() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
UnsignedInt enough[2];
char toomuch[2*(32768 + sizeof(UnsignedInt))];
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
const char helloStringData[5]{};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* These should be fine */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32767}, SceneFieldType::UnsignedInt, enough};
SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32768}.flipped<0>(), SceneFieldType::UnsignedInt, enough};
SceneFieldData{SceneField::Mesh, 2, SceneMappingType::UnsignedInt, 0, 32767, SceneFieldType::UnsignedInt, 0, 4};
SceneFieldData{SceneField::Mesh, 2, SceneMappingType::UnsignedInt, 65536, -32768, SceneFieldType::UnsignedInt, 0, 4};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
SceneFieldData{sceneFieldCustom(773), SceneMappingType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32767}, Containers::BitArrayView{enough, 0, 2}};
SceneFieldData{sceneFieldCustom(773), SceneMappingType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32768}.flipped<0>(), Containers::BitArrayView{enough, 0, 2}};
SceneFieldData{sceneFieldCustom(773), 2, SceneMappingType::UnsignedInt, 0, 32767, 0, 0, 4};
SceneFieldData{sceneFieldCustom(773), 2, SceneMappingType::UnsignedInt, 65536, -32768, 0, 0, 4};
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
SceneFieldData{sceneFieldCustom(25), SceneMappingType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32767}, helloStringData, SceneFieldType::StringOffset32, enough};
SceneFieldData{sceneFieldCustom(25), SceneMappingType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32768}.flipped<0>(), helloStringData, SceneFieldType::StringOffset32, enough};
SceneFieldData{sceneFieldCustom(35), 2, SceneMappingType::UnsignedInt, 0, 32767, 0, SceneFieldType::StringOffset32, 0, 4};
SceneFieldData{sceneFieldCustom(35), 2, SceneMappingType::UnsignedInt, 65536, -32768, 0, SceneFieldType::StringOffset32, 0, 4};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32768}, SceneFieldType::UnsignedInt, enough};
SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32769}.flipped<0>(), SceneFieldType::UnsignedInt, enough};
SceneFieldData{SceneField::Mesh, 2, SceneMappingType::UnsignedInt, 0, 32768, SceneFieldType::UnsignedInt, 0, 4};
SceneFieldData{SceneField::Mesh, 2, SceneMappingType::UnsignedInt, 65538, -32769, SceneFieldType::UnsignedInt, 0, 4};
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
SceneFieldData{sceneFieldCustom(773), SceneMappingType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32768}, Containers::BitArrayView{enough, 0, 2}};
SceneFieldData{sceneFieldCustom(773), SceneMappingType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32769}.flipped<0>(), Containers::BitArrayView{enough, 0, 2}};
SceneFieldData{sceneFieldCustom(773), 2, SceneMappingType::UnsignedInt, 0, 32768, 0, 0, 4};
SceneFieldData{sceneFieldCustom(773), 2, SceneMappingType::UnsignedInt, 65538, -32769, 0, 0, 4};
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
SceneFieldData{sceneFieldCustom(25), SceneMappingType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32768}, helloStringData, SceneFieldType::StringOffset32, enough};
SceneFieldData{sceneFieldCustom(25), SceneMappingType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32769}.flipped<0>(), helloStringData, SceneFieldType::StringOffset32, enough};
SceneFieldData{sceneFieldCustom(35), 2, SceneMappingType::UnsignedInt, 0, 32768, 0, SceneFieldType::StringOffset32, 0, 4};
SceneFieldData{sceneFieldCustom(35), 2, SceneMappingType::UnsignedInt, 65538, -32769, 0, SceneFieldType::StringOffset32, 0, 4};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
"Trade::SceneFieldData: expected mapping view stride to fit into 16 bits but got 32768\n"
"Trade::SceneFieldData: expected mapping view stride to fit into 16 bits but got -32769\n"
"Trade::SceneFieldData: expected mapping view stride to fit into 16 bits but got 32768\n"
"Trade::SceneFieldData: expected mapping view stride to fit into 16 bits but got -32769\n"
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
"Trade::SceneFieldData: expected mapping view stride to fit into 16 bits but got 32768\n"
"Trade::SceneFieldData: expected mapping view stride to fit into 16 bits but got -32769\n"
"Trade::SceneFieldData: expected mapping view stride to fit into 16 bits but got 32768\n"
"Trade::SceneFieldData: expected mapping view stride to fit into 16 bits but got -32769\n"
Trade: the comma in this assert feels weird.
4 years ago
"Trade::SceneFieldData: expected mapping view stride to fit into 16 bits but got 32768\n"
"Trade::SceneFieldData: expected mapping view stride to fit into 16 bits but got -32769\n"
"Trade::SceneFieldData: expected mapping view stride to fit into 16 bits but got 32768\n"
"Trade::SceneFieldData: expected mapping view stride to fit into 16 bits but got -32769\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
void SceneDataTest::constructFieldTooLargeFieldStride() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
UnsignedInt enough[2];
char toomuch[2*(32768 + sizeof(UnsignedInt))];
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
const char helloStringData[5]{};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* These should be fine */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedInt, enough, SceneFieldType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32767}};
SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedInt, enough, SceneFieldType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32768}.flipped<0>()};
SceneFieldData{SceneField::Mesh, 2, SceneMappingType::UnsignedInt, 0, 4, SceneFieldType::UnsignedInt, 0, 32767};
SceneFieldData{SceneField::Mesh, 2, SceneMappingType::UnsignedInt, 0, 4, SceneFieldType::UnsignedInt, 65536, -32768};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
SceneFieldData{sceneFieldCustom(773), SceneMappingType::UnsignedInt, enough, Containers::StridedBitArrayView1D{Containers::BitArrayView{toomuch}, 2, 32767}};
SceneFieldData{sceneFieldCustom(773), SceneMappingType::UnsignedInt, enough, Containers::StridedBitArrayView1D{Containers::BitArrayView{toomuch}, 2, 32768}.flipped<0>()};
SceneFieldData{sceneFieldCustom(773), 2, SceneMappingType::UnsignedInt, 0, 4, SceneFieldType::UnsignedInt, 0, 32767};
SceneFieldData{sceneFieldCustom(773), 2, SceneMappingType::UnsignedInt, 0, 4, SceneFieldType::UnsignedInt, 65536, -32768};
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
SceneFieldData{sceneFieldCustom(35), SceneMappingType::UnsignedInt, enough, helloStringData, SceneFieldType::StringRangeNullTerminated32, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32767}};
SceneFieldData{sceneFieldCustom(35), SceneMappingType::UnsignedInt, enough, helloStringData, SceneFieldType::StringRangeNullTerminated32, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32768}.flipped<0>()};
SceneFieldData{sceneFieldCustom(35), 2, SceneMappingType::UnsignedInt, 0, 4, 0, SceneFieldType::StringRangeNullTerminated32, 0, 32767};
SceneFieldData{sceneFieldCustom(35), 2, SceneMappingType::UnsignedInt, 0, 4, 0, SceneFieldType::StringRangeNullTerminated32, 65536, -32768};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedInt, enough, SceneFieldType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32768}};
SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedInt, enough, SceneFieldType::UnsignedInt, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32769}.flipped<0>()};
SceneFieldData{SceneField::Mesh, 2, SceneMappingType::UnsignedInt, 0, 4, SceneFieldType::UnsignedInt, 0, 32768};
SceneFieldData{SceneField::Mesh, 2, SceneMappingType::UnsignedInt, 0, 4, SceneFieldType::UnsignedInt, 65538, -32769};
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
SceneFieldData{sceneFieldCustom(773), SceneMappingType::UnsignedInt, enough, Containers::StridedBitArrayView1D{Containers::BitArrayView{toomuch}, 2, 32768}};
SceneFieldData{sceneFieldCustom(773), SceneMappingType::UnsignedInt, enough, Containers::StridedBitArrayView1D{Containers::BitArrayView{toomuch}, 2, 32769}.flipped<0>()};
SceneFieldData{sceneFieldCustom(773), 2, SceneMappingType::UnsignedInt, 0, 4, SceneFieldType::UnsignedInt, 0, 32768};
SceneFieldData{sceneFieldCustom(773), 2, SceneMappingType::UnsignedInt, 0, 4, SceneFieldType::UnsignedInt, 65538, -32769};
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
SceneFieldData{sceneFieldCustom(35), SceneMappingType::UnsignedInt, enough, helloStringData, SceneFieldType::StringRangeNullTerminated32, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32768}};
SceneFieldData{sceneFieldCustom(35), SceneMappingType::UnsignedInt, enough, helloStringData, SceneFieldType::StringRangeNullTerminated32, Containers::StridedArrayView1D<UnsignedInt>{Containers::arrayCast<UnsignedInt>(toomuch), 2, 32769}.flipped<0>()};
SceneFieldData{sceneFieldCustom(35), 2, SceneMappingType::UnsignedInt, 0, 4, 0, SceneFieldType::StringRangeNullTerminated32, 0, 32768};
SceneFieldData{sceneFieldCustom(35), 2, SceneMappingType::UnsignedInt, 0, 4, 0, SceneFieldType::StringRangeNullTerminated32, 65538, -32769};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
"Trade::SceneFieldData: expected field view stride to fit into 16 bits but got 32768\n"
"Trade::SceneFieldData: expected field view stride to fit into 16 bits but got -32769\n"
"Trade::SceneFieldData: expected field view stride to fit into 16 bits but got 32768\n"
"Trade::SceneFieldData: expected field view stride to fit into 16 bits but got -32769\n"
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
"Trade::SceneFieldData: expected field view stride to fit into 16 bits but got 32768\n"
"Trade::SceneFieldData: expected field view stride to fit into 16 bits but got -32769\n"
"Trade::SceneFieldData: expected field view stride to fit into 16 bits but got 32768\n"
"Trade::SceneFieldData: expected field view stride to fit into 16 bits but got -32769\n"
Trade: the comma in this assert feels weird.
4 years ago
"Trade::SceneFieldData: expected field view stride to fit into 16 bits but got 32768\n"
"Trade::SceneFieldData: expected field view stride to fit into 16 bits but got -32769\n"
"Trade::SceneFieldData: expected field view stride to fit into 16 bits but got 32768\n"
"Trade::SceneFieldData: expected field view stride to fit into 16 bits but got -32769\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
void SceneDataTest::constructFieldFlagNotAllowed() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
const UnsignedShort mappingData[3]{};
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
const Quaternion rotationFieldData[3];
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
const char hiddenFieldData[1]{};
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
const char helloStringData[5]{};
const UnsignedShort helloFieldData[3]{};
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
/* These are fine */
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
SceneFieldData{SceneField::Rotation, 3, SceneMappingType::UnsignedShort, 0, sizeof(UnsignedShort), SceneFieldType::Quaternion, 0, sizeof(Quaternion), SceneFieldFlag::OffsetOnly};
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
SceneFieldData{sceneFieldCustom(773), 3, SceneMappingType::UnsignedShort, 0, sizeof(UnsignedShort), 0, 0, sizeof(Quaternion), SceneFieldFlag::OffsetOnly};
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
SceneFieldData{sceneFieldCustom(24), Containers::arrayView(mappingData), helloStringData, SceneFieldType::StringOffset32, helloFieldData, SceneFieldFlag::NullTerminatedString};
SceneFieldData{sceneFieldCustom(24), 3, SceneMappingType::UnsignedShort, 0, 2, 0, SceneFieldType::StringOffset32, 0, 4, SceneFieldFlag::NullTerminatedString};
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
std::ostringstream out;
Error redirectError{&out};
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
SceneFieldData{SceneField::Rotation, Containers::arrayView(mappingData), Containers::arrayView(rotationFieldData), SceneFieldFlag::OffsetOnly};
SceneFieldData{SceneField::Rotation, Containers::arrayView(mappingData), Containers::arrayView(rotationFieldData), SceneFieldFlag::NullTerminatedString};
SceneFieldData{SceneField::Rotation, Containers::arrayView(mappingData), Containers::arrayView(rotationFieldData), SceneFieldFlag::OffsetOnly|SceneFieldFlag::NullTerminatedString};
SceneFieldData{SceneField::Rotation, 3, SceneMappingType::UnsignedShort, 0, 2, SceneFieldType::Quaternion, 0, 16, SceneFieldFlag::NullTerminatedString};
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
SceneFieldData{sceneFieldCustom(773), Containers::arrayView(mappingData), Containers::BitArrayView{hiddenFieldData, 0, 3}, SceneFieldFlag::OffsetOnly};
SceneFieldData{sceneFieldCustom(773), Containers::arrayView(mappingData), Containers::BitArrayView{hiddenFieldData, 0, 3}, SceneFieldFlag::NullTerminatedString};
SceneFieldData{sceneFieldCustom(773), Containers::arrayView(mappingData), Containers::BitArrayView{hiddenFieldData, 0, 3}, SceneFieldFlag::OffsetOnly|SceneFieldFlag::NullTerminatedString};
SceneFieldData{sceneFieldCustom(773), 3, SceneMappingType::UnsignedShort, 0, 2, 0, 0, 16, SceneFieldFlag::NullTerminatedString};
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
SceneFieldData{sceneFieldCustom(24), Containers::arrayView(mappingData), helloStringData, SceneFieldType::StringOffset32, helloFieldData, SceneFieldFlag::OffsetOnly};
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
CORRADE_COMPARE(out.str(),
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
"Trade::SceneFieldData: can't pass Trade::SceneFieldFlag::OffsetOnly for a view of Trade::SceneFieldType::Quaternion\n"
"Trade::SceneFieldData: can't pass Trade::SceneFieldFlag::NullTerminatedString for a view of Trade::SceneFieldType::Quaternion\n"
"Trade::SceneFieldData: can't pass Trade::SceneFieldFlag::OffsetOnly|Trade::SceneFieldFlag::NullTerminatedString for a view of Trade::SceneFieldType::Quaternion\n"
"Trade::SceneFieldData: can't pass Trade::SceneFieldFlag::NullTerminatedString for Trade::SceneFieldType::Quaternion\n"
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
"Trade::SceneFieldData: can't pass Trade::SceneFieldFlag::OffsetOnly for a view of Trade::SceneFieldType::Bit\n"
"Trade::SceneFieldData: can't pass Trade::SceneFieldFlag::NullTerminatedString for a view of Trade::SceneFieldType::Bit\n"
"Trade::SceneFieldData: can't pass Trade::SceneFieldFlag::OffsetOnly|Trade::SceneFieldFlag::NullTerminatedString for a view of Trade::SceneFieldType::Bit\n"
"Trade::SceneFieldData: can't pass Trade::SceneFieldFlag::NullTerminatedString for Trade::SceneFieldType::Bit\n"
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
"Trade::SceneFieldData: can't pass Trade::SceneFieldFlag::OffsetOnly for a view\n");
}
Trade: rename a test case for clarity.
3 years ago
void SceneDataTest::constructFieldWrongOffsetOnlyDataAccess() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
const UnsignedShort rotationMappingData[3]{};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
const Quaternion rotationFieldData[3];
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
const char hello[5]{};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData a{SceneField::Rotation, Containers::arrayView(rotationMappingData), Containers::arrayView(rotationFieldData)};
SceneFieldData b{SceneField::Rotation, 3, SceneMappingType::UnsignedShort, 0, sizeof(UnsignedShort), SceneFieldType::Quaternion, 0, sizeof(Quaternion)};
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
SceneFieldData c{sceneFieldCustom(773), 3, SceneMappingType::UnsignedShort, 0, sizeof(UnsignedShort), 0, 0, 1};
SceneFieldData d{sceneFieldCustom(25), 3, SceneMappingType::UnsignedShort, 0, sizeof(UnsignedShort), 0, SceneFieldType::StringRange32, 0, 64};
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
CORRADE_COMPARE(a.flags(), SceneFieldFlags{});
CORRADE_COMPARE(b.flags(), SceneFieldFlag::OffsetOnly);
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
CORRADE_COMPARE(c.flags(), SceneFieldFlag::OffsetOnly);
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
CORRADE_COMPARE(d.flags(), SceneFieldFlag::OffsetOnly);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
a.mappingData(rotationMappingData); /* This is fine, no asserts */
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
b.fieldData(rotationFieldData);
c.fieldBitData(hello);
d.stringData(hello);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
b.mappingData();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
b.fieldData();
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
d.fieldBitData();
d.stringData();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneFieldData::mappingData(): the field is offset-only, supply a data array\n"
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
"Trade::SceneFieldData::fieldData(): the field is offset-only, supply a data array\n"
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
"Trade::SceneFieldData::fieldBitData(): the field is offset-only, supply a data array\n"
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
"Trade::SceneFieldData::stringData(): the field is offset-only, supply a data array\n");
}
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void SceneDataTest::constructFieldWrongBitDataAccess() {
CORRADE_SKIP_IF_NO_ASSERT();
const UnsignedShort mappingData[3]{};
const char hiddenFieldData[3]{};
const Quaternion rotationFieldData[3];
SceneFieldData a{sceneFieldCustom(773), Containers::arrayView(mappingData), Containers::BitArrayView{hiddenFieldData, 0, 3}};
SceneFieldData b{SceneField::Rotation, Containers::arrayView(mappingData), Containers::arrayView(rotationFieldData)};
std::ostringstream out;
Error redirectError{&out};
a.fieldData();
a.fieldData(hiddenFieldData);
b.fieldBitData();
b.fieldBitData(rotationFieldData);
CORRADE_COMPARE(out.str(),
"Trade::SceneFieldData::fieldData(): the field is Trade::SceneFieldType::Bit, use fieldBitData() instead\n"
"Trade::SceneFieldData::fieldData(): the field is Trade::SceneFieldType::Bit, use fieldBitData() instead\n"
"Trade::SceneFieldData::fieldBitData(): the field is Trade::SceneFieldType::Quaternion, not a bit\n"
"Trade::SceneFieldData::fieldBitData(): the field is Trade::SceneFieldType::Quaternion, not a bit\n");
}
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
void SceneDataTest::constructFieldWrongStringDataAccess() {
CORRADE_SKIP_IF_NO_ASSERT();
const UnsignedShort rotationMappingData[3]{};
const Quaternion rotationFieldData[3];
SceneFieldData a{SceneField::Rotation, Containers::arrayView(rotationMappingData), Containers::arrayView(rotationFieldData)};
std::ostringstream out;
Error redirectError{&out};
a.stringData();
a.stringData(rotationFieldData);
CORRADE_COMPARE(out.str(),
"Trade::SceneFieldData::stringData(): the field is Trade::SceneFieldType::Quaternion, not a string\n"
"Trade::SceneFieldData::stringData(): the field is Trade::SceneFieldType::Quaternion, not a string\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
void SceneDataTest::constructFieldTypeErased2DWrongSize() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
char mappingData[5*sizeof(UnsignedInt)];
char rotationFieldData[4*sizeof(Complex)];
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
char hiddenFieldData[1]{};
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
char helloStringData[3]{};
char helloFieldData[4*sizeof(UnsignedShort)]{};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
std::ostringstream out;
Error redirectError{&out};
SceneFieldData{SceneField::Rotation,
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
Containers::StridedArrayView2D<char>{mappingData, {4, 5}}.every(2),
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldType::Complex,
Containers::StridedArrayView2D<char>{rotationFieldData, {4, sizeof(Complex)}}.every(2)};
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
SceneFieldData{sceneFieldCustom(773),
Containers::StridedArrayView2D<char>{mappingData, {4, 5}}.every(2),
Containers::StridedBitArrayView1D{Containers::BitArrayView{hiddenFieldData}, 4}.every(2)};
SceneFieldData{sceneFieldCustom(773),
Containers::StridedArrayView2D<char>{mappingData, {4, 5}}.every(2),
Containers::StridedBitArrayView2D{Containers::BitArrayView{hiddenFieldData}, {4, 2}}.every(2)};
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
SceneFieldData{sceneFieldCustom(32),
Containers::StridedArrayView2D<char>{mappingData, {4, 5}}.every(2),
helloStringData,
SceneFieldType::StringOffset16,
Containers::StridedArrayView2D<char>{helloFieldData, {4, sizeof(UnsignedShort)}}.every(2)};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Translation,
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
Containers::StridedArrayView2D<char>{mappingData, {4, sizeof(UnsignedInt)}}.every(2),
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldType::Vector3,
Containers::StridedArrayView2D<char>{rotationFieldData, {4, sizeof(Complex)}}.every(2)};
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
/* All second field dimension sizes are fine for SceneFieldType::Bit */
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
SceneFieldData{sceneFieldCustom(32),
Containers::StridedArrayView2D<char>{mappingData, {4, sizeof(UnsignedInt)}}.every(2),
helloStringData,
SceneFieldType::StringRange16,
Containers::StridedArrayView2D<char>{helloFieldData, {4, sizeof(UnsignedShort)}}.every(2)};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
"Trade::SceneFieldData: expected second mapping view dimension size 1, 2, 4 or 8 but got 5\n"
"Trade::SceneFieldData: expected second mapping view dimension size 1, 2, 4 or 8 but got 5\n"
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneFieldData: expected second mapping view dimension size 1, 2, 4 or 8 but got 5\n"
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
"Trade::SceneFieldData: expected second mapping view dimension size 1, 2, 4 or 8 but got 5\n"
"Trade::SceneFieldData: second field view dimension size 8 doesn't match Trade::SceneFieldType::Vector3\n"
"Trade::SceneFieldData: second field view dimension size 2 doesn't match Trade::SceneFieldType::StringRange16\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
void SceneDataTest::constructFieldTypeErased2DNonContiguous() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
char mappingData[8*sizeof(UnsignedInt)];
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
char rotationFieldData[8*sizeof(Complex)];
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
char hiddenFieldData[1]{};
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
char helloStringData[3]{};
char helloFieldData[8*sizeof(UnsignedShort)]{};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
std::ostringstream out;
Error redirectError{&out};
SceneFieldData{SceneField::Rotation,
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
Containers::StridedArrayView2D<char>{mappingData, {4, 2*sizeof(UnsignedInt)}}.every({1, 2}),
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldType::Complex,
Containers::StridedArrayView2D<char>{rotationFieldData, {4, sizeof(Complex)}}};
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
SceneFieldData{sceneFieldCustom(773),
Containers::StridedArrayView2D<char>{mappingData, {4, 2*sizeof(UnsignedInt)}}.every({1, 2}),
Containers::StridedBitArrayView1D{Containers::BitArrayView{hiddenFieldData}, 4}};
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
SceneFieldData{sceneFieldCustom(32),
Containers::StridedArrayView2D<char>{mappingData, {4, 2*sizeof(UnsignedInt)}}.every({1, 2}),
helloStringData,
SceneFieldType::StringOffset16,
Containers::StridedArrayView2D<char>{helloFieldData, {4, sizeof(UnsignedShort)}}};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Rotation,
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
Containers::StridedArrayView2D<char>{mappingData, {4, sizeof(UnsignedInt)}},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldType::Complex,
Containers::StridedArrayView2D<char>{rotationFieldData, {4, 2*sizeof(Complex)}}.every({1, 2})};
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
/* SceneFieldType::Bit has no type-erased 2D field case, the constructor
taking a 2D bit array view is tested in
constructFieldArrayNonContiguous() below */
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
SceneFieldData{sceneFieldCustom(32),
/* Just to cover the case of a 1-byte mapping type (lazy) */
Containers::StridedArrayView2D<char>{mappingData, {4, sizeof(UnsignedByte)}, {4, 1}},
helloStringData,
SceneFieldType::StringOffset8,
Containers::StridedArrayView2D<char>{helloFieldData, {4, 2*sizeof(UnsignedByte)}}.every({1, 2})};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
"Trade::SceneFieldData: second mapping view dimension is not contiguous\n"
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneFieldData: second mapping view dimension is not contiguous\n"
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
"Trade::SceneFieldData: second mapping view dimension is not contiguous\n"
"Trade::SceneFieldData: second field view dimension is not contiguous\n"
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
"Trade::SceneFieldData: second field view dimension is not contiguous\n");
}
void SceneDataTest::constructFieldArrayNonContiguous() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
UnsignedByte mappingData[3];
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Int offsetFieldData[3*4];
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
char hiddenFieldData[2]{};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
std::ostringstream out;
Error redirectError{&out};
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
SceneFieldData data{sceneFieldCustom(34), Containers::arrayView(mappingData), Containers::StridedArrayView2D<Int>{offsetFieldData, {3, 4}}.every({1, 2})};
SceneFieldData{sceneFieldCustom(773),
Containers::arrayView(mappingData),
Containers::StridedBitArrayView2D{Containers::BitArrayView{hiddenFieldData}, {3, 4}}.every({1, 2})};
CORRADE_COMPARE(out.str(),
"Trade::SceneFieldData: second field view dimension is not contiguous\n"
"Trade::SceneFieldData: second field view dimension is not contiguous\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
void SceneDataTest::constructFieldArrayNotAllowed() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedShort rotationMappingData[3]{};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Quaternion rotationFieldData[3];
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::ArrayView<UnsignedShort> rotationMapping = rotationMappingData;
Containers::ArrayView<Quaternion> rotationField = rotationFieldData;
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Containers::StridedArrayView2D<Quaternion> rotationFields2D{rotationFieldData, {3, 3}, {0, sizeof(Quaternion)}};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
auto rotationMappingChar = Containers::arrayCast<2, const char>(rotationMapping);
auto rotationField2DChar = Containers::arrayCast<2, const char>(rotationFields2D);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
/* This is all fine -- builtin fields can be created with the array
constructors if the array size is set to 0, custom fields of any type
can do anything */
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Rotation,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneMappingType::UnsignedShort, rotationMapping,
SceneFieldType::Quaternion, rotationField, 0};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Rotation, 3,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneMappingType::UnsignedShort, 0, sizeof(UnsignedShort),
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldType::Quaternion, 0, sizeof(Quaternion), 0};
SceneFieldData{sceneFieldCustom(37),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
rotationMapping,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
rotationFields2D};
SceneFieldData{sceneFieldCustom(37),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
rotationMappingChar,
SceneFieldType::Quaternion, rotationField2DChar, 3};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{sceneFieldCustom(37), 3,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneMappingType::UnsignedShort, 0, sizeof(UnsignedShort),
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldType::Quaternion, 0, sizeof(Quaternion), 3};
/* This is not */
std::ostringstream out;
Error redirectError{&out};
SceneFieldData{SceneField::Rotation,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneMappingType::UnsignedShort, rotationMapping,
SceneFieldType::Quaternion, rotationField, 3};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Rotation, 3,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneMappingType::UnsignedShort, 0, sizeof(UnsignedShort),
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldType::Quaternion, 0, sizeof(Quaternion), 3};
SceneFieldData{SceneField::Rotation,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
rotationMapping,
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
rotationFields2D};
SceneFieldData{SceneField::Rotation,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
rotationMappingChar,
SceneFieldType::Quaternion, rotationField2DChar, 3};
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
/* String fields can't be arrays, but for those the constructor doesn't
even offer the array size; and constructing them with the regular
constructor will fail as tested in constructFieldWrongTypeString() */
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
"Trade::SceneFieldData: Trade::SceneField::Rotation can't be an array field\n"
"Trade::SceneFieldData: Trade::SceneField::Rotation can't be an array field\n"
"Trade::SceneFieldData: Trade::SceneField::Rotation can't be an array field\n"
"Trade::SceneFieldData: Trade::SceneField::Rotation can't be an array field\n");
}
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
void SceneDataTest::constructFieldArrayTypeErased2DWrongSize() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
char rotationMappingData[4*sizeof(UnsignedInt)];
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
char rotationFieldData[4*sizeof(Complex)];
std::ostringstream out;
Error redirectError{&out};
SceneFieldData{sceneFieldCustom(37),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::StridedArrayView2D<char>{rotationMappingData, {4, sizeof(UnsignedInt)}}.every(2),
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldType::Int,
Containers::StridedArrayView2D<char>{rotationFieldData, {4, sizeof(Complex)}}.every(2), 3};
CORRADE_COMPARE(out.str(),
"Trade::SceneFieldData: second field view dimension size 8 doesn't match Trade::SceneFieldType::Int and field array size 3\n");
}
Trade: rename SceneFieldData constructor tests for clarity. The 2D constructors in question are type-erased as well, so don't confuse them with 2D constructors that are for arrays.
3 years ago
void SceneDataTest::constructFieldArrayTypeErased2DNonContiguous() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
char mappingData[18*sizeof(UnsignedInt)];
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
char offsetFieldData[18*sizeof(Int)];
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
char hiddenFieldData[2]{};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
std::ostringstream out;
Error redirectError{&out};
SceneFieldData{sceneFieldCustom(37),
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
Containers::StridedArrayView2D<char>{mappingData, {3, 2*sizeof(UnsignedInt)}}.every({1, 2}),
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldType::Int,
Containers::StridedArrayView2D<char>{offsetFieldData, {3, 3*sizeof(Int)}}, 3};
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
SceneFieldData{sceneFieldCustom(773),
Containers::StridedArrayView2D<char>{mappingData, {3, sizeof(UnsignedInt)}}.every({1, 2}),
Containers::StridedBitArrayView2D{Containers::BitArrayView{hiddenFieldData}, {3, 4}}};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{sceneFieldCustom(37),
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
Containers::StridedArrayView2D<char>{mappingData, {3, sizeof(UnsignedInt)}},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldType::Int,
Containers::StridedArrayView2D<char>{offsetFieldData, {3, 6*sizeof(Int)}}.every({1, 2}), 3};
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
SceneFieldData{sceneFieldCustom(773),
Containers::StridedArrayView2D<char>{mappingData, {3, sizeof(UnsignedInt)}},
Containers::StridedBitArrayView2D{Containers::BitArrayView{hiddenFieldData}, {3, 4}}.every({1, 2})};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneFieldData: second mapping view dimension is not contiguous\n"
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
"Trade::SceneFieldData: second mapping view dimension is not contiguous\n"
"Trade::SceneFieldData: second field view dimension is not contiguous\n"
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
"Trade::SceneFieldData: second field view dimension is not contiguous\n");
Trade: test construction and assignments of the container classes.
10 years ago
}
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void SceneDataTest::constructFieldBitTooLargeBitOffset() {
CORRADE_SKIP_IF_NO_DEBUG_ASSERT();
/* Only checked in the offset-only constructor, the StridedBitArrayView
checks this on its own already. There it's a debug-only assert, be
consistent and have it debug-only here as well. */
std::ostringstream out;
Error redirectError{&out};
SceneFieldData{sceneFieldCustom(773), 3, SceneMappingType::UnsignedInt, 0, sizeof(UnsignedInt), 0, 8, 1};
CORRADE_COMPARE(out.str(), "Trade::SceneFieldData: bit offset expected to be smaller than 8, got 8\n");
}
void SceneDataTest::constructFieldBitTooLargeSize() {
CORRADE_SKIP_IF_NO_DEBUG_ASSERT();
/* Only checked in the offset-only constructor, the StridedBitArrayView
checks this on its own already. There it's a debug-only assert, be
consistent and have it debug-only here as well. */
std::ostringstream out;
Error redirectError{&out};
SceneFieldData{sceneFieldCustom(773), std::size_t{1} << (sizeof(std::size_t)*8 - 3), SceneMappingType::UnsignedInt, 0, sizeof(UnsignedInt), 0, 0, 1};
#ifndef CORRADE_TARGET_32BIT
CORRADE_COMPARE(out.str(), "Trade::SceneFieldData: size expected to be smaller than 2^61 bits, got 2305843009213693952\n");
#else
CORRADE_COMPARE(out.str(), "Trade::SceneFieldData: size expected to be smaller than 2^29 bits, got 536870912\n");
#endif
}
Trade: test construction and assignments of the container classes.
10 years ago
void SceneDataTest::construct() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
struct TransformParent {
UnsignedShort object;
Matrix4 transformation;
Int parent;
};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::StridedArrayView1D<TransformParent> transformsParentFieldMappingData;
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Containers::StridedArrayView1D<UnsignedByte> meshFieldData;
Containers::StridedArrayView1D<Vector2> radiusFieldData;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::StridedArrayView1D<UnsignedShort> materialMeshRadiusMappingData;
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Containers::ArrayTuple data{
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
{NoInit, 5, transformsParentFieldMappingData},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
{NoInit, 2, meshFieldData},
{NoInit, 2, radiusFieldData},
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
{NoInit, 2, materialMeshRadiusMappingData},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
};
Trade: use Utility::copy() instead of painstakingly filling test data.
3 years ago
Utility::copy({
{4, Matrix4::translation(Vector3::xAxis(5.0f)), -1},
{2, Matrix4::translation(Vector3::yAxis(5.0f)), 0},
{3, Matrix4::translation(Vector3::zAxis(5.0f)), 2},
{0, Matrix4::translation(Vector3::yScale(5.0f)), 1},
{1, Matrix4::translation(Vector3::zScale(5.0f)), -1},
}, transformsParentFieldMappingData);
Utility::copy({5, 7}, meshFieldData);
Utility::copy({{37.5f, 1.5f}, {22.5f, 0.5f}}, radiusFieldData);
Utility::copy({2, 6}, materialMeshRadiusMappingData);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
int importerState;
SceneFieldData transformations{SceneField::Transformation,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
transformsParentFieldMappingData.slice(&TransformParent::object),
transformsParentFieldMappingData.slice(&TransformParent::transformation)};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* Offset-only */
SceneFieldData parents{SceneField::Parent, 5,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneMappingType::UnsignedShort, offsetof(TransformParent, object), sizeof(TransformParent),
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldType::Int, offsetof(TransformParent, parent), sizeof(TransformParent)};
SceneFieldData meshes{SceneField::Mesh,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
materialMeshRadiusMappingData,
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
meshFieldData, SceneFieldFlag::OrderedMapping};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* Custom & array */
SceneFieldData radiuses{sceneFieldCustom(37),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
materialMeshRadiusMappingData,
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
Containers::arrayCast<2, Float>(radiusFieldData), SceneFieldFlag::OrderedMapping};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedShort, 8, std::move(data), {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
transformations, parents, meshes, radiuses
}, &importerState};
/* Basics */
CORRADE_COMPARE(scene.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
Adapt to Corrade changes.
4 years ago
CORRADE_VERIFY(!scene.fieldData().isEmpty());
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(static_cast<const void*>(scene.data()), transformsParentFieldMappingData.data());
CORRADE_COMPARE(static_cast<void*>(scene.mutableData()), transformsParentFieldMappingData.data());
CORRADE_COMPARE(scene.mappingBound(), 8);
CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedShort);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.fieldCount(), 4);
Trade: add SceneData::fieldSizeBound(). Like mappingBound(), but instead of giving an upper bound for object count, gives an upper bound for field size.
4 years ago
CORRADE_COMPARE(scene.fieldSizeBound(), 5);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.importerState(), &importerState);
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
/* is2D() / is3D() exhaustively tested in transformations*DAsArray[TRS]()
and constructZeroFields() */
Trade: add SceneData::transformationFieldSize().
4 years ago
/* transformationFieldSize() exhaustively tested in
transformations*DAsArray[TRS]() */
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* Field property access by ID */
CORRADE_COMPARE(scene.fieldName(0), SceneField::Transformation);
CORRADE_COMPARE(scene.fieldName(1), SceneField::Parent);
CORRADE_COMPARE(scene.fieldName(2), SceneField::Mesh);
CORRADE_COMPARE(scene.fieldName(3), sceneFieldCustom(37));
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
CORRADE_COMPARE(scene.fieldFlags(0), SceneFieldFlags{});
CORRADE_COMPARE(scene.fieldFlags(1), SceneFieldFlag::OffsetOnly);
CORRADE_COMPARE(scene.fieldFlags(2), SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(scene.fieldFlags(3), SceneFieldFlag::OrderedMapping);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.fieldType(0), SceneFieldType::Matrix4x4);
CORRADE_COMPARE(scene.fieldType(1), SceneFieldType::Int);
CORRADE_COMPARE(scene.fieldType(2), SceneFieldType::UnsignedByte);
CORRADE_COMPARE(scene.fieldType(3), SceneFieldType::Float);
CORRADE_COMPARE(scene.fieldSize(0), 5);
CORRADE_COMPARE(scene.fieldSize(1), 5);
CORRADE_COMPARE(scene.fieldSize(2), 2);
CORRADE_COMPARE(scene.fieldSize(3), 2);
CORRADE_COMPARE(scene.fieldArraySize(0), 0);
CORRADE_COMPARE(scene.fieldArraySize(1), 0);
CORRADE_COMPARE(scene.fieldArraySize(2), 0);
CORRADE_COMPARE(scene.fieldArraySize(3), 2);
/* Raw field data access by ID */
CORRADE_COMPARE(scene.fieldData(2).name(), SceneField::Mesh);
CORRADE_COMPARE(scene.fieldData(2).size(), 2);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(scene.fieldData(2).mappingType(), SceneMappingType::UnsignedShort);
CORRADE_COMPARE(Containers::arrayCast<const UnsignedShort>(scene.fieldData(2).mappingData())[1], 6);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(Containers::arrayCast<const UnsignedByte>(scene.fieldData(2).fieldData())[1], 7);
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
CORRADE_COMPARE(scene.fieldData(2).flags(), SceneFieldFlag::OrderedMapping);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.fieldData(2).fieldType(), SceneFieldType::UnsignedByte);
CORRADE_COMPARE(scene.fieldData(2).fieldArraySize(), 0);
/* Offset-only */
CORRADE_COMPARE(scene.fieldData(1).name(), SceneField::Parent);
CORRADE_COMPARE(scene.fieldData(1).size(), 5);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(scene.fieldData(1).mappingType(), SceneMappingType::UnsignedShort);
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
CORRADE_COMPARE(scene.fieldData(1).flags(), SceneFieldFlags{});
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.fieldData(1).fieldType(), SceneFieldType::Int);
CORRADE_COMPARE(scene.fieldData(1).fieldArraySize(), 0);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(Containers::arrayCast<const UnsignedShort>(scene.fieldData(1).mappingData())[4], 1);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(Containers::arrayCast<const Int>(scene.fieldData(1).fieldData())[4], -1);
/* Array */
CORRADE_COMPARE(scene.fieldData(3).name(), sceneFieldCustom(37));
CORRADE_COMPARE(scene.fieldData(3).size(), 2);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(scene.fieldData(3).mappingType(), SceneMappingType::UnsignedShort);
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
CORRADE_COMPARE(scene.fieldData(3).flags(), SceneFieldFlag::OrderedMapping);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.fieldData(3).fieldType(), SceneFieldType::Float);
CORRADE_COMPARE(scene.fieldData(3).fieldArraySize(), 2);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(Containers::arrayCast<const UnsignedShort>(scene.fieldData(3).mappingData())[0], 2);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(Containers::arrayCast<const Vector2>(scene.fieldData(3).fieldData())[0], (Vector2{37.5f, 1.5f}));
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
/* Typeless mapping access by ID with a cast later */
CORRADE_COMPARE(scene.mapping(0).size()[0], 5);
CORRADE_COMPARE(scene.mapping(1).size()[0], 5);
CORRADE_COMPARE(scene.mapping(2).size()[0], 2);
CORRADE_COMPARE(scene.mapping(3).size()[0], 2);
CORRADE_COMPARE(scene.mutableMapping(0).size()[0], 5);
CORRADE_COMPARE(scene.mutableMapping(1).size()[0], 5);
CORRADE_COMPARE(scene.mutableMapping(2).size()[0], 2);
CORRADE_COMPARE(scene.mutableMapping(3).size()[0], 2);
CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.mapping(0))[2]), 3);
CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.mapping(1))[4]), 1);
CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.mapping(2))[1]), 6);
CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.mapping(3))[0]), 2);
CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableMapping(0))[2]), 3);
CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableMapping(1))[4]), 1);
CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableMapping(2))[1]), 6);
CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableMapping(3))[0]), 2);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* Typeless field access by ID with a cast later */
CORRADE_COMPARE(scene.field(0).size()[0], 5);
CORRADE_COMPARE(scene.field(1).size()[0], 5);
CORRADE_COMPARE(scene.field(2).size()[0], 2);
CORRADE_COMPARE(scene.field(3).size()[0], 2);
CORRADE_COMPARE(scene.mutableField(0).size()[0], 5);
CORRADE_COMPARE(scene.mutableField(1).size()[0], 5);
CORRADE_COMPARE(scene.mutableField(2).size()[0], 2);
CORRADE_COMPARE(scene.mutableField(3).size()[0], 2);
CORRADE_COMPARE((Containers::arrayCast<1, const Matrix4>(scene.field(0))[2]), Matrix4::translation(Vector3::zAxis(5.0f)));
CORRADE_COMPARE((Containers::arrayCast<1, const Int>(scene.field(1))[4]), -1);
CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedByte>(scene.field(2))[1]), 7);
CORRADE_COMPARE((Containers::arrayCast<1, const Vector2>(scene.field(3))[0]), (Vector2{37.5f, 1.5f}));
CORRADE_COMPARE((Containers::arrayCast<1, Matrix4>(scene.mutableField(0))[2]), Matrix4::translation(Vector3::zAxis(5.0f)));
CORRADE_COMPARE((Containers::arrayCast<1, Int>(scene.mutableField(1))[4]), -1);
CORRADE_COMPARE((Containers::arrayCast<1, UnsignedByte>(scene.mutableField(2))[1]), 7);
CORRADE_COMPARE((Containers::arrayCast<1, Vector2>(scene.mutableField(3))[0]), (Vector2{37.5f, 1.5f}));
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
/* Typed mapping access by ID */
CORRADE_COMPARE(scene.mapping<UnsignedShort>(0).size(), 5);
CORRADE_COMPARE(scene.mapping<UnsignedShort>(1).size(), 5);
CORRADE_COMPARE(scene.mapping<UnsignedShort>(2).size(), 2);
CORRADE_COMPARE(scene.mapping<UnsignedShort>(3).size(), 2);
CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(0).size(), 5);
CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(1).size(), 5);
CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(2).size(), 2);
CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(3).size(), 2);
CORRADE_COMPARE(scene.mapping<UnsignedShort>(0)[2], 3);
CORRADE_COMPARE(scene.mapping<UnsignedShort>(1)[4], 1);
CORRADE_COMPARE(scene.mapping<UnsignedShort>(2)[1], 6);
CORRADE_COMPARE(scene.mapping<UnsignedShort>(3)[0], 2);
CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(0)[2], 3);
CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(1)[4], 1);
CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(2)[1], 6);
CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(3)[0], 2);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* Typed field access by ID */
CORRADE_COMPARE(scene.field<Matrix4>(0).size(), 5);
CORRADE_COMPARE(scene.field<Int>(1).size(), 5);
CORRADE_COMPARE(scene.field<UnsignedByte>(2).size(), 2);
Trade: simplify SceneData array field tests a bit.
3 years ago
CORRADE_COMPARE(scene.field<Float[]>(3).size(), (Containers::Size2D{2, 2}));
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.mutableField<Matrix4>(0).size(), 5);
CORRADE_COMPARE(scene.mutableField<Int>(1).size(), 5);
CORRADE_COMPARE(scene.mutableField<UnsignedByte>(2).size(), 2);
Trade: simplify SceneData array field tests a bit.
3 years ago
CORRADE_COMPARE(scene.mutableField<Float[]>(3).size(), (Containers::Size2D{2, 2}));
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.field<Matrix4>(0)[2], Matrix4::translation(Vector3::zAxis(5.0f)));
CORRADE_COMPARE(scene.field<Int>(1)[4], -1);
CORRADE_COMPARE(scene.field<UnsignedByte>(2)[1], 7);
Trade: simplify SceneData array field tests a bit.
3 years ago
CORRADE_COMPARE_AS(scene.field<Float[]>(3)[0],
Containers::arrayView({37.5f, 1.5f}),
TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.mutableField<Matrix4>(0)[2], Matrix4::translation(Vector3::zAxis(5.0f)));
CORRADE_COMPARE(scene.mutableField<Int>(1)[4], -1);
CORRADE_COMPARE(scene.mutableField<UnsignedByte>(2)[1], 7);
Trade: simplify SceneData array field tests a bit.
3 years ago
CORRADE_COMPARE_AS(scene.mutableField<Float[]>(3)[0],
Containers::stridedArrayView({37.5f, 1.5f}),
TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: allow array access to all SceneData/MeshData fields/attributes. In retrospect, the limitation made no sense and only prevented user code from having a common handling for all possible variants.
3 years ago
/* Accessing a non-array field as an array should be possible as well --
the second dimension is then just 1 */
CORRADE_COMPARE(scene.field<UnsignedByte[]>(2).size(), (Containers::Size2D{2, 1}));
CORRADE_COMPARE(scene.mutableField<UnsignedByte[]>(2).size(), (Containers::Size2D{2, 1}));
CORRADE_COMPARE(scene.field<UnsignedByte[]>(2)[1][0], 7);
CORRADE_COMPARE(scene.mutableField<UnsignedByte[]>(2)[1][0], 7);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* Field property access by name */
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
CORRADE_COMPARE(scene.fieldFlags(SceneField::Transformation), SceneFieldFlags{});
CORRADE_COMPARE(scene.fieldFlags(SceneField::Parent), SceneFieldFlag::OffsetOnly);
CORRADE_COMPARE(scene.fieldFlags(SceneField::Mesh), SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(scene.fieldFlags(sceneFieldCustom(37)), SceneFieldFlag::OrderedMapping);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.fieldType(SceneField::Transformation), SceneFieldType::Matrix4x4);
CORRADE_COMPARE(scene.fieldType(SceneField::Parent), SceneFieldType::Int);
CORRADE_COMPARE(scene.fieldType(SceneField::Mesh), SceneFieldType::UnsignedByte);
CORRADE_COMPARE(scene.fieldType(sceneFieldCustom(37)), SceneFieldType::Float);
CORRADE_COMPARE(scene.fieldSize(SceneField::Transformation), 5);
CORRADE_COMPARE(scene.fieldSize(SceneField::Parent), 5);
CORRADE_COMPARE(scene.fieldSize(SceneField::Mesh), 2);
CORRADE_COMPARE(scene.fieldSize(sceneFieldCustom(37)), 2);
CORRADE_COMPARE(scene.fieldArraySize(SceneField::Transformation), 0);
CORRADE_COMPARE(scene.fieldArraySize(SceneField::Parent), 0);
CORRADE_COMPARE(scene.fieldArraySize(SceneField::Mesh), 0);
CORRADE_COMPARE(scene.fieldArraySize(sceneFieldCustom(37)), 2);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
/* Typeless mapping access by name with a cast later */
CORRADE_COMPARE(scene.mapping(SceneField::Transformation).size()[0], 5);
CORRADE_COMPARE(scene.mapping(SceneField::Parent).size()[0], 5);
CORRADE_COMPARE(scene.mapping(2).size()[0], 2);
CORRADE_COMPARE(scene.mapping(3).size()[0], 2);
CORRADE_COMPARE(scene.mutableMapping(SceneField::Transformation).size()[0], 5);
CORRADE_COMPARE(scene.mutableMapping(SceneField::Parent).size()[0], 5);
CORRADE_COMPARE(scene.mutableMapping(2).size()[0], 2);
CORRADE_COMPARE(scene.mutableMapping(3).size()[0], 2);
CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.mapping(SceneField::Transformation))[2]), 3);
CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.mapping(SceneField::Parent))[4]), 1);
CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.mapping(2))[1]), 6);
CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedShort>(scene.mapping(3))[0]), 2);
CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableMapping(SceneField::Transformation))[2]), 3);
CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableMapping(SceneField::Parent))[4]), 1);
CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableMapping(2))[1]), 6);
CORRADE_COMPARE((Containers::arrayCast<1, UnsignedShort>(scene.mutableMapping(3))[0]), 2);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* Typeless field access by name with a cast later */
CORRADE_COMPARE(scene.field(SceneField::Transformation).size()[0], 5);
CORRADE_COMPARE(scene.field(SceneField::Parent).size()[0], 5);
CORRADE_COMPARE(scene.field(SceneField::Mesh).size()[0], 2);
CORRADE_COMPARE(scene.field(sceneFieldCustom(37)).size()[0], 2);
CORRADE_COMPARE(scene.mutableField(SceneField::Transformation).size()[0], 5);
CORRADE_COMPARE(scene.mutableField(SceneField::Parent).size()[0], 5);
CORRADE_COMPARE(scene.mutableField(SceneField::Mesh).size()[0], 2);
CORRADE_COMPARE(scene.mutableField(sceneFieldCustom(37)).size()[0], 2);
CORRADE_COMPARE((Containers::arrayCast<1, const Matrix4>(scene.field(SceneField::Transformation))[2]), Matrix4::translation(Vector3::zAxis(5.0f)));
CORRADE_COMPARE((Containers::arrayCast<1, const Int>(scene.field(SceneField::Parent))[4]), -1);
CORRADE_COMPARE((Containers::arrayCast<1, const UnsignedByte>(scene.field(SceneField::Mesh))[1]), 7);
CORRADE_COMPARE((Containers::arrayCast<1, const Vector2>(scene.field(sceneFieldCustom(37)))[0]), (Vector2{37.5f, 1.5f}));
CORRADE_COMPARE((Containers::arrayCast<1, Matrix4>(scene.mutableField(SceneField::Transformation))[2]), Matrix4::translation(Vector3::zAxis(5.0f)));
CORRADE_COMPARE((Containers::arrayCast<1, Int>(scene.mutableField(SceneField::Parent))[4]), -1);
CORRADE_COMPARE((Containers::arrayCast<1, UnsignedByte>(scene.mutableField(SceneField::Mesh))[1]), 7);
CORRADE_COMPARE((Containers::arrayCast<1, Vector2>(scene.mutableField(sceneFieldCustom(37)))[0]), (Vector2{37.5f, 1.5f}));
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
/* Typed mapping access by name */
CORRADE_COMPARE(scene.mapping<UnsignedShort>(SceneField::Transformation).size(), 5);
CORRADE_COMPARE(scene.mapping<UnsignedShort>(SceneField::Parent).size(), 5);
CORRADE_COMPARE(scene.mapping<UnsignedShort>(SceneField::Mesh).size(), 2);
CORRADE_COMPARE(scene.mapping<UnsignedShort>(sceneFieldCustom(37)).size(), 2);
CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(SceneField::Transformation).size(), 5);
CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(SceneField::Parent).size(), 5);
CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(SceneField::Mesh).size(), 2);
CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(sceneFieldCustom(37)).size(), 2);
CORRADE_COMPARE(scene.mapping<UnsignedShort>(SceneField::Transformation)[2], 3);
CORRADE_COMPARE(scene.mapping<UnsignedShort>(SceneField::Parent)[4], 1);
CORRADE_COMPARE(scene.mapping<UnsignedShort>(SceneField::Mesh)[1], 6);
CORRADE_COMPARE(scene.mapping<UnsignedShort>(sceneFieldCustom(37))[0], 2);
CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(SceneField::Transformation)[2], 3);
CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(SceneField::Parent)[4], 1);
CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(SceneField::Mesh)[1], 6);
CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(sceneFieldCustom(37))[0], 2);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* Typed field access by name */
CORRADE_COMPARE(scene.field<Matrix4>(SceneField::Transformation).size(), 5);
CORRADE_COMPARE(scene.field<Int>(SceneField::Parent).size(), 5);
CORRADE_COMPARE(scene.field<UnsignedByte>(SceneField::Mesh).size(), 2);
Trade: simplify SceneData array field tests a bit.
3 years ago
CORRADE_COMPARE(scene.field<Float[]>(sceneFieldCustom(37)).size(), (Containers::Size2D{2, 2}));
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.mutableField<Matrix4>(SceneField::Transformation).size(), 5);
CORRADE_COMPARE(scene.mutableField<Int>(SceneField::Parent).size(), 5);
CORRADE_COMPARE(scene.mutableField<UnsignedByte>(SceneField::Mesh).size(), 2);
Trade: simplify SceneData array field tests a bit.
3 years ago
CORRADE_COMPARE(scene.mutableField<Float[]>(sceneFieldCustom(37)).size(), (Containers::Size2D{2, 2}));
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.field<Matrix4>(SceneField::Transformation)[2], Matrix4::translation(Vector3::zAxis(5.0f)));
CORRADE_COMPARE(scene.field<Int>(SceneField::Parent)[4], -1);
CORRADE_COMPARE(scene.field<UnsignedByte>(SceneField::Mesh)[1], 7);
Trade: simplify SceneData array field tests a bit.
3 years ago
CORRADE_COMPARE_AS(scene.field<Float[]>(sceneFieldCustom(37))[0],
Containers::arrayView({37.5f, 1.5f}),
TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.mutableField<Matrix4>(SceneField::Transformation)[2], Matrix4::translation(Vector3::zAxis(5.0f)));
CORRADE_COMPARE(scene.mutableField<Int>(SceneField::Parent)[4], -1);
CORRADE_COMPARE(scene.mutableField<UnsignedByte>(SceneField::Mesh)[1], 7);
Trade: simplify SceneData array field tests a bit.
3 years ago
CORRADE_COMPARE_AS(scene.mutableField<Float[]>(sceneFieldCustom(37))[0],
Containers::stridedArrayView({37.5f, 1.5f}),
TestSuite::Compare::Container);
Trade: allow array access to all SceneData/MeshData fields/attributes. In retrospect, the limitation made no sense and only prevented user code from having a common handling for all possible variants.
3 years ago
/* Accessing a non-array field as an array should be possible as well --
the second dimension is then just 1 */
CORRADE_COMPARE(scene.field<UnsignedByte[]>(SceneField::Mesh).size(), (Containers::Size2D{2, 1}));
CORRADE_COMPARE(scene.mutableField<UnsignedByte[]>(SceneField::Mesh).size(), (Containers::Size2D{2, 1}));
CORRADE_COMPARE(scene.field<UnsignedByte[]>(SceneField::Mesh)[1][0], 7);
CORRADE_COMPARE(scene.mutableField<UnsignedByte[]>(SceneField::Mesh)[1][0], 7);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
void SceneDataTest::constructZeroFields() {
Trade: GCC 11, your warning is again useless.
4 years ago
/* GCC 11 complains that "maybe uninitialized" w/o the {} */
int importerState{};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedShort, 37563, nullptr, {}, &importerState};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
Adapt to Corrade changes.
4 years ago
CORRADE_VERIFY(scene.fieldData().isEmpty());
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(static_cast<const void*>(scene.data()), nullptr);
CORRADE_COMPARE(static_cast<void*>(scene.mutableData()), nullptr);
CORRADE_COMPARE(scene.importerState(), &importerState);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(scene.mappingBound(), 37563);
CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedShort);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.fieldCount(), 0);
Trade: add SceneData::fieldSizeBound(). Like mappingBound(), but instead of giving an upper bound for object count, gives an upper bound for field size.
4 years ago
CORRADE_COMPARE(scene.fieldSizeBound(), 0);
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
CORRADE_VERIFY(!scene.is2D());
CORRADE_VERIFY(!scene.is3D());
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: test construction and assignments of the container classes.
10 years ago
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void SceneDataTest::constructZeroObjects() {
Trade: GCC 11, your warning is again useless.
4 years ago
/* GCC 11 complains that "maybe uninitialized" w/o the {} */
int importerState{};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData meshes{SceneField::Mesh, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::UnsignedShort, nullptr};
SceneFieldData materials{SceneField::MeshMaterial, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr};
SceneData scene{SceneMappingType::UnsignedInt, 0, nullptr, {meshes, materials}, &importerState};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
Adapt to Corrade changes.
4 years ago
CORRADE_VERIFY(!scene.fieldData().isEmpty());
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(static_cast<const void*>(scene.data()), nullptr);
CORRADE_COMPARE(static_cast<void*>(scene.mutableData()), nullptr);
CORRADE_COMPARE(scene.importerState(), &importerState);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(scene.mappingBound(), 0);
CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedInt);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.fieldCount(), 2);
Trade: add SceneData::fieldSizeBound(). Like mappingBound(), but instead of giving an upper bound for object count, gives an upper bound for field size.
4 years ago
CORRADE_COMPARE(scene.fieldSizeBound(), 0);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* Field property access by name */
CORRADE_COMPARE(scene.fieldType(SceneField::Mesh), SceneFieldType::UnsignedShort);
Trade: make SceneField::MeshMaterial signed. Because the material index has to share the object mapping with a mesh, there needs to be a way to express meshes without associated materials.
5 years ago
CORRADE_COMPARE(scene.fieldType(SceneField::MeshMaterial), SceneFieldType::Int);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.fieldSize(SceneField::Mesh), 0);
CORRADE_COMPARE(scene.fieldSize(SceneField::MeshMaterial), 0);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(scene.mapping(SceneField::Mesh).data(), nullptr);
CORRADE_COMPARE(scene.mapping(SceneField::MeshMaterial).data(), nullptr);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
void SceneDataTest::constructNotOwned() {
auto&& instanceData = NotOwnedData[testCaseInstanceId()];
setTestCaseDescription(instanceData.name);
struct Data {
UnsignedShort object;
UnsignedByte mesh;
} data[]{
{0, 2},
{1, 1},
{2, 0}
};
int importerState;
SceneFieldData mesh{SceneField::Mesh,
Containers::stridedArrayView(data).slice(&Data::object),
Containers::stridedArrayView(data).slice(&Data::mesh)};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedShort, 7, instanceData.dataFlags, Containers::arrayView(data), {mesh}, &importerState};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.dataFlags(), instanceData.dataFlags);
CORRADE_COMPARE(static_cast<const void*>(scene.data()), +data);
if(instanceData.dataFlags & DataFlag::Mutable)
Trade: MSVC 2017, what are you doing. How is the data const? Why?
5 years ago
CORRADE_COMPARE(static_cast<void*>(scene.mutableData()), static_cast<void*>(data));
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(scene.mappingBound(), 7);
CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedShort);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.fieldCount(), 1);
CORRADE_COMPARE(scene.importerState(), &importerState);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(scene.mapping<UnsignedShort>(0).size(), 3);
CORRADE_COMPARE(scene.mapping<UnsignedShort>(0)[2], 2);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
if(instanceData.dataFlags & DataFlag::Mutable)
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(scene.mutableMapping<UnsignedShort>(0)[2], 2);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(scene.field<UnsignedByte>(0).size(), 3);
CORRADE_COMPARE(scene.field<UnsignedByte>(0)[2], 0);
if(instanceData.dataFlags & DataFlag::Mutable)
CORRADE_COMPARE(scene.mutableField<UnsignedByte>(0)[2], 0);
}
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void SceneDataTest::constructBit() {
struct Data {
UnsignedByte object;
/* Bit 3 is one field, 5-7 the other; both are then included as both
direct and offset-only fields, the array then also with a negative
stride */
UnsignedByte bits;
} data[]{
{4, 0x01 << 3 | 0x02 << 5},
{0, 0x01 << 3 | 0x02 << 5},
{9, 0x00 << 3 | 0x05 << 5},
{2, 0x01 << 3 | 0x07 << 5},
};
auto view = Containers::stridedArrayView(data);
constexpr SceneField bitField = sceneFieldCustom(0);
constexpr SceneField arrayField = sceneFieldCustom(1);
constexpr SceneField bitFieldOffsetOnly = sceneFieldCustom(10);
constexpr SceneField arrayFieldOffsetOnly = sceneFieldCustom(11);
SceneData scene{SceneMappingType::UnsignedByte, 10, DataFlag::Mutable, data, {
SceneFieldData{bitField, view.slice(&Data::object),
Containers::StridedBitArrayView1D{Containers::BitArrayView{data}, &data[0].bits, 3, 4, sizeof(Data)*8}, SceneFieldFlag::ImplicitMapping},
SceneFieldData{arrayField, view.slice(&Data::object),
Containers::StridedBitArrayView2D{Containers::BitArrayView{data}, &data[0].bits, 5, {4, 3}, {sizeof(Data)*8, 1}}, SceneFieldFlag::OrderedMapping},
/* The two above, just as offset-only */
SceneFieldData{bitFieldOffsetOnly, 4,
SceneMappingType::UnsignedByte, 0, sizeof(Data),
offsetof(Data, bits), 3, sizeof(Data)*8, SceneFieldFlag::ImplicitMapping},
SceneFieldData{arrayFieldOffsetOnly, 4,
SceneMappingType::UnsignedByte, 0, sizeof(Data),
offsetof(Data, bits), 5, sizeof(Data)*8, 3, SceneFieldFlag::OrderedMapping},
}};
/* Raw field data access has special handling for bits, as offset-only
fields are always converted to real views */
for(UnsignedInt i: {0, 2}) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(scene.fieldData(i).flags(), SceneFieldFlag::ImplicitMapping);
CORRADE_COMPARE(scene.fieldData(i).mappingType(), SceneMappingType::UnsignedByte);
CORRADE_COMPARE(scene.fieldData(i).mappingData().data(), &data[0].object);
CORRADE_COMPARE(scene.fieldData(i).mappingData().size(), 4);
CORRADE_COMPARE(scene.fieldData(i).mappingData().stride(), sizeof(Data));
CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedByte>(scene.fieldData(i).mappingData()),
Containers::arrayView<UnsignedByte>({4, 0, 9, 2}),
TestSuite::Compare::Container);
CORRADE_COMPARE(scene.fieldData(i).fieldType(), SceneFieldType::Bit);
CORRADE_COMPARE(scene.fieldData(i).fieldArraySize(), 0);
CORRADE_COMPARE(scene.fieldData(i).fieldBitData().data(), &data[0].bits);
CORRADE_COMPARE(scene.fieldData(i).fieldBitData().offset(), 3);
CORRADE_COMPARE(scene.fieldData(i).fieldBitData().size(), (Containers::Size2D{4, 1}));
CORRADE_COMPARE(scene.fieldData(i).fieldBitData().stride(), (Containers::Stride2D{sizeof(Data)*8, 1}));
CORRADE_COMPARE_AS((scene.fieldData(i).fieldBitData().transposed<0, 1>())[0], Containers::stridedArrayView({
true, true, false, true
}).sliceBit(0), TestSuite::Compare::Container);
}
for(UnsignedInt i: {1, 3}) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(scene.fieldData(i).flags(), SceneFieldFlag::OrderedMapping);
CORRADE_COMPARE(scene.fieldData(i).mappingType(), SceneMappingType::UnsignedByte);
CORRADE_COMPARE(scene.fieldData(i).mappingData().data(), &data[0].object);
CORRADE_COMPARE(scene.fieldData(i).mappingData().size(), 4);
CORRADE_COMPARE(scene.fieldData(i).mappingData().stride(), sizeof(Data));
CORRADE_COMPARE_AS(Containers::arrayCast<const UnsignedByte>(scene.fieldData(i).mappingData()),
Containers::arrayView<UnsignedByte>({4, 0, 9, 2}),
TestSuite::Compare::Container);
CORRADE_COMPARE(scene.fieldData(i).fieldType(), SceneFieldType::Bit);
CORRADE_COMPARE(scene.fieldData(i).fieldArraySize(), 3);
CORRADE_COMPARE(scene.fieldData(i).fieldBitData().data(), &data[0].bits);
CORRADE_COMPARE(scene.fieldData(i).fieldBitData().offset(), 5);
CORRADE_COMPARE(scene.fieldData(i).fieldBitData().size(), (Containers::Size2D{4, 3}));
CORRADE_COMPARE(scene.fieldData(i).fieldBitData().stride(), (Containers::Stride2D{sizeof(Data)*8, 1}));
/* Testing just the first slice, should be enough. The whole data is
tested properly below */
CORRADE_COMPARE_AS((scene.fieldData(i).fieldBitData().transposed<0, 1>())[0], Containers::stridedArrayView({
false, false, true, true
}).sliceBit(0), TestSuite::Compare::Container);
}
/* Field propery access -- nothing special is done for bits, so just verify
roughly that the calls work */
CORRADE_COMPARE(scene.fieldFlags(bitFieldOffsetOnly), SceneFieldFlag::OffsetOnly|SceneFieldFlag::ImplicitMapping);
CORRADE_COMPARE(scene.fieldType(arrayField), SceneFieldType::Bit);
CORRADE_COMPARE(scene.fieldArraySize(arrayFieldOffsetOnly), 3);
/* Single-bit field access using an ID and a name. The view and offset-only
variants should give the same results, const and mutable variant as
well, the array variant should working here too. */
for(UnsignedInt i: {0, 2}) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(scene.fieldBits(i).size(), 4);
CORRADE_COMPARE(scene.fieldBits(i).stride(), sizeof(Data)*8);
CORRADE_COMPARE_AS(scene.fieldBits(i), Containers::stridedArrayView({
true, true, false, true
}).sliceBit(0), TestSuite::Compare::Container);
CORRADE_COMPARE(scene.mutableFieldBits(i).size(), 4);
CORRADE_COMPARE(scene.mutableFieldBits(i).stride(), sizeof(Data)*8);
CORRADE_COMPARE_AS(scene.mutableFieldBits(i), Containers::stridedArrayView({
true, true, false, true
}).sliceBit(0), TestSuite::Compare::Container);
CORRADE_COMPARE(scene.fieldBitArrays(i).size(), (Containers::Size2D{4, 1}));
CORRADE_COMPARE(scene.fieldBitArrays(i).stride(), (Containers::Stride2D{sizeof(Data)*8, 1}));
CORRADE_COMPARE_AS((scene.fieldBitArrays(i).transposed<0, 1>())[0], Containers::stridedArrayView({
true, true, false, true
}).sliceBit(0), TestSuite::Compare::Container);
CORRADE_COMPARE(scene.mutableFieldBitArrays(i).size(), (Containers::Size2D{4, 1}));
CORRADE_COMPARE(scene.mutableFieldBitArrays(i).stride(), (Containers::Stride2D{sizeof(Data)*8, 1}));
CORRADE_COMPARE_AS((scene.mutableFieldBitArrays(i).transposed<0, 1>())[0], Containers::stridedArrayView({
true, true, false, true
}).sliceBit(0), TestSuite::Compare::Container);
}
for(SceneField i: {bitField, bitFieldOffsetOnly}) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(scene.fieldBits(i).size(), 4);
CORRADE_COMPARE(scene.fieldBits(i).stride(), sizeof(Data)*8);
CORRADE_COMPARE_AS(scene.fieldBits(i), Containers::stridedArrayView({
true, true, false, true
}).sliceBit(0), TestSuite::Compare::Container);
CORRADE_COMPARE(scene.mutableFieldBits(i).size(), 4);
CORRADE_COMPARE(scene.mutableFieldBits(i).stride(), sizeof(Data)*8);
CORRADE_COMPARE_AS(scene.mutableFieldBits(i), Containers::stridedArrayView({
true, true, false, true
}).sliceBit(0), TestSuite::Compare::Container);
CORRADE_COMPARE(scene.fieldBitArrays(i).size(), (Containers::Size2D{4, 1}));
CORRADE_COMPARE(scene.fieldBitArrays(i).stride(), (Containers::Stride2D{sizeof(Data)*8, 1}));
CORRADE_COMPARE_AS((scene.fieldBitArrays(i).transposed<0, 1>())[0], Containers::stridedArrayView({
true, true, false, true
}).sliceBit(0), TestSuite::Compare::Container);
CORRADE_COMPARE(scene.mutableFieldBitArrays(i).size(), (Containers::Size2D{4, 1}));
CORRADE_COMPARE(scene.mutableFieldBitArrays(i).stride(), (Containers::Stride2D{sizeof(Data)*8, 1}));
CORRADE_COMPARE_AS((scene.mutableFieldBitArrays(i).transposed<0, 1>())[0], Containers::stridedArrayView({
true, true, false, true
}).sliceBit(0), TestSuite::Compare::Container);
}
/* Bit array field access using ID and name. The view and offset-only
variants should give the same results, const and mutable variant as
well. */
for(UnsignedInt i: {1, 3}) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(scene.fieldBitArrays(i).size(), (Containers::Size2D{4, 3}));
CORRADE_COMPARE(scene.fieldBitArrays(i).stride(), (Containers::Stride2D{sizeof(Data)*8, 1}));
/* Taking all first array items, all second etc, because that's less
comparisons than comparing 3 bits 4 times */
CORRADE_COMPARE_AS((scene.fieldBitArrays(i).transposed<0, 1>())[0], Containers::stridedArrayView({
false, false, true, true
}).sliceBit(0), TestSuite::Compare::Container);
CORRADE_COMPARE_AS((scene.fieldBitArrays(i).transposed<0, 1>())[1], Containers::stridedArrayView({
true, true, false, true
}).sliceBit(0), TestSuite::Compare::Container);
CORRADE_COMPARE_AS((scene.fieldBitArrays(i).transposed<0, 1>())[2], Containers::stridedArrayView({
false, false, true, true
}).sliceBit(0), TestSuite::Compare::Container);
CORRADE_COMPARE(scene.mutableFieldBitArrays(i).size(), (Containers::Size2D{4, 3}));
CORRADE_COMPARE(scene.mutableFieldBitArrays(i).stride(), (Containers::Stride2D{sizeof(Data)*8, 1}));
/* Taking all first array items, all second etc, because that's less
comparisons than comparing 3 bits 4 times */
CORRADE_COMPARE_AS((scene.mutableFieldBitArrays(i).transposed<0, 1>())[0], Containers::stridedArrayView({
false, false, true, true
}).sliceBit(0), TestSuite::Compare::Container);
CORRADE_COMPARE_AS((scene.mutableFieldBitArrays(i).transposed<0, 1>())[1], Containers::stridedArrayView({
true, true, false, true
}).sliceBit(0), TestSuite::Compare::Container);
CORRADE_COMPARE_AS((scene.mutableFieldBitArrays(i).transposed<0, 1>())[2], Containers::stridedArrayView({
false, false, true, true
}).sliceBit(0), TestSuite::Compare::Container);
}
for(SceneField i: {arrayField, arrayFieldOffsetOnly}) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(scene.fieldBitArrays(i).size(), (Containers::Size2D{4, 3}));
CORRADE_COMPARE(scene.fieldBitArrays(i).stride(), (Containers::Stride2D{sizeof(Data)*8, 1}));
/* Taking all first array items, all second etc, because that's less
comparisons than comparing 3 bits 4 times */
CORRADE_COMPARE_AS((scene.fieldBitArrays(i).transposed<0, 1>())[0], Containers::stridedArrayView({
false, false, true, true
}).sliceBit(0), TestSuite::Compare::Container);
CORRADE_COMPARE_AS((scene.fieldBitArrays(i).transposed<0, 1>())[1], Containers::stridedArrayView({
true, true, false, true
}).sliceBit(0), TestSuite::Compare::Container);
CORRADE_COMPARE_AS((scene.fieldBitArrays(i).transposed<0, 1>())[2], Containers::stridedArrayView({
false, false, true, true
}).sliceBit(0), TestSuite::Compare::Container);
CORRADE_COMPARE(scene.mutableFieldBitArrays(i).size(), (Containers::Size2D{4, 3}));
CORRADE_COMPARE(scene.mutableFieldBitArrays(i).stride(), (Containers::Stride2D{sizeof(Data)*8, 1}));
/* Taking all first array items, all second etc, because that's less
comparisons than comparing 3 bits 4 times */
CORRADE_COMPARE_AS((scene.mutableFieldBitArrays(i).transposed<0, 1>())[0], Containers::stridedArrayView({
false, false, true, true
}).sliceBit(0), TestSuite::Compare::Container);
CORRADE_COMPARE_AS((scene.mutableFieldBitArrays(i).transposed<0, 1>())[1], Containers::stridedArrayView({
true, true, false, true
}).sliceBit(0), TestSuite::Compare::Container);
CORRADE_COMPARE_AS((scene.mutableFieldBitArrays(i).transposed<0, 1>())[2], Containers::stridedArrayView({
false, false, true, true
}).sliceBit(0), TestSuite::Compare::Container);
}
}
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
template<class T> struct StringFieldTraits;
template<> struct StringFieldTraits<UnsignedByte> {
static const char* name() { return "8"; }
static SceneFieldType offsetType() { return SceneFieldType::StringOffset8; }
static SceneFieldType rangeType() { return SceneFieldType::StringRange8; }
static SceneFieldType rangeNullTerminatedType() {
return SceneFieldType::StringRangeNullTerminated8;
}
};
template<> struct StringFieldTraits<UnsignedShort> {
static const char* name() { return "16"; }
static SceneFieldType offsetType() { return SceneFieldType::StringOffset16; }
static SceneFieldType rangeType() { return SceneFieldType::StringRange16; }
static SceneFieldType rangeNullTerminatedType() {
return SceneFieldType::StringRangeNullTerminated16;
}
};
template<> struct StringFieldTraits<UnsignedInt> {
static const char* name() { return "32"; }
static SceneFieldType offsetType() { return SceneFieldType::StringOffset32; }
static SceneFieldType rangeType() { return SceneFieldType::StringRange32; }
static SceneFieldType rangeNullTerminatedType() {
return SceneFieldType::StringRangeNullTerminated32;
}
};
template<> struct StringFieldTraits<UnsignedLong> {
static const char* name() { return "64"; }
static SceneFieldType offsetType() { return SceneFieldType::StringOffset64; }
static SceneFieldType rangeType() { return SceneFieldType::StringRange64; }
static SceneFieldType rangeNullTerminatedType() {
return SceneFieldType::StringRangeNullTerminated64;
}
};
template<class T> void SceneDataTest::constructString() {
setTestCaseTemplateName(StringFieldTraits<T>::name());
/* Assumption is that these will be populated by some helper in SceneTools,
with offsets/sizes remembered. Things tested:
- names are offsets w/o null termination, thus have to be referenced
only once and in the order they are in the string
- keys are null-terminated ranges, thus can be referenced multiple
times, the only complication is that there's an extra \0 after
which doesn't count into the size
- values are non-null-terminated (offset, size) ranges, nothing
special about these, can be also referenced multiple times
including subsets (such as "brown" out of "lightbrown"
- files are offsets w/ null terminated, thus again have to be
referenced only once an in the order they are in the string, the
implicit size has to exclude the null terminator
- keys are null terminated (offset, implicit size) ranges, are
defined at the end of the string in order to verify a null
terminator gets added by ArrayTuple after, compared to plain
offsets the reference order doesn't matter and can be referenced
multiple times */
Containers::StringView namesKeysValues =
"Chair" /* 5 */
"Lampshade" /* 14 */
"color\0" /* 14, 5 */
"age\0" /* 20, 3 */
"lightbrown" /* 24, 10; 29, 5 */
"old" /* 34, 3 */
"new"_s; /* 37, 3 doesn't assume null termination */
CORRADE_COMPARE(namesKeysValues.size(), 37 + 3);
Containers::StringView filesTags =
"chair.glb\0" /* 0 */
"empty.obj\0" /* 10 */
"lampshade.fbx\0" /* 20 */
"MAPPABLE\0" /* 34 */
"STRANGE"_s; /* 43, assumes it's stored null-terminated */
CORRADE_COMPARE(filesTags.size(), 43 + 7);
struct Name {
UnsignedShort object;
T nameOffset;
};
struct KeyValue {
UnsignedShort object;
Containers::Pair<T, T> keyRangeNullTerminated;
Containers::Pair<T, T> valueRange;
};
struct FileTag {
UnsignedShort object;
T fileOffsetNullTerminated;
T tagRangeNullTerminated;
};
Containers::StridedArrayView1D<Name> nameData;
Containers::StridedArrayView1D<KeyValue> keyValueData;
Containers::MutableStringView nameKeyValueStringData;
Containers::StridedArrayView1D<FileTag> fileTagData;
Containers::MutableStringView fileTagStringData;
Containers::ArrayTuple data{
{NoInit, 2, nameData},
{NoInit, 4, keyValueData},
{NoInit, filesTags.size(), fileTagStringData, Containers::StringViewFlag::NullTerminated},
{NoInit, 3, fileTagData},
{NoInit, namesKeysValues.size(), nameKeyValueStringData}
};
/* The offset has to be monotonically increasing, so the view is flipped in
the SceneFieldData */
Utility::copy({
{3, 14}, /* Chair */
{1, 5} /* Lampshade */
}, nameData);
Utility::copy({
{3, {20, 3}, {37, 3}}, /* age=new */
{3, {14, 5}, {24, 10}}, /* color=lightbrown */
{1, {20, 3}, {34, 3}}, /* age=old */
{1, {14, 5}, {29, 5}} /* color=brown */
}, keyValueData);
Utility::copy({
{1, 10, 34}, /* chair.glb, MAPPABLE */
{2, 20, 43}, /* empty.obj, STRANGE */
{3, 34, 43}, /* lampshade.fbx, STRANGE */
}, fileTagData);
Utility::copy(namesKeysValues, nameKeyValueStringData);
Utility::copy(filesTags, fileTagStringData);
const SceneField nameField = sceneFieldCustom(5);
const SceneField keyField = sceneFieldCustom(6);
const SceneField valueField = sceneFieldCustom(7);
const SceneField fileField = sceneFieldCustom(8);
const SceneField tagField = sceneFieldCustom(9);
/* Calculate offsets for the offset-only field before the data is moved
out */
const std::size_t keyValueDataOffset = static_cast<char*>(keyValueData.data()) - data.data();
const std::size_t nameKeyValueStringDataOffset = nameKeyValueStringData.data() - data.data();
/* The fileTagStringData should be before the file/tag field data in order
to test storing negative string data offset */
CORRADE_VERIFY(fileTagStringData.data() < fileTagData.data());
SceneData scene{SceneMappingType::UnsignedShort, 4, std::move(data), {
/* Has a negative stride */
SceneFieldData{nameField, nameData.slice(&Name::object).template flipped<0>(),
nameKeyValueStringData.data(), StringFieldTraits<T>::offsetType(),
nameData.slice(&Name::nameOffset).template flipped<0>()},
SceneFieldData{keyField, keyValueData.slice(&KeyValue::object),
nameKeyValueStringData.data(), StringFieldTraits<T>::rangeType(),
keyValueData.slice(&KeyValue::keyRangeNullTerminated),
SceneFieldFlag::NullTerminatedString},
/* Offset-only */
SceneFieldData{valueField, 4,
SceneMappingType::UnsignedShort, keyValueDataOffset + offsetof(KeyValue, object), sizeof(KeyValue),
nameKeyValueStringDataOffset,
StringFieldTraits<T>::rangeType(), keyValueDataOffset + offsetof(KeyValue, valueRange), sizeof(KeyValue)},
/* These two have the string data defined *before* the field data, thus
storing a negative string data offset */
SceneFieldData{fileField, fileTagData.slice(&FileTag::object),
fileTagStringData.data(), StringFieldTraits<T>::offsetType(),
fileTagData.slice(&FileTag::fileOffsetNullTerminated),
SceneFieldFlag::NullTerminatedString},
SceneFieldData{tagField, fileTagData.slice(&FileTag::object),
fileTagStringData.data(), StringFieldTraits<T>::rangeNullTerminatedType(),
fileTagData.slice(&FileTag::tagRangeNullTerminated)},
}};
/* Raw field data access to verify it correctly special-cases */
CORRADE_COMPARE(scene.fieldData(1).mappingType(), SceneMappingType::UnsignedShort);
CORRADE_COMPARE(scene.fieldData(1).mappingData().data(), keyValueData.data());
CORRADE_COMPARE(scene.fieldData(1).stringData(), nameKeyValueStringData.data());
CORRADE_COMPARE(scene.fieldData(1).fieldType(), StringFieldTraits<T>::rangeType());
CORRADE_COMPARE(scene.fieldData(1).fieldData().data(), keyValueData.slice(&KeyValue::keyRangeNullTerminated).data());
CORRADE_COMPARE(scene.fieldData(1).fieldArraySize(), 0);
CORRADE_COMPARE(scene.fieldData(1).flags(), SceneFieldFlag::NullTerminatedString);
/* Field property access, to verify it correctly special-cases */
CORRADE_COMPARE(scene.fieldType(keyField), StringFieldTraits<T>::rangeType());
CORRADE_COMPARE(scene.fieldArraySize(keyField), 0);
/* Field flags should contain the string-specific flags */
CORRADE_COMPARE(scene.fieldFlags(nameField), SceneFieldFlags{});
CORRADE_COMPARE(scene.fieldFlags(keyField), SceneFieldFlag::NullTerminatedString);
CORRADE_COMPARE(scene.fieldFlags(valueField), SceneFieldFlag::OffsetOnly);
CORRADE_COMPARE(scene.fieldFlags(fileField), SceneFieldFlag::NullTerminatedString);
/* This one is added implicitly */
CORRADE_COMPARE(scene.fieldFlags(tagField), SceneFieldFlag::NullTerminatedString);
/* Mapping access should correctly special-case the string type stored in
the same byte */
CORRADE_COMPARE_AS(scene.mapping<UnsignedShort>(nameField), Containers::arrayView<UnsignedShort>({
1, 3
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.mutableMapping<UnsignedShort>(nameField), Containers::stridedArrayView<UnsignedShort>({
1, 3
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.mappingAsArray(nameField), Containers::arrayView<UnsignedInt>({
1, 3
}), TestSuite::Compare::Container);
/* Raw field data access. ID vs name of this API tested thoroughly enough
in construct(). */
CORRADE_COMPARE_AS(scene.field<T>(nameField), Containers::arrayView<T>({
5, 14
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS((scene.field<Containers::Pair<T, T>>(keyField)), (Containers::arrayView<Containers::Pair<T, T>>({
{20, 3}, {14, 5}, {20, 3}, {14, 5}
})), TestSuite::Compare::Container);
CORRADE_COMPARE_AS((scene.field<Containers::Pair<T, T>>(valueField)), (Containers::arrayView<Containers::Pair<T, T>>({
{37, 3}, {24, 10}, {34, 3}, {29, 5}
})), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.field<T>(fileField), Containers::arrayView<T>({
10, 20, 34
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.field<T>(tagField), Containers::arrayView<T>({
34, 43, 43
}), TestSuite::Compare::Container);
/* Raw string data access using an ID */
CORRADE_COMPARE(scene.fieldStringData(0), static_cast<const void*>(nameKeyValueStringData.data()));
CORRADE_COMPARE(scene.fieldStringData(1), static_cast<const void*>(nameKeyValueStringData.data()));
CORRADE_COMPARE(scene.fieldStringData(2), static_cast<const void*>(nameKeyValueStringData.data()));
CORRADE_COMPARE(scene.fieldStringData(3), static_cast<const void*>(fileTagStringData.data()));
CORRADE_COMPARE(scene.fieldStringData(4), static_cast<const void*>(fileTagStringData.data()));
/* Raw string data access using a name */
CORRADE_COMPARE(scene.fieldStringData(nameField), static_cast<const void*>(nameKeyValueStringData.data()));
CORRADE_COMPARE(scene.fieldStringData(keyField), static_cast<const void*>(nameKeyValueStringData.data()));
CORRADE_COMPARE(scene.fieldStringData(valueField), static_cast<const void*>(nameKeyValueStringData.data()));
CORRADE_COMPARE(scene.fieldStringData(fileField), static_cast<const void*>(fileTagStringData.data()));
CORRADE_COMPARE(scene.fieldStringData(tagField), static_cast<const void*>(fileTagStringData.data()));
/* String access using an ID */
CORRADE_COMPARE_AS(scene.fieldStrings(0), Containers::arrayView({
"Chair"_s, "Lampshade"_s
}), TestSuite::Compare::Container);
for(Containers::StringView i: scene.fieldStrings(0)) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(i.flags(), Containers::StringViewFlags{});
}
CORRADE_COMPARE_AS(scene.fieldStrings(1), Containers::arrayView({
"age"_s, "color"_s, "age"_s, "color"_s
}), TestSuite::Compare::Container);
for(Containers::StringView i: scene.fieldStrings(1)) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(i.flags(), Containers::StringViewFlag::NullTerminated);
CORRADE_COMPARE(i[i.size()], '\0');
}
CORRADE_COMPARE_AS(scene.fieldStrings(2), Containers::arrayView({
"new"_s, "lightbrown"_s, "old"_s, "brown"_s
}), TestSuite::Compare::Container);
for(Containers::StringView i: scene.fieldStrings(2)) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(i.flags(), Containers::StringViewFlags{});
}
CORRADE_COMPARE_AS(scene.fieldStrings(3), Containers::arrayView({
"chair.glb"_s, "empty.obj"_s, "lampshade.fbx"_s
}), TestSuite::Compare::Container);
for(Containers::StringView i: scene.fieldStrings(3)) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(i.flags(), Containers::StringViewFlag::NullTerminated);
CORRADE_COMPARE(i[i.size()], '\0');
}
CORRADE_COMPARE_AS(scene.fieldStrings(4), Containers::arrayView({
"MAPPABLE"_s, "STRANGE"_s, "STRANGE"_s
}), TestSuite::Compare::Container);
for(Containers::StringView i: scene.fieldStrings(4)) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(i.flags(), Containers::StringViewFlag::NullTerminated);
CORRADE_COMPARE(i[i.size()], '\0');
}
/* String access using a name */
CORRADE_COMPARE_AS(scene.fieldStrings(nameField), Containers::arrayView({
"Chair"_s, "Lampshade"_s
}), TestSuite::Compare::Container);
for(Containers::StringView i: scene.fieldStrings(nameField)) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(i.flags(), Containers::StringViewFlags{});
}
CORRADE_COMPARE_AS(scene.fieldStrings(keyField), Containers::arrayView({
"age"_s, "color"_s, "age"_s, "color"_s
}), TestSuite::Compare::Container);
for(Containers::StringView i: scene.fieldStrings(keyField)) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(i.flags(), Containers::StringViewFlag::NullTerminated);
CORRADE_COMPARE(i[i.size()], '\0');
}
CORRADE_COMPARE_AS(scene.fieldStrings(valueField), Containers::arrayView({
"new"_s, "lightbrown"_s, "old"_s, "brown"_s
}), TestSuite::Compare::Container);
for(Containers::StringView i: scene.fieldStrings(valueField)) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(i.flags(), Containers::StringViewFlags{});
}
CORRADE_COMPARE_AS(scene.fieldStrings(fileField), Containers::arrayView({
"chair.glb"_s, "empty.obj"_s, "lampshade.fbx"_s
}), TestSuite::Compare::Container);
for(Containers::StringView i: scene.fieldStrings(fileField)) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(i.flags(), Containers::StringViewFlag::NullTerminated);
CORRADE_COMPARE(i[i.size()], '\0');
}
CORRADE_COMPARE_AS(scene.fieldStrings(tagField), Containers::arrayView({
"MAPPABLE"_s, "STRANGE"_s, "STRANGE"_s
}), TestSuite::Compare::Container);
for(Containers::StringView i: scene.fieldStrings(tagField)) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(i.flags(), Containers::StringViewFlag::NullTerminated);
CORRADE_COMPARE(i[i.size()], '\0');
}
}
Trade: move a test case to a better place. It'll be together with a test case for special bit strides, so it should be after the place where to put constructBit().
3 years ago
void SceneDataTest::constructSpecialStrides() {
Containers::StridedArrayView1D<UnsignedShort> broadcastedData;
Containers::StridedArrayView1D<UnsignedShort> nonBroadcastedData;
Containers::ArrayTuple data{
{NoInit, 1, broadcastedData},
{NoInit, 4, nonBroadcastedData}
};
broadcastedData[0] = 15;
Utility::copy({1, 2, 3, 4}, nonBroadcastedData);
SceneFieldData broadcastedMapping{sceneFieldCustom(38),
broadcastedData.broadcasted<0>(4), nonBroadcastedData};
SceneFieldData broadcastedField{sceneFieldCustom(39),
nonBroadcastedData, broadcastedData.broadcasted<0>(4)};
SceneFieldData flippedField{sceneFieldCustom(40),
nonBroadcastedData.flipped<0>(), nonBroadcastedData.flipped<0>()};
SceneFieldData flippedFieldOffsetOnly{sceneFieldCustom(41),
4, SceneMappingType::UnsignedShort, std::size_t(static_cast<char*>(nonBroadcastedData.flipped<0>().data()) - data.data()), -2,
SceneFieldType::UnsignedShort, std::size_t(static_cast<char*>(nonBroadcastedData.flipped<0>().data()) - data.data()), -2};
SceneData scene{SceneMappingType::UnsignedShort, 8, std::move(data), {
broadcastedMapping, broadcastedField, flippedField, flippedFieldOffsetOnly
}};
CORRADE_COMPARE_AS(scene.mapping<UnsignedShort>(0),
Containers::arrayView<UnsignedShort>({15, 15, 15, 15}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.field<UnsignedShort>(0),
Containers::arrayView<UnsignedShort>({1, 2, 3, 4}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.mapping<UnsignedShort>(1),
Containers::arrayView<UnsignedShort>({1, 2, 3, 4}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.field<UnsignedShort>(1),
Containers::arrayView<UnsignedShort>({15, 15, 15, 15}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.mapping<UnsignedShort>(2),
Containers::arrayView<UnsignedShort>({4, 3, 2, 1}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.field<UnsignedShort>(2),
Containers::arrayView<UnsignedShort>({4, 3, 2, 1}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.mapping<UnsignedShort>(3),
Containers::arrayView<UnsignedShort>({4, 3, 2, 1}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.field<UnsignedShort>(3),
Containers::arrayView<UnsignedShort>({4, 3, 2, 1}),
TestSuite::Compare::Container);
}
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void SceneDataTest::constructSpecialStridesBit() {
auto&& instanceData = ConstructSpecialStridesBitData[testCaseInstanceId()];
setTestCaseDescription(instanceData.name);
/* Similar to constructBit(), except that the strides are negative and
zero, and only properties related to those are tested */
struct Data {
UnsignedByte object;
/* Bit 3 is one field, 5-7 the other; both are then included as both
direct and offset-only fields, the array then also with a negative
stride */
UnsignedByte bits;
} data[]{
{4, 0x01 << 3 | 0x02 << 5},
{0, 0x01 << 3 | 0x02 << 5},
{9, 0x00 << 3 | 0x05 << 5},
{2, 0x01 << 3 | 0x07 << 5},
};
auto view = Containers::stridedArrayView(data);
constexpr SceneField bitField = sceneFieldCustom(0);
constexpr SceneField arrayField = sceneFieldCustom(1);
constexpr SceneField bitFieldOffsetOnly = sceneFieldCustom(10);
constexpr SceneField arrayFieldOffsetOnly = sceneFieldCustom(11);
SceneData scene{SceneMappingType::UnsignedByte, 10, DataFlag::Mutable, data, {
SceneFieldData{bitField, view.slice(&Data::object),
Containers::StridedBitArrayView1D{Containers::BitArrayView{data}, &data[0].bits + instanceData.offset, instanceData.bitOffset, 4, instanceData.stride}, SceneFieldFlag::ImplicitMapping},
SceneFieldData{arrayField, view.slice(&Data::object),
Containers::StridedBitArrayView2D{Containers::BitArrayView{data}, &data[0].bits + instanceData.offset, instanceData.arrayBitOffset, {4, 3}, {instanceData.stride, 1}}, SceneFieldFlag::OrderedMapping},
/* The two above, just as offset-only */
SceneFieldData{bitFieldOffsetOnly, 4,
SceneMappingType::UnsignedByte, 0, sizeof(Data),
offsetof(Data, bits) + instanceData.offset, instanceData.bitOffset, instanceData.stride, SceneFieldFlag::ImplicitMapping},
SceneFieldData{arrayFieldOffsetOnly, 4,
SceneMappingType::UnsignedByte, 0, sizeof(Data),
offsetof(Data, bits) + instanceData.offset, instanceData.arrayBitOffset, instanceData.stride, 3, SceneFieldFlag::OrderedMapping},
}};
/* Raw field data access */
for(UnsignedInt i: {0, 2}) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(scene.fieldData(i).fieldBitData().size(), (Containers::Size2D{4, 1}));
CORRADE_COMPARE(scene.fieldData(i).fieldBitData().stride(), (Containers::Stride2D{instanceData.stride, 1}));
CORRADE_COMPARE_AS((scene.fieldData(i).fieldBitData().transposed<0, 1>())[0],
(Containers::BitArrayView{&instanceData.expectedBits, 0, 4}),
TestSuite::Compare::Container);
}
for(UnsignedInt i: {1, 3}) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(scene.fieldData(i).fieldBitData().size(), (Containers::Size2D{4, 3}));
CORRADE_COMPARE(scene.fieldData(i).fieldBitData().stride(), (Containers::Stride2D{instanceData.stride, 1}));
/* Testing just the first slice, should be enough. The whole data is
tested properly below */
CORRADE_COMPARE_AS((scene.fieldData(i).fieldBitData().transposed<0, 1>())[0],
(Containers::BitArrayView{&instanceData.expectedArrayBits[0], 0, 4}),
TestSuite::Compare::Container);
}
/* Bit fields */
for(SceneField i: {bitField, bitFieldOffsetOnly}) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(scene.fieldBits(i).stride(), instanceData.stride);
CORRADE_COMPARE_AS(scene.fieldBits(i),
(Containers::BitArrayView{&instanceData.expectedBits, 0, 4}),
TestSuite::Compare::Container);
CORRADE_COMPARE(scene.mutableFieldBits(i).stride(), instanceData.stride);
CORRADE_COMPARE_AS(scene.mutableFieldBits(i),
(Containers::BitArrayView{&instanceData.expectedBits, 0, 4}),
TestSuite::Compare::Container<Containers::StridedBitArrayView1D>);
}
/* Bit array fields */
for(SceneField i: {arrayField, arrayFieldOffsetOnly}) {
CORRADE_ITERATION(i);
CORRADE_COMPARE(scene.fieldBitArrays(i).size(), (Containers::Size2D{4, 3}));
CORRADE_COMPARE(scene.fieldBitArrays(i).stride(), (Containers::Stride2D{instanceData.stride, 1}));
CORRADE_COMPARE_AS((scene.fieldBitArrays(i).transposed<0, 1>())[0],
(Containers::BitArrayView{&instanceData.expectedArrayBits[0], 0, 4}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS((scene.fieldBitArrays(i).transposed<0, 1>())[1],
(Containers::BitArrayView{&instanceData.expectedArrayBits[1], 0, 4}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS((scene.fieldBitArrays(i).transposed<0, 1>())[2],
(Containers::BitArrayView{&instanceData.expectedArrayBits[0], 0, 4}),
TestSuite::Compare::Container);
CORRADE_COMPARE(scene.mutableFieldBitArrays(i).size(), (Containers::Size2D{4, 3}));
CORRADE_COMPARE(scene.mutableFieldBitArrays(i).stride(), (Containers::Stride2D{instanceData.stride, 1}));
CORRADE_COMPARE_AS((scene.mutableFieldBitArrays(i).transposed<0, 1>())[0],
(Containers::BitArrayView{&instanceData.expectedArrayBits[0], 0, 4}),
TestSuite::Compare::Container<Containers::StridedBitArrayView1D>);
CORRADE_COMPARE_AS((scene.mutableFieldBitArrays(i).transposed<0, 1>())[1],
(Containers::BitArrayView{&instanceData.expectedArrayBits[1], 0, 4}),
TestSuite::Compare::Container<Containers::StridedBitArrayView1D>);
CORRADE_COMPARE_AS((scene.mutableFieldBitArrays(i).transposed<0, 1>())[2],
(Containers::BitArrayView{&instanceData.expectedArrayBits[0], 0, 4}),
TestSuite::Compare::Container<Containers::StridedBitArrayView1D>);
}
}
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
void SceneDataTest::constructDeprecated() {
auto&& data = ChildrenDeprecatedData[testCaseInstanceId()];
setTestCaseDescription(data.name);
int a;
CORRADE_IGNORE_DEPRECATED_PUSH
SceneData scene{
data.is2D ? std::vector<UnsignedInt>{5, 17, 36, 22} : std::vector<UnsignedInt>{},
data.is3D ? std::vector<UnsignedInt>{5, 17, 36, 22} : std::vector<UnsignedInt>{},
&a};
CORRADE_IGNORE_DEPRECATED_POP
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedInt);
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
if(data.is2D || data.is3D)
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(scene.mappingBound(), 37);
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
else
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(scene.mappingBound(), 0);
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
CORRADE_COMPARE(scene.dataFlags(), DataFlag::Mutable|DataFlag::Owned);
CORRADE_COMPARE(scene.importerState(), &a);
CORRADE_COMPARE(scene.fieldCount(), 1);
CORRADE_COMPARE(scene.fieldName(0), SceneField::Parent);
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
CORRADE_COMPARE(scene.fieldFlags(0), SceneFieldFlags{});
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
CORRADE_COMPARE(scene.fieldType(0), SceneFieldType::Int);
if(data.is2D || data.is3D) {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE_AS(scene.mapping<UnsignedInt>(0),
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
Containers::arrayView<UnsignedInt>({5, 17, 36, 22}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.field<Int>(0),
Containers::arrayView<Int>({-1, -1, -1, -1}),
TestSuite::Compare::Container);
} else CORRADE_COMPARE(scene.fieldSize(SceneField::Parent), 0);
/* There's no transformation field that would disambiguate this, the state
is set directly */
CORRADE_COMPARE(scene.is2D(), data.is2D);
CORRADE_COMPARE(scene.is3D(), data.is3D);
Trade: ensure the deprecated SceneData constructor uses default deleters. Otherwise the instances wouldn't be usable from AbstractImporter subclasses.
5 years ago
/* The deleters have to be trivial, otherwise this instance wouldn't be
usable from an AbstractImporter */
CORRADE_VERIFY(!scene.releaseFieldData().deleter());
CORRADE_VERIFY(!scene.releaseData().deleter());
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
}
void SceneDataTest::constructDeprecatedBoth2DAnd3D() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
std::ostringstream out;
Error redirectError{&out};
CORRADE_IGNORE_DEPRECATED_PUSH
SceneData scene{{5, 17}, {36, 22}};
CORRADE_IGNORE_DEPRECATED_POP
CORRADE_COMPARE(out.str(), "Trade::SceneData: it's no longer possible to have a scene with both 2D and 3D objects\n");
}
#endif
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void SceneDataTest::constructDuplicateField() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* Builtin fields are checked using a bitfield, as they have monotonic
numbering */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData meshes{SceneField::Mesh, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::UnsignedShort, nullptr};
SceneFieldData materials{SceneField::MeshMaterial, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr};
SceneFieldData meshesAgain{SceneField::Mesh, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::UnsignedInt, nullptr};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 0, nullptr, {meshes, materials, meshesAgain}};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(), "Trade::SceneData: duplicate field Trade::SceneField::Mesh\n");
}
void SceneDataTest::constructDuplicateCustomField() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* These are checked in an O(n^2) way, separately from builtin fields.
Can't use a bitfield since the field index can be anything. */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData customA{sceneFieldCustom(37), SceneMappingType::UnsignedInt, nullptr, SceneFieldType::UnsignedShort, nullptr};
SceneFieldData customB{sceneFieldCustom(1038576154), SceneMappingType::UnsignedInt, nullptr, SceneFieldType::UnsignedInt, nullptr};
SceneFieldData customAAgain{sceneFieldCustom(37), SceneMappingType::UnsignedInt, nullptr, SceneFieldType::UnsignedInt, nullptr};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 0, nullptr, {customA, customB, customAAgain}};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(), "Trade::SceneData: duplicate field Trade::SceneField::Custom(37)\n");
}
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
void SceneDataTest::constructInconsistentMappingType() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData meshes{SceneField::Mesh, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::UnsignedShort, nullptr};
SceneFieldData materials{SceneField::MeshMaterial, SceneMappingType::UnsignedShort, nullptr, SceneFieldType::Int, nullptr};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 0, nullptr, {meshes, materials}};
CORRADE_COMPARE(out.str(), "Trade::SceneData: inconsistent mapping type, got Trade::SceneMappingType::UnsignedShort for field 1 but expected Trade::SceneMappingType::UnsignedInt\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
void SceneDataTest::constructMappingDataNotContained() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 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> data{reinterpret_cast<char*>(0xbadda9), 5*sizeof(UnsignedShort), [](char*, std::size_t){}};
Containers::Array<char> sameDataButMovable{reinterpret_cast<char*>(0xbadda9), 5*sizeof(UnsignedShort), [](char*, std::size_t){}};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Containers::ArrayView<UnsignedShort> dataIn{reinterpret_cast<UnsignedShort*>(0xbadda9), 5};
Containers::ArrayView<UnsignedShort> dataSlightlyOut{reinterpret_cast<UnsignedShort*>(0xbaddaa), 5};
Containers::ArrayView<UnsignedShort> dataOut{reinterpret_cast<UnsignedShort*>(0xdead), 5};
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 data */
Trade: fix SceneData field containment checks for negative strides. Why didn't I think of extracting the common code earlier?
4 years ago
SceneData{SceneMappingType::UnsignedShort, 5, std::move(sameDataButMovable), {
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
/* This is here to test that not just the first field gets checked and
that the message shows proper ID */
Trade: make SceneField::MeshMaterial signed. Because the material index has to share the object mapping with a mesh, there needs to be a way to express meshes without associated materials.
5 years ago
SceneFieldData{SceneField::Light, dataIn, dataIn},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Mesh, dataOut, dataIn}
}};
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
/* A "slightly off" view that exceeds the original by one byte */
SceneData{SceneMappingType::UnsignedShort, 5, {}, data, {
SceneFieldData{SceneField::Mesh, dataSlightlyOut, dataIn}
}};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* And if we have no data at all, it doesn't try to dereference them but
still checks properly */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData{SceneMappingType::UnsignedShort, 5, nullptr, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Mesh, dataOut, dataIn}
}};
Trade: fix SceneData field containment checks for negative strides. Why didn't I think of extracting the common code earlier?
4 years ago
/* Offset-only fields with a different message */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData{SceneMappingType::UnsignedByte, 6, Containers::Array<char>{24}, {
SceneFieldData{SceneField::Mesh, 6, SceneMappingType::UnsignedByte, 4, 4, SceneFieldType::UnsignedByte, 0, 4}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}};
Trade: fix SceneData field containment checks for negative strides. Why didn't I think of extracting the common code earlier?
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". */
SceneData{SceneMappingType::UnsignedShort, 5, {}, data, {
SceneFieldData{SceneField::Mesh, stridedArrayView(dataSlightlyOut).flipped<0>(), dataIn}
}};
SceneData{SceneMappingType::UnsignedByte, 6, Containers::Array<char>{24}, {
SceneFieldData{SceneField::Mesh, 6, SceneMappingType::UnsignedByte, 24, -4, SceneFieldType::UnsignedByte, 0, 4}
}};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData: mapping data [0xdead:0xdeb7] of field 1 are not contained in passed data array [0xbadda9:0xbaddb3]\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::SceneData: mapping data [0xbaddaa:0xbaddb4] of field 0 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData: mapping data [0xdead:0xdeb7] of field 0 are not contained in passed data array [0x0:0x0]\n"
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: fix SceneData field containment checks for negative strides. Why didn't I think of extracting the common code earlier?
4 years ago
"Trade::SceneData: offset-only mapping data of field 0 span 25 bytes but passed data array has only 24\n"
"Trade::SceneData: mapping data [0xbaddaa:0xbaddb4] of field 0 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData: offset-only mapping data of field 0 span 25 bytes but passed data array has only 24\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
void SceneDataTest::constructFieldDataNotContained() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
/* Mostly the same as constructMappingDataNotContained() with mapping and
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
field views swapped, and added checks for array fields. Bit fields have
many special cases on their own and are tested in
constructBitFieldDataNotContained() below. */
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: fix SceneData field containment checks for negative strides. Why didn't I think of extracting the common code earlier?
4 years ago
const Containers::Array<char> data{reinterpret_cast<char*>(0xbadda9), 10, [](char*, std::size_t){}};
Containers::Array<char> sameDataButMovable{reinterpret_cast<char*>(0xbadda9), 10, [](char*, std::size_t){}};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Containers::ArrayView<UnsignedShort> dataIn{reinterpret_cast<UnsignedShort*>(0xbadda9), 5};
Containers::ArrayView<UnsignedShort> dataSlightlyOut{reinterpret_cast<UnsignedShort*>(0xbaddaa), 5};
Containers::ArrayView<UnsignedShort> dataOut{reinterpret_cast<UnsignedShort*>(0xdead), 5};
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 data */
SceneData{SceneMappingType::UnsignedShort, 5, std::move(sameDataButMovable), {
/* This is here to test that not just the first attribute gets checked
and that the message shows proper ID */
Trade: make SceneField::MeshMaterial signed. Because the material index has to share the object mapping with a mesh, there needs to be a way to express meshes without associated materials.
5 years ago
SceneFieldData{SceneField::Light, dataIn, dataIn},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Mesh, dataIn, dataOut}
}};
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
/* A "slightly off" view that exceeds the original by one byte */
SceneData{SceneMappingType::UnsignedShort, 5, {}, data, {
SceneFieldData{SceneField::Mesh, dataIn, dataSlightlyOut}
}};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* Verify array size is taken into account as well. If not, the data would
span only 7 bytes out of 10 (instead of 12), which is fine. */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData{SceneMappingType::UnsignedShort, 5, {}, data, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{sceneFieldCustom(37), dataIn.prefix(2), Containers::StridedArrayView2D<UnsignedByte>{Containers::ArrayView<UnsignedByte>{reinterpret_cast<UnsignedByte*>(0xbadda9), 12}, {2, 6}}}
}};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
/* Not checking for nullptr data, since that got checked for mapping view
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
already and there's no way to trigger it for fields */
Trade: fix SceneData field containment checks for negative strides. Why didn't I think of extracting the common code earlier?
4 years ago
/* Offset-only fields with a different message */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData{SceneMappingType::UnsignedShort, 6, Containers::Array<char>{24}, {
SceneFieldData{SceneField::Mesh, 6, SceneMappingType::UnsignedShort, 0, 4, SceneFieldType::UnsignedByte, 4, 4}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}};
/* This again spans 21 bytes if array size isn't taken into account, and 25
if it is */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData{SceneMappingType::UnsignedShort, 5, Containers::Array<char>{24}, {
SceneFieldData{sceneFieldCustom(37), 5, SceneMappingType::UnsignedShort, 0, 5, SceneFieldType::UnsignedByte, 0, 5, 5}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}};
Trade: fix SceneData field containment checks for negative strides. Why didn't I think of extracting the common code earlier?
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". */
SceneData{SceneMappingType::UnsignedShort, 5, {}, data, {
SceneFieldData{SceneField::Mesh, dataIn, stridedArrayView(dataSlightlyOut).flipped<0>()}
}};
SceneData{SceneMappingType::UnsignedByte, 6, Containers::Array<char>{24}, {
SceneFieldData{SceneField::Mesh, 6, SceneMappingType::UnsignedByte, 0, 4, SceneFieldType::UnsignedByte, 24, -4}
}};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
"Trade::SceneData: field data [0xdead:0xdeb7] of field 1 are not contained in passed data array [0xbadda9:0xbaddb3]\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::SceneData: field data [0xbaddaa:0xbaddb4] of field 0 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
"Trade::SceneData: field data [0xbadda9:0xbaddb5] of field 0 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
"Trade::SceneData: offset-only field data of field 0 span 25 bytes but passed data array has only 24\n"
Trade: fix SceneData field containment checks for negative strides. Why didn't I think of extracting the common code earlier?
4 years ago
"Trade::SceneData: offset-only field data of field 0 span 25 bytes but passed data array has only 24\n"
"Trade::SceneData: field data [0xbaddaa:0xbaddb4] of field 0 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
"Trade::SceneData: offset-only field data of field 0 span 25 bytes but passed data array has only 24\n");
}
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
void SceneDataTest::constructBitFieldDataNotContained() {
CORRADE_SKIP_IF_NO_ASSERT();
/* Tested separately from constructFieldDataNotContained() as there's
enough bit-related cases on its own. It goes through the same variants,
but explicitly checks also non-zero bit offset. */
const Containers::Array<char> data{reinterpret_cast<char*>(0xbadda9), 10, [](char*, std::size_t){}};
Containers::Array<char> sameDataButMovable{reinterpret_cast<char*>(0xbadda9), 10, [](char*, std::size_t){}};
Containers::ArrayView<UnsignedByte> mappingData{reinterpret_cast<UnsignedByte*>(0xbadda9), 10};
Containers::StridedBitArrayView1D dataOneByteOut{Containers::BitArrayView{reinterpret_cast<void*>(0xbaddaa), 0, 80}, 10, 8};
Containers::StridedBitArrayView1D dataTwoBitsOut{Containers::BitArrayView{reinterpret_cast<void*>(0xbadda9), 0, 90}, 10, 9};
Containers::StridedBitArrayView1D dataOneBitOffsetOut{Containers::BitArrayView{reinterpret_cast<void*>(0xbadda9), 4, 95}, 5, 19};
Containers::StridedBitArrayView1D dataOneBitOffsetBeforeOut{Containers::BitArrayView{reinterpret_cast<void*>(0xbadda8), 7, 80}, 10, 8};
Containers::BitArrayView dataOut{reinterpret_cast<void*>(0xdead), 7, 10};
std::ostringstream out;
Error redirectError{&out};
/* Basic "obviously wrong" case with owned data */
SceneData{SceneMappingType::UnsignedByte, 10, std::move(sameDataButMovable), {
/* This is here to test that not just the first attribute gets checked
and that the message shows proper ID */
SceneFieldData{SceneField::Light, mappingData, mappingData},
SceneFieldData{sceneFieldCustom(773), mappingData, dataOut}
}};
/* A "slightly off" view that exceeds the original by one byte and two bits,
respectively */
SceneData{SceneMappingType::UnsignedByte, 10, {}, data, {
SceneFieldData{sceneFieldCustom(773), mappingData, dataOneByteOut}
}};
SceneData{SceneMappingType::UnsignedByte, 10, {}, data, {
SceneFieldData{sceneFieldCustom(773), mappingData, dataTwoBitsOut}
}};
/* Verify the bit offset is taken into account. On begin it shouldn't be
rounded up, otherwise the second variant would pass.*/
SceneData{SceneMappingType::UnsignedByte, 10, {}, data, {
SceneFieldData{sceneFieldCustom(773), mappingData.prefix(5), dataOneBitOffsetOut}
}};
SceneData{SceneMappingType::UnsignedByte, 10, {}, data, {
SceneFieldData{sceneFieldCustom(773), mappingData, dataOneBitOffsetBeforeOut}
}};
/* Verify array size is taken into account as well. If not, the data would
span only 9 bytes instead of 11, which would pass. */
SceneData{SceneMappingType::UnsignedByte, 10, {}, data, {
SceneFieldData{sceneFieldCustom(773), mappingData.prefix(9), Containers::StridedBitArrayView2D{Containers::BitArrayView{reinterpret_cast<void*>(0xbadda9), 0, 81}, {9, 9}}}
}};
/* Not checking for nullptr data, since that got checked for mapping view
already and there's no way to trigger it for fields */
/* Offset-only fields with a different message, again both one byte and one
bit off, one bit with offset */
SceneData{SceneMappingType::UnsignedByte, 10, Containers::Array<char>{10}, {
SceneFieldData{sceneFieldCustom(773), 10, SceneMappingType::UnsignedByte, 0, 1, 1, 0, 8}
}};
SceneData{SceneMappingType::UnsignedByte, 10, Containers::Array<char>{10}, {
SceneFieldData{sceneFieldCustom(773), 10, SceneMappingType::UnsignedByte, 0, 1, 0, 0, 9}
}};
SceneData{SceneMappingType::UnsignedByte, 10, Containers::Array<char>{10}, {
SceneFieldData{sceneFieldCustom(773), 5, SceneMappingType::UnsignedByte, 0, 1, 0, 4, 19}
}};
/* One with array */
SceneData{SceneMappingType::UnsignedByte, 10, Containers::Array<char>{10}, {
SceneFieldData{sceneFieldCustom(773), 9, SceneMappingType::UnsignedByte, 0, 1, 0, 0, 9, 9}
}};
/* And the final boss, negative strides -- one byte off and two bits off.
Both only caught if the element size gets properly added to the larger
offset, not just the "end". */
SceneData{SceneMappingType::UnsignedByte, 10, {}, data, {
SceneFieldData{sceneFieldCustom(773), mappingData, dataOneByteOut.flipped<0>()}
}};
SceneData{SceneMappingType::UnsignedByte, 10, {}, data, {
SceneFieldData{sceneFieldCustom(773), mappingData, dataTwoBitsOut.flipped<0>()}
}};
SceneData{SceneMappingType::UnsignedByte, 10, Containers::Array<char>{10}, {
SceneFieldData{sceneFieldCustom(773), 10, SceneMappingType::UnsignedByte, 0, 1, 10, 0, -8}
}};
SceneData{SceneMappingType::UnsignedByte, 10, Containers::Array<char>{10}, {
SceneFieldData{sceneFieldCustom(773), 9, SceneMappingType::UnsignedByte, 0, 1, 10, 0, -9}
}};
CORRADE_COMPARE(out.str(),
"Trade::SceneData: field data [0xdead:0xdeb0] of field 1 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
"Trade::SceneData: field data [0xbaddaa:0xbaddb4] of field 0 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
"Trade::SceneData: field data [0xbadda9:0xbaddb4] of field 0 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
"Trade::SceneData: field data [0xbadda9:0xbaddb4] of field 0 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
"Trade::SceneData: field data [0xbadda8:0xbaddb2] of field 0 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
"Trade::SceneData: field data [0xbadda9:0xbaddb4] of field 0 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
"Trade::SceneData: offset-only field data of field 0 span 11 bytes but passed data array has only 10\n"
"Trade::SceneData: offset-only field data of field 0 span 11 bytes but passed data array has only 10\n"
"Trade::SceneData: offset-only field data of field 0 span 11 bytes but passed data array has only 10\n"
"Trade::SceneData: offset-only field data of field 0 span 11 bytes but passed data array has only 10\n"
"Trade::SceneData: field data [0xbaddaa:0xbaddb4] of field 0 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
"Trade::SceneData: field data [0xbadda9:0xbaddb4] of field 0 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
"Trade::SceneData: offset-only field data of field 0 span 11 bytes but passed data array has only 10\n"
"Trade::SceneData: offset-only field data of field 0 span 11 bytes but passed data array has only 10\n"
);
}
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
void SceneDataTest::constructStringDataNotContained() {
CORRADE_SKIP_IF_NO_ASSERT();
Containers::ArrayView<char> data{reinterpret_cast<char*>(0xbadda9), 10};
Containers::ArrayView<UnsignedShort> dataIn{reinterpret_cast<UnsignedShort*>(0xbadda9), 5};
/* This should be fine even though it points to the very end (the string
array could be empty) */
SceneData{SceneMappingType::UnsignedShort, 5, {}, data, {
SceneFieldData{sceneFieldCustom(35), dataIn,
reinterpret_cast<char*>(0xbadda9 + 10), SceneFieldType::StringOffset16,
dataIn}
}};
std::ostringstream out;
Error redirectError{&out};
/* Data too early */
SceneData{SceneMappingType::UnsignedShort, 5, {}, data, {
/* This is here to test that not just the first attribute gets checked
and that the message shows proper ID */
SceneFieldData{SceneField::Light, dataIn, dataIn},
SceneFieldData{sceneFieldCustom(35), dataIn,
reinterpret_cast<char*>(0xbadda9 - 1), SceneFieldType::StringOffset16,
dataIn}
}};
/* Data too late */
SceneData{SceneMappingType::UnsignedShort, 5, {}, data, {
SceneFieldData{sceneFieldCustom(35), dataIn,
reinterpret_cast<char*>(0xbaddaa9 + 11), SceneFieldType::StringRange8,
dataIn}
}};
CORRADE_COMPARE(out.str(),
"Trade::SceneData: field string data 0xbadda8 of field 1 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
"Trade::SceneData: field string data 0xbaddab4 of field 0 are not contained in passed data array [0xbadda9:0xbaddb3]\n");
}
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
void SceneDataTest::constructMappingTypeTooSmall() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* This is fine */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData{SceneMappingType::UnsignedByte, 0xff, nullptr, {}};
SceneData{SceneMappingType::UnsignedShort, 0xffff, nullptr, {}};
SceneData{SceneMappingType::UnsignedInt, 0xffffffffu, nullptr, {}};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData{SceneMappingType::UnsignedByte, 0x100, nullptr, {}};
SceneData{SceneMappingType::UnsignedShort, 0x10000, nullptr, {}};
SceneData{SceneMappingType::UnsignedInt, 0x100000000ull, nullptr, {}};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData: Trade::SceneMappingType::UnsignedByte is too small for 256 objects\n"
"Trade::SceneData: Trade::SceneMappingType::UnsignedShort is too small for 65536 objects\n"
"Trade::SceneData: Trade::SceneMappingType::UnsignedInt is too small for 4294967296 objects\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
void SceneDataTest::constructNotOwnedFlagOwned() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
const char data[32]{};
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData{SceneMappingType::UnsignedByte, 5, DataFlag::Owned, Containers::arrayView(data), {}};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
"Trade::SceneData: can't construct with non-owned data but Trade::DataFlag::Owned\n");
}
void SceneDataTest::constructMismatchedTRSViews() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Containers::ArrayView<const char> data{reinterpret_cast<char*>(0xcafe0000),
/* Three entries, each having a 2D TRS and 3 object IDs */
3*(24 + 12)};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::ArrayView<const UnsignedInt> translationMappingData{
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
reinterpret_cast<const UnsignedInt*>(data.data()), 3};
Containers::ArrayView<const Vector2> translationFieldData{
reinterpret_cast<const Vector2*>(data.data() + 0x0c), 3};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::ArrayView<const UnsignedInt> rotationMappingData{
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
reinterpret_cast<const UnsignedInt*>(data.data() + 0x24), 3};
Containers::ArrayView<const Complex> rotationFieldData{
reinterpret_cast<const Complex*>(data.data() + 0x30), 3};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::ArrayView<const UnsignedInt> scalingMappingData{
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
reinterpret_cast<const UnsignedInt*>(data.data() + 0x48), 3};
Containers::ArrayView<const Vector2> scalingFieldData{
reinterpret_cast<const Vector2*>(data.data() + 0x54), 3};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData translations{SceneField::Translation, translationMappingData, translationFieldData};
SceneFieldData rotationsDifferent{SceneField::Rotation, rotationMappingData, rotationFieldData};
SceneFieldData scalingsDifferent{SceneField::Scaling, scalingMappingData, scalingFieldData};
Adapt to Corrade changes.
4 years ago
SceneFieldData rotationsSameButLess{SceneField::Rotation, translationMappingData.exceptSuffix(1), rotationFieldData.exceptSuffix(1)};
SceneFieldData scalingsSameButLess{SceneField::Scaling, translationMappingData.exceptSuffix(2), scalingFieldData.exceptSuffix(2)};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* Test that all pairs get checked */
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData{SceneMappingType::UnsignedInt, 3, {}, data, {translations, rotationsDifferent}};
SceneData{SceneMappingType::UnsignedInt, 3, {}, data, {translations, scalingsDifferent}};
SceneData{SceneMappingType::UnsignedInt, 3, {}, data, {rotationsDifferent, scalingsDifferent}};
SceneData{SceneMappingType::UnsignedInt, 3, {}, data, {translations, rotationsSameButLess}};
SceneData{SceneMappingType::UnsignedInt, 3, {}, data, {translations, scalingsSameButLess}};
SceneData{SceneMappingType::UnsignedInt, 3, {}, data, {rotationsSameButLess, scalingsSameButLess}};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData: Trade::SceneField::Rotation mapping data [0xcafe0024:0xcafe0030] is different from Trade::SceneField::Translation mapping data [0xcafe0000:0xcafe000c]\n"
"Trade::SceneData: Trade::SceneField::Scaling mapping data [0xcafe0048:0xcafe0054] is different from Trade::SceneField::Translation mapping data [0xcafe0000:0xcafe000c]\n"
"Trade::SceneData: Trade::SceneField::Scaling mapping data [0xcafe0048:0xcafe0054] is different from Trade::SceneField::Rotation mapping data [0xcafe0024:0xcafe0030]\n"
"Trade::SceneData: Trade::SceneField::Rotation mapping data [0xcafe0000:0xcafe0008] is different from Trade::SceneField::Translation mapping data [0xcafe0000:0xcafe000c]\n"
"Trade::SceneData: Trade::SceneField::Scaling mapping data [0xcafe0000:0xcafe0004] is different from Trade::SceneField::Translation mapping data [0xcafe0000:0xcafe000c]\n"
"Trade::SceneData: Trade::SceneField::Scaling mapping data [0xcafe0000:0xcafe0004] is different from Trade::SceneField::Rotation mapping data [0xcafe0000:0xcafe0008]\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
template<class> struct NameTraits;
#define _c(format) template<> struct NameTraits<format> { \
static const char* name() { return #format; } \
};
_c(UnsignedByte)
_c(Byte)
_c(UnsignedShort)
_c(Short)
_c(UnsignedInt)
_c(Int)
_c(UnsignedLong)
_c(Long)
_c(Float)
_c(Double)
_c(Vector2)
_c(Vector2d)
_c(Vector3)
_c(Vector3d)
_c(Matrix3)
_c(Matrix3d)
Trade: allow SceneField::Transformation to be a 3x2 or a 4x3 matrix. Another thought I had was about allowing a 2x2 / 3x3 matrix to be used for rotation, but there's the ambiguity with it possibly containing scaling / shear / whatever, which would then cause EXPLODING HEADACHES when converting to quaternions / complex numbers.
5 years ago
_c(Matrix3x2)
_c(Matrix3x2d)
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
_c(Matrix4)
_c(Matrix4d)
Trade: allow SceneField::Transformation to be a 3x2 or a 4x3 matrix. Another thought I had was about allowing a 2x2 / 3x3 matrix to be used for rotation, but there's the ambiguity with it possibly containing scaling / shear / whatever, which would then cause EXPLODING HEADACHES when converting to quaternions / complex numbers.
5 years ago
_c(Matrix4x3)
_c(Matrix4x3d)
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
_c(Complex)
_c(Complexd)
_c(Quaternion)
_c(Quaterniond)
_c(DualComplex)
_c(DualComplexd)
_c(DualQuaternion)
_c(DualQuaterniond)
template<class T> struct NameTraits<const T*> {
static const char* name() { return "Pointer"; }
};
template<class T> struct NameTraits<T*> {
static const char* name() { return "MutablePointer"; }
};
#undef _c
template<class T> void SceneDataTest::constructMismatchedTRSDimensionality() {
setTestCaseTemplateName(NameTraits<T>::name());
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData transformationMatrices2D{SceneField::Transformation, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Matrix3<T>>::type(), nullptr};
SceneFieldData transformationRectangularMatrices2D{SceneField::Transformation, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Matrix3x2<T>>::type(), nullptr};
SceneFieldData transformations2D{SceneField::Transformation, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::DualComplex<T>>::type(), nullptr};
SceneFieldData transformationMatrices3D{SceneField::Transformation, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Matrix4<T>>::type(), nullptr};
SceneFieldData transformationRectangularMatrices3D{SceneField::Transformation, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Matrix4x3<T>>::type(), nullptr};
SceneFieldData transformations3D{SceneField::Transformation, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::DualQuaternion<T>>::type(), nullptr};
SceneFieldData translations2D{SceneField::Translation, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Vector2<T>>::type(), nullptr};
SceneFieldData translations3D{SceneField::Translation, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Vector3<T>>::type(), nullptr};
SceneFieldData rotations2D{SceneField::Rotation, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Complex<T>>::type(), nullptr};
SceneFieldData rotations3D{SceneField::Rotation, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Quaternion<T>>::type(), nullptr};
SceneFieldData scalings2D{SceneField::Scaling, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Vector2<T>>::type(), nullptr};
SceneFieldData scalings3D{SceneField::Scaling, SceneMappingType::UnsignedInt, nullptr, Implementation::SceneFieldTypeFor<Math::Vector3<T>>::type(), nullptr};
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
/* Test that all pairs get checked */
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationMatrices2D, translations3D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationMatrices2D, rotations3D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationMatrices2D, scalings3D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationRectangularMatrices2D, translations3D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationRectangularMatrices2D, rotations3D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationRectangularMatrices2D, scalings3D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformations2D, translations3D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformations2D, rotations3D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformations2D, scalings3D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {translations2D, rotations3D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {translations2D, scalings3D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {rotations2D, scalings3D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationMatrices3D, translations2D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationMatrices3D, rotations2D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationMatrices3D, scalings2D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationRectangularMatrices3D, translations2D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationRectangularMatrices3D, rotations2D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformationRectangularMatrices3D, scalings2D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformations3D, translations2D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformations3D, rotations2D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {transformations3D, scalings2D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {translations3D, rotations2D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {translations3D, scalings2D}};
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {rotations3D, scalings2D}};
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
CORRADE_COMPARE(out.str(), Utility::formatString(
"Trade::SceneData: expected a 2D translation field but got Trade::SceneFieldType::{0}\n"
"Trade::SceneData: expected a 2D rotation field but got Trade::SceneFieldType::{1}\n"
"Trade::SceneData: expected a 2D scaling field but got Trade::SceneFieldType::{0}\n"
Trade: allow SceneField::Transformation to be a 3x2 or a 4x3 matrix. Another thought I had was about allowing a 2x2 / 3x3 matrix to be used for rotation, but there's the ambiguity with it possibly containing scaling / shear / whatever, which would then cause EXPLODING HEADACHES when converting to quaternions / complex numbers.
5 years ago
"Trade::SceneData: expected a 2D translation field but got Trade::SceneFieldType::{0}\n"
"Trade::SceneData: expected a 2D rotation field but got Trade::SceneFieldType::{1}\n"
"Trade::SceneData: expected a 2D scaling field but got Trade::SceneFieldType::{0}\n"
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
"Trade::SceneData: expected a 2D translation field but got Trade::SceneFieldType::{0}\n"
"Trade::SceneData: expected a 2D rotation field but got Trade::SceneFieldType::{1}\n"
"Trade::SceneData: expected a 2D scaling field but got Trade::SceneFieldType::{0}\n"
"Trade::SceneData: expected a 2D rotation field but got Trade::SceneFieldType::{1}\n"
"Trade::SceneData: expected a 2D scaling field but got Trade::SceneFieldType::{0}\n"
"Trade::SceneData: expected a 2D scaling field but got Trade::SceneFieldType::{0}\n"
"Trade::SceneData: expected a 3D translation field but got Trade::SceneFieldType::{2}\n"
"Trade::SceneData: expected a 3D rotation field but got Trade::SceneFieldType::{3}\n"
"Trade::SceneData: expected a 3D scaling field but got Trade::SceneFieldType::{2}\n"
Trade: allow SceneField::Transformation to be a 3x2 or a 4x3 matrix. Another thought I had was about allowing a 2x2 / 3x3 matrix to be used for rotation, but there's the ambiguity with it possibly containing scaling / shear / whatever, which would then cause EXPLODING HEADACHES when converting to quaternions / complex numbers.
5 years ago
"Trade::SceneData: expected a 3D translation field but got Trade::SceneFieldType::{2}\n"
"Trade::SceneData: expected a 3D rotation field but got Trade::SceneFieldType::{3}\n"
"Trade::SceneData: expected a 3D scaling field but got Trade::SceneFieldType::{2}\n"
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
"Trade::SceneData: expected a 3D translation field but got Trade::SceneFieldType::{2}\n"
"Trade::SceneData: expected a 3D rotation field but got Trade::SceneFieldType::{3}\n"
"Trade::SceneData: expected a 3D scaling field but got Trade::SceneFieldType::{2}\n"
"Trade::SceneData: expected a 3D rotation field but got Trade::SceneFieldType::{3}\n"
"Trade::SceneData: expected a 3D scaling field but got Trade::SceneFieldType::{2}\n"
"Trade::SceneData: expected a 3D scaling field but got Trade::SceneFieldType::{2}\n",
NameTraits<Math::Vector3<T>>::name(),
NameTraits<Math::Quaternion<T>>::name(),
NameTraits<Math::Vector2<T>>::name(),
NameTraits<Math::Complex<T>>::name()));
}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void SceneDataTest::constructMismatchedMeshMaterialView() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Containers::ArrayView<const char> data{reinterpret_cast<char*>(0xcafe0000),
/* Three entries, each having mesh/material ID and 2 object IDs */
3*(8 + 8)};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::ArrayView<const UnsignedInt> meshMappingData{
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
reinterpret_cast<const UnsignedInt*>(data.data()), 3};
Containers::ArrayView<const UnsignedInt> meshFieldData{
reinterpret_cast<const UnsignedInt*>(data.data() + 0x0c), 3};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::ArrayView<const UnsignedInt> meshMaterialMappingData{
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
reinterpret_cast<const UnsignedInt*>(data.data() + 0x18), 3};
Trade: make SceneField::MeshMaterial signed. Because the material index has to share the object mapping with a mesh, there needs to be a way to express meshes without associated materials.
5 years ago
Containers::ArrayView<const Int> meshMaterialFieldData{
reinterpret_cast<const Int*>(data.data() + 0x24), 3};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData meshes{SceneField::Mesh, meshMappingData, meshFieldData};
SceneFieldData meshMaterialsDifferent{SceneField::MeshMaterial, meshMaterialMappingData, meshMaterialFieldData};
Adapt to Corrade changes.
4 years ago
SceneFieldData meshMaterialsSameButLess{SceneField::MeshMaterial, meshMappingData.exceptSuffix(1), meshMaterialFieldData.exceptSuffix(1)};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData{SceneMappingType::UnsignedInt, 3, {}, data, {meshes, meshMaterialsDifferent}};
SceneData{SceneMappingType::UnsignedInt, 3, {}, data, {meshes, meshMaterialsSameButLess}};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData: Trade::SceneField::MeshMaterial mapping data [0xcafe0018:0xcafe0024] is different from Trade::SceneField::Mesh mapping data [0xcafe0000:0xcafe000c]\n"
"Trade::SceneData: Trade::SceneField::MeshMaterial mapping data [0xcafe0000:0xcafe0008] is different from Trade::SceneField::Mesh mapping data [0xcafe0000:0xcafe000c]\n");
Trade: test construction and assignments of the container classes.
10 years ago
}
Trade: SceneField::Skin now requires a transformation to be present. Even an empty field, it's there just to disambiguate whether the skin is 2D or 3D.
5 years ago
void SceneDataTest::constructAmbiguousSkinDimensions() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: SceneField::Skin now requires a transformation to be present. Even an empty field, it's there just to disambiguate whether the skin is 2D or 3D.
5 years ago
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {
SceneFieldData{SceneField::Skin, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::UnsignedInt, nullptr}
Trade: SceneField::Skin now requires a transformation to be present. Even an empty field, it's there just to disambiguate whether the skin is 2D or 3D.
5 years ago
}};
CORRADE_COMPARE(out.str(), "Trade::SceneData: a skin field requires some transformation field to be present in order to disambiguate between 2D and 3D\n");
}
Trade: test construction and assignments of the container classes.
10 years ago
void SceneDataTest::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<SceneData>{});
CORRADE_VERIFY(!std::is_copy_assignable<SceneData>{});
Trade: test construction and assignments of the container classes.
10 years ago
}
void SceneDataTest::constructMove() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
struct Mesh {
UnsignedShort object;
UnsignedInt mesh;
};
Trade: test construction and assignments of the container classes.
10 years ago
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Containers::Array<char> data{NoInit, 3*sizeof(Mesh)};
auto meshData = Containers::arrayCast<Mesh>(data);
meshData[0] = {0, 2};
meshData[1] = {73, 1};
meshData[2] = {122, 2};
Trade: test construction and assignments of the container classes.
10 years ago
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
int importerState;
SceneFieldData meshes{SceneField::Mesh, stridedArrayView(meshData).slice(&Mesh::object), stridedArrayView(meshData).slice(&Mesh::mesh)};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData a{SceneMappingType::UnsignedShort, 15, std::move(data), {meshes}, &importerState};
Trade: test construction and assignments of the container classes.
10 years ago
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneData b{std::move(a)};
CORRADE_COMPARE(b.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(b.mappingBound(), 15);
CORRADE_COMPARE(b.mappingType(), SceneMappingType::UnsignedShort);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(b.fieldCount(), 1);
CORRADE_COMPARE(b.importerState(), &importerState);
CORRADE_COMPARE(static_cast<const void*>(b.data()), meshData.data());
CORRADE_COMPARE(b.fieldName(0), SceneField::Mesh);
CORRADE_COMPARE(b.fieldType(0), SceneFieldType::UnsignedInt);
CORRADE_COMPARE(b.fieldSize(0), 3);
CORRADE_COMPARE(b.fieldArraySize(0), 0);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(b.mapping<UnsignedShort>(0)[2], 122);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(b.field<UnsignedInt>(0)[2], 2);
Trade: test construction and assignments of the container classes.
10 years ago
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData c{SceneMappingType::UnsignedByte, 76, nullptr, {}};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
c = std::move(b);
CORRADE_COMPARE(c.dataFlags(), DataFlag::Owned|DataFlag::Mutable);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(c.mappingBound(), 15);
CORRADE_COMPARE(c.mappingType(), SceneMappingType::UnsignedShort);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(c.fieldCount(), 1);
CORRADE_COMPARE(c.importerState(), &importerState);
CORRADE_COMPARE(static_cast<const void*>(c.data()), meshData.data());
CORRADE_COMPARE(c.fieldName(0), SceneField::Mesh);
CORRADE_COMPARE(c.fieldType(0), SceneFieldType::UnsignedInt);
CORRADE_COMPARE(c.fieldSize(0), 3);
CORRADE_COMPARE(c.fieldArraySize(0), 0);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(c.mapping<UnsignedShort>(0)[2], 122);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(c.field<UnsignedInt>(0)[2], 2);
Trade: test that all *Data move constructors/assignments are noexcept.
7 years ago
CORRADE_VERIFY(std::is_nothrow_move_constructible<SceneData>::value);
CORRADE_VERIFY(std::is_nothrow_move_assignable<SceneData>::value);
Trade: test construction and assignments of the container classes.
10 years ago
}
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
void SceneDataTest::findFieldId() {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 0, {}, nullptr, {
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::UnsignedByte, nullptr}
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
}};
CORRADE_COMPARE(scene.findFieldId(SceneField::Parent), 0);
CORRADE_COMPARE(scene.findFieldId(SceneField::Mesh), 1);
CORRADE_COMPARE(scene.findFieldId(SceneField::MeshMaterial), Containers::NullOpt);
CORRADE_COMPARE(scene.fieldId(SceneField::Parent), 0);
CORRADE_COMPARE(scene.fieldId(SceneField::Mesh), 1);
CORRADE_VERIFY(scene.hasField(SceneField::Parent));
CORRADE_VERIFY(scene.hasField(SceneField::Mesh));
CORRADE_VERIFY(!scene.hasField(SceneField::MeshMaterial));
}
template<class T> void SceneDataTest::findFieldObjectOffset() {
setTestCaseTemplateName(NameTraits<T>::name());
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
auto&& data = FindFieldObjectOffsetData[testCaseInstanceId()];
setTestCaseDescription(data.name);
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
struct Field {
T object;
UnsignedInt mesh;
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
} fields[5]{
{T(data.mapping[0]), 0},
{T(data.mapping[1]), 0},
{T(data.mapping[2]), 0},
{T(data.mapping[3]), 0},
{T(data.mapping[4]), 0}
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{Implementation::sceneMappingTypeFor<T>(), 7, {}, fields, {
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
/* Test also with a completely empty field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, Implementation::sceneMappingTypeFor<T>(), nullptr, SceneFieldType::Int, nullptr},
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh), data.flags}
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
}};
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
/* An empty field should not find anything for any query with any flags */
if(data.offset == 0) {
CORRADE_COMPARE(scene.findFieldObjectOffset(0, data.object), Containers::NullOpt);
CORRADE_COMPARE(scene.findFieldObjectOffset(SceneField::Parent, data.object), Containers::NullOpt);
CORRADE_VERIFY(!scene.hasFieldObject(0, data.object));
CORRADE_VERIFY(!scene.hasFieldObject(SceneField::Parent, data.object));
}
CORRADE_COMPARE(scene.findFieldObjectOffset(1, data.object, data.offset), data.expected);
CORRADE_COMPARE(scene.findFieldObjectOffset(SceneField::Mesh, data.object, data.offset), data.expected);
if(data.offset == 0) {
CORRADE_COMPARE(scene.hasFieldObject(1, data.object), !!data.expected);
CORRADE_COMPARE(scene.hasFieldObject(SceneField::Mesh, data.object), !!data.expected);
}
if(data.expected) {
CORRADE_COMPARE(scene.fieldObjectOffset(1, data.object, data.offset), *data.expected);
CORRADE_COMPARE(scene.fieldObjectOffset(SceneField::Mesh, data.object, data.offset), *data.expected);
}
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
}
void SceneDataTest::findFieldObjectOffsetInvalidOffset() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
struct Field {
UnsignedInt object;
UnsignedInt mesh;
} fields[]{
{4, 1},
{1, 3},
{2, 4}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)}
}};
std::ostringstream out;
Error redirectError{&out};
scene.findFieldObjectOffset(0, 1, 4);
scene.findFieldObjectOffset(SceneField::Mesh, 1, 4);
scene.fieldObjectOffset(0, 1, 4);
scene.fieldObjectOffset(SceneField::Mesh, 1, 4);
CORRADE_COMPARE(out.str(),
"Trade::SceneData::findFieldObjectOffset(): offset 4 out of bounds for a field of size 3\n"
"Trade::SceneData::findFieldObjectOffset(): offset 4 out of bounds for a field of size 3\n"
"Trade::SceneData::fieldObjectOffset(): offset 4 out of bounds for a field of size 3\n"
"Trade::SceneData::fieldObjectOffset(): offset 4 out of bounds for a field of size 3\n");
}
void SceneDataTest::fieldObjectOffsetNotFound() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
struct Field {
UnsignedInt object;
UnsignedInt mesh;
} fields[]{
{4, 1},
{1, 3},
{2, 4},
{0, 5},
{2, 5}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
/* Test also with a completely empty field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)}
}};
std::ostringstream out;
Error redirectError{&out};
scene.fieldObjectOffset(0, 4);
scene.fieldObjectOffset(SceneField::Parent, 4);
scene.fieldObjectOffset(1, 1, 2);
scene.fieldObjectOffset(SceneField::Mesh, 1, 2);
CORRADE_COMPARE(out.str(),
"Trade::SceneData::fieldObjectOffset(): object 4 not found in field Trade::SceneField::Parent starting at offset 0\n"
"Trade::SceneData::fieldObjectOffset(): object 4 not found in field Trade::SceneField::Parent starting at offset 0\n"
"Trade::SceneData::fieldObjectOffset(): object 1 not found in field Trade::SceneField::Mesh starting at offset 2\n"
"Trade::SceneData::fieldObjectOffset(): object 1 not found in field Trade::SceneField::Mesh starting at offset 2\n");
}
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
template<class T> void SceneDataTest::mappingAsArrayByIndex() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
setTestCaseTemplateName(NameTraits<T>::name());
struct Field {
T object;
UnsignedByte mesh;
} fields[]{
{T(15), 0},
{T(37), 1},
{T(44), 15}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{Implementation::sceneMappingTypeFor<T>(), 50, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, Implementation::sceneMappingTypeFor<T>(), nullptr, SceneFieldType::Int, nullptr},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)}
}};
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE_AS(scene.mappingAsArray(1),
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Containers::arrayView<UnsignedInt>({15, 37, 44}),
TestSuite::Compare::Container);
}
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
template<class T> void SceneDataTest::mappingAsArrayByName() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
setTestCaseTemplateName(NameTraits<T>::name());
struct Field {
T object;
UnsignedByte mesh;
} fields[]{
{T(15), 0},
{T(37), 1},
{T(44), 15}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{Implementation::sceneMappingTypeFor<T>(), 50, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, Implementation::sceneMappingTypeFor<T>(), nullptr, SceneFieldType::Int, nullptr},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)}
}};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE_AS(scene.mappingAsArray(SceneField::Mesh),
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
Containers::arrayView<UnsignedInt>({15, 37, 44}),
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
TestSuite::Compare::Container);
}
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
void SceneDataTest::mappingIntoArrayByIndex() {
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
auto&& data = IntoArrayOffsetData[testCaseInstanceId()];
setTestCaseDescription(data.name);
/* Both AsArray() and Into() share a common helper. The AsArray() test
above verified handling of various data types and this checks the
offset/size parameters of the Into() variant. */
struct Field {
UnsignedInt object;
UnsignedInt mesh;
} fields[] {
{15, 0},
{37, 1},
{44, 15}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 50, {}, fields, {
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
SceneFieldData{SceneField::Mesh,
view.slice(&Field::object),
view.slice(&Field::mesh)},
}};
/* The offset-less overload should give back all data */
{
UnsignedInt out[3];
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
scene.mappingInto(1, out);
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
CORRADE_COMPARE_AS(Containers::stridedArrayView(out),
view.slice(&Field::object),
TestSuite::Compare::Container);
/* The offset variant only a subset */
} {
Containers::Array<UnsignedInt> out{data.size};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(scene.mappingInto(1, data.offset, out), data.expectedSize);
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
CORRADE_COMPARE_AS(out.prefix(data.expectedSize),
view.slice(&Field::object)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
}
}
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
void SceneDataTest::mappingIntoArrayByName() {
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
auto&& data = IntoArrayOffsetData[testCaseInstanceId()];
setTestCaseDescription(data.name);
/* Both AsArray() and Into() share a common helper. The AsArray() test
above verified handling of various data types and this checks the
offset/size parameters of the Into() variant. */
struct Field {
UnsignedInt object;
UnsignedInt mesh;
} fields[] {
{15, 0},
{37, 1},
{44, 15}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 50, {}, fields, {
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
SceneFieldData{SceneField::Mesh,
view.slice(&Field::object),
view.slice(&Field::mesh)},
}};
/* The offset-less overload should give back all data */
{
UnsignedInt out[3];
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
scene.mappingInto(SceneField::Mesh, out);
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
CORRADE_COMPARE_AS(Containers::stridedArrayView(out),
view.slice(&Field::object),
TestSuite::Compare::Container);
/* The offset variant only a subset */
} {
Containers::Array<UnsignedInt> out{data.size};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(scene.mappingInto(SceneField::Mesh, data.offset, out), data.expectedSize);
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
CORRADE_COMPARE_AS(out.prefix(data.expectedSize),
view.slice(&Field::object)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
}
}
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
void SceneDataTest::mappingIntoArrayInvalidSizeOrOffset() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
struct Field {
UnsignedInt object;
UnsignedByte mesh;
} fields[3]{};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)}
}};
std::ostringstream out;
Error redirectError{&out};
UnsignedInt destination[2];
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
scene.mappingInto(0, destination);
scene.mappingInto(SceneField::Mesh, destination);
scene.mappingInto(0, 4, destination);
scene.mappingInto(SceneField::Mesh, 4, destination);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::mappingInto(): expected a view with 3 elements but got 2\n"
"Trade::SceneData::mappingInto(): expected a view with 3 elements but got 2\n"
"Trade::SceneData::mappingInto(): offset 4 out of bounds for a field of size 3\n"
"Trade::SceneData::mappingInto(): offset 4 out of bounds for a field of size 3\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
template<class T> void SceneDataTest::parentsAsArray() {
setTestCaseTemplateName(NameTraits<T>::name());
struct Field {
UnsignedByte object;
T parent;
} fields[]{
{0, T(15)},
{1, T(-1)},
{15, T(44)}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedByte, 50, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::UnsignedInt, nullptr},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Parent, view.slice(&Field::object), view.slice(&Field::parent)}
}};
Trade: avoid double lookup in SceneData::fooAsArray(). These need to query field size for allocating the output array which means looking up the field by name, but the same lookup was then done again in the fooInto() implementation.
5 years ago
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.parentsAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Int>>({
{0, 15},
{1, -1},
{15, 44}
})), TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
void SceneDataTest::parentsIntoArray() {
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
auto&& data = IntoArrayOffset1Data[testCaseInstanceId()];
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
setTestCaseDescription(data.name);
/* Both AsArray() and Into() share a common helper. The AsArray() test
above verified handling of various data types and this checks the
offset/size parameters of the Into() variant. */
struct Field {
UnsignedInt object;
Int parent;
} fields[] {
{1, 15},
{0, -1},
{4, 44}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Mesh, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::UnsignedInt, nullptr},
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
SceneFieldData{SceneField::Parent,
view.slice(&Field::object),
view.slice(&Field::parent)},
}};
/* The offset-less overload should give back all data */
{
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mapping[3];
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Int field[3];
scene.parentsInto(
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? Containers::arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field ? Containers::arrayView(field) : nullptr
);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object),
TestSuite::Compare::Container);
if(data.field) CORRADE_COMPARE_AS(Containers::stridedArrayView(field),
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
view.slice(&Field::parent),
TestSuite::Compare::Container);
/* The offset variant only a subset */
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::Array<UnsignedInt> mapping{data.size};
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Containers::Array<Int> field{data.size};
CORRADE_COMPARE(scene.parentsInto(data.offset,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field ? arrayView(field) : nullptr
), data.expectedSize);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
if(data.field) CORRADE_COMPARE_AS(field.prefix(data.expectedSize),
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
view.slice(&Field::parent)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
}
}
void SceneDataTest::parentsIntoArrayInvalidSizeOrOffset() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
struct Field {
UnsignedInt object;
Int parent;
} fields[3]{};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Parent, view.slice(&Field::object), view.slice(&Field::parent)}
}};
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mappingDestinationCorrect[3];
UnsignedInt mappingDestination[2];
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Int fieldDestinationCorrect[3];
Int fieldDestination[2];
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
scene.parentsInto(mappingDestination, fieldDestinationCorrect);
scene.parentsInto(mappingDestinationCorrect, fieldDestination);
scene.parentsInto(4, mappingDestination, fieldDestination);
scene.parentsInto(0, mappingDestinationCorrect, fieldDestination);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::parentsInto(): expected mapping destination view either empty or with 3 elements but got 2\n"
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
"Trade::SceneData::parentsInto(): expected field destination view either empty or with 3 elements but got 2\n"
"Trade::SceneData::parentsInto(): offset 4 out of bounds for a field of size 3\n"
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::parentsInto(): mapping and field destination views have different size, 3 vs 2\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: allow SceneField::Transformation to be a 3x2 or a 4x3 matrix. Another thought I had was about allowing a 2x2 / 3x3 matrix to be used for rotation, but there's the ambiguity with it possibly containing scaling / shear / whatever, which would then cause EXPLODING HEADACHES when converting to quaternions / complex numbers.
5 years ago
template<class T> struct TransformationTypeFor {
typedef T Type;
};
template<class T> struct TransformationTypeFor<Math::Matrix3x2<T>> {
typedef Math::Matrix3<T> Type;
};
template<class T> struct TransformationTypeFor<Math::Matrix4x3<T>> {
typedef Math::Matrix4<T> Type;
};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
template<class T> void SceneDataTest::transformations2DAsArray() {
setTestCaseTemplateName(NameTraits<T>::name());
typedef typename T::Type U;
Trade: allow SceneField::Transformation to be a 3x2 or a 4x3 matrix. Another thought I had was about allowing a 2x2 / 3x3 matrix to be used for rotation, but there's the ambiguity with it possibly containing scaling / shear / whatever, which would then cause EXPLODING HEADACHES when converting to quaternions / complex numbers.
5 years ago
typedef typename TransformationTypeFor<T>::Type TT;
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
struct Transformation {
UnsignedInt object;
T transformation;
};
struct Component {
UnsignedInt object;
Vector2 translation;
Vector2 scaling;
};
Containers::StridedArrayView1D<Transformation> transformations;
Containers::StridedArrayView1D<Component> components;
Containers::Array<char> data = Containers::ArrayTuple{
{NoInit, 4, transformations},
{NoInit, 2, components}
};
Trade: allow SceneField::Transformation to be a 3x2 or a 4x3 matrix. Another thought I had was about allowing a 2x2 / 3x3 matrix to be used for rotation, but there's the ambiguity with it possibly containing scaling / shear / whatever, which would then cause EXPLODING HEADACHES when converting to quaternions / complex numbers.
5 years ago
transformations[0] = {1, T{TT::translation({U(3.0), U(2.0)})}};
transformations[1] = {0, T{TT::rotation(Math::Deg<U>(35.0))}};
transformations[2] = {4, T{TT::translation({U(1.5), U(2.5)})*
TT::rotation(Math::Deg<U>(-15.0))}};
transformations[3] = {5, T{TT::rotation(Math::Deg<U>(-15.0))*
TT::translation({U(1.5), U(2.5)})}};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* Object number 4 additionally has a scaling component (which isn't
representable with dual complex numbers). It currently doesn't get added
to the transformations returned from transformations2DInto() but that
may change in the future for dual complex numbers). The translation
component is then *assumed* to be equivalent to what's stored in the
Transformation field and so applied neither. Here it's different, and
that shouldn't affect anything. */
components[0] = {4, {-1.5f, -2.5f}, {2.0f, 5.0f}};
/* This is deliberately an error -- specifying a TRS for an object that
doesn't have a Transformation field. Since there's no fast way to check
for those and error/warn on those, they get just ignored. */
components[1] = {2, {3.5f, -1.0f}, {1.0f, 1.5f}};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 6, std::move(data), {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Transformation,
transformations.slice(&Transformation::object),
transformations.slice(&Transformation::transformation)},
SceneFieldData{SceneField::Translation,
components.slice(&Component::object),
components.slice(&Component::translation)},
SceneFieldData{SceneField::Scaling,
components.slice(&Component::object),
components.slice(&Component::scaling)},
}};
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
CORRADE_VERIFY(scene.is2D());
CORRADE_VERIFY(!scene.is3D());
Trade: add SceneData::transformationFieldSize().
4 years ago
CORRADE_COMPARE(scene.transformationFieldSize(), 4);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.transformations2DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Matrix3>>({
{1, Matrix3::translation({3.0f, 2.0f})},
{0, Matrix3::rotation(35.0_degf)},
{4, Matrix3::translation({1.5f, 2.5f})*Matrix3::rotation(-15.0_degf)},
{5, Matrix3::rotation(-15.0_degf)*Matrix3::translation({1.5f, 2.5f})}
})), TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: SceneData TRS components can each have different type, test that.
5 years ago
template<class T, class U, class V> void SceneDataTest::transformations2DAsArrayTRS() {
setTestCaseTemplateName({NameTraits<T>::name(), NameTraits<U>::name(), NameTraits<V>::name()});
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
struct Field {
UnsignedInt object;
Math::Vector2<T> translation;
Trade: SceneData TRS components can each have different type, test that.
5 years ago
Math::Complex<U> rotation;
Math::Vector2<V> scaling;
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
} fields[]{
{1, {T(3.0), T(2.0)},
{},
Trade: SceneData TRS components can each have different type, test that.
5 years ago
{V(1.0), V(1.0)}},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
{0, {},
Trade: SceneData TRS components can each have different type, test that.
5 years ago
Math::Complex<U>::rotation(Math::Deg<U>{U(35.0)}),
{V(1.0), V(1.0)}},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
{2, {}, /* Identity transformation here */
{},
Trade: SceneData TRS components can each have different type, test that.
5 years ago
{V(1.0), V(1.0)}},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
{4, {},
{},
Trade: SceneData TRS components can each have different type, test that.
5 years ago
{V(2.0), V(1.0)}},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
{7, {T(1.5), T(2.5)},
Trade: SceneData TRS components can each have different type, test that.
5 years ago
Math::Complex<U>::rotation(Math::Deg<U>{U(-15.0)}),
{V(-0.5), V(4.0)}},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
};
Containers::StridedArrayView1D<Field> view = fields;
SceneFieldData translation{SceneField::Translation,
view.slice(&Field::object),
view.slice(&Field::translation)};
SceneFieldData rotation{SceneField::Rotation,
view.slice(&Field::object),
view.slice(&Field::rotation)};
SceneFieldData scaling{SceneField::Scaling,
view.slice(&Field::object),
view.slice(&Field::scaling)};
/* Just one of translation / rotation / scaling */
{
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
translation
}};
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
CORRADE_VERIFY(scene.is2D());
CORRADE_VERIFY(!scene.is3D());
Trade: add SceneData::transformationFieldSize().
4 years ago
CORRADE_COMPARE(scene.transformationFieldSize(), 5);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.transformations2DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Matrix3>>({
{1, Matrix3::translation({3.0f, 2.0f})},
{0, Matrix3{Math::IdentityInit}},
{2, Matrix3{Math::IdentityInit}},
{4, Matrix3{Math::IdentityInit}},
{7, Matrix3::translation({1.5f, 2.5f})}
})), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.translationsRotationsScalings2DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Containers::Triple<Vector2, Complex, Vector2>>>({
{1, {{3.0f, 2.0f}, {}, Vector2{1.0f}}},
{0, {{}, {}, Vector2{1.0f}}},
{2, {{}, {}, Vector2{1.0f}}},
{4, {{}, {}, Vector2{1.0f}}},
{7, {{1.5f, 2.5f}, {}, Vector2{1.0f}}},
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
})), TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
rotation
}};
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
CORRADE_VERIFY(scene.is2D());
CORRADE_VERIFY(!scene.is3D());
Trade: add SceneData::transformationFieldSize().
4 years ago
CORRADE_COMPARE(scene.transformationFieldSize(), 5);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.transformations2DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Matrix3>>({
{1, Matrix3{Math::IdentityInit}},
{0, Matrix3::rotation(35.0_degf)},
{2, Matrix3{Math::IdentityInit}},
{4, Matrix3{Math::IdentityInit}},
{7, Matrix3::rotation(-15.0_degf)}
})), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.translationsRotationsScalings2DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Containers::Triple<Vector2, Complex, Vector2>>>({
{1, {{}, {}, Vector2{1.0f}}},
{0, {{}, Complex::rotation(35.0_degf), Vector2{1.0f}}},
{2, {{}, {}, Vector2{1.0f}}},
{4, {{}, {}, Vector2{1.0f}}},
{7, {{}, Complex::rotation(-15.0_degf), Vector2{1.0f}}},
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
})), TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
scaling
}};
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
CORRADE_VERIFY(scene.is2D());
CORRADE_VERIFY(!scene.is3D());
Trade: add SceneData::transformationFieldSize().
4 years ago
CORRADE_COMPARE(scene.transformationFieldSize(), 5);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.transformations2DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Matrix3>>({
{1, Matrix3{Math::IdentityInit}},
{0, Matrix3{Math::IdentityInit}},
{2, Matrix3{Math::IdentityInit}},
{4, Matrix3::scaling({2.0f, 1.0f})},
{7, Matrix3::scaling({-0.5f, 4.0f})}
})), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.translationsRotationsScalings2DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Containers::Triple<Vector2, Complex, Vector2>>>({
{1, {{}, {}, Vector2{1.0f}}},
{0, {{}, {}, Vector2{1.0f}}},
{2, {{}, {}, Vector2{1.0f}}},
{4, {{}, {}, {2.0f, 1.0f}}},
{7, {{}, {}, {-0.5f, 4.0f}}},
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
})), TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
/* Pairs */
{
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
translation,
rotation
}};
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
CORRADE_VERIFY(scene.is2D());
CORRADE_VERIFY(!scene.is3D());
Trade: add SceneData::transformationFieldSize().
4 years ago
CORRADE_COMPARE(scene.transformationFieldSize(), 5);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.transformations2DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Matrix3>>({
{1, Matrix3::translation({3.0f, 2.0f})},
{0, Matrix3::rotation(35.0_degf)},
{2, Matrix3{Math::IdentityInit}},
{4, Matrix3{Math::IdentityInit}},
{7, Matrix3::translation({1.5f, 2.5f})*Matrix3::rotation({-15.0_degf})}
})), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.translationsRotationsScalings2DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Containers::Triple<Vector2, Complex, Vector2>>>({
{1, {{3.0f, 2.0f}, {}, Vector2{1.0f}}},
{0, {{}, Complex::rotation(35.0_degf), Vector2{1.0f}}},
{2, {{}, {}, Vector2{1.0f}}},
{4, {{}, {}, Vector2{1.0f}}},
{7, {{1.5f, 2.5f}, Complex::rotation(-15.0_degf), Vector2{1.0f}}},
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
})), TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
translation,
scaling
}};
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
CORRADE_VERIFY(scene.is2D());
CORRADE_VERIFY(!scene.is3D());
Trade: add SceneData::transformationFieldSize().
4 years ago
CORRADE_COMPARE(scene.transformationFieldSize(), 5);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.transformations2DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Matrix3>>({
{1, Matrix3::translation({3.0f, 2.0f})},
{0, Matrix3{Math::IdentityInit}},
{2, Matrix3{Math::IdentityInit}},
{4, Matrix3::scaling({2.0f, 1.0f})},
{7, Matrix3::translation({1.5f, 2.5f})*Matrix3::scaling({-0.5f, 4.0f})}
})), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.translationsRotationsScalings2DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Containers::Triple<Vector2, Complex, Vector2>>>({
{1, {{3.0f, 2.0f}, {}, Vector2{1.0f}}},
{0, {{}, {}, Vector2{1.0f}}},
{2, {{}, {}, Vector2{1.0f}}},
{4, {{}, {}, {2.0f, 1.0f}}},
{7, {{1.5f, 2.5f}, {}, {-0.5f, 4.0f}}},
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
})), TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
rotation,
scaling
}};
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
CORRADE_VERIFY(scene.is2D());
CORRADE_VERIFY(!scene.is3D());
Trade: add SceneData::transformationFieldSize().
4 years ago
CORRADE_COMPARE(scene.transformationFieldSize(), 5);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.transformations2DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Matrix3>>({
{1, Matrix3{Math::IdentityInit}},
{0, Matrix3::rotation(35.0_degf)},
{2, Matrix3{Math::IdentityInit}},
{4, Matrix3::scaling({2.0f, 1.0f})},
{7, Matrix3::rotation({-15.0_degf})*Matrix3::scaling({-0.5f, 4.0f})}
})), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.translationsRotationsScalings2DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Containers::Triple<Vector2, Complex, Vector2>>>({
{1, {{}, {}, Vector2{1.0f}}},
{0, {{}, Complex::rotation(35.0_degf), Vector2{1.0f}}},
{2, {{}, {}, Vector2{1.0f}}},
{4, {{}, {}, {2.0f, 1.0f}}},
{7, {{}, Complex::rotation(-15.0_degf), {-0.5f, 4.0f}}},
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
})), TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
/* All */
{
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
translation,
rotation,
scaling
}};
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
CORRADE_VERIFY(scene.is2D());
CORRADE_VERIFY(!scene.is3D());
Trade: add SceneData::transformationFieldSize().
4 years ago
CORRADE_COMPARE(scene.transformationFieldSize(), 5);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.transformations2DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Matrix3>>({
{1, Matrix3::translation({3.0f, 2.0f})},
{0, Matrix3::rotation(35.0_degf)},
{2, Matrix3{Math::IdentityInit}},
{4, Matrix3::scaling({2.0f, 1.0f})},
{7, Matrix3::translation({1.5f, 2.5f})*Matrix3::rotation({-15.0_degf})*Matrix3::scaling({-0.5f, 4.0f})}
})), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.translationsRotationsScalings2DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Containers::Triple<Vector2, Complex, Vector2>>>({
{1, {{3.0f, 2.0f}, {}, Vector2{1.0f}}},
{0, {{}, Complex::rotation(35.0_degf), Vector2{1.0f}}},
{2, {{}, {}, Vector2{1.0f}}},
{4, {{}, {}, {2.0f, 1.0f}}},
{7, {{1.5f, 2.5f}, Complex::rotation(-15.0_degf), {-0.5f, 4.0f}}},
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
})), TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
}
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
void SceneDataTest::transformations2DAsArrayBut3DType() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
/* Because TRSAsArray() allocates an Array<Triple> and then calls
TRSInto(), which skips views that are nullptr, we wouldn't get the
assertion for translations, as those are at offset 0, which would be
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
interpreted as an empty view if there were no elements. Thus using
rotations instead. */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 0, nullptr, {
SceneFieldData{SceneField::Rotation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Quaternion, nullptr}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}};
std::ostringstream out;
Error redirectError{&out};
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
scene.transformations2DAsArray();
scene.translationsRotationsScalings2DAsArray();
CORRADE_COMPARE(out.str(),
"Trade::SceneData::transformations2DInto(): scene has a 3D transformation type\n"
"Trade::SceneData::translationsRotationsScalings2DInto(): scene has a 3D transformation type\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
void SceneDataTest::transformations2DIntoArray() {
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
auto&& data = IntoArrayOffset1Data[testCaseInstanceId()];
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
setTestCaseDescription(data.name);
/* Both AsArray() and Into() share a common helper. The AsArray() test
above verified handling of various data types and this checks the
offset/size parameters of the Into() variant. */
struct Field {
UnsignedInt object;
Matrix3 transformation;
} fields[] {
{1, Matrix3::translation({3.0f, 2.0f})*Matrix3::scaling({1.5f, 2.0f})},
{0, Matrix3::rotation(35.0_degf)},
{4, Matrix3::translation({3.0f, 2.0f})*Matrix3::rotation(35.0_degf)}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
SceneFieldData{SceneField::Transformation,
view.slice(&Field::object),
view.slice(&Field::transformation)},
}};
/* The offset-less overload should give back all data */
{
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mapping[3];
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Matrix3 field[3];
scene.transformations2DInto(
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? Containers::arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field ? Containers::arrayView(field) : nullptr
);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object),
TestSuite::Compare::Container);
if(data.field) CORRADE_COMPARE_AS(Containers::stridedArrayView(field),
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
view.slice(&Field::transformation),
TestSuite::Compare::Container);
/* The offset variant only a subset */
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::Array<UnsignedInt> mapping{data.size};
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Containers::Array<Matrix3> field{data.size};
CORRADE_COMPARE(scene.transformations2DInto(data.offset,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field ? arrayView(field) : nullptr
), data.expectedSize);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
if(data.field) CORRADE_COMPARE_AS(field.prefix(data.expectedSize),
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
view.slice(&Field::transformation)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
}
}
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
void SceneDataTest::transformations2DTRSIntoArray() {
auto&& data = IntoArrayOffset1Data[testCaseInstanceId()];
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
setTestCaseDescription(data.name);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
/* Same APIs tested as in transformations2DIntoArray(), but with a TRS
input */
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
struct Field {
UnsignedInt object;
Vector2 translation;
Complex rotation;
Vector2 scaling;
} fields[] {
{1, {3.0f, 2.0f}, {}, {1.5f, 2.0f}},
{0, {}, Complex::rotation(35.0_degf), {1.0f, 1.0f}},
{4, {3.0f, 2.0f}, Complex::rotation(35.0_degf), {1.0f, 1.0f}}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
SceneFieldData{SceneField::Translation,
view.slice(&Field::object),
view.slice(&Field::translation)},
SceneFieldData{SceneField::Rotation,
view.slice(&Field::object),
view.slice(&Field::rotation)},
SceneFieldData{SceneField::Scaling,
view.slice(&Field::object),
view.slice(&Field::scaling)},
}};
Matrix3 expected[]{
Matrix3::translation({3.0f, 2.0f})*Matrix3::scaling({1.5f, 2.0f}),
Matrix3::rotation(35.0_degf),
Matrix3::translation({3.0f, 2.0f})*Matrix3::rotation(35.0_degf)
};
/* The offset-less overload should give back all data */
{
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mapping[3];
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Matrix3 field[3];
scene.transformations2DInto(
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? Containers::arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field ? Containers::arrayView(field) : nullptr
);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object),
TestSuite::Compare::Container);
if(data.field) CORRADE_COMPARE_AS(Containers::stridedArrayView(field),
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
Containers::arrayView(expected),
TestSuite::Compare::Container);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
/* The offset variant only a subset */
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::Array<UnsignedInt> mapping{data.size};
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Containers::Array<Matrix3> field{data.size};
CORRADE_COMPARE(scene.transformations2DInto(data.offset,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field ? arrayView(field) : nullptr
), data.expectedSize);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object)
.slice(data.offset, data.offset + data.expectedSize),
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
TestSuite::Compare::Container);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
if(data.field) CORRADE_COMPARE_AS(field.prefix(data.expectedSize),
Containers::arrayView(expected).slice(data.offset, data.offset + data.expectedSize),
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
TestSuite::Compare::Container);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
}
}
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
void SceneDataTest::transformations2DIntoArrayTRS() {
auto&& data = IntoArrayOffset3Data[testCaseInstanceId()];
setTestCaseDescription(data.name);
/* Both AsArray() and Into() share a common helper. The AsArray() test
above verified handling of various data types and this checks the
offset/size parameters of the Into() variant. */
struct Field {
UnsignedInt object;
Vector2 translation;
Complex rotation;
Vector2 scaling;
} fields[] {
{1, {3.0f, 2.0f}, {}, {1.5f, 2.0f}},
{0, {}, Complex::rotation(35.0_degf), {1.0f, 1.0f}},
{4, {3.0f, 2.0f}, Complex::rotation(35.0_degf), {1.0f, 1.0f}}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
SceneFieldData{SceneField::Translation,
view.slice(&Field::object),
view.slice(&Field::translation)},
SceneFieldData{SceneField::Rotation,
view.slice(&Field::object),
view.slice(&Field::rotation)},
SceneFieldData{SceneField::Scaling,
view.slice(&Field::object),
view.slice(&Field::scaling)},
}};
/* The offset-less overload should give back all data */
{
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mapping[3];
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Vector2 translations[3];
Complex rotations[3];
Vector2 scalings[3];
scene.translationsRotationsScalings2DInto(
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? Containers::arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field1 ? Containers::arrayView(translations) : nullptr,
data.field2 ? Containers::arrayView(rotations) : nullptr,
data.field3 ? Containers::arrayView(scalings) : nullptr
);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object),
TestSuite::Compare::Container);
if(data.field1) CORRADE_COMPARE_AS(Containers::stridedArrayView(translations),
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
view.slice(&Field::translation),
TestSuite::Compare::Container);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
if(data.field2) CORRADE_COMPARE_AS(Containers::stridedArrayView(rotations),
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
view.slice(&Field::rotation),
TestSuite::Compare::Container);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
if(data.field3) CORRADE_COMPARE_AS(Containers::stridedArrayView(scalings),
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
view.slice(&Field::scaling),
TestSuite::Compare::Container);
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
/* The offset variant only a subset */
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::Array<UnsignedInt> mapping{data.size};
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Containers::Array<Vector2> translations{data.size};
Containers::Array<Complex> rotations{data.size};
Containers::Array<Vector2> scalings{data.size};
CORRADE_COMPARE(scene.translationsRotationsScalings2DInto(data.offset,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field1 ? arrayView(translations) : nullptr,
data.field2 ? arrayView(rotations) : nullptr,
data.field3 ? arrayView(scalings) : nullptr
), data.expectedSize);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object)
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
if(data.field1) CORRADE_COMPARE_AS(translations.prefix(data.expectedSize),
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
view.slice(&Field::translation)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
if(data.field2) CORRADE_COMPARE_AS(rotations.prefix(data.expectedSize),
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
view.slice(&Field::rotation)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
if(data.field3) CORRADE_COMPARE_AS(scalings.prefix(data.expectedSize),
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
view.slice(&Field::scaling)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
}
}
void SceneDataTest::transformations2DIntoArrayInvalidSizeOrOffset() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
struct Field {
UnsignedInt object;
Matrix3 transformation;
Trade: GCC 4.8, hello!
5 years ago
} fields[3]; /* GCC 4.8 ICEs if I do a {} here */
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Transformation, view.slice(&Field::object), view.slice(&Field::transformation)}
}};
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mappingDestinationCorrect[3];
UnsignedInt mappingDestination[2];
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Matrix3 fieldDestinationCorrect[3];
Matrix3 fieldDestination[2];
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
scene.transformations2DInto(mappingDestination, fieldDestinationCorrect);
scene.transformations2DInto(mappingDestinationCorrect, fieldDestination);
scene.transformations2DInto(4, mappingDestination, fieldDestination);
scene.transformations2DInto(0, mappingDestinationCorrect, fieldDestination);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::transformations2DInto(): expected mapping destination view either empty or with 3 elements but got 2\n"
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
"Trade::SceneData::transformations2DInto(): expected field destination view either empty or with 3 elements but got 2\n"
"Trade::SceneData::transformations2DInto(): offset 4 out of bounds for a field of size 3\n"
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::transformations2DInto(): mapping and field destination views have different size, 3 vs 2\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
void SceneDataTest::transformations2DIntoArrayInvalidSizeOrOffsetTRS() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
struct Field {
UnsignedInt object;
Vector2 translation;
Trade: GCC 4.8, hello!
5 years ago
} fields[3]; /* GCC 4.8 ICEs if I do a {} here */
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
SceneFieldData{SceneField::Translation, view.slice(&Field::object), view.slice(&Field::translation)}
}};
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mappingDestinationCorrect[3];
UnsignedInt mappingDestination[2];
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
Vector2 translationDestinationCorrect[3];
Vector2 translationDestination[2];
Complex rotationDestinationCorrect[3];
Complex rotationDestination[2];
Vector2 scalingDestinationCorrect[3];
Vector2 scalingDestination[2];
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
scene.translationsRotationsScalings2DInto(mappingDestination, translationDestinationCorrect, rotationDestinationCorrect, scalingDestinationCorrect);
scene.translationsRotationsScalings2DInto(mappingDestinationCorrect, translationDestination, rotationDestinationCorrect, scalingDestinationCorrect);
scene.translationsRotationsScalings2DInto(mappingDestinationCorrect, translationDestinationCorrect, rotationDestination, scalingDestinationCorrect);
scene.translationsRotationsScalings2DInto(mappingDestinationCorrect, translationDestinationCorrect, rotationDestinationCorrect, scalingDestination);
scene.translationsRotationsScalings2DInto(4, mappingDestination, translationDestination, rotationDestination, scalingDestination);
scene.translationsRotationsScalings2DInto(0, mappingDestinationCorrect, translationDestination, nullptr, nullptr);
scene.translationsRotationsScalings2DInto(0, mappingDestinationCorrect, nullptr, rotationDestination, nullptr);
scene.translationsRotationsScalings2DInto(0, mappingDestinationCorrect, nullptr, nullptr, scalingDestination);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
scene.translationsRotationsScalings2DInto(0, nullptr, translationDestinationCorrect, rotationDestination, nullptr);
scene.translationsRotationsScalings2DInto(0, nullptr, translationDestinationCorrect, nullptr, scalingDestination);
scene.translationsRotationsScalings2DInto(0, nullptr, nullptr, rotationDestinationCorrect, scalingDestination);
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::translationsRotationsScalings2DInto(): expected mapping destination view either empty or with 3 elements but got 2\n"
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
"Trade::SceneData::translationsRotationsScalings2DInto(): expected translation destination view either empty or with 3 elements but got 2\n"
"Trade::SceneData::translationsRotationsScalings2DInto(): expected rotation destination view either empty or with 3 elements but got 2\n"
"Trade::SceneData::translationsRotationsScalings2DInto(): expected scaling destination view either empty or with 3 elements but got 2\n"
"Trade::SceneData::translationsRotationsScalings2DInto(): offset 4 out of bounds for a field of size 3\n"
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::translationsRotationsScalings2DInto(): mapping and translation destination views have different size, 3 vs 2\n"
"Trade::SceneData::translationsRotationsScalings2DInto(): mapping and rotation destination views have different size, 3 vs 2\n"
"Trade::SceneData::translationsRotationsScalings2DInto(): mapping and scaling destination views have different size, 3 vs 2\n"
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
"Trade::SceneData::translationsRotationsScalings2DInto(): translation and rotation destination views have different size, 3 vs 2\n"
"Trade::SceneData::translationsRotationsScalings2DInto(): translation and scaling destination views have different size, 3 vs 2\n"
"Trade::SceneData::translationsRotationsScalings2DInto(): rotation and scaling destination views have different size, 3 vs 2\n");
}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
template<class T> void SceneDataTest::transformations3DAsArray() {
setTestCaseTemplateName(NameTraits<T>::name());
typedef typename T::Type U;
Trade: allow SceneField::Transformation to be a 3x2 or a 4x3 matrix. Another thought I had was about allowing a 2x2 / 3x3 matrix to be used for rotation, but there's the ambiguity with it possibly containing scaling / shear / whatever, which would then cause EXPLODING HEADACHES when converting to quaternions / complex numbers.
5 years ago
typedef typename TransformationTypeFor<T>::Type TT;
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
struct Transformation {
UnsignedInt object;
T transformation;
};
struct Component {
UnsignedInt object;
Vector3 translation;
Vector3 scaling;
};
Containers::StridedArrayView1D<Transformation> transformations;
Containers::StridedArrayView1D<Component> components;
Containers::Array<char> data = Containers::ArrayTuple{
{NoInit, 4, transformations},
{NoInit, 2, components}
};
Trade: allow SceneField::Transformation to be a 3x2 or a 4x3 matrix. Another thought I had was about allowing a 2x2 / 3x3 matrix to be used for rotation, but there's the ambiguity with it possibly containing scaling / shear / whatever, which would then cause EXPLODING HEADACHES when converting to quaternions / complex numbers.
5 years ago
transformations[0] = {1, T{TT::translation({U(3.0), U(2.0), U(-0.5)})}};
transformations[1] = {0, T{TT::rotation(Math::Deg<U>(35.0),
Math::Vector3<U>::yAxis())}};
transformations[2] = {4, T{TT::translation({U(1.5), U(2.5), U(0.75)})*
TT::rotation(Math::Deg<U>(-15.0),
Math::Vector3<U>::xAxis())}};
transformations[3] = {5, T{TT::rotation(Math::Deg<U>(-15.0),
Math::Vector3<U>::xAxis())*
TT::translation({U(1.5), U(2.5), U(0.75)})}};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* Object number 4 additionally has a scaling component (which isn't
representable with dual quaternions). It currently doesn't get added
to the transformations returned from transformations2DInto() but that
may change in the future for dual quaternions). The translation
component is then *assumed* to be equivalent to what's stored in the
Transformation field and so applied neither. Here it's different, and
that shouldn't affect anything. */
components[0] = {4, {-1.5f, -2.5f, 5.5f}, {2.0f, 5.0f, 3.0f}};
/* This is deliberately an error -- specifying a TRS for an object that
doesn't have a Transformation field. Since there's no fast way to check
for those and error/warn on those, they get just ignored. */
components[1] = {2, {3.5f, -1.0f, 2.2f}, {1.0f, 1.5f, 1.0f}};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 6, std::move(data), {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Transformation,
transformations.slice(&Transformation::object),
transformations.slice(&Transformation::transformation)},
SceneFieldData{SceneField::Translation,
components.slice(&Component::object),
components.slice(&Component::translation)},
SceneFieldData{SceneField::Scaling,
components.slice(&Component::object),
components.slice(&Component::scaling)},
}};
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
CORRADE_VERIFY(!scene.is2D());
CORRADE_VERIFY(scene.is3D());
Trade: add SceneData::transformationFieldSize().
4 years ago
CORRADE_COMPARE(scene.transformationFieldSize(), 4);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.transformations3DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Matrix4>>({
{1, Matrix4::translation({3.0f, 2.0f, -0.5f})},
{0, Matrix4::rotationY(35.0_degf)},
{4, Matrix4::translation({1.5f, 2.5f, 0.75f})*Matrix4::rotationX(-15.0_degf)},
{5, Matrix4::rotationX(-15.0_degf)*Matrix4::translation({1.5f, 2.5f, 0.75f})}
})), TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: SceneData TRS components can each have different type, test that.
5 years ago
template<class T, class U, class V> void SceneDataTest::transformations3DAsArrayTRS() {
setTestCaseTemplateName({NameTraits<T>::name(), NameTraits<U>::name(), NameTraits<V>::name()});
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
struct Field {
UnsignedInt object;
Math::Vector3<T> translation;
Trade: SceneData TRS components can each have different type, test that.
5 years ago
Math::Quaternion<U> rotation;
Math::Vector3<V> scaling;
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
} fields[]{
{1, {T(3.0), T(2.0), T(1.0)},
{},
Trade: SceneData TRS components can each have different type, test that.
5 years ago
{V(1.0), V(1.0), V(1.0)}},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
{0, {},
Trade: SceneData TRS components can each have different type, test that.
5 years ago
Math::Quaternion<U>::rotation(Math::Deg<U>{U(35.0)}, Math::Vector3<U>::yAxis()),
{V(1.0), V(1.0), V(1.0)}},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
{2, {}, /* Identity transformation here */
{},
Trade: SceneData TRS components can each have different type, test that.
5 years ago
{V(1.0), V(1.0), V(1.0)}},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
{4, {},
{},
Trade: SceneData TRS components can each have different type, test that.
5 years ago
{V(2.0), V(1.0), V(0.0)}},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
{7, {T(1.5), T(2.5), T(3.5)},
Trade: SceneData TRS components can each have different type, test that.
5 years ago
Math::Quaternion<U>::rotation(Math::Deg<U>{U(-15.0)}, Math::Vector3<U>::xAxis()),
{V(-0.5), V(4.0), V(-16.0)}},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
};
Containers::StridedArrayView1D<Field> view = fields;
SceneFieldData translation{SceneField::Translation,
view.slice(&Field::object),
view.slice(&Field::translation)};
SceneFieldData rotation{SceneField::Rotation,
view.slice(&Field::object),
view.slice(&Field::rotation)};
SceneFieldData scaling{SceneField::Scaling,
view.slice(&Field::object),
view.slice(&Field::scaling)};
/* Just one of translation / rotation / scaling */
{
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
translation
}};
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
CORRADE_VERIFY(!scene.is2D());
CORRADE_VERIFY(scene.is3D());
Trade: add SceneData::transformationFieldSize().
4 years ago
CORRADE_COMPARE(scene.transformationFieldSize(), 5);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.transformations3DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Matrix4>>({
{1, Matrix4::translation({3.0f, 2.0, 1.0f})},
{0, Matrix4{Math::IdentityInit}},
{2, Matrix4{Math::IdentityInit}},
{4, Matrix4{Math::IdentityInit}},
{7, Matrix4::translation({1.5f, 2.5f, 3.5f})}
})), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.translationsRotationsScalings3DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Containers::Triple<Vector3, Quaternion, Vector3>>>({
{1, {{3.0f, 2.0, 1.0f}, {}, Vector3{1.0f}}},
{0, {{}, {}, Vector3{1.0f}}},
{2, {{}, {}, Vector3{1.0f}}},
{4, {{}, {}, Vector3{1.0f}}},
{7, {{1.5f, 2.5f, 3.5f}, {}, Vector3{1.0f}}},
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
})), TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
rotation
}};
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
CORRADE_VERIFY(!scene.is2D());
CORRADE_VERIFY(scene.is3D());
Trade: add SceneData::transformationFieldSize().
4 years ago
CORRADE_COMPARE(scene.transformationFieldSize(), 5);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.transformations3DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Matrix4>>({
{1, Matrix4{Math::IdentityInit}},
{0, Matrix4::rotationY(35.0_degf)},
{2, Matrix4{Math::IdentityInit}},
{4, Matrix4{Math::IdentityInit}},
{7, Matrix4::rotationX(-15.0_degf)}
})), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.translationsRotationsScalings3DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Containers::Triple<Vector3, Quaternion, Vector3>>>({
{1, {{}, {}, Vector3{1.0f}}},
{0, {{}, Quaternion::rotation(35.0_degf, Vector3::yAxis()), Vector3{1.0f}}},
{2, {{}, {}, Vector3{1.0f}}},
{4, {{}, {}, Vector3{1.0f}}},
{7, {{}, Quaternion::rotation(-15.0_degf, Vector3::xAxis()), Vector3{1.0f}}},
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
})), TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
scaling
}};
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
CORRADE_VERIFY(!scene.is2D());
CORRADE_VERIFY(scene.is3D());
Trade: add SceneData::transformationFieldSize().
4 years ago
CORRADE_COMPARE(scene.transformationFieldSize(), 5);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.transformations3DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Matrix4>>({
{1, Matrix4{Math::IdentityInit}},
{0, Matrix4{Math::IdentityInit}},
{2, Matrix4{Math::IdentityInit}},
{4, Matrix4::scaling({2.0f, 1.0f, 0.0f})},
{7, Matrix4::scaling({-0.5f, 4.0f, -16.0f})}
})), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.translationsRotationsScalings3DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Containers::Triple<Vector3, Quaternion, Vector3>>>({
{1, {{}, {}, Vector3{1.0f}}},
{0, {{}, {}, Vector3{1.0f}}},
{2, {{}, {}, Vector3{1.0f}}},
{4, {{}, {}, {2.0f, 1.0f, 0.0f}}},
{7, {{}, {}, {-0.5f, 4.0f, -16.0f}}},
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
})), TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
/* Pairs */
{
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
translation,
rotation
}};
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
CORRADE_VERIFY(!scene.is2D());
CORRADE_VERIFY(scene.is3D());
Trade: add SceneData::transformationFieldSize().
4 years ago
CORRADE_COMPARE(scene.transformationFieldSize(), 5);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.transformations3DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Matrix4>>({
{1, Matrix4::translation({3.0f, 2.0, 1.0f})},
{0, Matrix4::rotationY(35.0_degf)},
{2, Matrix4{Math::IdentityInit}},
{4, Matrix4{Math::IdentityInit}},
{7, Matrix4::translation({1.5f, 2.5f, 3.5f})*Matrix4::rotationX(-15.0_degf)}
})), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.translationsRotationsScalings3DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Containers::Triple<Vector3, Quaternion, Vector3>>>({
{1, {{3.0f, 2.0, 1.0f}, {}, Vector3{1.0f}}},
{0, {{}, Quaternion::rotation(35.0_degf, Vector3::yAxis()), Vector3{1.0f}}},
{2, {{}, {}, Vector3{1.0f}}},
{4, {{}, {}, Vector3{1.0f}}},
{7, {{1.5f, 2.5f, 3.5f}, Quaternion::rotation(-15.0_degf, Vector3::xAxis()), Vector3{1.0f}}},
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
})), TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
translation,
scaling
}};
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
CORRADE_VERIFY(!scene.is2D());
CORRADE_VERIFY(scene.is3D());
Trade: add SceneData::transformationFieldSize().
4 years ago
CORRADE_COMPARE(scene.transformationFieldSize(), 5);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.transformations3DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Matrix4>>({
{1, Matrix4::translation({3.0f, 2.0, 1.0f})},
{0, Matrix4{Math::IdentityInit}},
{2, Matrix4{Math::IdentityInit}},
{4, Matrix4::scaling({2.0f, 1.0f, 0.0f})},
{7, Matrix4::translation({1.5f, 2.5f, 3.5f})*Matrix4::scaling({-0.5f, 4.0f, -16.0f})}
})), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.translationsRotationsScalings3DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Containers::Triple<Vector3, Quaternion, Vector3>>>({
{1, {{3.0f, 2.0, 1.0f}, {}, Vector3{1.0f}}},
{0, {{}, {}, Vector3{1.0f}}},
{2, {{}, {}, Vector3{1.0f}}},
{4, {{}, {}, {2.0f, 1.0f, 0.0f}}},
{7, {{1.5f, 2.5f, 3.5f}, {}, {-0.5f, 4.0f, -16.0f}}},
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
})), TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
rotation,
scaling
}};
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
CORRADE_VERIFY(!scene.is2D());
CORRADE_VERIFY(scene.is3D());
Trade: add SceneData::transformationFieldSize().
4 years ago
CORRADE_COMPARE(scene.transformationFieldSize(), 5);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.transformations3DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Matrix4>>({
{1, Matrix4{Math::IdentityInit}},
{0, Matrix4::rotationY(35.0_degf)},
{2, Matrix4{Math::IdentityInit}},
{4, Matrix4::scaling({2.0f, 1.0f, 0.0f})},
{7, Matrix4::rotationX({-15.0_degf})*Matrix4::scaling({-0.5f, 4.0f, -16.0f})}
})), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.translationsRotationsScalings3DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Containers::Triple<Vector3, Quaternion, Vector3>>>({
{1, {{}, {}, Vector3{1.0f}}},
{0, {{}, Quaternion::rotation(35.0_degf, Vector3::yAxis()), Vector3{1.0f}}},
{2, {{}, {}, Vector3{1.0f}}},
{4, {{}, {}, {2.0f, 1.0f, 0.0f}}},
{7, {{}, Quaternion::rotation(-15.0_degf, Vector3::xAxis()), {-0.5f, 4.0f, -16.0f}}},
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
})), TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
/* All */
{
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 8, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
translation,
rotation,
scaling
}};
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
CORRADE_VERIFY(!scene.is2D());
CORRADE_VERIFY(scene.is3D());
Trade: add SceneData::transformationFieldSize().
4 years ago
CORRADE_COMPARE(scene.transformationFieldSize(), 5);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.transformations3DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Matrix4>>({
{1, Matrix4::translation({3.0f, 2.0, 1.0f})},
{0, Matrix4::rotationY(35.0_degf)},
{2, Matrix4{Math::IdentityInit}},
{4, Matrix4::scaling({2.0f, 1.0f, 0.0f})},
{7, Matrix4::translation({1.5f, 2.5f, 3.5f})*Matrix4::rotationX({-15.0_degf})*Matrix4::scaling({-0.5f, 4.0f, -16.0f})}
})), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.translationsRotationsScalings3DAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Containers::Triple<Vector3, Quaternion, Vector3>>>({
{1, {{3.0f, 2.0, 1.0f}, {}, Vector3{1.0f}}},
{0, {{}, Quaternion::rotation(35.0_degf, Vector3::yAxis()), Vector3{1.0f}}},
{2, {{}, {}, Vector3{1.0f}}},
{4, {{}, {}, {2.0f, 1.0f, 0.0f}}},
{7, {{1.5f, 2.5f, 3.5f}, Quaternion::rotation(-15.0_degf, Vector3::xAxis()), {-0.5f, 4.0f, -16.0f}}},
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
})), TestSuite::Compare::Container);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
}
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
void SceneDataTest::transformations3DAsArrayBut2DType() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
/* Because TRSAsArray() allocates an Array<Triple> and then calls
TRSInto(), which skips views that are nullptr, we wouldn't get the
assertion for translations, as those are at offset 0, which would be
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
interpreted as an empty view if there were no elements. Thus using
rotations instead. */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 0, nullptr, {
SceneFieldData{SceneField::Rotation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Complex, nullptr}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}};
std::ostringstream out;
Error redirectError{&out};
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
scene.transformations3DAsArray();
scene.translationsRotationsScalings3DAsArray();
CORRADE_COMPARE(out.str(),
"Trade::SceneData::transformations3DInto(): scene has a 2D transformation type\n"
"Trade::SceneData::translationsRotationsScalings3DInto(): scene has a 2D transformation type\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
void SceneDataTest::transformations3DIntoArray() {
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
auto&& data = IntoArrayOffset1Data[testCaseInstanceId()];
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
setTestCaseDescription(data.name);
/* Both AsArray() and Into() share a common helper. The AsArray() test
above verified handling of various data types and this checks the
offset/size parameters of the Into() variant. */
struct Field {
UnsignedInt object;
Matrix4 transformation;
} fields[] {
{1, Matrix4::translation({3.0f, 2.0f, 1.0f})*Matrix4::scaling({1.5f, 2.0f, 4.5f})},
{0, Matrix4::rotationX(35.0_degf)},
{4, Matrix4::translation({3.0f, 2.0f, 1.0f})*Matrix4::rotationX(35.0_degf)}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
SceneFieldData{SceneField::Transformation,
view.slice(&Field::object),
view.slice(&Field::transformation)},
}};
/* The offset-less overload should give back all data */
{
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mapping[3];
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Matrix4 field[3];
scene.transformations3DInto(
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? Containers::arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field ? Containers::arrayView(field) : nullptr
);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object),
TestSuite::Compare::Container);
if(data.field) CORRADE_COMPARE_AS(Containers::stridedArrayView(field),
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
view.slice(&Field::transformation),
TestSuite::Compare::Container);
/* The offset variant only a subset */
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::Array<UnsignedInt> mapping{data.size};
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Containers::Array<Matrix4> field{data.size};
CORRADE_COMPARE(scene.transformations3DInto(data.offset,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field ? arrayView(field) : nullptr
), data.expectedSize);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
if(data.field) CORRADE_COMPARE_AS(field.prefix(data.expectedSize),
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
view.slice(&Field::transformation)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
}
}
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
void SceneDataTest::transformations3DTRSIntoArray() {
auto&& data = IntoArrayOffset1Data[testCaseInstanceId()];
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
setTestCaseDescription(data.name);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
/* Same APIs tested as in transformations3DIntoArray(), but with a TRS
input */
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
struct Field {
UnsignedInt object;
Vector3 translation;
Quaternion rotation;
Vector3 scaling;
} fields[] {
{1, {3.0f, 2.0f, 1.0f}, {}, {1.5f, 2.0f, 4.5f}},
{0, {}, Quaternion::rotation(35.0_degf, Vector3::xAxis()), {1.0f, 1.0f, 1.0f}},
{4, {3.0f, 2.0f, 1.0f}, Quaternion::rotation(35.0_degf, Vector3::xAxis()), {1.0f, 1.0f, 1.0f}}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
SceneFieldData{SceneField::Translation,
view.slice(&Field::object),
view.slice(&Field::translation)},
SceneFieldData{SceneField::Rotation,
view.slice(&Field::object),
view.slice(&Field::rotation)},
SceneFieldData{SceneField::Scaling,
view.slice(&Field::object),
view.slice(&Field::scaling)},
}};
Matrix4 expected[]{
Matrix4::translation({3.0f, 2.0f, 1.0f})*Matrix4::scaling({1.5f, 2.0f, 4.5f}),
Matrix4::rotationX(35.0_degf),
Matrix4::translation({3.0f, 2.0f, 1.0f})*Matrix4::rotationX(35.0_degf)
};
/* The offset-less overload should give back all data */
{
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mapping[3];
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Matrix4 field[3];
scene.transformations3DInto(
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? Containers::arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field ? Containers::arrayView(field) : nullptr
);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object),
TestSuite::Compare::Container);
if(data.field) CORRADE_COMPARE_AS(Containers::stridedArrayView(field),
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
Containers::arrayView(expected),
TestSuite::Compare::Container);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
/* The offset variant only a subset */
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::Array<UnsignedInt> mapping{data.size};
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Containers::Array<Matrix4> field{data.size};
CORRADE_COMPARE(scene.transformations3DInto(data.offset,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field ? arrayView(field) : nullptr
), data.expectedSize);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object)
.slice(data.offset, data.offset + data.expectedSize),
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
TestSuite::Compare::Container);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
if(data.field) CORRADE_COMPARE_AS(field.prefix(data.expectedSize),
Containers::arrayView(expected).slice(data.offset, data.offset + data.expectedSize),
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
TestSuite::Compare::Container);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
}
}
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
void SceneDataTest::transformations3DIntoArrayTRS() {
auto&& data = IntoArrayOffset3Data[testCaseInstanceId()];
setTestCaseDescription(data.name);
/* Both AsArray() and Into() share a common helper. The AsArray() test
above verified handling of various data types and this checks the
offset/size parameters of the Into() variant. */
struct Field {
UnsignedInt object;
Vector3 translation;
Quaternion rotation;
Vector3 scaling;
} fields[] {
{1, {3.0f, 2.0f, 1.0f}, {}, {1.5f, 2.0f, 4.5f}},
{0, {}, Quaternion::rotation(35.0_degf, Vector3::xAxis()), {1.0f, 1.0f, 1.0f}},
{4, {3.0f, 2.0f, 1.0f}, Quaternion::rotation(35.0_degf, Vector3::xAxis()), {1.0f, 1.0f, 1.0f}}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
SceneFieldData{SceneField::Translation,
view.slice(&Field::object),
view.slice(&Field::translation)},
SceneFieldData{SceneField::Rotation,
view.slice(&Field::object),
view.slice(&Field::rotation)},
SceneFieldData{SceneField::Scaling,
view.slice(&Field::object),
view.slice(&Field::scaling)},
}};
/* The offset-less overload should give back all data */
{
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mapping[3];
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Vector3 translations[3];
Quaternion rotations[3];
Vector3 scalings[3];
scene.translationsRotationsScalings3DInto(
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? Containers::arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field1 ? Containers::arrayView(translations) : nullptr,
data.field2 ? Containers::arrayView(rotations) : nullptr,
data.field3 ? Containers::arrayView(scalings) : nullptr
);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object),
TestSuite::Compare::Container);
if(data.field1) CORRADE_COMPARE_AS(Containers::stridedArrayView(translations),
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
view.slice(&Field::translation),
TestSuite::Compare::Container);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
if(data.field2) CORRADE_COMPARE_AS(Containers::stridedArrayView(rotations),
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
view.slice(&Field::rotation),
TestSuite::Compare::Container);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
if(data.field3) CORRADE_COMPARE_AS(Containers::stridedArrayView(scalings),
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
view.slice(&Field::scaling),
TestSuite::Compare::Container);
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
/* The offset variant only a subset */
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::Array<UnsignedInt> mapping{data.size};
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Containers::Array<Vector3> translations{data.size};
Containers::Array<Quaternion> rotations{data.size};
Containers::Array<Vector3> scalings{data.size};
CORRADE_COMPARE(scene.translationsRotationsScalings3DInto(data.offset,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field1 ? arrayView(translations) : nullptr,
data.field2 ? arrayView(rotations) : nullptr,
data.field3 ? arrayView(scalings) : nullptr
), data.expectedSize);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object)
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
if(data.field1) CORRADE_COMPARE_AS(translations.prefix(data.expectedSize),
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
view.slice(&Field::translation)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
if(data.field2) CORRADE_COMPARE_AS(rotations.prefix(data.expectedSize),
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
view.slice(&Field::rotation)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
if(data.field3) CORRADE_COMPARE_AS(scalings.prefix(data.expectedSize),
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
view.slice(&Field::scaling)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
}
}
void SceneDataTest::transformations3DIntoArrayInvalidSizeOrOffset() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
struct Field {
UnsignedInt object;
Matrix4 transformation;
Trade: GCC 4.8, hello!
5 years ago
} fields[3]; /* GCC 4.8 ICEs if I do a {} here */
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Transformation, view.slice(&Field::object), view.slice(&Field::transformation)}
}};
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mappingDestinationCorrect[3];
UnsignedInt mappingDestination[2];
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Matrix4 fieldDestinationCorrect[3];
Matrix4 fieldDestination[2];
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
scene.transformations3DInto(mappingDestination, fieldDestinationCorrect);
scene.transformations3DInto(mappingDestinationCorrect, fieldDestination);
scene.transformations3DInto(4, mappingDestination, fieldDestination);
scene.transformations3DInto(0, mappingDestinationCorrect, fieldDestination);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::transformations3DInto(): expected mapping destination view either empty or with 3 elements but got 2\n"
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
"Trade::SceneData::transformations3DInto(): expected field destination view either empty or with 3 elements but got 2\n"
"Trade::SceneData::transformations3DInto(): offset 4 out of bounds for a field of size 3\n"
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::transformations3DInto(): mapping and field destination views have different size, 3 vs 2\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
void SceneDataTest::transformations3DIntoArrayInvalidSizeOrOffsetTRS() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
struct Field {
UnsignedInt object;
Vector2 translation;
Trade: GCC 4.8, hello!
5 years ago
} fields[3]; /* GCC 4.8 ICEs if I do a {} here */
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
SceneFieldData{SceneField::Translation, view.slice(&Field::object), view.slice(&Field::translation)}
}};
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mappingDestinationCorrect[3];
UnsignedInt mappingDestination[2];
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
Vector3 translationDestinationCorrect[3];
Vector3 translationDestination[2];
Quaternion rotationDestinationCorrect[3];
Quaternion rotationDestination[2];
Vector3 scalingDestinationCorrect[3];
Vector3 scalingDestination[2];
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
scene.translationsRotationsScalings3DInto(mappingDestination, translationDestinationCorrect, rotationDestinationCorrect, scalingDestinationCorrect);
scene.translationsRotationsScalings3DInto(mappingDestinationCorrect, translationDestination, rotationDestinationCorrect, scalingDestinationCorrect);
scene.translationsRotationsScalings3DInto(mappingDestinationCorrect, translationDestinationCorrect, rotationDestination, scalingDestinationCorrect);
scene.translationsRotationsScalings3DInto(mappingDestinationCorrect, translationDestinationCorrect, rotationDestinationCorrect, scalingDestination);
scene.translationsRotationsScalings3DInto(4, mappingDestination, translationDestination, rotationDestination, scalingDestination);
scene.translationsRotationsScalings3DInto(0, mappingDestinationCorrect, translationDestination, nullptr, nullptr);
scene.translationsRotationsScalings3DInto(0, mappingDestinationCorrect, nullptr, rotationDestination, nullptr);
scene.translationsRotationsScalings3DInto(0, mappingDestinationCorrect, nullptr, nullptr, scalingDestination);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
scene.translationsRotationsScalings3DInto(0, nullptr, translationDestinationCorrect, rotationDestination, nullptr);
scene.translationsRotationsScalings3DInto(0, nullptr, translationDestinationCorrect, nullptr, scalingDestination);
scene.translationsRotationsScalings3DInto(0, nullptr, nullptr, rotationDestinationCorrect, scalingDestination);
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::translationsRotationsScalings3DInto(): expected mapping destination view either empty or with 3 elements but got 2\n"
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
"Trade::SceneData::translationsRotationsScalings3DInto(): expected translation destination view either empty or with 3 elements but got 2\n"
"Trade::SceneData::translationsRotationsScalings3DInto(): expected rotation destination view either empty or with 3 elements but got 2\n"
"Trade::SceneData::translationsRotationsScalings3DInto(): expected scaling destination view either empty or with 3 elements but got 2\n"
"Trade::SceneData::translationsRotationsScalings3DInto(): offset 4 out of bounds for a field of size 3\n"
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::translationsRotationsScalings3DInto(): mapping and translation destination views have different size, 3 vs 2\n"
"Trade::SceneData::translationsRotationsScalings3DInto(): mapping and rotation destination views have different size, 3 vs 2\n"
"Trade::SceneData::translationsRotationsScalings3DInto(): mapping and scaling destination views have different size, 3 vs 2\n"
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
"Trade::SceneData::translationsRotationsScalings3DInto(): translation and rotation destination views have different size, 3 vs 2\n"
"Trade::SceneData::translationsRotationsScalings3DInto(): translation and scaling destination views have different size, 3 vs 2\n"
"Trade::SceneData::translationsRotationsScalings3DInto(): rotation and scaling destination views have different size, 3 vs 2\n");
}
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
template<class T, class U> void SceneDataTest::meshesMaterialsAsArray() {
setTestCaseTemplateName({NameTraits<T>::name(), NameTraits<U>::name()});
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
struct Field {
UnsignedByte object;
T mesh;
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
U meshMaterial;
} fields[]{
{0, T(15), U(3)},
{1, T(37), U(-1)},
{15, T(44), U(25)}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
SceneFieldData meshes{SceneField::Mesh,
view.slice(&Field::object),
view.slice(&Field::mesh)};
SceneFieldData meshMaterials{SceneField::MeshMaterial,
view.slice(&Field::object),
view.slice(&Field::meshMaterial)};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
/* Both meshes and materials */
{
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedByte, 50, {}, fields, {
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Int, nullptr},
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
meshes,
meshMaterials
}};
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.meshesMaterialsAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Containers::Pair<UnsignedInt, Int>>>({
{0, {15, 3}},
{1, {37, -1}},
{15, {44, 25}}
})), TestSuite::Compare::Container);
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
/* Only meshes */
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedByte, 50, {}, fields, {
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
meshes
}};
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.meshesMaterialsAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, Containers::Pair<UnsignedInt, Int>>>({
{0, {15, -1}},
{1, {37, -1}},
{15, {44, -1}}
})), TestSuite::Compare::Container);
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
}
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
void SceneDataTest::meshesMaterialsIntoArray() {
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
auto&& data = IntoArrayOffset2Data[testCaseInstanceId()];
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
setTestCaseDescription(data.name);
/* Both AsArray() and Into() share a common helper. The AsArray() test
above verified handling of various data types and this checks the
offset/size parameters of the Into() variant. */
struct Field {
UnsignedInt object;
UnsignedInt mesh;
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
Int meshMaterial;
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
} fields[]{
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
{1, 15, 3},
{0, 37, -1},
{4, 44, 22}
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
SceneFieldData{SceneField::Mesh,
view.slice(&Field::object),
view.slice(&Field::mesh)},
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
SceneFieldData{SceneField::MeshMaterial,
view.slice(&Field::object),
view.slice(&Field::meshMaterial)},
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
}};
/* The offset-less overload should give back all data */
{
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mapping[3];
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
UnsignedInt meshes[3];
Int meshMaterials[3];
scene.meshesMaterialsInto(
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? Containers::arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field1 ? Containers::arrayView(meshes) : nullptr,
data.field2 ? Containers::arrayView(meshMaterials) : nullptr
);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object),
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
TestSuite::Compare::Container);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
if(data.field1) CORRADE_COMPARE_AS(Containers::stridedArrayView(meshes),
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
view.slice(&Field::mesh),
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
TestSuite::Compare::Container);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
if(data.field2) CORRADE_COMPARE_AS(Containers::stridedArrayView(meshMaterials),
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
view.slice(&Field::meshMaterial),
TestSuite::Compare::Container);
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
/* The offset variant should give back only a subset */
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::Array<UnsignedInt> mapping{data.size};
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Containers::Array<UnsignedInt> meshes{data.size};
Containers::Array<Int> meshMaterials{data.size};
CORRADE_COMPARE(scene.meshesMaterialsInto(data.offset,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field1 ? arrayView(meshes) : nullptr,
data.field2 ? arrayView(meshMaterials) : nullptr
), data.expectedSize);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object)
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
if(data.field1) CORRADE_COMPARE_AS(meshes.prefix(data.expectedSize),
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
view.slice(&Field::mesh)
.slice(data.offset, data.offset + data.expectedSize),
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
TestSuite::Compare::Container);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
if(data.field2) CORRADE_COMPARE_AS(meshMaterials.prefix(data.expectedSize),
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
view.slice(&Field::meshMaterial)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
void SceneDataTest::meshesMaterialsIntoArrayInvalidSizeOrOffset() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
struct Field {
UnsignedInt object;
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
UnsignedInt mesh;
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
} fields[3]{};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}};
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mappingDestinationCorrect[3];
UnsignedInt mappingDestination[2];
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
UnsignedInt meshDestinationCorrect[3];
UnsignedInt meshDestination[2];
Int meshMaterialDestinationCorrect[3];
Int meshMaterialDestination[2];
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
scene.meshesMaterialsInto(mappingDestination, meshDestinationCorrect, meshMaterialDestinationCorrect);
scene.meshesMaterialsInto(mappingDestinationCorrect, meshDestination, meshMaterialDestinationCorrect);
scene.meshesMaterialsInto(mappingDestinationCorrect, meshDestinationCorrect, meshMaterialDestination);
scene.meshesMaterialsInto(4, mappingDestination, meshDestination, meshMaterialDestination);
scene.meshesMaterialsInto(0, mappingDestinationCorrect, meshDestination, nullptr);
scene.meshesMaterialsInto(0, mappingDestinationCorrect, nullptr, meshMaterialDestination);
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
scene.meshesMaterialsInto(0, nullptr, meshDestinationCorrect, meshMaterialDestination);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::meshesMaterialsInto(): expected mapping destination view either empty or with 3 elements but got 2\n"
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
"Trade::SceneData::meshesMaterialsInto(): expected mesh destination view either empty or with 3 elements but got 2\n"
"Trade::SceneData::meshesMaterialsInto(): expected mesh material destination view either empty or with 3 elements but got 2\n"
"Trade::SceneData::meshesMaterialsInto(): offset 4 out of bounds for a field of size 3\n"
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::meshesMaterialsInto(): mapping and mesh destination views have different size, 3 vs 2\n"
"Trade::SceneData::meshesMaterialsInto(): mapping and mesh material destination views have different size, 3 vs 2\n"
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
"Trade::SceneData::meshesMaterialsInto(): mesh and mesh material destination views have different size, 3 vs 2\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
template<class T> void SceneDataTest::lightsAsArray() {
setTestCaseTemplateName(NameTraits<T>::name());
struct Field {
UnsignedByte object;
T light;
} fields[]{
{0, T(15)},
{1, T(37)},
{15, T(44)}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedByte, 50, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Int, nullptr},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Light, view.slice(&Field::object), view.slice(&Field::light)}
}};
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.lightsAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, UnsignedInt>>({
{0, 15},
{1, 37},
{15, 44}
})), TestSuite::Compare::Container);
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
void SceneDataTest::lightsIntoArray() {
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
auto&& data = IntoArrayOffset1Data[testCaseInstanceId()];
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
setTestCaseDescription(data.name);
/* Both AsArray() and Into() share a common helper. The AsArray() test
above verified handling of various data types and this checks the
offset/size parameters of the Into() variant. */
struct Field {
UnsignedInt object;
UnsignedInt light;
} fields[] {
{1, 15},
{0, 37},
{4, 44}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
SceneFieldData{SceneField::Light,
view.slice(&Field::object),
view.slice(&Field::light)},
}};
/* The offset-less overload should give back all data */
{
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mapping[3];
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
UnsignedInt field[3];
scene.lightsInto(
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? Containers::arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field ? Containers::arrayView(field) : nullptr
);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object),
TestSuite::Compare::Container);
if(data.field) CORRADE_COMPARE_AS(Containers::stridedArrayView(field),
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
view.slice(&Field::light),
TestSuite::Compare::Container);
/* The offset variant only a subset */
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::Array<UnsignedInt> mapping{data.size};
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Containers::Array<UnsignedInt> field{data.size};
CORRADE_COMPARE(scene.lightsInto(data.offset,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field ? arrayView(field) : nullptr
), data.expectedSize);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
if(data.field) CORRADE_COMPARE_AS(field.prefix(data.expectedSize),
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
view.slice(&Field::light)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
void SceneDataTest::lightsIntoArrayInvalidSizeOrOffset() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
struct Field {
UnsignedInt object;
UnsignedInt light;
} fields[3]{};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Light, view.slice(&Field::object), view.slice(&Field::light)}
}};
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mappingDestinationCorrect[3];
UnsignedInt mappingDestination[2];
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
UnsignedInt fieldDestinationCorrect[3];
UnsignedInt fieldDestination[2];
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
scene.lightsInto(mappingDestination, fieldDestinationCorrect);
scene.lightsInto(mappingDestinationCorrect, fieldDestination);
scene.lightsInto(4, mappingDestination, fieldDestination);
scene.lightsInto(0, mappingDestinationCorrect, fieldDestination);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::lightsInto(): expected mapping destination view either empty or with 3 elements but got 2\n"
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
"Trade::SceneData::lightsInto(): expected field destination view either empty or with 3 elements but got 2\n"
"Trade::SceneData::lightsInto(): offset 4 out of bounds for a field of size 3\n"
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::lightsInto(): mapping and field destination views have different size, 3 vs 2\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
template<class T> void SceneDataTest::camerasAsArray() {
setTestCaseTemplateName(NameTraits<T>::name());
struct Field {
UnsignedByte object;
T camera;
} fields[]{
{0, T(15)},
{1, T(37)},
{15, T(44)}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedByte, 50, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Int, nullptr},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Camera, view.slice(&Field::object), view.slice(&Field::camera)}
}};
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.camerasAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, UnsignedInt>>({
{0, 15},
{1, 37},
{15, 44}
})), TestSuite::Compare::Container);
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
void SceneDataTest::camerasIntoArray() {
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
auto&& data = IntoArrayOffset1Data[testCaseInstanceId()];
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
setTestCaseDescription(data.name);
/* Both AsArray() and Into() share a common helper. The AsArray() test
above verified handling of various data types and this checks the
offset/size parameters of the Into() variant. */
struct Field {
UnsignedInt object;
UnsignedInt camera;
} fields[]{
{1, 15},
{0, 37},
{4, 44}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
SceneFieldData{SceneField::Camera,
view.slice(&Field::object),
view.slice(&Field::camera)},
}};
/* The offset-less overload should give back all data */
{
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mapping[3];
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
UnsignedInt field[3];
scene.camerasInto(
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? Containers::arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field ? Containers::arrayView(field) : nullptr
);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object),
TestSuite::Compare::Container);
if(data.field) CORRADE_COMPARE_AS(Containers::stridedArrayView(field),
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
view.slice(&Field::camera),
TestSuite::Compare::Container);
/* The offset variant only a subset */
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::Array<UnsignedInt> mapping{data.size};
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Containers::Array<UnsignedInt> field{data.size};
CORRADE_COMPARE(scene.camerasInto(data.offset,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field ? arrayView(field) : nullptr
), data.expectedSize);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
if(data.field) CORRADE_COMPARE_AS(field.prefix(data.expectedSize),
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
view.slice(&Field::camera)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
void SceneDataTest::camerasIntoArrayInvalidSizeOrOffset() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
struct Field {
UnsignedInt object;
UnsignedInt camera;
} fields[3]{};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Camera, view.slice(&Field::object), view.slice(&Field::camera)}
}};
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mappingDestinationCorrect[3];
UnsignedInt mappingDestination[2];
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
UnsignedInt fieldDestinationCorrect[3];
UnsignedInt fieldDestination[2];
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
scene.camerasInto(mappingDestination, fieldDestinationCorrect);
scene.camerasInto(mappingDestinationCorrect, fieldDestination);
scene.camerasInto(4, mappingDestination, fieldDestination);
scene.camerasInto(0, mappingDestinationCorrect, fieldDestination);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::camerasInto(): expected mapping destination view either empty or with 3 elements but got 2\n"
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
"Trade::SceneData::camerasInto(): expected field destination view either empty or with 3 elements but got 2\n"
"Trade::SceneData::camerasInto(): offset 4 out of bounds for a field of size 3\n"
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::camerasInto(): mapping and field destination views have different size, 3 vs 2\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
template<class T> void SceneDataTest::skinsAsArray() {
setTestCaseTemplateName(NameTraits<T>::name());
struct Field {
UnsignedByte object;
T skin;
} fields[]{
{0, T(15)},
{1, T(37)},
{15, T(44)}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedByte, 50, {}, fields, {
Trade: SceneField::Skin now requires a transformation to be present. Even an empty field, it's there just to disambiguate whether the skin is 2D or 3D.
5 years ago
/* To verify it isn't just picking the first ever field; also to
satisfy the requirement of having a transformation field to
disambiguate the dimensionality */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Translation, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Vector3, nullptr},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Skin, view.slice(&Field::object), view.slice(&Field::skin)}
}};
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.skinsAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, UnsignedInt>>({
{0, 15},
{1, 37},
{15, 44}
})), TestSuite::Compare::Container);
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
void SceneDataTest::skinsIntoArray() {
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
auto&& data = IntoArrayOffset1Data[testCaseInstanceId()];
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
setTestCaseDescription(data.name);
/* Both AsArray() and Into() share a common helper. The AsArray() test
above verified handling of various data types and this checks the
offset/size parameters of the Into() variant. */
struct Field {
UnsignedInt object;
UnsignedInt skin;
} fields[] {
{1, 15},
{0, 37},
{4, 44}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: SceneField::Skin now requires a transformation to be present. Even an empty field, it's there just to disambiguate whether the skin is 2D or 3D.
5 years ago
/* To verify it isn't just picking the first ever field; also to
satisfy the requirement of having a transformation field to
disambiguate the dimensionality */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Translation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Vector3, nullptr},
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
SceneFieldData{SceneField::Skin,
view.slice(&Field::object),
view.slice(&Field::skin)},
}};
/* The offset-less overload should give back all data */
{
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mapping[3];
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
UnsignedInt field[3];
scene.skinsInto(
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? Containers::arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field ? Containers::arrayView(field) : nullptr
);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object),
TestSuite::Compare::Container);
if(data.field) CORRADE_COMPARE_AS(Containers::stridedArrayView(field),
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
view.slice(&Field::skin),
TestSuite::Compare::Container);
/* The offset variant only a subset */
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::Array<UnsignedInt> mapping{data.size};
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Containers::Array<UnsignedInt> field{data.size};
CORRADE_COMPARE(scene.skinsInto(data.offset,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field ? arrayView(field) : nullptr
), data.expectedSize);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
if(data.field) CORRADE_COMPARE_AS(field.prefix(data.expectedSize),
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
view.slice(&Field::skin)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
void SceneDataTest::skinsIntoArrayInvalidSizeOrOffset() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
struct Field {
UnsignedInt object;
UnsignedInt skin;
} fields[3]{};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: SceneField::Skin now requires a transformation to be present. Even an empty field, it's there just to disambiguate whether the skin is 2D or 3D.
5 years ago
/* To satisfy the requirement of having a transformation field to
disambiguate the dimensionality */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Translation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Vector3, nullptr},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Skin, view.slice(&Field::object), view.slice(&Field::skin)}
}};
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mappingDestinationCorrect[3];
UnsignedInt mappingDestination[2];
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
UnsignedInt fieldDestinationCorrect[3];
UnsignedInt fieldDestination[2];
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
scene.skinsInto(mappingDestination, fieldDestinationCorrect);
scene.skinsInto(mappingDestinationCorrect, fieldDestination);
scene.skinsInto(4, mappingDestination, fieldDestination);
scene.skinsInto(0, mappingDestinationCorrect, fieldDestination);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::skinsInto(): expected mapping destination view either empty or with 3 elements but got 2\n"
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
"Trade::SceneData::skinsInto(): expected field destination view either empty or with 3 elements but got 2\n"
"Trade::SceneData::skinsInto(): offset 4 out of bounds for a field of size 3\n"
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::skinsInto(): mapping and field destination views have different size, 3 vs 2\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
template<class T> void SceneDataTest::importerStateAsArray() {
setTestCaseTemplateName(NameTraits<T>::name());
int a, b;
struct Field {
UnsignedByte object;
T importerState;
} fields[]{
{0, &a},
{1, nullptr},
{15, &b}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedByte, 50, {}, fields, {
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Int, nullptr},
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
SceneFieldData{SceneField::ImporterState, view.slice(&Field::object), view.slice(&Field::importerState)}
}};
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
CORRADE_COMPARE_AS(scene.importerStateAsArray(), (Containers::arrayView<Containers::Pair<UnsignedInt, const void*>>({
{0, &a},
{1, nullptr},
{15, &b}
})), TestSuite::Compare::Container);
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
}
void SceneDataTest::importerStateIntoArray() {
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
auto&& data = IntoArrayOffset1Data[testCaseInstanceId()];
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
setTestCaseDescription(data.name);
/* Both AsArray() and Into() share a common helper. The AsArray() test
above verified handling of various data types and this checks the
offset/size parameters of the Into() variant. */
int a, b;
struct Field {
UnsignedInt object;
const void* importerState;
} fields[]{
{1, &a},
{0, nullptr},
{4, &b}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
/* To verify it isn't just picking the first ever field */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
SceneFieldData{SceneField::ImporterState,
view.slice(&Field::object),
view.slice(&Field::importerState)},
}};
/* The offset-less overload should give back all data */
{
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mapping[3];
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
const void* field[3];
scene.importerStateInto(
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? Containers::arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field ? Containers::arrayView(field) : nullptr
);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(Containers::stridedArrayView(mapping),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object),
TestSuite::Compare::Container);
if(data.field) CORRADE_COMPARE_AS(Containers::stridedArrayView(field),
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
view.slice(&Field::importerState),
TestSuite::Compare::Container);
/* The offset variant only a subset */
} {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::Array<UnsignedInt> mapping{data.size};
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
Containers::Array<const void*> field{data.size};
CORRADE_COMPARE(scene.importerStateInto(data.offset,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
data.mapping ? arrayView(mapping) : nullptr,
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
data.field ? arrayView(field) : nullptr
), data.expectedSize);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
if(data.mapping) CORRADE_COMPARE_AS(mapping.prefix(data.expectedSize),
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
view.slice(&Field::object)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
if(data.field) CORRADE_COMPARE_AS(field.prefix(data.expectedSize),
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
view.slice(&Field::importerState)
.slice(data.offset, data.offset + data.expectedSize),
TestSuite::Compare::Container);
}
}
void SceneDataTest::importerStateIntoArrayInvalidSizeOrOffset() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
struct Field {
UnsignedInt object;
const void* importerState;
} fields[3]{};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
SceneFieldData{SceneField::ImporterState, view.slice(&Field::object), view.slice(&Field::importerState)}
}};
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mappingDestinationCorrect[3];
UnsignedInt mappingDestination[2];
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
const void* fieldDestinationCorrect[3];
const void* fieldDestination[2];
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
scene.importerStateInto(mappingDestination, fieldDestinationCorrect);
scene.importerStateInto(mappingDestinationCorrect, fieldDestination);
scene.importerStateInto(4, mappingDestination, fieldDestination);
scene.importerStateInto(0, mappingDestinationCorrect, fieldDestination);
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::importerStateInto(): expected mapping destination view either empty or with 3 elements but got 2\n"
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
"Trade::SceneData::importerStateInto(): expected field destination view either empty or with 3 elements but got 2\n"
"Trade::SceneData::importerStateInto(): offset 4 out of bounds for a field of size 3\n"
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::importerStateInto(): mapping and field destination views have different size, 3 vs 2\n");
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void SceneDataTest::mutableAccessNotAllowed() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
const struct Field {
UnsignedInt object;
UnsignedShort foobar;
UnsignedShort mesh;
} fields[2]{};
Containers::StridedArrayView1D<const Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, {}, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{sceneFieldCustom(35),
view.slice(&Field::object),
view.slice(&Field::foobar)},
SceneFieldData{SceneField::Mesh,
view.slice(&Field::object),
view.slice(&Field::mesh)},
}};
std::ostringstream out;
Error redirectError{&out};
scene.mutableData();
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
scene.mutableMapping(0);
scene.mutableMapping<UnsignedInt>(0);
scene.mutableMapping(SceneField::Mesh);
scene.mutableMapping<UnsignedInt>(SceneField::Mesh);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
scene.mutableField(0);
scene.mutableField<UnsignedInt>(0);
scene.mutableField<UnsignedInt[]>(1);
scene.mutableField(SceneField::Mesh);
scene.mutableField<UnsignedInt>(SceneField::Mesh);
scene.mutableField<UnsignedInt[]>(sceneFieldCustom(35));
CORRADE_COMPARE(out.str(),
"Trade::SceneData::mutableData(): data not mutable\n"
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::mutableMapping(): data not mutable\n"
"Trade::SceneData::mutableMapping(): data not mutable\n"
"Trade::SceneData::mutableMapping(): data not mutable\n"
"Trade::SceneData::mutableMapping(): data not mutable\n"
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
"Trade::SceneData::mutableField(): data not mutable\n"
"Trade::SceneData::mutableField(): data not mutable\n"
"Trade::SceneData::mutableField(): data not mutable\n"
"Trade::SceneData::mutableField(): data not mutable\n"
"Trade::SceneData::mutableField(): data not mutable\n"
"Trade::SceneData::mutableField(): data not mutable\n");
}
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
void SceneDataTest::mappingNotFound() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
struct Field {
UnsignedInt object;
UnsignedShort foobar;
UnsignedShort mesh;
} fields[2]{};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, DataFlag::Mutable, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{sceneFieldCustom(35), view.slice(&Field::object), view.slice(&Field::foobar)},
SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)},
}};
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
scene.mapping(2);
scene.mapping<UnsignedInt>(2);
scene.mutableMapping(2);
scene.mutableMapping<UnsignedInt>(2);
scene.mapping(sceneFieldCustom(666));
scene.mapping<UnsignedInt>(sceneFieldCustom(666));
scene.mutableMapping(sceneFieldCustom(666));
scene.mutableMapping<UnsignedInt>(sceneFieldCustom(666));
scene.mappingAsArray(2);
scene.mappingAsArray(sceneFieldCustom(666));
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::mapping(): index 2 out of range for 2 fields\n"
"Trade::SceneData::mapping(): index 2 out of range for 2 fields\n"
"Trade::SceneData::mutableMapping(): index 2 out of range for 2 fields\n"
"Trade::SceneData::mutableMapping(): index 2 out of range for 2 fields\n"
"Trade::SceneData::mapping(): field Trade::SceneField::Custom(666) not found\n"
"Trade::SceneData::mapping(): field Trade::SceneField::Custom(666) not found\n"
"Trade::SceneData::mutableMapping(): field Trade::SceneField::Custom(666) not found\n"
"Trade::SceneData::mutableMapping(): field Trade::SceneField::Custom(666) not found\n"
"Trade::SceneData::mappingInto(): index 2 out of range for 2 fields\n"
"Trade::SceneData::mappingInto(): field Trade::SceneField::Custom(666) not found\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
void SceneDataTest::mappingWrongType() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
struct Field {
UnsignedShort object;
UnsignedShort foobar;
UnsignedInt mesh;
} fields[2]{};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedShort, 5, DataFlag::Mutable, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{sceneFieldCustom(35), view.slice(&Field::object), view.slice(&Field::foobar)},
SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)},
}};
std::ostringstream out;
Error redirectError{&out};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
scene.mapping<UnsignedByte>(1);
scene.mutableMapping<UnsignedByte>(1);
scene.mapping<UnsignedByte>(SceneField::Mesh);
scene.mutableMapping<UnsignedByte>(SceneField::Mesh);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
"Trade::SceneData::mapping(): mapping is Trade::SceneMappingType::UnsignedShort but requested Trade::SceneMappingType::UnsignedByte\n"
"Trade::SceneData::mutableMapping(): mapping is Trade::SceneMappingType::UnsignedShort but requested Trade::SceneMappingType::UnsignedByte\n"
"Trade::SceneData::mapping(): mapping is Trade::SceneMappingType::UnsignedShort but requested Trade::SceneMappingType::UnsignedByte\n"
"Trade::SceneData::mutableMapping(): mapping is Trade::SceneMappingType::UnsignedShort but requested Trade::SceneMappingType::UnsignedByte\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
void SceneDataTest::fieldNotFound() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
struct Field {
UnsignedInt object;
UnsignedInt foo, bar;
} fields[2]{};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, DataFlag::Mutable, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{sceneFieldCustom(34), view.slice(&Field::object), view.slice(&Field::foo)},
SceneFieldData{sceneFieldCustom(35), view.slice(&Field::object), view.slice(&Field::bar)},
}};
std::ostringstream out;
Error redirectError{&out};
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
scene.findFieldObjectOffset(2, 0);
scene.fieldObjectOffset(2, 0);
scene.hasFieldObject(2, 0);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
scene.fieldData(2);
scene.fieldName(2);
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
scene.fieldFlags(2);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
scene.fieldType(2);
scene.fieldSize(2);
scene.fieldArraySize(2);
scene.field(2);
scene.field<UnsignedInt>(2);
scene.field<UnsignedInt[]>(2);
scene.mutableField(2);
scene.mutableField<UnsignedInt>(2);
scene.mutableField<UnsignedInt[]>(2);
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
scene.fieldBits(2);
scene.fieldBitArrays(2);
scene.mutableFieldBits(2);
scene.mutableFieldBitArrays(2);
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
scene.fieldStringData(2);
scene.fieldStrings(2);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
scene.fieldId(sceneFieldCustom(666));
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
scene.fieldFlags(sceneFieldCustom(666));
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
scene.findFieldObjectOffset(sceneFieldCustom(666), 0);
scene.fieldObjectOffset(sceneFieldCustom(666), 0);
scene.hasFieldObject(sceneFieldCustom(666), 0);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
scene.fieldType(sceneFieldCustom(666));
scene.fieldSize(sceneFieldCustom(666));
scene.fieldArraySize(sceneFieldCustom(666));
scene.field(sceneFieldCustom(666));
scene.field<UnsignedInt>(sceneFieldCustom(666));
scene.field<UnsignedInt[]>(sceneFieldCustom(666));
scene.mutableField(sceneFieldCustom(666));
scene.mutableField<UnsignedInt>(sceneFieldCustom(666));
scene.mutableField<UnsignedInt[]>(sceneFieldCustom(666));
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
scene.fieldBits(sceneFieldCustom(666));
scene.fieldBitArrays(sceneFieldCustom(666));
scene.mutableFieldBits(sceneFieldCustom(666));
scene.mutableFieldBitArrays(sceneFieldCustom(666));
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
scene.fieldStringData(sceneFieldCustom(666));
scene.fieldStrings(sceneFieldCustom(666));
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
scene.parentsAsArray();
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
scene.parentsInto(nullptr, nullptr);
scene.parentsInto(0, nullptr, nullptr);
Trade: add SceneData::transformationFieldSize().
4 years ago
scene.transformationFieldSize();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
scene.transformations2DAsArray();
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
scene.transformations2DInto(nullptr, nullptr);
scene.transformations2DInto(0, nullptr, nullptr);
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
scene.translationsRotationsScalings2DAsArray();
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
scene.translationsRotationsScalings2DInto(nullptr, nullptr, nullptr, nullptr);
scene.translationsRotationsScalings2DInto(0, nullptr, nullptr, nullptr, nullptr);
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
scene.transformations3DAsArray();
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
scene.transformations3DInto(nullptr, nullptr);
scene.transformations3DInto(0, nullptr, nullptr);
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
scene.translationsRotationsScalings3DAsArray();
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
scene.translationsRotationsScalings3DInto(nullptr, nullptr, nullptr, nullptr);
scene.translationsRotationsScalings3DInto(0, nullptr, nullptr, nullptr, nullptr);
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
scene.meshesMaterialsAsArray();
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
scene.meshesMaterialsInto(nullptr, nullptr, nullptr);
scene.meshesMaterialsInto(0, nullptr, nullptr, nullptr);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
scene.lightsAsArray();
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
scene.lightsInto(nullptr, nullptr);
scene.lightsInto(0, nullptr, nullptr);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
scene.camerasAsArray();
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
scene.camerasInto(nullptr, nullptr);
scene.camerasInto(0, nullptr, nullptr);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
scene.skinsAsArray();
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
scene.skinsInto(nullptr, nullptr);
scene.skinsInto(0, nullptr, nullptr);
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
scene.importerStateAsArray();
Trade: SceneData::*AsArray() and *Into() now return object IDs as well. Because that way one can query a field with *AsArray() and iterate through it in a single expression. This also resolves the pending issue where it was more than annoying to fetch object mapping for TRS fields when only a subset of the fields is available.
5 years ago
scene.importerStateInto(nullptr, nullptr);
scene.importerStateInto(0, nullptr, nullptr);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
"Trade::SceneData::findFieldObjectOffset(): index 2 out of range for 2 fields\n"
"Trade::SceneData::fieldObjectOffset(): index 2 out of range for 2 fields\n"
"Trade::SceneData::hasFieldObject(): index 2 out of range for 2 fields\n"
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
"Trade::SceneData::fieldData(): index 2 out of range for 2 fields\n"
"Trade::SceneData::fieldName(): index 2 out of range for 2 fields\n"
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
"Trade::SceneData::fieldFlags(): index 2 out of range for 2 fields\n"
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
"Trade::SceneData::fieldType(): index 2 out of range for 2 fields\n"
"Trade::SceneData::fieldSize(): index 2 out of range for 2 fields\n"
"Trade::SceneData::fieldArraySize(): index 2 out of range for 2 fields\n"
"Trade::SceneData::field(): index 2 out of range for 2 fields\n"
"Trade::SceneData::field(): index 2 out of range for 2 fields\n"
"Trade::SceneData::field(): index 2 out of range for 2 fields\n"
"Trade::SceneData::mutableField(): index 2 out of range for 2 fields\n"
"Trade::SceneData::mutableField(): index 2 out of range for 2 fields\n"
"Trade::SceneData::mutableField(): index 2 out of range for 2 fields\n"
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
"Trade::SceneData::fieldBits(): index 2 out of range for 2 fields\n"
"Trade::SceneData::fieldBitArrays(): index 2 out of range for 2 fields\n"
"Trade::SceneData::mutableFieldBits(): index 2 out of range for 2 fields\n"
"Trade::SceneData::mutableFieldBitArrays(): index 2 out of range for 2 fields\n"
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
"Trade::SceneData::fieldStringData(): index 2 out of range for 2 fields\n"
"Trade::SceneData::fieldStrings(): index 2 out of range for 2 fields\n"
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
"Trade::SceneData::fieldId(): field Trade::SceneField::Custom(666) not found\n"
Trade: flags for annotating SceneData field object mappings. Currently used by the per-object access APIs to make the lookup constant- or logarithmic-time instead of linear, available for use by external data consumers as well.
4 years ago
"Trade::SceneData::fieldFlags(): field Trade::SceneField::Custom(666) not found\n"
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
"Trade::SceneData::findFieldObjectOffset(): field Trade::SceneField::Custom(666) not found\n"
"Trade::SceneData::fieldObjectOffset(): field Trade::SceneField::Custom(666) not found\n"
"Trade::SceneData::hasFieldObject(): field Trade::SceneField::Custom(666) not found\n"
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
"Trade::SceneData::fieldType(): field Trade::SceneField::Custom(666) not found\n"
"Trade::SceneData::fieldSize(): field Trade::SceneField::Custom(666) not found\n"
"Trade::SceneData::fieldArraySize(): field Trade::SceneField::Custom(666) not found\n"
"Trade::SceneData::field(): field Trade::SceneField::Custom(666) not found\n"
"Trade::SceneData::field(): field Trade::SceneField::Custom(666) not found\n"
"Trade::SceneData::field(): field Trade::SceneField::Custom(666) not found\n"
"Trade::SceneData::mutableField(): field Trade::SceneField::Custom(666) not found\n"
"Trade::SceneData::mutableField(): field Trade::SceneField::Custom(666) not found\n"
"Trade::SceneData::mutableField(): field Trade::SceneField::Custom(666) not found\n"
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
"Trade::SceneData::fieldBits(): field Trade::SceneField::Custom(666) not found\n"
"Trade::SceneData::fieldBitArrays(): field Trade::SceneField::Custom(666) not found\n"
"Trade::SceneData::mutableFieldBits(): field Trade::SceneField::Custom(666) not found\n"
"Trade::SceneData::mutableFieldBitArrays(): field Trade::SceneField::Custom(666) not found\n"
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
"Trade::SceneData::fieldStringData(): field Trade::SceneField::Custom(666) not found\n"
"Trade::SceneData::fieldStrings(): field Trade::SceneField::Custom(666) not found\n"
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
/* AsArray() and Into() each share a common helper but have different
top-level code paths. They however have the same assertion messages
to save binary size a bit. */
"Trade::SceneData::parentsInto(): field not found\n"
"Trade::SceneData::parentsInto(): field not found\n"
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
"Trade::SceneData::parentsInto(): field not found\n"
Trade: add SceneData::transformationFieldSize().
4 years ago
"Trade::SceneData::transformationFieldSize(): no transformation-related field found\n"
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
"Trade::SceneData::transformations2DInto(): no transformation-related field found\n"
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
"Trade::SceneData::transformations2DInto(): no transformation-related field found\n"
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
"Trade::SceneData::transformations2DInto(): no transformation-related field found\n"
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
"Trade::SceneData::translationsRotationsScalings2DInto(): no transformation-related field found\n"
"Trade::SceneData::translationsRotationsScalings2DInto(): no transformation-related field found\n"
"Trade::SceneData::translationsRotationsScalings2DInto(): no transformation-related field found\n"
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
"Trade::SceneData::transformations3DInto(): no transformation-related field found\n"
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
"Trade::SceneData::transformations3DInto(): no transformation-related field found\n"
"Trade::SceneData::transformations3DInto(): no transformation-related field found\n"
Trade: convenience access to separate TRS components in SceneData. Because just the combined transformation may not be enough for handling animations. For example.
5 years ago
"Trade::SceneData::translationsRotationsScalings3DInto(): no transformation-related field found\n"
"Trade::SceneData::translationsRotationsScalings3DInto(): no transformation-related field found\n"
"Trade::SceneData::translationsRotationsScalings3DInto(): no transformation-related field found\n"
Trade: combine mesh and material SceneData convenience APIs together. In most cases the user would want to fetch both anyway, and since they're forced to share the same object mapping this is easy to do.
5 years ago
"Trade::SceneData::meshesMaterialsInto(): field Trade::SceneField::Mesh not found\n"
"Trade::SceneData::meshesMaterialsInto(): field Trade::SceneField::Mesh not found\n"
"Trade::SceneData::meshesMaterialsInto(): field Trade::SceneField::Mesh not found\n"
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
"Trade::SceneData::lightsInto(): field not found\n"
"Trade::SceneData::lightsInto(): field not found\n"
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
"Trade::SceneData::lightsInto(): field not found\n"
"Trade::SceneData::camerasInto(): field not found\n"
Trade: add SceneData::fooInto() overloads for subranges. Useful for cases when it's desirable to extract just some elements, for example just for a particular object ID. Or when allocating an arbitrarily large array isn't wanted for perf/memory reasons.
5 years ago
"Trade::SceneData::camerasInto(): field not found\n"
"Trade::SceneData::camerasInto(): field not found\n"
"Trade::SceneData::skinsInto(): field not found\n"
"Trade::SceneData::skinsInto(): field not found\n"
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
"Trade::SceneData::skinsInto(): field not found\n"
"Trade::SceneData::importerStateInto(): field not found\n"
"Trade::SceneData::importerStateInto(): field not found\n"
"Trade::SceneData::importerStateInto(): field not found\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
void SceneDataTest::fieldWrongType() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
struct Field {
UnsignedInt object;
UnsignedShort foobar;
UnsignedShort mesh;
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
bool yes;
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
} fields[2]{};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, DataFlag::Mutable, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{sceneFieldCustom(35), view.slice(&Field::object), view.slice(&Field::foobar)},
SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)},
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
SceneFieldData{sceneFieldCustom(773), view.slice(&Field::object), view.slice(&Field::yes).sliceBit(0)},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}};
std::ostringstream out;
Error redirectError{&out};
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
scene.field(2);
scene.mutableField(2);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
scene.field<UnsignedByte>(1);
scene.field<UnsignedByte[]>(1);
scene.mutableField<UnsignedByte>(1);
scene.mutableField<UnsignedByte[]>(1);
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
/* Accessing SceneFieldType::Bit through field<T>(2) etc. is handled by the
same code path as accessing via a mismatched type, no need to test those
explicitly */
scene.fieldBits(1);
scene.fieldBitArrays(1);
scene.mutableFieldBits(1);
scene.mutableFieldBitArrays(1);
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
scene.fieldStringData(1);
scene.fieldStrings(1);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
scene.field<UnsignedByte>(SceneField::Mesh);
scene.field<UnsignedByte[]>(SceneField::Mesh);
scene.mutableField<UnsignedByte>(SceneField::Mesh);
scene.mutableField<UnsignedByte[]>(SceneField::Mesh);
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
scene.field(sceneFieldCustom(773));
scene.mutableField(sceneFieldCustom(773));
/* Accessing SceneFieldType::Bit through field<T>(2) etc. is handled by the
same code path as accessing via a mismatched type, no need to test those
explicitly */
scene.fieldBits(SceneField::Mesh);
scene.fieldBitArrays(SceneField::Mesh);
scene.mutableFieldBits(SceneField::Mesh);
scene.mutableFieldBitArrays(SceneField::Mesh);
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
scene.fieldStringData(SceneField::Mesh);
scene.fieldStrings(SceneField::Mesh);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
"Trade::SceneData::field(): Trade::SceneField::Custom(773) is Trade::SceneFieldType::Bit, use fieldBits() or fieldBitArrays() to access it\n"
"Trade::SceneData::mutableField(): Trade::SceneField::Custom(773) is Trade::SceneFieldType::Bit, use mutableFieldBits() or mutableFieldBitArrays() to access it\n"
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
"Trade::SceneData::field(): Trade::SceneField::Mesh is Trade::SceneFieldType::UnsignedShort but requested a type equivalent to Trade::SceneFieldType::UnsignedByte\n"
"Trade::SceneData::field(): Trade::SceneField::Mesh is Trade::SceneFieldType::UnsignedShort but requested a type equivalent to Trade::SceneFieldType::UnsignedByte\n"
"Trade::SceneData::mutableField(): Trade::SceneField::Mesh is Trade::SceneFieldType::UnsignedShort but requested a type equivalent to Trade::SceneFieldType::UnsignedByte\n"
"Trade::SceneData::mutableField(): Trade::SceneField::Mesh is Trade::SceneFieldType::UnsignedShort but requested a type equivalent to Trade::SceneFieldType::UnsignedByte\n"
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
"Trade::SceneData::fieldBits(): Trade::SceneField::Mesh is Trade::SceneFieldType::UnsignedShort, not a bit\n"
"Trade::SceneData::fieldBitArrays(): Trade::SceneField::Mesh is Trade::SceneFieldType::UnsignedShort, not a bit\n"
"Trade::SceneData::mutableFieldBits(): Trade::SceneField::Mesh is Trade::SceneFieldType::UnsignedShort, not a bit\n"
"Trade::SceneData::mutableFieldBitArrays(): Trade::SceneField::Mesh is Trade::SceneFieldType::UnsignedShort, not a bit\n"
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
"Trade::SceneData::fieldStringData(): Trade::SceneField::Mesh is Trade::SceneFieldType::UnsignedShort, not a string\n"
"Trade::SceneData::fieldStrings(): Trade::SceneField::Mesh is Trade::SceneFieldType::UnsignedShort, not a string\n"
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
"Trade::SceneData::field(): Trade::SceneField::Mesh is Trade::SceneFieldType::UnsignedShort but requested a type equivalent to Trade::SceneFieldType::UnsignedByte\n"
"Trade::SceneData::field(): Trade::SceneField::Mesh is Trade::SceneFieldType::UnsignedShort but requested a type equivalent to Trade::SceneFieldType::UnsignedByte\n"
"Trade::SceneData::mutableField(): Trade::SceneField::Mesh is Trade::SceneFieldType::UnsignedShort but requested a type equivalent to Trade::SceneFieldType::UnsignedByte\n"
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
"Trade::SceneData::mutableField(): Trade::SceneField::Mesh is Trade::SceneFieldType::UnsignedShort but requested a type equivalent to Trade::SceneFieldType::UnsignedByte\n"
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
"Trade::SceneData::field(): Trade::SceneField::Custom(773) is Trade::SceneFieldType::Bit, use fieldBits() or fieldBitArrays() to access it\n"
"Trade::SceneData::mutableField(): Trade::SceneField::Custom(773) is Trade::SceneFieldType::Bit, use mutableFieldBits() or mutableFieldBitArrays() to access it\n"
"Trade::SceneData::fieldBits(): Trade::SceneField::Mesh is Trade::SceneFieldType::UnsignedShort, not a bit\n"
"Trade::SceneData::fieldBitArrays(): Trade::SceneField::Mesh is Trade::SceneFieldType::UnsignedShort, not a bit\n"
"Trade::SceneData::mutableFieldBits(): Trade::SceneField::Mesh is Trade::SceneFieldType::UnsignedShort, not a bit\n"
"Trade::SceneData::mutableFieldBitArrays(): Trade::SceneField::Mesh is Trade::SceneFieldType::UnsignedShort, not a bit\n"
Trade: support storing string fields in SceneData. Finally got an idea how to provide various options store these efficiently, so it's implemented now. Five different storage variants times four different type sizes.
3 years ago
"Trade::SceneData::fieldStringData(): Trade::SceneField::Mesh is Trade::SceneFieldType::UnsignedShort, not a string\n"
"Trade::SceneData::fieldStrings(): Trade::SceneField::Mesh is Trade::SceneFieldType::UnsignedShort, not a string\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
void SceneDataTest::fieldWrongPointerType() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
struct Thing {
UnsignedInt object;
Int* foobar;
const Int* importerState;
} things[2];
Containers::StridedArrayView1D<Thing> view = things;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, DataFlag::Mutable, things, {
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
SceneFieldData{sceneFieldCustom(35), view.slice(&Thing::object), Containers::arrayCast<2, Int*>(view.slice(&Thing::foobar))},
SceneFieldData{SceneField::ImporterState, view.slice(&Thing::object), view.slice(&Thing::importerState)},
}};
/* These are fine (type is not checked) */
scene.field<Float*[]>(0);
scene.field<const Float*>(1);
scene.mutableField<Float*[]>(0);
scene.mutableField<const Float*>(1);
scene.field<Float*[]>(sceneFieldCustom(35));
scene.field<const Float*>(SceneField::ImporterState);
scene.mutableField<Float*[]>(sceneFieldCustom(35));
scene.mutableField<const Float*>(SceneField::ImporterState);
std::ostringstream out;
Error redirectError{&out};
scene.field<Int>(0);
scene.field<const Int*>(0);
scene.field<const Int*[]>(0);
scene.field<Int*>(1);
scene.field<Int*[]>(1);
scene.mutableField<Int>(0);
scene.mutableField<const Int*>(0);
scene.mutableField<const Int*[]>(0);
scene.mutableField<Int*>(1);
scene.mutableField<Int*[]>(1);
scene.field<Int>(sceneFieldCustom(35));
scene.field<const Int*>(sceneFieldCustom(35));
scene.field<const Int*[]>(sceneFieldCustom(35));
scene.field<Int*>(SceneField::ImporterState);
scene.field<Int*>(SceneField::ImporterState);
scene.mutableField<Int>(sceneFieldCustom(35));
scene.mutableField<const Int*>(sceneFieldCustom(35));
scene.mutableField<const Int*[]>(sceneFieldCustom(35));
scene.mutableField<Int*>(SceneField::ImporterState);
scene.mutableField<Int*[]>(SceneField::ImporterState);
CORRADE_COMPARE(out.str(),
"Trade::SceneData::field(): Trade::SceneField::Custom(35) is Trade::SceneFieldType::MutablePointer but requested a type equivalent to Trade::SceneFieldType::Int\n"
"Trade::SceneData::field(): Trade::SceneField::Custom(35) is Trade::SceneFieldType::MutablePointer but requested a type equivalent to Trade::SceneFieldType::Pointer\n"
"Trade::SceneData::field(): Trade::SceneField::Custom(35) is Trade::SceneFieldType::MutablePointer but requested a type equivalent to Trade::SceneFieldType::Pointer\n"
"Trade::SceneData::field(): Trade::SceneField::ImporterState is Trade::SceneFieldType::Pointer but requested a type equivalent to Trade::SceneFieldType::MutablePointer\n"
"Trade::SceneData::field(): Trade::SceneField::ImporterState is Trade::SceneFieldType::Pointer but requested a type equivalent to Trade::SceneFieldType::MutablePointer\n"
"Trade::SceneData::mutableField(): Trade::SceneField::Custom(35) is Trade::SceneFieldType::MutablePointer but requested a type equivalent to Trade::SceneFieldType::Int\n"
"Trade::SceneData::mutableField(): Trade::SceneField::Custom(35) is Trade::SceneFieldType::MutablePointer but requested a type equivalent to Trade::SceneFieldType::Pointer\n"
"Trade::SceneData::mutableField(): Trade::SceneField::Custom(35) is Trade::SceneFieldType::MutablePointer but requested a type equivalent to Trade::SceneFieldType::Pointer\n"
"Trade::SceneData::mutableField(): Trade::SceneField::ImporterState is Trade::SceneFieldType::Pointer but requested a type equivalent to Trade::SceneFieldType::MutablePointer\n"
"Trade::SceneData::mutableField(): Trade::SceneField::ImporterState is Trade::SceneFieldType::Pointer but requested a type equivalent to Trade::SceneFieldType::MutablePointer\n"
"Trade::SceneData::field(): Trade::SceneField::Custom(35) is Trade::SceneFieldType::MutablePointer but requested a type equivalent to Trade::SceneFieldType::Int\n"
"Trade::SceneData::field(): Trade::SceneField::Custom(35) is Trade::SceneFieldType::MutablePointer but requested a type equivalent to Trade::SceneFieldType::Pointer\n"
"Trade::SceneData::field(): Trade::SceneField::Custom(35) is Trade::SceneFieldType::MutablePointer but requested a type equivalent to Trade::SceneFieldType::Pointer\n"
"Trade::SceneData::field(): Trade::SceneField::ImporterState is Trade::SceneFieldType::Pointer but requested a type equivalent to Trade::SceneFieldType::MutablePointer\n"
"Trade::SceneData::field(): Trade::SceneField::ImporterState is Trade::SceneFieldType::Pointer but requested a type equivalent to Trade::SceneFieldType::MutablePointer\n"
"Trade::SceneData::mutableField(): Trade::SceneField::Custom(35) is Trade::SceneFieldType::MutablePointer but requested a type equivalent to Trade::SceneFieldType::Int\n"
"Trade::SceneData::mutableField(): Trade::SceneField::Custom(35) is Trade::SceneFieldType::MutablePointer but requested a type equivalent to Trade::SceneFieldType::Pointer\n"
"Trade::SceneData::mutableField(): Trade::SceneField::Custom(35) is Trade::SceneFieldType::MutablePointer but requested a type equivalent to Trade::SceneFieldType::Pointer\n"
"Trade::SceneData::mutableField(): Trade::SceneField::ImporterState is Trade::SceneFieldType::Pointer but requested a type equivalent to Trade::SceneFieldType::MutablePointer\n"
"Trade::SceneData::mutableField(): Trade::SceneField::ImporterState is Trade::SceneFieldType::Pointer but requested a type equivalent to Trade::SceneFieldType::MutablePointer\n");
}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void SceneDataTest::fieldWrongArrayAccess() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
struct Field {
UnsignedInt object;
UnsignedInt foobar;
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
bool yes;
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
} fields[2]{};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 5, DataFlag::Mutable, fields, {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{sceneFieldCustom(35), view.slice(&Field::object), Containers::arrayCast<2, UnsignedInt>(view.slice(&Field::foobar))},
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
SceneFieldData{sceneFieldCustom(773), view.slice(&Field::object), Containers::StridedBitArrayView2D{Containers::BitArrayView{fields}, &fields[0].yes, 0, {2, 3}, {sizeof(Field)*8, 1}}},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}};
Trade: allow array access to all SceneData/MeshData fields/attributes. In retrospect, the limitation made no sense and only prevented user code from having a common handling for all possible variants.
3 years ago
/* Array access is allowed for non-array fields (the second dimension is
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
then always 1), tested directly in construct() and constructBit() */
Trade: allow array access to all SceneData/MeshData fields/attributes. In retrospect, the limitation made no sense and only prevented user code from having a common handling for all possible variants.
3 years ago
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
std::ostringstream out;
Error redirectError{&out};
Trade: allow array access to all SceneData/MeshData fields/attributes. In retrospect, the limitation made no sense and only prevented user code from having a common handling for all possible variants.
3 years ago
scene.field<UnsignedInt>(0);
scene.mutableField<UnsignedInt>(0);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
scene.field<UnsignedInt>(sceneFieldCustom(35));
scene.mutableField<UnsignedInt>(sceneFieldCustom(35));
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
scene.fieldBits(1);
scene.mutableFieldBits(1);
scene.fieldBits(sceneFieldCustom(773));
scene.mutableFieldBits(sceneFieldCustom(773));
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
CORRADE_COMPARE(out.str(),
"Trade::SceneData::field(): Trade::SceneField::Custom(35) is an array field, use T[] to access it\n"
"Trade::SceneData::mutableField(): Trade::SceneField::Custom(35) is an array field, use T[] to access it\n"
"Trade::SceneData::field(): Trade::SceneField::Custom(35) is an array field, use T[] to access it\n"
Trade: implement SceneField::Bit. Uses StridedBitArrayView underneath. Waited for this container to exist, because implementing this using bools and wasting 8x more memory wasn't a good option. Plus, being able to address single bits opens a possibility to describe individual bits in enum flags, whereas the only other option would be to take the whole flag as an opaque type containing "some bit values".
3 years ago
"Trade::SceneData::mutableField(): Trade::SceneField::Custom(35) is an array field, use T[] to access it\n"
"Trade::SceneData::fieldBits(): Trade::SceneField::Custom(773) is an array field, use fieldBitArrays() to access it\n"
"Trade::SceneData::mutableFieldBits(): Trade::SceneField::Custom(773) is an array field, use fieldBitArrays() to access it\n"
"Trade::SceneData::fieldBits(): Trade::SceneField::Custom(773) is an array field, use fieldBitArrays() to access it\n"
"Trade::SceneData::mutableFieldBits(): Trade::SceneField::Custom(773) is an array field, use fieldBitArrays() to access it\n");
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
void SceneDataTest::parentFor() {
Trade: convenience per-object field access in SceneData.
5 years ago
struct Field {
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
UnsignedInt object;
Trade: convenience per-object field access in SceneData.
5 years ago
Int parent;
Trade: add a parentFor() object-oriented accessor as well. For a lack of better API right now, this will be used to check if an object belongs to a certain scene. In the future, when BitArray is a thing, there will be a dedicated field with a mask telling which objects belong to the scene and which not, with a fallback that goes through all field object mappings and collects objects that have at least one field.
5 years ago
} fields[]{
{3, -1},
Trade: remove the useless indirection from SceneField::Parent. This got originally added as some sort of a kludge to make it easy to go to the parent transformation, assuming Parent and Transformation share the same object mapping: parentTransformation = transformations[parents[i]] But after some ACTUAL REAL WORLD use, I realized that there's often a set of objects that have a Parent defined, and then another, completely disjoint, set of objects that have a transformation (for example certain nodes having no transformation at all because it's an identity). And so this parent indirection is not only useless, but in fact an additional complication. Let's say we make a map of the transformations, where transformationMap[i] is a transformation for object i: transformationMap = {} for j in range(len(transformations)): transformationMap[transformationObject[j]] = transformation[j] Then, with *no* assumptions about shared object mapping, the indirection would cause parent transformation retrieval to look like this: parentTransformation = transformationMap[parentObjects[parents[i]] While *without* the indirection, it'd be just parentTransformation = transformationMap[parents[i]]
5 years ago
{4, 3},
{2, 4},
Trade: add a parentFor() object-oriented accessor as well. For a lack of better API right now, this will be used to check if an object belongs to a certain scene. In the future, when BitArray is a thing, there will be a dedicated field with a mask telling which objects belong to the scene and which not, with a fallback that goes through all field object mappings and collects objects that have at least one field.
5 years ago
{4, 2} /* duplicate, ignored */
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
Trade: add a parentFor() object-oriented accessor as well. For a lack of better API right now, this will be used to check if an object belongs to a certain scene. In the future, when BitArray is a thing, there will be a dedicated field with a mask telling which objects belong to the scene and which not, with a fallback that goes through all field object mappings and collects objects that have at least one field.
5 years ago
SceneFieldData{SceneField::Parent, view.slice(&Field::object), view.slice(&Field::parent)}
}};
CORRADE_COMPARE(scene.parentFor(2), 4);
CORRADE_COMPARE(scene.parentFor(3), -1);
/* Duplicate entries -- only the first one gets used, it doesn't traverse
further */
CORRADE_COMPARE(scene.parentFor(4), 3);
/* Object that's not in the array at all */
CORRADE_COMPARE(scene.parentFor(1), Containers::NullOpt);
}
Trade: test SceneData::{parentFor,childrenFor}() with trivial parents. Hmm, doesn't look right. A bug somewhere!
5 years ago
void SceneDataTest::parentForTrivialParent() {
/* Going a bit overboard with the arrays, it makes the view creation below
easier tho */
struct Field {
UnsignedInt object[4];
Int parent[1];
} fields[]{{
{3, 4, 2, 4 /* duplicate, ignored */}, {-1}
}};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
Trade: test SceneData::{parentFor,childrenFor}() with trivial parents. Hmm, doesn't look right. A bug somewhere!
5 years ago
SceneFieldData{SceneField::Parent,
Containers::stridedArrayView(fields->object), Containers::stridedArrayView(fields->parent).broadcasted<0>(4)}
}};
CORRADE_COMPARE(scene.parentFor(2), -1);
CORRADE_COMPARE(scene.parentFor(3), -1);
/* Duplicate entries -- only the first one gets used, it doesn't traverse
further */
CORRADE_COMPARE(scene.parentFor(4), -1);
/* Object that's not in the array at all */
CORRADE_COMPARE(scene.parentFor(1), Containers::NullOpt);
}
Trade: add a parentFor() object-oriented accessor as well. For a lack of better API right now, this will be used to check if an object belongs to a certain scene. In the future, when BitArray is a thing, there will be a dedicated field with a mask telling which objects belong to the scene and which not, with a fallback that goes through all field object mappings and collects objects that have at least one field.
5 years ago
void SceneDataTest::childrenFor() {
struct Field {
UnsignedInt object;
Int parent;
Trade: convenience per-object field access in SceneData.
5 years ago
} fields[]{
{4, -1},
Trade: remove the useless indirection from SceneField::Parent. This got originally added as some sort of a kludge to make it easy to go to the parent transformation, assuming Parent and Transformation share the same object mapping: parentTransformation = transformations[parents[i]] But after some ACTUAL REAL WORLD use, I realized that there's often a set of objects that have a Parent defined, and then another, completely disjoint, set of objects that have a transformation (for example certain nodes having no transformation at all because it's an identity). And so this parent indirection is not only useless, but in fact an additional complication. Let's say we make a map of the transformations, where transformationMap[i] is a transformation for object i: transformationMap = {} for j in range(len(transformations)): transformationMap[transformationObject[j]] = transformation[j] Then, with *no* assumptions about shared object mapping, the indirection would cause parent transformation retrieval to look like this: parentTransformation = transformationMap[parentObjects[parents[i]] While *without* the indirection, it'd be just parentTransformation = transformationMap[parents[i]]
5 years ago
{3, 4},
{2, 3},
{1, 4},
{5, 4},
Trade: convenience per-object field access in SceneData.
5 years ago
{0, -1},
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
Trade: convenience per-object field access in SceneData.
5 years ago
SceneFieldData{SceneField::Parent, view.slice(&Field::object), view.slice(&Field::parent)}
}};
/* Just one child */
CORRADE_COMPARE_AS(scene.childrenFor(3),
Trade: use 64-bit values in object-oriented SceneData APIs. Mostly just to avoid the return types changing to incompatible types in the future, breaking existing code. The internals are currently not fully ready to operate with 64-bit object IDs, especially the AsArray() APIs -- those I will have to solve in the future somehow. Returning 64-bit values in the pairs would add four byte padding after basically each value, which is way too wasteful for the common case. The Into() APIs could eventually get 64-bit overloads though.
4 years ago
Containers::arrayView<UnsignedLong>({2}),
Trade: convenience per-object field access in SceneData.
5 years ago
TestSuite::Compare::Container);
/* More */
CORRADE_COMPARE_AS(scene.childrenFor(-1),
Trade: use 64-bit values in object-oriented SceneData APIs. Mostly just to avoid the return types changing to incompatible types in the future, breaking existing code. The internals are currently not fully ready to operate with 64-bit object IDs, especially the AsArray() APIs -- those I will have to solve in the future somehow. Returning 64-bit values in the pairs would add four byte padding after basically each value, which is way too wasteful for the common case. The Into() APIs could eventually get 64-bit overloads though.
4 years ago
Containers::arrayView<UnsignedLong>({4, 0}),
Trade: convenience per-object field access in SceneData.
5 years ago
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.childrenFor(4),
Trade: use 64-bit values in object-oriented SceneData APIs. Mostly just to avoid the return types changing to incompatible types in the future, breaking existing code. The internals are currently not fully ready to operate with 64-bit object IDs, especially the AsArray() APIs -- those I will have to solve in the future somehow. Returning 64-bit values in the pairs would add four byte padding after basically each value, which is way too wasteful for the common case. The Into() APIs could eventually get 64-bit overloads though.
4 years ago
Containers::arrayView<UnsignedLong>({3, 1, 5}),
Trade: convenience per-object field access in SceneData.
5 years ago
TestSuite::Compare::Container);
/* Object that is present in the parent array but has no children */
CORRADE_COMPARE_AS(scene.childrenFor(5),
Trade: use 64-bit values in object-oriented SceneData APIs. Mostly just to avoid the return types changing to incompatible types in the future, breaking existing code. The internals are currently not fully ready to operate with 64-bit object IDs, especially the AsArray() APIs -- those I will have to solve in the future somehow. Returning 64-bit values in the pairs would add four byte padding after basically each value, which is way too wasteful for the common case. The Into() APIs could eventually get 64-bit overloads though.
4 years ago
Containers::arrayView<UnsignedLong>({}),
Trade: convenience per-object field access in SceneData.
5 years ago
TestSuite::Compare::Container);
/* Object that is not in the parent array at all */
CORRADE_COMPARE_AS(scene.childrenFor(6),
Trade: use 64-bit values in object-oriented SceneData APIs. Mostly just to avoid the return types changing to incompatible types in the future, breaking existing code. The internals are currently not fully ready to operate with 64-bit object IDs, especially the AsArray() APIs -- those I will have to solve in the future somehow. Returning 64-bit values in the pairs would add four byte padding after basically each value, which is way too wasteful for the common case. The Into() APIs could eventually get 64-bit overloads though.
4 years ago
Containers::arrayView<UnsignedLong>({}),
Trade: convenience per-object field access in SceneData.
5 years ago
TestSuite::Compare::Container);
}
Trade: test SceneData::{parentFor,childrenFor}() with trivial parents. Hmm, doesn't look right. A bug somewhere!
5 years ago
void SceneDataTest::childrenForTrivialParent() {
/* Going a bit overboard with the arrays, it makes the view creation below
easier tho */
struct Field {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
UnsignedInt mapping[4];
Trade: test SceneData::{parentFor,childrenFor}() with trivial parents. Hmm, doesn't look right. A bug somewhere!
5 years ago
Int parent[1];
} fields[]{{
{3, 4, 2, 4 /* duplicate, gets put to the output */}, {-1}
}};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
Trade: test SceneData::{parentFor,childrenFor}() with trivial parents. Hmm, doesn't look right. A bug somewhere!
5 years ago
SceneFieldData{SceneField::Parent,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
Containers::stridedArrayView(fields->mapping), Containers::stridedArrayView(fields->parent).broadcasted<0>(4)}
Trade: test SceneData::{parentFor,childrenFor}() with trivial parents. Hmm, doesn't look right. A bug somewhere!
5 years ago
}};
/* Trivial children */
CORRADE_COMPARE_AS(scene.childrenFor(-1),
Trade: use 64-bit values in object-oriented SceneData APIs. Mostly just to avoid the return types changing to incompatible types in the future, breaking existing code. The internals are currently not fully ready to operate with 64-bit object IDs, especially the AsArray() APIs -- those I will have to solve in the future somehow. Returning 64-bit values in the pairs would add four byte padding after basically each value, which is way too wasteful for the common case. The Into() APIs could eventually get 64-bit overloads though.
4 years ago
Containers::arrayView<UnsignedLong>({3, 4, 2, 4}),
Trade: test SceneData::{parentFor,childrenFor}() with trivial parents. Hmm, doesn't look right. A bug somewhere!
5 years ago
TestSuite::Compare::Container);
/* Object that is present in the parent array but has no children */
CORRADE_COMPARE_AS(scene.childrenFor(4),
Trade: use 64-bit values in object-oriented SceneData APIs. Mostly just to avoid the return types changing to incompatible types in the future, breaking existing code. The internals are currently not fully ready to operate with 64-bit object IDs, especially the AsArray() APIs -- those I will have to solve in the future somehow. Returning 64-bit values in the pairs would add four byte padding after basically each value, which is way too wasteful for the common case. The Into() APIs could eventually get 64-bit overloads though.
4 years ago
Containers::arrayView<UnsignedLong>({}),
Trade: test SceneData::{parentFor,childrenFor}() with trivial parents. Hmm, doesn't look right. A bug somewhere!
5 years ago
TestSuite::Compare::Container);
/* Object that is not in the parent array */
CORRADE_COMPARE_AS(scene.childrenFor(5),
Trade: use 64-bit values in object-oriented SceneData APIs. Mostly just to avoid the return types changing to incompatible types in the future, breaking existing code. The internals are currently not fully ready to operate with 64-bit object IDs, especially the AsArray() APIs -- those I will have to solve in the future somehow. Returning 64-bit values in the pairs would add four byte padding after basically each value, which is way too wasteful for the common case. The Into() APIs could eventually get 64-bit overloads though.
4 years ago
Containers::arrayView<UnsignedLong>({}),
Trade: test SceneData::{parentFor,childrenFor}() with trivial parents. Hmm, doesn't look right. A bug somewhere!
5 years ago
TestSuite::Compare::Container);
}
Trade: convenience per-object field access in SceneData.
5 years ago
void SceneDataTest::transformation2DFor() {
const struct Field {
UnsignedInt object;
Matrix3 transformation;
} fields[] {
{1, Matrix3::translation({3.0f, 2.0f})*Matrix3::scaling({1.5f, 2.0f})},
{0, Matrix3::rotation(35.0_degf)},
{4, Matrix3::translation({3.0f, 2.0f})*Matrix3::rotation(35.0_degf)},
{1, Matrix3::translation({1.0f, 2.0f})} /* duplicate, ignored */
};
Containers::StridedArrayView1D<const Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
Trade: convenience per-object field access in SceneData.
5 years ago
SceneFieldData{SceneField::Transformation, view.slice(&Field::object), view.slice(&Field::transformation)}
}};
CORRADE_COMPARE(scene.transformation2DFor(4),
Matrix3::translation({3.0f, 2.0f})*Matrix3::rotation(35.0_degf));
CORRADE_COMPARE(scene.transformation2DFor(0),
Matrix3::Matrix3::Matrix3::Matrix3::rotation(35.0_degf));
/* Duplicate entries -- only the first one gets used, it doesn't traverse
further */
CORRADE_COMPARE(scene.transformation2DFor(1),
Matrix3::translation({3.0f, 2.0f})*Matrix3::scaling({1.5f, 2.0f}));
/* Object that's not in the array at all */
CORRADE_COMPARE(scene.transformation2DFor(2),
Containers::NullOpt);
}
void SceneDataTest::transformation2DForTRS() {
const struct Field {
UnsignedInt object;
Vector2 translation;
Complex rotation;
Vector2 scaling;
} fields[] {
{1, {3.0f, 2.0f}, {}, {1.5f, 2.0f}},
{0, {}, Complex::rotation(35.0_degf), {1.0f, 1.0f}},
{4, {3.0f, 2.0f}, Complex::rotation(35.0_degf), {1.0f, 1.0f}},
{1, {1.0f, 2.0f}, {}, {1.0f, 1.0f}} /* duplicate, ignored */
};
Containers::StridedArrayView1D<const Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
Trade: convenience per-object field access in SceneData.
5 years ago
SceneFieldData{SceneField::Translation, view.slice(&Field::object), view.slice(&Field::translation)},
SceneFieldData{SceneField::Rotation, view.slice(&Field::object), view.slice(&Field::rotation)},
SceneFieldData{SceneField::Scaling, view.slice(&Field::object), view.slice(&Field::scaling)}
}};
CORRADE_COMPARE(scene.transformation2DFor(4),
Matrix3::translation({3.0f, 2.0f})*Matrix3::rotation(35.0_degf));
CORRADE_COMPARE(scene.translationRotationScaling2DFor(4),
Containers::triple(Vector2{3.0f, 2.0f}, Complex::rotation(35.0_degf), Vector2{1.0f}));
CORRADE_COMPARE(scene.transformation2DFor(0),
Matrix3::rotation(35.0_degf));
CORRADE_COMPARE(scene.translationRotationScaling2DFor(0),
Containers::triple(Vector2{}, Complex::rotation(35.0_degf), Vector2{1.0f}));
/* Duplicate entries -- only the first one gets used, it doesn't traverse
further */
CORRADE_COMPARE(scene.transformation2DFor(1),
Matrix3::translation({3.0f, 2.0f})*Matrix3::scaling({1.5f, 2.0f}));
CORRADE_COMPARE(scene.translationRotationScaling2DFor(1),
Containers::triple(Vector2{3.0f, 2.0f}, Complex{}, Vector2{1.5f, 2.0f}));
/* Object that's not in the array at all */
CORRADE_COMPARE(scene.transformation2DFor(2),
Containers::NullOpt);
CORRADE_COMPARE(scene.translationRotationScaling2DFor(2),
Containers::NullOpt);
}
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
void SceneDataTest::transformation2DForBut3DType() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: convenience per-object field access in SceneData.
5 years ago
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 1, nullptr, {
SceneFieldData{SceneField::Translation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Vector3, nullptr}
Trade: convenience per-object field access in SceneData.
5 years ago
}};
std::ostringstream out;
Error redirectError{&out};
scene.transformation2DFor(0);
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
scene.translationRotationScaling2DFor(0);
CORRADE_COMPARE(out.str(),
"Trade::SceneData::transformation2DFor(): scene has a 3D transformation type\n"
"Trade::SceneData::translationRotationScaling2DFor(): scene has a 3D transformation type\n");
Trade: convenience per-object field access in SceneData.
5 years ago
}
void SceneDataTest::transformation3DFor() {
const struct Field {
UnsignedInt object;
Matrix4 transformation;
} fields[] {
{1, Matrix4::translation({3.0f, 2.0f, 1.0f})*Matrix4::scaling({1.5f, 2.0f, 4.5f})},
{0, Matrix4::rotationX(35.0_degf)},
{4, Matrix4::translation({3.0f, 2.0f, 1.0f})*Matrix4::rotationX(35.0_degf)},
{1, Matrix4::translation({1.0f, 2.0f, 3.0f})} /* duplicate, ignored */
};
Containers::StridedArrayView1D<const Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
Trade: convenience per-object field access in SceneData.
5 years ago
SceneFieldData{SceneField::Transformation, view.slice(&Field::object), view.slice(&Field::transformation)}
}};
CORRADE_COMPARE(scene.transformation3DFor(4),
Matrix4::translation({3.0f, 2.0f, 1.0f})*Matrix4::rotationX(35.0_degf));
CORRADE_COMPARE(scene.transformation3DFor(0),
Matrix4::rotationX(35.0_degf));
/* Duplicate entries -- only the first one gets used, it doesn't traverse
further */
CORRADE_COMPARE(scene.transformation3DFor(1),
Matrix4::translation({3.0f, 2.0f, 1.0f})*Matrix4::scaling({1.5f, 2.0f, 4.5f}));
/* Object that's not in the array at all */
CORRADE_COMPARE(scene.transformation3DFor(2),
Containers::NullOpt);
}
void SceneDataTest::transformation3DForTRS() {
const struct Field {
UnsignedInt object;
Vector3 translation;
Quaternion rotation;
Vector3 scaling;
} fields[] {
{1, {3.0f, 2.0f, 1.0f}, {}, {1.5f, 2.0f, 4.5f}},
{0, {}, Quaternion::rotation(35.0_degf, Vector3::xAxis()), {1.0f, 1.0f, 1.0f}},
{4, {3.0f, 2.0f, 1.0f}, Quaternion::rotation(35.0_degf, Vector3::xAxis()), {1.0f, 1.0f, 1.0f}},
{1, {1.0f, 2.0f, 3.0f}, Quaternion{}, Vector3{1.0f}} /* duplicate, ignored */
};
Containers::StridedArrayView1D<const Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
Trade: convenience per-object field access in SceneData.
5 years ago
SceneFieldData{SceneField::Translation, view.slice(&Field::object), view.slice(&Field::translation)},
SceneFieldData{SceneField::Rotation, view.slice(&Field::object), view.slice(&Field::rotation)},
SceneFieldData{SceneField::Scaling, view.slice(&Field::object), view.slice(&Field::scaling)}
}};
CORRADE_COMPARE(scene.transformation3DFor(4),
Matrix4::translation({3.0f, 2.0f, 1.0f})*Matrix4::rotationX(35.0_degf));
CORRADE_COMPARE(scene.translationRotationScaling3DFor(4),
Containers::triple(Vector3{3.0f, 2.0f, 1.0f}, Quaternion::rotation(35.0_degf, Vector3::xAxis()), Vector3{1.0f}));
CORRADE_COMPARE(scene.transformation3DFor(0),
Matrix4::rotationX(35.0_degf));
CORRADE_COMPARE(scene.translationRotationScaling3DFor(0),
Containers::triple(Vector3{}, Quaternion::rotation(35.0_degf, Vector3::xAxis()), Vector3{1.0f}));
/* Duplicate entries -- only the first one gets used, it doesn't traverse
further */
CORRADE_COMPARE(scene.transformation3DFor(1),
Matrix4::translation({3.0f, 2.0f, 1.0f})*Matrix4::scaling({1.5f, 2.0f, 4.5f}));
CORRADE_COMPARE(scene.translationRotationScaling3DFor(1),
Containers::triple(Vector3{3.0f, 2.0f, 1.0f}, Quaternion{}, Vector3{1.5f, 2.0f, 4.5f}));
/* Object that's not in the array at all */
CORRADE_COMPARE(scene.transformation3DFor(2),
Containers::NullOpt);
CORRADE_COMPARE(scene.translationRotationScaling3DFor(2),
Containers::NullOpt);
}
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
void SceneDataTest::transformation3DForBut2DType() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: convenience per-object field access in SceneData.
5 years ago
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 1, nullptr, {
SceneFieldData{SceneField::Translation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Vector2, nullptr}
Trade: convenience per-object field access in SceneData.
5 years ago
}};
std::ostringstream out;
Error redirectError{&out};
scene.transformation3DFor(0);
Trade: introduce SceneData::is2D() and is3D(). This moves the transformation type consistency checks directly into the constructor and makes the discovered dimension count available through a getter. As a result, a lot of duplicate assertions (and corresponding tests) could be removed while tightening the behavior -- before it was possible to have a 2D transformation matrix complemented with a 3D rotation quaternion and all asserts would pass, yet the user would be required to call transformations2DAsArray() *but* translationsRotationsScalings3DAsArray(). Since scenes can exist without any transformation field, there's both is2D() and is3D() and they both return false in that case.
5 years ago
scene.translationRotationScaling3DFor(0);
CORRADE_COMPARE(out.str(),
"Trade::SceneData::transformation3DFor(): scene has a 2D transformation type\n"
"Trade::SceneData::translationRotationScaling3DFor(): scene has a 2D transformation type\n");
Trade: convenience per-object field access in SceneData.
5 years ago
}
void SceneDataTest::meshesMaterialsFor() {
struct Field {
UnsignedInt object;
UnsignedInt mesh;
Int meshMaterial;
} fields[]{
{4, 1, -1},
{1, 3, 0},
{2, 4, 1},
{2, 5, -1},
{2, 1, 0},
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
Trade: convenience per-object field access in SceneData.
5 years ago
SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)},
SceneFieldData{SceneField::MeshMaterial, view.slice(&Field::object), view.slice(&Field::meshMaterial)}
}};
/* Just one */
CORRADE_COMPARE_AS(scene.meshesMaterialsFor(1),
(Containers::arrayView<Containers::Pair<UnsignedInt, Int>>({{3, 0}})),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.meshesMaterialsFor(4),
(Containers::arrayView<Containers::Pair<UnsignedInt, Int>>({{1, -1}})),
TestSuite::Compare::Container);
/* More */
CORRADE_COMPARE_AS(scene.meshesMaterialsFor(2),
(Containers::arrayView<Containers::Pair<UnsignedInt, Int>>({
{4, 1}, {5, -1}, {1, 0}
})), TestSuite::Compare::Container);
/* Object that is not in the array at all */
CORRADE_COMPARE_AS(scene.meshesMaterialsFor(6),
(Containers::arrayView<Containers::Pair<UnsignedInt, Int>>({})),
TestSuite::Compare::Container);
}
void SceneDataTest::lightsFor() {
struct Field {
UnsignedInt object;
UnsignedInt light;
} fields[]{
{4, 1},
{1, 3},
{2, 4},
{2, 5}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
Trade: convenience per-object field access in SceneData.
5 years ago
SceneFieldData{SceneField::Light, view.slice(&Field::object), view.slice(&Field::light)}
}};
/* Just one */
CORRADE_COMPARE_AS(scene.lightsFor(1),
(Containers::arrayView<UnsignedInt>({3})),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.lightsFor(4),
(Containers::arrayView<UnsignedInt>({1})),
TestSuite::Compare::Container);
/* More */
CORRADE_COMPARE_AS(scene.lightsFor(2),
(Containers::arrayView<UnsignedInt>({
4, 5
})), TestSuite::Compare::Container);
/* Object that is not in the array at all */
CORRADE_COMPARE_AS(scene.lightsFor(6),
(Containers::arrayView<UnsignedInt>({})),
TestSuite::Compare::Container);
}
void SceneDataTest::camerasFor() {
struct Field {
UnsignedInt object;
UnsignedInt camera;
} fields[]{
{4, 1},
{1, 3},
{2, 4},
{2, 5}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
Trade: convenience per-object field access in SceneData.
5 years ago
SceneFieldData{SceneField::Camera, view.slice(&Field::object), view.slice(&Field::camera)}
}};
/* Just one */
CORRADE_COMPARE_AS(scene.camerasFor(1),
(Containers::arrayView<UnsignedInt>({3})),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.camerasFor(4),
(Containers::arrayView<UnsignedInt>({1})),
TestSuite::Compare::Container);
/* More */
CORRADE_COMPARE_AS(scene.camerasFor(2),
(Containers::arrayView<UnsignedInt>({
4, 5
})), TestSuite::Compare::Container);
/* Object that is not in the array at all */
CORRADE_COMPARE_AS(scene.camerasFor(6),
(Containers::arrayView<UnsignedInt>({})),
TestSuite::Compare::Container);
}
void SceneDataTest::skinsFor() {
struct Field {
UnsignedInt object;
UnsignedInt skin;
} fields[]{
{4, 1},
{1, 3},
{2, 4},
{2, 5}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
Trade: SceneField::Skin now requires a transformation to be present. Even an empty field, it's there just to disambiguate whether the skin is 2D or 3D.
5 years ago
/* To satisfy the requirement of having a transformation field to
disambiguate the dimensionality */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Translation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Vector3, nullptr},
Trade: convenience per-object field access in SceneData.
5 years ago
SceneFieldData{SceneField::Skin, view.slice(&Field::object), view.slice(&Field::skin)}
}};
/* Just one */
CORRADE_COMPARE_AS(scene.skinsFor(1),
(Containers::arrayView<UnsignedInt>({3})),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.skinsFor(4),
(Containers::arrayView<UnsignedInt>({1})),
TestSuite::Compare::Container);
/* More */
CORRADE_COMPARE_AS(scene.skinsFor(2),
(Containers::arrayView<UnsignedInt>({
4, 5
})), TestSuite::Compare::Container);
/* Object that is not in the array at all */
CORRADE_COMPARE_AS(scene.skinsFor(6),
(Containers::arrayView<UnsignedInt>({})),
TestSuite::Compare::Container);
}
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
void SceneDataTest::importerStateFor() {
int a, b, c;
struct Field {
UnsignedInt object;
const void* importerState;
} fields[]{
{3, &a},
{4, &b},
{2, nullptr},
{4, &c}
};
Containers::StridedArrayView1D<Field> view = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 7, {}, fields, {
Trade: support storing pointers (and thus importer state) in SceneData.
5 years ago
SceneFieldData{SceneField::ImporterState, view.slice(&Field::object), view.slice(&Field::importerState)}
}};
CORRADE_COMPARE(scene.importerStateFor(2), nullptr);
CORRADE_COMPARE(scene.importerStateFor(3), &a);
/* Duplicate entries -- only the first one gets used, it doesn't traverse
further */
CORRADE_COMPARE(scene.importerStateFor(4), &b);
/* Object that's not in the array at all */
CORRADE_COMPARE(scene.importerStateFor(1), Containers::NullOpt);
}
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
void SceneDataTest::childrenDeprecated() {
auto&& data = ChildrenDeprecatedData[testCaseInstanceId()];
setTestCaseDescription(data.name);
struct Field {
UnsignedByte object;
Short parent;
} fields[]{
{5, -1},
{2, 0},
{3, 0},
{0, -1},
{1, 2},
{4, -1}
};
Containers::StridedArrayView1D<Field> view = fields;
Containers::Array<SceneFieldData> fieldData;
Trade: warn in deprecated SceneData::children*D() if there's no parent. Even though this API is deprecated and thus not meant to be used, most existing code is still using the previous APIs and relying on the backwards compatibiity interfaces. And I wasted quite some time debugging why the scene looks like empty.
5 years ago
if(!data.skipParent)
arrayAppend(fieldData, SceneFieldData{SceneField::Parent, view.slice(&Field::object), view.slice(&Field::parent)});
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
if(data.is2D)
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
arrayAppend(fieldData, SceneFieldData{SceneField::Translation, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Vector2, nullptr});
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
if(data.is3D)
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
arrayAppend(fieldData, SceneFieldData{SceneField::Translation, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Vector3, nullptr});
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedByte, 25, {}, fields, std::move(fieldData)};
Trade: warn in deprecated SceneData::children*D() if there's no parent. Even though this API is deprecated and thus not meant to be used, most existing code is still using the previous APIs and relying on the backwards compatibiity interfaces. And I wasted quite some time debugging why the scene looks like empty.
5 years ago
if(!data.skipParent) {
CORRADE_IGNORE_DEPRECATED_PUSH
CORRADE_COMPARE_AS(scene.children2D(),
(data.is2D ? std::vector<UnsignedInt>{5, 0, 4} : std::vector<UnsignedInt>{}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.children3D(),
(data.is3D ? std::vector<UnsignedInt>{5, 0, 4} : std::vector<UnsignedInt>{}),
TestSuite::Compare::Container);
CORRADE_IGNORE_DEPRECATED_POP
} else {
std::ostringstream out;
Warning redirectWarning{&out};
CORRADE_IGNORE_DEPRECATED_PUSH
CORRADE_VERIFY(scene.children2D().empty());
CORRADE_VERIFY(scene.children3D().empty());
CORRADE_IGNORE_DEPRECATED_POP
if(data.is2D)
CORRADE_COMPARE(out.str(), "Trade::SceneData::children2D(): no parent field present, returned array will be empty\n");
else if(data.is3D)
CORRADE_COMPARE(out.str(), "Trade::SceneData::children3D(): no parent field present, returned array will be empty\n");
else
CORRADE_COMPARE(out.str(), "");
}
Trade: reintroduce original deprecated SceneData APIs. Those now operate on top of the new data layout.
5 years ago
}
#endif
Trade: convenience per-object field access in SceneData.
5 years ago
void SceneDataTest::fieldForFieldMissing() {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 7, nullptr, {}};
Trade: convenience per-object field access in SceneData.
5 years ago
Trade: add a parentFor() object-oriented accessor as well. For a lack of better API right now, this will be used to check if an object belongs to a certain scene. In the future, when BitArray is a thing, there will be a dedicated field with a mask telling which objects belong to the scene and which not, with a fallback that goes through all field object mappings and collects objects that have at least one field.
5 years ago
CORRADE_COMPARE(scene.parentFor(6), Containers::NullOpt);
Trade: convenience per-object field access in SceneData.
5 years ago
CORRADE_COMPARE_AS(scene.childrenFor(6),
Trade: use 64-bit values in object-oriented SceneData APIs. Mostly just to avoid the return types changing to incompatible types in the future, breaking existing code. The internals are currently not fully ready to operate with 64-bit object IDs, especially the AsArray() APIs -- those I will have to solve in the future somehow. Returning 64-bit values in the pairs would add four byte padding after basically each value, which is way too wasteful for the common case. The Into() APIs could eventually get 64-bit overloads though.
4 years ago
Containers::arrayView<UnsignedLong>({}),
Trade: convenience per-object field access in SceneData.
5 years ago
TestSuite::Compare::Container);
CORRADE_COMPARE(scene.transformation2DFor(6), Containers::NullOpt);
CORRADE_COMPARE(scene.translationRotationScaling2DFor(6), Containers::NullOpt);
CORRADE_COMPARE(scene.transformation3DFor(6), Containers::NullOpt);
CORRADE_COMPARE(scene.translationRotationScaling3DFor(6), Containers::NullOpt);
CORRADE_COMPARE_AS(scene.meshesMaterialsFor(6),
(Containers::arrayView<Containers::Pair<UnsignedInt, Int>>({})),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.lightsFor(6),
Containers::arrayView<UnsignedInt>({}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.camerasFor(6),
Containers::arrayView<UnsignedInt>({}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(scene.skinsFor(6),
Containers::arrayView<UnsignedInt>({}),
TestSuite::Compare::Container);
}
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
void SceneDataTest::findFieldObjectOffsetInvalidObject() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: convenience per-object field access in SceneData.
5 years ago
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedInt, 7, nullptr, {
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Int, nullptr},
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
}};
Trade: convenience per-object field access in SceneData.
5 years ago
std::ostringstream out;
Error redirectError{&out};
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
scene.findFieldObjectOffset(0, 7);
scene.findFieldObjectOffset(SceneField::Parent, 7);
scene.fieldObjectOffset(0, 7);
scene.fieldObjectOffset(SceneField::Parent, 7);
scene.hasFieldObject(0, 7);
scene.hasFieldObject(SceneField::Parent, 7);
Trade: add a parentFor() object-oriented accessor as well. For a lack of better API right now, this will be used to check if an object belongs to a certain scene. In the future, when BitArray is a thing, there will be a dedicated field with a mask telling which objects belong to the scene and which not, with a fallback that goes through all field object mappings and collects objects that have at least one field.
5 years ago
scene.parentFor(7);
Trade: convenience per-object field access in SceneData.
5 years ago
scene.childrenFor(-2);
scene.childrenFor(7);
scene.transformation2DFor(7);
scene.translationRotationScaling2DFor(7);
scene.transformation3DFor(7);
scene.translationRotationScaling3DFor(7);
scene.meshesMaterialsFor(7);
scene.lightsFor(7);
scene.camerasFor(7);
scene.skinsFor(7);
CORRADE_COMPARE(out.str(),
Trade: add public SceneData APIs for finding fields and objects. Using hasField() + fieldId() was a bad usage pattern leading to a double linear lookup, so there's now findFieldId() returning an Optional which covers both. Similarly for finding an object offset in an field, there's a findFieldObjectOffset() returning an Optional, fieldObjectOffset() asserting if an object is not found (for convenience to avoid explicit error handling on user side) and hasFieldObject(). The internal helpers were also renamed and the offset argument moved to be last for consistency.
4 years ago
"Trade::SceneData::findFieldObjectOffset(): object 7 out of bounds for 7 objects\n"
"Trade::SceneData::findFieldObjectOffset(): object 7 out of bounds for 7 objects\n"
"Trade::SceneData::fieldObjectOffset(): object 7 out of bounds for 7 objects\n"
"Trade::SceneData::fieldObjectOffset(): object 7 out of bounds for 7 objects\n"
"Trade::SceneData::hasFieldObject(): object 7 out of bounds for 7 objects\n"
"Trade::SceneData::hasFieldObject(): object 7 out of bounds for 7 objects\n"
Trade: add a parentFor() object-oriented accessor as well. For a lack of better API right now, this will be used to check if an object belongs to a certain scene. In the future, when BitArray is a thing, there will be a dedicated field with a mask telling which objects belong to the scene and which not, with a fallback that goes through all field object mappings and collects objects that have at least one field.
5 years ago
"Trade::SceneData::parentFor(): object 7 out of bounds for 7 objects\n"
Trade: convenience per-object field access in SceneData.
5 years ago
"Trade::SceneData::childrenFor(): object -2 out of bounds for 7 objects\n"
"Trade::SceneData::childrenFor(): object 7 out of bounds for 7 objects\n"
"Trade::SceneData::transformation2DFor(): object 7 out of bounds for 7 objects\n"
"Trade::SceneData::translationRotationScaling2DFor(): object 7 out of bounds for 7 objects\n"
"Trade::SceneData::transformation3DFor(): object 7 out of bounds for 7 objects\n"
"Trade::SceneData::translationRotationScaling3DFor(): object 7 out of bounds for 7 objects\n"
"Trade::SceneData::meshesMaterialsFor(): object 7 out of bounds for 7 objects\n"
"Trade::SceneData::lightsFor(): object 7 out of bounds for 7 objects\n"
"Trade::SceneData::camerasFor(): object 7 out of bounds for 7 objects\n"
"Trade::SceneData::skinsFor(): object 7 out of bounds for 7 objects\n");
}
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
void SceneDataTest::releaseFieldData() {
struct Field {
UnsignedByte object;
UnsignedInt mesh;
};
Containers::Array<char> data{NoInit, 3*sizeof(Field)};
Containers::StridedArrayView1D<Field> view = Containers::arrayCast<Field>(data);
auto fields = Containers::array({
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Int, nullptr},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)}
});
SceneFieldData* originalFields = fields;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedByte, 50, std::move(data), std::move(fields)};
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
Containers::Array<SceneFieldData> released = scene.releaseFieldData();
CORRADE_COMPARE(released.data(), originalFields);
CORRADE_COMPARE(released.size(), 2);
/* Fields are all gone */
CORRADE_COMPARE(static_cast<const void*>(scene.fieldData()), nullptr);
CORRADE_COMPARE(scene.fieldCount(), 0);
/* Data stays untouched, object count and type as well, as it con't result
in any dangling data access */
Test: MSVC 2019 with /permissive- doesn't like this? Huh?
4 years ago
CORRADE_COMPARE(scene.data().data(), view.data());
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(scene.mappingBound(), 50);
CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedByte);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
void SceneDataTest::releaseData() {
struct Field {
UnsignedByte object;
UnsignedByte mesh;
};
Containers::Array<char> data{NoInit, 3*sizeof(Field)};
Containers::StridedArrayView1D<Field> view = Containers::arrayCast<Field>(data);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
SceneData scene{SceneMappingType::UnsignedByte, 50, std::move(data), {
SceneFieldData{SceneField::Parent, SceneMappingType::UnsignedByte, nullptr, SceneFieldType::Int, nullptr},
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
SceneFieldData{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)}
}};
Containers::Array<char> released = scene.releaseData();
CORRADE_COMPARE(released.data(), view.data());
CORRADE_COMPARE(released.size(), 3*sizeof(Field));
/* Both fields and data are all gone */
CORRADE_COMPARE(static_cast<const void*>(scene.fieldData()), nullptr);
CORRADE_COMPARE(scene.fieldCount(), 0);
CORRADE_COMPARE(static_cast<const void*>(scene.data()), nullptr);
/* Object count and type stays untouched, as it con't result in any
dangling data access */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in the object mapping views. Which is quite self-explanatory without having to mention every time that the range may be sparse.
4 years ago
CORRADE_COMPARE(scene.mappingBound(), 50);
CORRADE_COMPARE(scene.mappingType(), SceneMappingType::UnsignedByte);
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
}
Wrap all tests in unnamed namespaces. This makes the compiler warn about test cases that aren't ever used, which is a good thing.
7 years ago
}}}}
Trade: test construction and assignments of the container classes.
10 years ago
CORRADE_TEST_MAIN(Magnum::Trade::Test::SceneDataTest)