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

5596 lines
260 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.
5 years ago
2020, 2021 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: initial redesign of 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: 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>
#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"
Split the OpenGL layer out, pt 18: adapted Trade.
8 years ago
#include "Magnum/Trade/SceneData.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();
Trade: initial redesign of 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();
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();
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();
void debugFieldFlags();
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();
void constructField2D();
void constructFieldTypeErased();
void constructFieldNonOwningArray();
void constructFieldOffsetOnly();
void constructFieldArray();
void constructFieldArray2D();
void constructFieldArrayTypeErased();
void constructFieldArrayOffsetOnly();
void constructFieldWrongType();
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: 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 constructFieldOffsetOnlyNotAllowed();
Trade: initial redesign of 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 constructFieldWrongDataAccess();
void constructField2DWrongSize();
void constructField2DNonContiguous();
void constructFieldArrayNonContiguous();
void constructFieldArrayNotAllowed();
void constructFieldArray2DWrongSize();
void constructFieldArray2DNonContiguous();
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();
Trade: fix SceneData object view retrieval & test it more thoroughly.
5 years ago
void constructSpecialStrides();
Trade: initial redesign of 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 constructNotOwned();
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: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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: 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,
Trade: initial redesign of 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,
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,
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,
&SceneDataTest::debugFieldFlags,
&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,
&SceneDataTest::constructField2D,
&SceneDataTest::constructFieldTypeErased,
&SceneDataTest::constructFieldNonOwningArray,
&SceneDataTest::constructFieldOffsetOnly,
&SceneDataTest::constructFieldArray,
&SceneDataTest::constructFieldArray2D,
&SceneDataTest::constructFieldArrayTypeErased,
&SceneDataTest::constructFieldArrayOffsetOnly,
&SceneDataTest::constructFieldWrongType,
&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: 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::constructFieldOffsetOnlyNotAllowed,
Trade: initial redesign of 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::constructFieldWrongDataAccess,
&SceneDataTest::constructField2DWrongSize,
&SceneDataTest::constructField2DNonContiguous,
&SceneDataTest::constructFieldArrayNonContiguous,
&SceneDataTest::constructFieldArrayNotAllowed,
&SceneDataTest::constructFieldArray2DWrongSize,
&SceneDataTest::constructFieldArray2DNonContiguous,
&SceneDataTest::construct,
&SceneDataTest::constructZeroFields,
Trade: fix SceneData object view retrieval & test it more thoroughly.
5 years ago
&SceneDataTest::constructZeroObjects,
&SceneDataTest::constructSpecialStrides});
Trade: initial redesign of 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: 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: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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});
}
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() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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
}
void SceneDataTest::customFieldName() {
CORRADE_VERIFY(!isSceneFieldCustom(SceneField::Rotation));
CORRADE_VERIFY(!isSceneFieldCustom(SceneField(0x0fffffffu)));
CORRADE_VERIFY(isSceneFieldCustom(SceneField::Custom));
CORRADE_VERIFY(isSceneFieldCustom(SceneField(0x80000000u)));
CORRADE_COMPARE(UnsignedInt(sceneFieldCustom(0)), 0x80000000u);
CORRADE_COMPARE(UnsignedInt(sceneFieldCustom(0xabcd)), 0x8000abcdu);
CORRADE_COMPARE(UnsignedInt(sceneFieldCustom(0x7fffffff)), 0xffffffffu);
CORRADE_COMPARE(sceneFieldCustom(SceneField::Custom), 0);
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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
std::ostringstream out;
Error redirectError{&out};
sceneFieldCustom(1u << 31);
CORRADE_COMPARE(out.str(), "Trade::sceneFieldCustom(): index 2147483648 too large\n");
}
void SceneDataTest::customFieldNameNotCustom() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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");
}
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));
CORRADE_COMPARE(sceneFieldTypeAlignment(SceneFieldType::DualComplexd), alignof(Double));
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() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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: initial redesign of 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::sceneFieldTypeAlignment(): invalid type Trade::SceneFieldType(0xdead)\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");
}
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");
}
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");
}
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: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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 RotationMapping2D[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
17,
35,
98
};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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 Complexd RotationField2D[3] {
Complexd{Constantsd::sqrtHalf(), Constantsd::sqrtHalf()}, /* 45° */
Complexd{1.0, 0.0}, /* 0° */
Complexd{0.0, 1.0}, /* 90° */
};
Trade: initial redesign of 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));
CORRADE_VERIFY(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));
CORRADE_VERIFY(rotations.fieldData().data() == rotationFieldData);
/* This is allowed too for simplicity, the parameter has to be large enough
tho */
char someArray[3*sizeof(Complexd)];
CORRADE_COMPARE(rotations.fieldData(someArray).size(), 3);
CORRADE_COMPARE(rotations.fieldData(someArray).stride(), sizeof(Complexd));
CORRADE_VERIFY(rotations.fieldData(someArray).data() == rotationFieldData);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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));
CORRADE_VERIFY(rotations.mappingData(someArray).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
Trade: hi, MSVC 2015, you ancient curse.
5 years ago
#ifndef CORRADE_MSVC2015_COMPATIBILITY /* Won't bother anymore */
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: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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();
constexpr Containers::StridedArrayView1D<const void> mappingData = crotations.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
constexpr SceneFieldType fieldType = crotations.fieldType();
constexpr UnsignedShort fieldArraySize = crotations.fieldArraySize();
constexpr Containers::StridedArrayView1D<const void> fieldData = crotations.fieldData();
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: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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);
CORRADE_COMPARE(mappingData.size(), 3);
CORRADE_COMPARE(mappingData.stride(), sizeof(UnsignedShort));
CORRADE_COMPARE(mappingData.data(), RotationMapping2D);
Trade: initial redesign of 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(fieldType, SceneFieldType::Complexd);
CORRADE_COMPARE(fieldArraySize, 0);
CORRADE_COMPARE(fieldData.size(), 3);
CORRADE_COMPARE(fieldData.stride(), 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(fieldData.data(), RotationField2D);
Trade: hi, MSVC 2015, you ancient curse.
5 years ago
#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::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);
}
void SceneDataTest::constructField2D() {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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());
}
void SceneDataTest::constructFieldTypeErased() {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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 UnsignedLong scalingMappingData[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 Vector3 scalingFieldData[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 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);
Trade: initial redesign of 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(scalings.name(), SceneField::Scaling);
CORRADE_COMPARE(scalings.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(scalings.mappingType(), SceneMappingType::UnsignedLong);
CORRADE_COMPARE(scalings.mappingData().size(), 3);
CORRADE_COMPARE(scalings.mappingData().stride(), sizeof(UnsignedLong));
CORRADE_COMPARE(scalings.mappingData().data(), 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
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);
}
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: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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};
CORRADE_COMPARE(cdata.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(cdata.name(), sceneFieldCustom(34));
CORRADE_COMPARE(cdata.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(cdata.mappingType(), SceneMappingType::UnsignedByte);
CORRADE_COMPARE(cdata.mappingData().size(), 3);
CORRADE_COMPARE(cdata.mappingData().stride(), sizeof(UnsignedByte));
CORRADE_VERIFY(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.fieldType(), SceneFieldType::Int);
CORRADE_COMPARE(cdata.fieldArraySize(), 4);
CORRADE_COMPARE(cdata.fieldData().size(), 3);
CORRADE_COMPARE(cdata.fieldData().stride(), 4*sizeof(Int));
CORRADE_VERIFY(cdata.fieldData().data() == ArrayOffsetFieldData);
}
void SceneDataTest::constructFieldArray2D() {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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 offsetMappingData[3*sizeof(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
char offsetFieldData[3*4*sizeof(Int)];
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::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: initial redesign of 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);
}
void SceneDataTest::constructFieldArrayTypeErased() {
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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];
Int offsetFieldData[3*4];
Containers::StridedArrayView1D<Int> offset{offsetFieldData, 3, 4*sizeof(Int)};
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), 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);
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));
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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: initial redesign of 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;
Int offset[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), 3, SceneMappingType::UnsignedByte, offsetof(Data, object), sizeof(Data), SceneFieldType::Int, offsetof(Data, offset), sizeof(Data), 4, SceneFieldFlag::ImplicitMapping};
CORRADE_COMPARE(data.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(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);
Trade: initial redesign of 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);
Data actual[3];
CORRADE_COMPARE(data.fieldData(actual).size(), 3);
CORRADE_COMPARE(data.fieldData(actual).stride(), sizeof(Data));
CORRADE_VERIFY(data.fieldData(actual).data() == &actual[0].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
CORRADE_COMPARE(data.mappingData(actual).size(), 3);
CORRADE_COMPARE(data.mappingData(actual).stride(), sizeof(Data));
CORRADE_VERIFY(data.mappingData(actual).data() == &actual[0].object);
Trade: initial redesign of 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 cdata{sceneFieldCustom(34), 3, SceneMappingType::UnsignedByte, offsetof(Data, object), sizeof(Data), SceneFieldType::Int, offsetof(Data, offset), sizeof(Data), 4, SceneFieldFlag::OrderedMapping};
CORRADE_COMPARE(cdata.flags(), SceneFieldFlag::OffsetOnly|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(cdata.name(), sceneFieldCustom(34));
CORRADE_COMPARE(cdata.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(cdata.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
CORRADE_COMPARE(cdata.fieldType(), SceneFieldType::Int);
CORRADE_COMPARE(cdata.fieldArraySize(), 4);
}
void SceneDataTest::constructFieldInconsistentViewSize() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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[2];
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::Rotation, Containers::arrayView(rotationMappingData), Containers::arrayView(rotationFieldData)};
CORRADE_COMPARE(out.str(), "Trade::SceneFieldData: expected 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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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: initial redesign of 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: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
UnsignedInt enough[2];
char toomuch[2*(32768 + sizeof(UnsignedInt))];
/* 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
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: initial redesign of 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: 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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
UnsignedInt enough[2];
char toomuch[2*(32768 + sizeof(UnsignedInt))];
/* 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
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: initial redesign of 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: 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: 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::constructFieldOffsetOnlyNotAllowed() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
const UnsignedShort rotationMappingData[3]{};
const Quaternion rotationFieldData[3];
/* This one is fine */
SceneFieldData{SceneField::Rotation, 3, SceneMappingType::UnsignedShort, 0, sizeof(UnsignedShort), SceneFieldType::Quaternion, 0, sizeof(Quaternion), SceneFieldFlag::OffsetOnly};
std::ostringstream out;
Error redirectError{&out};
SceneFieldData{SceneField::Rotation, Containers::arrayView(rotationMappingData), Containers::arrayView(rotationFieldData), SceneFieldFlag::OffsetOnly};
CORRADE_COMPARE(out.str(),
"Trade::SceneFieldData: can't pass Trade::SceneFieldFlag::OffsetOnly for a view\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::constructFieldWrongDataAccess() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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: 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: initial redesign of 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: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
a.fieldData(rotationFieldData);
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();
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: initial redesign of 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::fieldData(): the field is offset-only, supply a data array\n");
}
void SceneDataTest::constructField2DWrongSize() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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[5*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[5*sizeof(Complex)];
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
Containers::StridedArrayView2D<char>{rotationMappingData, {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)};
SceneFieldData{SceneField::Translation,
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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::Vector3,
Containers::StridedArrayView2D<char>{rotationFieldData, {4, sizeof(Complex)}}.every(2)};
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: expected second mapping view dimension size 1, 2, 4 or 8 but got 5\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 size 8 doesn't match Trade::SceneFieldType::Vector3\n");
}
void SceneDataTest::constructField2DNonContiguous() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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[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)];
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
Containers::StridedArrayView2D<char>{rotationMappingData, {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)}}};
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
Containers::StridedArrayView2D<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
SceneFieldType::Complex,
Containers::StridedArrayView2D<char>{rotationFieldData, {4, 2*sizeof(Complex)}}.every({1, 2})};
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: initial redesign of 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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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];
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 data{sceneFieldCustom(34), Containers::arrayView(offsetMappingData), Containers::StridedArrayView2D<Int>{offsetFieldData, {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::SceneFieldData: second field view dimension is not contiguous\n");
}
void SceneDataTest::constructFieldArrayNotAllowed() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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
/* This is all fine */
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: initial redesign of 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");
}
void SceneDataTest::constructFieldArray2DWrongSize() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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");
}
void SceneDataTest::constructFieldArray2DNonContiguous() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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 offsetMappingData[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)];
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>{offsetMappingData, {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};
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>{offsetMappingData, {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};
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: initial redesign of 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
}
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: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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[0].object = 4;
transformsParentFieldMappingData[0].transformation = Matrix4::translation(Vector3::xAxis(5.0f));
transformsParentFieldMappingData[0].parent = -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: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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[1].object = 2;
transformsParentFieldMappingData[1].transformation = Matrix4::translation(Vector3::yAxis(5.0f));
transformsParentFieldMappingData[1].parent = 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
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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[2].object = 3;
transformsParentFieldMappingData[2].transformation = Matrix4::translation(Vector3::zAxis(5.0f));
transformsParentFieldMappingData[2].parent = 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
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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[3].object = 0;
transformsParentFieldMappingData[3].transformation = Matrix4::translation(Vector3::yScale(5.0f));
transformsParentFieldMappingData[3].parent = 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: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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[4].object = 1;
transformsParentFieldMappingData[4].transformation = Matrix4::translation(Vector3::zScale(5.0f));
transformsParentFieldMappingData[4].parent = -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
meshFieldData[0] = 5;
radiusFieldData[0] = {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
materialMeshRadiusMappingData[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
meshFieldData[1] = 7;
radiusFieldData[1] = {22.5f, 0.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
materialMeshRadiusMappingData[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
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);
CORRADE_VERIFY(!scene.fieldData().empty());
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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);
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: initial redesign of 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);
CORRADE_COMPARE(scene.field<Float[]>(3).size()[0], 2);
CORRADE_COMPARE(scene.field<Float[]>(3).size()[1], 2);
CORRADE_COMPARE(scene.mutableField<Matrix4>(0).size(), 5);
CORRADE_COMPARE(scene.mutableField<Int>(1).size(), 5);
CORRADE_COMPARE(scene.mutableField<UnsignedByte>(2).size(), 2);
CORRADE_COMPARE(scene.mutableField<Float[]>(3).size()[0], 2);
CORRADE_COMPARE(scene.mutableField<Float[]>(3).size()[1], 2);
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);
CORRADE_COMPARE(scene.field<Float[]>(3)[0][0], 37.5f);
CORRADE_COMPARE(scene.field<Float[]>(3)[0][1], 1.5f);
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);
CORRADE_COMPARE(scene.mutableField<Float[]>(3)[0][0], 37.5f);
CORRADE_COMPARE(scene.mutableField<Float[]>(3)[0][1], 1.5f);
/* 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);
CORRADE_COMPARE(scene.field<Float[]>(sceneFieldCustom(37)).size()[0], 2);
CORRADE_COMPARE(scene.field<Float[]>(sceneFieldCustom(37)).size()[1], 2);
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);
CORRADE_COMPARE(scene.mutableField<Float[]>(sceneFieldCustom(37)).size()[0], 2);
CORRADE_COMPARE(scene.mutableField<Float[]>(sceneFieldCustom(37)).size()[1], 2);
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);
CORRADE_COMPARE(scene.field<Float[]>(sceneFieldCustom(37))[0][0], 37.5f);
CORRADE_COMPARE(scene.field<Float[]>(sceneFieldCustom(37))[0][1], 1.5f);
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);
CORRADE_COMPARE(scene.mutableField<Float[]>(sceneFieldCustom(37))[0][0], 37.5f);
CORRADE_COMPARE(scene.mutableField<Float[]>(sceneFieldCustom(37))[0][1], 1.5f);
}
void SceneDataTest::constructZeroFields() {
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);
CORRADE_VERIFY(scene.fieldData().empty());
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: 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() {
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);
CORRADE_VERIFY(!scene.fieldData().empty());
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);
/* 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
}
Trade: fix SceneData object view retrieval & test it more thoroughly.
5 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;
nonBroadcastedData[0] = 1;
nonBroadcastedData[1] = 2;
nonBroadcastedData[2] = 3;
nonBroadcastedData[3] = 4;
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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 broadcastedMapping{sceneFieldCustom(38),
Trade: fix SceneData object view retrieval & test it more thoroughly.
5 years ago
broadcastedData.broadcasted<0>(4), nonBroadcastedData};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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 broadcastedField{sceneFieldCustom(39),
Trade: fix SceneData object view retrieval & test it more thoroughly.
5 years ago
nonBroadcastedData, broadcastedData.broadcasted<0>(4)};
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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 flippedField{sceneFieldCustom(40),
Trade: fix SceneData object view retrieval & test it more thoroughly.
5 years ago
nonBroadcastedData.flipped<0>(), nonBroadcastedData.flipped<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
SceneData scene{SceneMappingType::UnsignedShort, 8, std::move(data), {
broadcastedMapping, broadcastedField, flippedField
Trade: fix SceneData object view retrieval & test it more thoroughly.
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.mapping<UnsignedShort>(0),
Trade: fix SceneData object view retrieval & test it more thoroughly.
5 years ago
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);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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<UnsignedShort>(1),
Trade: fix SceneData object view retrieval & test it more thoroughly.
5 years ago
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);
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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<UnsignedShort>(2),
Trade: fix SceneData object view retrieval & test it more thoroughly.
5 years ago
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);
}
Trade: initial redesign of 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: 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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
/* 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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
/* 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() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Containers::Array<char> data{reinterpret_cast<char*>(0xbadda9), 10, [](char*, std::size_t){}};
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};
/* First a "slightly off" view that exceeds the original by one byte */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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{SceneField::Mesh, dataSlightlyOut, dataIn}
}};
/* Second a view that's in a completely different location */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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: 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}
}};
/* Verify the owning constructor does the checks as well */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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, std::move(data), {
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}
}};
/* 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}
}};
/* Finally, 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
}};
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 [0xbaddaa:0xbaddb4] of field 0 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
"Trade::SceneData: mapping data [0xdead:0xdeb7] of field 1 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
"Trade::SceneData: mapping data [0xdead:0xdeb7] of field 1 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
"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: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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: initial redesign of 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 views swapped, and added checks for array fields */
Containers::Array<char> data{reinterpret_cast<char*>(0xbadda9), 10, [](char*, std::size_t){}};
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};
/* First a "slightly off" view that exceeds the original by one byte */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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{SceneField::Mesh, dataIn, dataSlightlyOut}
}};
/* Second a view that's in a completely different location */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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: 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}
}};
/* 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}}}
}};
/* Verify the owning constructor does the checks as well */
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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, std::move(data), {
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: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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 */
/* Finally, 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
}};
CORRADE_COMPARE(out.str(),
"Trade::SceneData: field data [0xbaddaa:0xbaddb4] of field 0 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
"Trade::SceneData: field data [0xdead:0xdeb7] of field 1 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
"Trade::SceneData: field data [0xbadda9:0xbaddb5] of field 0 are not contained in passed data array [0xbadda9:0xbaddb3]\n"
"Trade::SceneData: field data [0xdead:0xdeb7] of field 1 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::SceneData: offset-only field data of field 0 span 25 bytes but passed data array has only 24\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() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
/* 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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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};
SceneFieldData rotationsSameButLess{SceneField::Rotation, translationMappingData.except(1), rotationFieldData.except(1)};
SceneFieldData scalingsSameButLess{SceneField::Scaling, translationMappingData.except(2), scalingFieldData.except(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());
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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};
SceneFieldData meshMaterialsSameButLess{SceneField::MeshMaterial, meshMappingData.except(1), meshMaterialFieldData.except(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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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: 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: 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: 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: 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: 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: 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: 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: 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() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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: 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: 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: 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: 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: 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: 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: 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: 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() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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() {
Trade: initial redesign of the SceneData class. No backwards compatibility in place yet, will get added back in the followup commits, together with proper documentation.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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);
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));
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: initial redesign of 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::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: 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::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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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};
scene.field<UnsignedByte>(1);
scene.field<UnsignedByte[]>(1);
scene.mutableField<UnsignedByte>(1);
scene.mutableField<UnsignedByte[]>(1);
scene.field<UnsignedByte>(SceneField::Mesh);
scene.field<UnsignedByte[]>(SceneField::Mesh);
scene.mutableField<UnsignedByte>(SceneField::Mesh);
scene.mutableField<UnsignedByte[]>(SceneField::Mesh);
CORRADE_COMPARE(out.str(),
"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::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 pointers (and thus importer state) in SceneData.
5 years ago
void SceneDataTest::fieldWrongPointerType() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
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() {
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
struct Field {
UnsignedInt object;
UnsignedInt mesh;
UnsignedInt foobar;
} 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{SceneField::Mesh, view.slice(&Field::object), view.slice(&Field::mesh)},
SceneFieldData{sceneFieldCustom(35), view.slice(&Field::object), Containers::arrayCast<2, UnsignedInt>(view.slice(&Field::foobar))},
}};
std::ostringstream out;
Error redirectError{&out};
scene.field<UnsignedInt[]>(0);
scene.field<UnsignedInt>(1);
scene.mutableField<UnsignedInt[]>(0);
scene.mutableField<UnsignedInt>(1);
scene.field<UnsignedInt[]>(SceneField::Mesh);
scene.field<UnsignedInt>(sceneFieldCustom(35));
scene.mutableField<UnsignedInt[]>(SceneField::Mesh);
scene.mutableField<UnsignedInt>(sceneFieldCustom(35));
CORRADE_COMPARE(out.str(),
"Trade::SceneData::field(): Trade::SceneField::Mesh is not an array field, can't use T[] to access it\n"
"Trade::SceneData::field(): Trade::SceneField::Custom(35) is an array field, use T[] to access it\n"
"Trade::SceneData::mutableField(): Trade::SceneField::Mesh is not an array field, can't 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::Mesh is not an array field, can't use T[] to access it\n"
"Trade::SceneData::field(): Trade::SceneField::Custom(35) is an array field, use T[] to access it\n"
"Trade::SceneData::mutableField(): Trade::SceneField::Mesh is not an array field, can't use T[] to access it\n"
"Trade::SceneData::mutableField(): Trade::SceneField::Custom(35) is an array field, use T[] to access it\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
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() {
Trade: convenience per-object field access in SceneData.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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() {
Trade: convenience per-object field access in SceneData.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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() {
Trade: convenience per-object field access in SceneData.
5 years ago
#ifdef CORRADE_NO_ASSERT
CORRADE_SKIP("CORRADE_NO_ASSERT defined, can't test assertions");
#endif
Trade: rename SceneData "objects" to "mapping". Now it's a field and its corresponding object mapping, instead of field and "objects": - Goes better with the concept that there's not really any materialized "object" anywhere, just fields mapped to them. - No more weird singular/plural difference between field() and objects(), it's field() and mapping() now. - The objectCount() that actually wasn't really object count is now a mappingBound(), an upper bound for object IDs contained in 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 */
CORRADE_COMPARE(scene.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)