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

7598 lines
302 KiB
Raw Normal View History Unescape

Trade: bootstrap scene converter plugins.
6 years ago
/*
This file is part of Magnum.
Updated copyright year.
6 years ago
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019,
Updated copyright year.
4 years ago
2020, 2021, 2022 Vladimír Vondruš <mosra@centrum.cz>
Trade: bootstrap scene converter plugins.
6 years ago
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#include <sstream>
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
#include <Corrade/Containers/Iterable.h>
Trade: reverse AbstractSceneConverter::convertToFile() argument order. It should be input first, output second, like with all other APIs. I remember I was trying something else here, but that didn't really make sense in the end. Also took that opportunity to get rid of one std::string. The original signature is a deprecated alias to the new one and will be removed in a future release.
5 years ago
#include <Corrade/Containers/StringView.h>
Trade: port to the new Utility::Path. For file opening there's no longer an unatomic pair of exists() + read(), but since Path::read() now returns an Optional, it means we can reliably distinguish between empty files and failures. While at it, also added TODOs for removal of the StringStl.h header that's needed in various places for compatibility with APIs still using STL strings.
4 years ago
#include <Corrade/Containers/StringStl.h> /** @todo remove once Debug is stream-free */
Trade: bootstrap scene converter plugins.
6 years ago
#include <Corrade/Containers/Optional.h>
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/TestSuite/Compare/Container.h>
#include <Corrade/TestSuite/Compare/FileToString.h>
Adapt tests to changes in Utility::Directory error reporting. Now comparing just the message coming out of our code, ignoring the system-specific message Directory prints.
4 years ago
#include <Corrade/TestSuite/Compare/String.h>
Trade: bootstrap scene converter plugins.
6 years ago
#include <Corrade/Utility/DebugStl.h>
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
#include <Corrade/Utility/Format.h>
#include <Corrade/Utility/FormatStl.h> /** @todo remove once Debug is stream-free */
Trade: port to the new Utility::Path. For file opening there's no longer an unatomic pair of exists() + read(), but since Path::read() now returns an Optional, it means we can reliably distinguish between empty files and failures. While at it, also added TODOs for removal of the StringStl.h header that's needed in various places for compatibility with APIs still using STL strings.
4 years ago
#include <Corrade/Utility/Path.h>
Trade: bootstrap scene converter plugins.
6 years ago
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
#include "Magnum/ImageView.h"
#include "Magnum/PixelFormat.h"
Trade: bootstrap scene converter plugins.
6 years ago
#include "Magnum/Math/Vector3.h"
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
#include "Magnum/Math/Matrix3.h"
#include "Magnum/Math/Matrix4.h"
Trade: bootstrap scene converter plugins.
6 years ago
#include "Magnum/Trade/ArrayAllocator.h"
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
#include "Magnum/Trade/AbstractImporter.h"
Trade: bootstrap scene converter plugins.
6 years ago
#include "Magnum/Trade/AbstractSceneConverter.h"
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
#include "Magnum/Trade/AnimationData.h"
#include "Magnum/Trade/CameraData.h"
#include "Magnum/Trade/ImageData.h"
#include "Magnum/Trade/LightData.h"
#include "Magnum/Trade/MaterialData.h"
Trade: bootstrap scene converter plugins.
6 years ago
#include "Magnum/Trade/MeshData.h"
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
#include "Magnum/Trade/SceneData.h"
#include "Magnum/Trade/SkinData.h"
#include "Magnum/Trade/TextureData.h"
Trade: bootstrap scene converter plugins.
6 years ago
#include "configure.h"
namespace Magnum { namespace Trade { namespace Test { namespace {
struct AbstractSceneConverterTest: TestSuite::Tester {
explicit AbstractSceneConverterTest();
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
void sceneContentsForImporterNone();
void sceneContentsForImporterAll();
void sceneContentsForImporterNotOpened();
void sceneContentsForConverterNone();
void sceneContentsForConverterSingleMesh();
void sceneContentsForConverterAll();
Trade: bootstrap scene converter plugins.
6 years ago
void featuresNone();
void setFlags();
void setFlagsNotImplemented();
void thingNotSupported();
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
/* Certain features need a combination of flags, test them explicitly */
void thingLevelsNotSupported();
Trade: bootstrap scene converter plugins.
6 years ago
void convertMesh();
ShaderTools,Trade: properly test failure states of all plugin APIs. Until now, these were only transitively tested in concrete plugin implementations, meaning that if the base implementation would have an error (such as accessing a null optional), it would only get discovered when building a plugin, worst case a plugin in a completely different repo.
4 years ago
void convertMeshFailed();
Trade: bootstrap scene converter plugins.
6 years ago
void convertMeshNotImplemented();
void convertMeshNonOwningDeleters();
void convertMeshGrowableDeleters();
void convertMeshCustomIndexDataDeleter();
void convertMeshCustomVertexDataDeleter();
void convertMeshCustomAttributeDataDeleter();
void convertMeshInPlace();
ShaderTools,Trade: properly test failure states of all plugin APIs. Until now, these were only transitively tested in concrete plugin implementations, meaning that if the base implementation would have an error (such as accessing a null optional), it would only get discovered when building a plugin, worst case a plugin in a completely different repo.
4 years ago
void convertMeshInPlaceFailed();
Trade: bootstrap scene converter plugins.
6 years ago
void convertMeshInPlaceNotImplemented();
void convertMeshToData();
ShaderTools,Trade: properly test failure states of all plugin APIs. Until now, these were only transitively tested in concrete plugin implementations, meaning that if the base implementation would have an error (such as accessing a null optional), it would only get discovered when building a plugin, worst case a plugin in a completely different repo.
4 years ago
void convertMeshToDataFailed();
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
void convertMeshToDataThroughBatch();
void convertMeshToDataThroughBatchAddFailed();
void convertMeshToDataThroughBatchEndFailed();
Trade: bootstrap scene converter plugins.
6 years ago
void convertMeshToDataNotImplemented();
Trade: test growable and non-owning deleters in all SceneConverter cases.
4 years ago
void convertMeshToDataNonOwningDeleter();
void convertMeshToDataGrowableDeleter();
Trade: bootstrap scene converter plugins.
6 years ago
void convertMeshToDataCustomDeleter();
void convertMeshToFile();
ShaderTools,Trade: properly test failure states of all plugin APIs. Until now, these were only transitively tested in concrete plugin implementations, meaning that if the base implementation would have an error (such as accessing a null optional), it would only get discovered when building a plugin, worst case a plugin in a completely different repo.
4 years ago
void convertMeshToFileFailed();
Trade: bootstrap scene converter plugins.
6 years ago
void convertMeshToFileThroughData();
Trade: explicitly test a case with failed conversion written to a file. Too easy to forget this check, write an empty file and return true.
6 years ago
void convertMeshToFileThroughDataFailed();
Trade: bootstrap scene converter plugins.
6 years ago
void convertMeshToFileThroughDataNotWritable();
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
void convertMeshToFileThroughBatch();
void convertMeshToFileThroughBatchAddFailed();
void convertMeshToFileThroughBatchEndFailed();
Trade: bootstrap scene converter plugins.
6 years ago
void convertMeshToFileNotImplemented();
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
void beginEnd();
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
void beginFailed();
void endFailed();
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
void beginNotImplemented();
void endNotImplemented();
void beginEndData();
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
void beginDataFailed();
void endDataFailed();
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
void beginDataNotImplemented();
void endDataNotImplemented();
void beginEndDataCustomDeleter();
void beginEndFile();
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
void beginFileFailed();
void endFileFailed();
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
void beginEndFileThroughData();
void beginEndFileThroughDataFailed();
void beginEndFileThroughDataNotWritable();
void beginFileNotImplemented();
void endFileNotImplemented();
void abort();
void abortNotImplemented();
Trade: implicitly abort previous conversion in all scene converter APIs. And properly test the behavior as well. While it's rare that a batch and immediate conversions would be mixed on a single converter instance, if it happens by accident it should not lead to unexpected internal state.
4 years ago
void abortImplicitlyConvertMesh();
void abortImplicitlyConvertMeshInPlace();
void abortImplicitlyConvertMeshToData();
void abortImplicitlyConvertMeshToFile();
void abortImplicitlyBegin();
void abortImplicitlyBeginData();
void abortImplicitlyBeginFile();
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
void thingNoBegin();
void endMismatchedBegin();
void endDataMismatchedBegin();
void endFileMismatchedBegin();
void addScene();
void addSceneFailed();
void addSceneNotImplemented();
void setSceneFieldName();
void setSceneFieldNameNotImplemented();
void setSceneFieldNameNotCustom();
void setObjectName();
void setObjectNameNotImplemented();
void setDefaultScene();
void setDefaultSceneNotImplemented();
void setDefaultSceneOutOfRange();
void addAnimation();
void addAnimationFailed();
void addAnimationNotImplemented();
Trade: ability to specify custom animation target names on conversion. Added this API to the importer, forgot about the converter. Sigh.
3 years ago
void setAnimationTrackTargetName();
void setAnimationTrackTargetNameNotImplemented();
void setAnimationTrackTargetNameNotCustom();
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
void addLight();
void addLightFailed();
void addLightNotImplemented();
void addCamera();
void addCameraFailed();
void addCameraNotImplemented();
void addSkin2D();
void addSkin2DFailed();
void addSkin2DNotImplemented();
void addSkin3D();
void addSkin3DFailed();
void addSkin3DNotImplemented();
void addMesh();
void addMeshFailed();
void addMeshThroughConvertMesh();
void addMeshThroughConvertMeshFailed();
void addMeshThroughConvertMeshZeroMeshes();
void addMeshThroughConvertMeshTwoMeshes();
void addMeshThroughConvertMeshToData();
void addMeshThroughConvertMeshToDataFailed();
void addMeshThroughConvertMeshToDataZeroMeshes();
void addMeshThroughConvertMeshToDataTwoMeshes();
void addMeshThroughConvertMeshToFile();
void addMeshThroughConvertMeshToFileThroughData();
void addMeshThroughConvertMeshToFileFailed();
void addMeshThroughConvertMeshToFileZeroMeshes();
void addMeshThroughConvertMeshToFileTwoMeshes();
void addMeshNotImplemented();
void addMeshLevels();
void addMeshLevelsFailed();
void addMeshLevelsNoLevels();
void addMeshLevelsNotImplemented();
void addMeshThroughLevels();
void setMeshAttributeName();
void setMeshAttributeNameNotImplemented();
void setMeshAttributeNameNotCustom();
void addMaterial();
void addMaterialFailed();
void addMaterialNotImplemented();
void addTexture();
void addTextureFailed();
void addTextureNotImplemented();
void addImage1D();
void addImage1DView();
void addImage1DCompressedView();
void addImage1DFailed();
/* 1D/2D/3D share the same image validity check function, so it's verified
only for 2D thoroughly and for others just that the check is used */
void addImage1DInvalidImage();
void addImage1DNotImplemented();
void addImage2D();
void addImage2DView();
void addImage2DCompressedView();
void addImage2DFailed();
void addImage2DZeroSize();
void addImage2DNullptr();
void addImage2DNotImplemented();
void addImage3D();
void addImage3DView();
void addImage3DCompressedView();
void addImage3DFailed();
/* 1D/2D/3D share the same image validity check function, so it's verified
only for 2D thoroughly and for others just that the check is used */
void addImage3DInvalidImage();
void addImage3DNotImplemented();
void addImageLevels1D();
void addImageLevels1DView();
void addImageLevels1DCompressedView();
void addImageLevels1DFailed();
/* 1D/2D/3D share the same image list validity check function, so it's
verified only for 2D thoroughly and for others just that the check is
used */
void addImageLevels1DInvalidImage();
void addImageLevels1DNotImplemented();
void addImageLevels2D();
void addImageLevels2DView();
void addImageLevels2DCompressedView();
void addImageLevels2DFailed();
void addImageLevels2DNoLevels();
void addImageLevels2DZeroSize();
void addImageLevels2DNullptr();
void addImageLevels2DInconsistentCompressed();
void addImageLevels2DInconsistentFormat();
void addImageLevels2DInconsistentFormatExtra();
void addImageLevels2DInconsistentCompressedFormat();
void addImageLevels2DInconsistentFlags();
void addImageLevels2DNotImplemented();
void addImageLevels3D();
void addImageLevels3DView();
void addImageLevels3DCompressedView();
void addImageLevels3DFailed();
/* 1D/2D/3D share the same image list validity check function, so it's
verified only for 2D thoroughly and for others just that the check is
used */
void addImageLevels3DInvalidImage();
void addImageLevels3DNotImplemented();
void addImage1DThroughLevels();
void addImage2DThroughLevels();
void addImage3DThroughLevels();
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
void addImporterContents();
void addImporterContentsCustomSceneFields();
void addImporterContentsCustomMeshAttributes();
void addImporterContentsImportFail();
void addImporterContentsConversionFail();
void addImporterContentsNotConverting();
void addImporterContentsNotOpened();
void addImporterContentsNotSupported();
void addImporterContentsNotSupportedLevels();
void addImporterContentsNotSupportedUncompressedImage();
void addImporterContentsNotSupportedCompressedImage();
void addSupportedImporterContents();
void addSupportedImporterContentsLevels();
Trade: bootstrap scene converter plugins.
6 years ago
void debugFeature();
Audio,ShaderTools,Text,Trade: packed debug printing for all Feature enums.
4 years ago
void debugFeaturePacked();
Trade: bootstrap scene converter plugins.
6 years ago
void debugFeatures();
Audio,ShaderTools,Text,Trade: packed debug printing for all Feature enums.
4 years ago
void debugFeaturesPacked();
ShaderTools,Trade: test printing of Feature flag supersets.
5 years ago
void debugFeaturesSupersets();
Trade: bootstrap scene converter plugins.
6 years ago
void debugFlag();
void debugFlags();
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
void debugContent();
void debugContentPacked();
void debugContents();
void debugContentsPacked();
Trade: bootstrap scene converter plugins.
6 years ago
};
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
using namespace Containers::Literals;
Trade: allow calling setMeshAttributeName() on single-mesh converters. It's useful there as well, for example the StanfordSceneConverter implements just single-mesh conversion but is capable of having the attributes named in a custom way (although it's not implemented at the moment). Or a mesh optimization plugin can have specialized behavior for custom attributes but only if it knows what they are.
3 years ago
const struct {
const char* name;
SceneConverterFeatures features;
} SetMeshAttributeData[]{
{"batch conversion supported", SceneConverterFeature::ConvertMultiple|SceneConverterFeature::AddMeshes},
{"single conversion supported", SceneConverterFeature::ConvertMesh},
{"single to file conversion supported", SceneConverterFeature::ConvertMeshToFile},
{"in-place conversion supported", SceneConverterFeature::ConvertMeshInPlace},
};
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
const struct {
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
TestSuite::TestCaseDescriptionSourceLocation name;
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
SceneContents contents;
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
SceneConverterFlags flags;
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
const char* expected;
} AddImporterContentsData[]{
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"scenes", SceneContent::Scenes, {},
"Adding scene 0 named with 0x5ce00000\n"
"Adding scene 1 named with 0x5ce00001\n"
"Setting default scene to 1\n"},
{"scenes, verbose", SceneContent::Scenes, SceneConverterFlag::Verbose,
"Trade::AbstractSceneConverter::addImporterContents(): adding scene 0 out of 2\n"
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding scene 0 named with 0x5ce00000\n"
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
"Trade::AbstractSceneConverter::addImporterContents(): adding scene 1 out of 2\n"
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding scene 1 named with 0x5ce00001\n"
"Setting default scene to 1\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"scenes + names", SceneContent::Scenes|SceneContent::Names, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Setting object 0 name to Object 0\n"
"Setting object 1 name to Object 1\n"
"Setting object 2 name to Object 2\n"
"Adding scene 0 named Scene 0 with 0x5ce00000\n"
"Adding scene 1 named Scene 1 with 0x5ce00001\n"
"Setting default scene to 1\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"animations", SceneContent::Animations, {},
"Adding animation 0 named with 0x40100000\n"
"Adding animation 1 named with 0x40100001\n"},
{"animations, verbose", SceneContent::Animations, SceneConverterFlag::Verbose,
"Trade::AbstractSceneConverter::addImporterContents(): adding animation 0 out of 2\n"
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding animation 0 named with 0x40100000\n"
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
"Trade::AbstractSceneConverter::addImporterContents(): adding animation 1 out of 2\n"
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding animation 1 named with 0x40100001\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"animations + names", SceneContent::Animations|SceneContent::Names, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding animation 0 named Animation 0 with 0x40100000\n"
"Adding animation 1 named Animation 1 with 0x40100001\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"lights", SceneContent::Lights, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding light 0 named with 0x11600000\n"
"Adding light 1 named with 0x11600001\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"lights, verbose", SceneContent::Lights, SceneConverterFlag::Verbose,
"Trade::AbstractSceneConverter::addImporterContents(): adding light 0 out of 2\n"
"Adding light 0 named with 0x11600000\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding light 1 out of 2\n"
"Adding light 1 named with 0x11600001\n"},
{"lights + names", SceneContent::Lights|SceneContent::Names, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding light 0 named Light 0 with 0x11600000\n"
"Adding light 1 named Light 1 with 0x11600001\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"cameras", SceneContent::Cameras, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding camera 0 named with 0xca0e0000\n"
"Adding camera 1 named with 0xca0e0001\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"cameras, verbose", SceneContent::Cameras, SceneConverterFlag::Verbose,
"Trade::AbstractSceneConverter::addImporterContents(): adding camera 0 out of 2\n"
"Adding camera 0 named with 0xca0e0000\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding camera 1 out of 2\n"
"Adding camera 1 named with 0xca0e0001\n"},
{"cameras + names", SceneContent::Cameras|SceneContent::Names, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding camera 0 named Camera 0 with 0xca0e0000\n"
"Adding camera 1 named Camera 1 with 0xca0e0001\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"2D skins", SceneContent::Skins2D, {},
"Adding 2D skin 0 named with 0x50102d00\n"
"Adding 2D skin 1 named with 0x50102d01\n"},
{"2D skins, verbose", SceneContent::Skins2D, SceneConverterFlag::Verbose,
"Trade::AbstractSceneConverter::addImporterContents(): adding 2D skin 0 out of 2\n"
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 2D skin 0 named with 0x50102d00\n"
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
"Trade::AbstractSceneConverter::addImporterContents(): adding 2D skin 1 out of 2\n"
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 2D skin 1 named with 0x50102d01\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"2D skins + names", SceneContent::Skins2D|SceneContent::Names, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 2D skin 0 named 2D skin 0 with 0x50102d00\n"
"Adding 2D skin 1 named 2D skin 1 with 0x50102d01\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"3D skins", SceneContent::Skins3D, {},
"Adding 3D skin 0 named with 0x50103d00\n"
"Adding 3D skin 1 named with 0x50103d01\n"},
{"3D skins, verbose", SceneContent::Skins3D, SceneConverterFlag::Verbose,
"Trade::AbstractSceneConverter::addImporterContents(): adding 3D skin 0 out of 2\n"
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 3D skin 0 named with 0x50103d00\n"
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
"Trade::AbstractSceneConverter::addImporterContents(): adding 3D skin 1 out of 2\n"
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 3D skin 1 named with 0x50103d01\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"3D skins + names", SceneContent::Skins3D|SceneContent::Names, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 3D skin 0 named 3D skin 0 with 0x50103d00\n"
"Adding 3D skin 1 named 3D skin 1 with 0x50103d01\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"meshes", SceneContent::Meshes, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding mesh 0 named with 0xe500000\n"
"Adding mesh 1 named with 0xe500001\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"meshes, verbose", SceneContent::Meshes, SceneConverterFlag::Verbose,
"Trade::AbstractSceneConverter::addImporterContents(): adding mesh 0 out of 2\n"
"Adding mesh 0 named with 0xe500000\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding mesh 1 out of 2\n"
"Adding mesh 1 named with 0xe500001\n"},
{"meshes + names", SceneContent::Meshes|SceneContent::Names, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding mesh 0 named Mesh 0 with 0xe500000\n"
"Adding mesh 1 named Mesh 1 with 0xe500001\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"meshes + levels", SceneContent::Meshes|SceneContent::MeshLevels, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding mesh 0 named with 0xe500000\n"
"Adding mesh 1 level 0 named with 0xe500001\n"
"Adding mesh 1 level 1 named with 0xe500011\n"
"Adding mesh 1 level 2 named with 0xe500021\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"meshes + levels, verbose", SceneContent::Meshes|SceneContent::MeshLevels, SceneConverterFlag::Verbose,
"Trade::AbstractSceneConverter::addImporterContents(): adding mesh 0 out of 2\n"
"Adding mesh 0 named with 0xe500000\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding mesh 1 out of 2\n"
"Trade::AbstractSceneConverter::addImporterContents(): importing mesh 1 level 0 out of 3\n"
"Trade::AbstractSceneConverter::addImporterContents(): importing mesh 1 level 1 out of 3\n"
"Trade::AbstractSceneConverter::addImporterContents(): importing mesh 1 level 2 out of 3\n"
"Adding mesh 1 level 0 named with 0xe500001\n"
"Adding mesh 1 level 1 named with 0xe500011\n"
"Adding mesh 1 level 2 named with 0xe500021\n"},
{"meshes + levels + names", SceneContent::Meshes|SceneContent::MeshLevels|SceneContent::Names, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding mesh 0 named Mesh 0 with 0xe500000\n"
"Adding mesh 1 level 0 named Mesh 1 with 0xe500001\n"
"Adding mesh 1 level 1 named Mesh 1 with 0xe500011\n"
"Adding mesh 1 level 2 named Mesh 1 with 0xe500021\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"materials", SceneContent::Materials, {},
"Adding material 0 named with 0xa7e0000\n"
"Adding material 1 named with 0xa7e0001\n"},
{"materials, verbose", SceneContent::Materials, SceneConverterFlag::Verbose,
"Trade::AbstractSceneConverter::addImporterContents(): adding material 0 out of 2\n"
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding material 0 named with 0xa7e0000\n"
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
"Trade::AbstractSceneConverter::addImporterContents(): adding material 1 out of 2\n"
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding material 1 named with 0xa7e0001\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"materials + names", SceneContent::Materials|SceneContent::Names, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding material 0 named Material 0 with 0xa7e0000\n"
"Adding material 1 named Material 1 with 0xa7e0001\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"textures", SceneContent::Textures, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding texture 0 named with 0x7e070000\n"
"Adding texture 1 named with 0x7e070001\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"textures, verbose", SceneContent::Textures, SceneConverterFlag::Verbose,
"Trade::AbstractSceneConverter::addImporterContents(): adding texture 0 out of 2\n"
"Adding texture 0 named with 0x7e070000\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding texture 1 out of 2\n"
"Adding texture 1 named with 0x7e070001\n"},
{"textures + names", SceneContent::Textures|SceneContent::Names, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding texture 0 named Texture 0 with 0x7e070000\n"
"Adding texture 1 named Texture 1 with 0x7e070001\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"1D images", SceneContent::Images1D, {},
"Adding 1D image 0 named with 0x10a91d00\n"
"Adding 1D image 1 named with 0x10a91d01\n"},
{"1D images, verbose", SceneContent::Images1D, SceneConverterFlag::Verbose,
"Trade::AbstractSceneConverter::addImporterContents(): adding 1D image 0 out of 2\n"
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 1D image 0 named with 0x10a91d00\n"
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
"Trade::AbstractSceneConverter::addImporterContents(): adding 1D image 1 out of 2\n"
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 1D image 1 named with 0x10a91d01\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"1D images + names", SceneContent::Images1D|SceneContent::Names, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 1D image 0 named 1D image 0 with 0x10a91d00\n"
"Adding 1D image 1 named 1D image 1 with 0x10a91d01\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"1D images + levels", SceneContent::Images1D|SceneContent::ImageLevels, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 1D image 0 named with 0x10a91d00\n"
"Adding 1D image 1 level 0 named with 0x10a91d01\n"
"Adding 1D image 1 level 1 named with 0x10a91d11\n"
"Adding 1D image 1 level 2 named with 0x10a91d21\n"
"Adding 1D image 1 level 3 named with 0x10a91d31\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"1D images + levels, verbose", SceneContent::Images1D|SceneContent::ImageLevels, SceneConverterFlag::Verbose,
"Trade::AbstractSceneConverter::addImporterContents(): adding 1D image 0 out of 2\n"
"Adding 1D image 0 named with 0x10a91d00\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding 1D image 1 out of 2\n"
"Trade::AbstractSceneConverter::addImporterContents(): importing 1D image 1 level 0 out of 4\n"
"Trade::AbstractSceneConverter::addImporterContents(): importing 1D image 1 level 1 out of 4\n"
"Trade::AbstractSceneConverter::addImporterContents(): importing 1D image 1 level 2 out of 4\n"
"Trade::AbstractSceneConverter::addImporterContents(): importing 1D image 1 level 3 out of 4\n"
"Adding 1D image 1 level 0 named with 0x10a91d01\n"
"Adding 1D image 1 level 1 named with 0x10a91d11\n"
"Adding 1D image 1 level 2 named with 0x10a91d21\n"
"Adding 1D image 1 level 3 named with 0x10a91d31\n"},
{"1D images + levels + names", SceneContent::Images1D|SceneContent::ImageLevels|SceneContent::Names, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 1D image 0 named 1D image 0 with 0x10a91d00\n"
"Adding 1D image 1 level 0 named 1D image 1 with 0x10a91d01\n"
"Adding 1D image 1 level 1 named 1D image 1 with 0x10a91d11\n"
"Adding 1D image 1 level 2 named 1D image 1 with 0x10a91d21\n"
"Adding 1D image 1 level 3 named 1D image 1 with 0x10a91d31\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"2D images", SceneContent::Images2D, {},
"Adding 2D image 0 named with 0x10a92d00\n"
"Adding 2D image 1 named with 0x10a92d01\n"},
{"2D images, verbose", SceneContent::Images2D, SceneConverterFlag::Verbose,
"Trade::AbstractSceneConverter::addImporterContents(): adding 2D image 0 out of 2\n"
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 2D image 0 named with 0x10a92d00\n"
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
"Trade::AbstractSceneConverter::addImporterContents(): adding 2D image 1 out of 2\n"
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 2D image 1 named with 0x10a92d01\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"2D images + names", SceneContent::Images2D|SceneContent::Names, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 2D image 0 named 2D image 0 with 0x10a92d00\n"
"Adding 2D image 1 named 2D image 1 with 0x10a92d01\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"2D images + levels", SceneContent::Images2D|SceneContent::ImageLevels, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 2D image 0 level 0 named with 0x10a92d00\n"
"Adding 2D image 0 level 1 named with 0x10a92d10\n"
"Adding 2D image 0 level 2 named with 0x10a92d20\n"
"Adding 2D image 1 named with 0x10a92d01\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"2D images + levels, verbose", SceneContent::Images2D|SceneContent::ImageLevels, SceneConverterFlag::Verbose,
"Trade::AbstractSceneConverter::addImporterContents(): adding 2D image 0 out of 2\n"
"Trade::AbstractSceneConverter::addImporterContents(): importing 2D image 0 level 0 out of 3\n"
"Trade::AbstractSceneConverter::addImporterContents(): importing 2D image 0 level 1 out of 3\n"
"Trade::AbstractSceneConverter::addImporterContents(): importing 2D image 0 level 2 out of 3\n"
"Adding 2D image 0 level 0 named with 0x10a92d00\n"
"Adding 2D image 0 level 1 named with 0x10a92d10\n"
"Adding 2D image 0 level 2 named with 0x10a92d20\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding 2D image 1 out of 2\n"
"Adding 2D image 1 named with 0x10a92d01\n"},
{"2D images + names", SceneContent::Images2D|SceneContent::ImageLevels|SceneContent::Names, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 2D image 0 level 0 named 2D image 0 with 0x10a92d00\n"
"Adding 2D image 0 level 1 named 2D image 0 with 0x10a92d10\n"
"Adding 2D image 0 level 2 named 2D image 0 with 0x10a92d20\n"
"Adding 2D image 1 named 2D image 1 with 0x10a92d01\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"3D images", SceneContent::Images3D, {},
"Adding 3D image 0 named with 0x10a93d00\n"
"Adding 3D image 1 named with 0x10a93d01\n"},
{"3D images, verbose", SceneContent::Images3D, SceneConverterFlag::Verbose,
"Trade::AbstractSceneConverter::addImporterContents(): adding 3D image 0 out of 2\n"
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 3D image 0 named with 0x10a93d00\n"
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
"Trade::AbstractSceneConverter::addImporterContents(): adding 3D image 1 out of 2\n"
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 3D image 1 named with 0x10a93d01\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"3D images + names", SceneContent::Images3D|SceneContent::Names, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 3D image 0 named 3D image 0 with 0x10a93d00\n"
"Adding 3D image 1 named 3D image 1 with 0x10a93d01\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"3D images + levels", SceneContent::Images3D|SceneContent::ImageLevels, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 3D image 0 named with 0x10a93d00\n"
"Adding 3D image 1 level 0 named with 0x10a93d01\n"
"Adding 3D image 1 level 1 named with 0x10a93d11\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"3D images + levels, verbose", SceneContent::Images3D|SceneContent::ImageLevels, SceneConverterFlag::Verbose,
"Trade::AbstractSceneConverter::addImporterContents(): adding 3D image 0 out of 2\n"
"Adding 3D image 0 named with 0x10a93d00\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding 3D image 1 out of 2\n"
"Trade::AbstractSceneConverter::addImporterContents(): importing 3D image 1 level 0 out of 2\n"
"Trade::AbstractSceneConverter::addImporterContents(): importing 3D image 1 level 1 out of 2\n"
"Adding 3D image 1 level 0 named with 0x10a93d01\n"
"Adding 3D image 1 level 1 named with 0x10a93d11\n"},
{"3D images + names", SceneContent::Images3D|SceneContent::ImageLevels|SceneContent::Names, {},
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding 3D image 0 named 3D image 0 with 0x10a93d00\n"
"Adding 3D image 1 level 0 named 3D image 1 with 0x10a93d01\n"
"Adding 3D image 1 level 1 named 3D image 1 with 0x10a93d11\n"},
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
{"names only", SceneContent::Names, {},
"" /* Nothing */},
{"names only, verbose", SceneContent::Names, SceneConverterFlag::Verbose,
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"" /* Nothing */},
};
const struct {
const char* name;
SceneContents contents;
} AddImporterContentsFailData[]{
{"scene", SceneContent::Scenes},
{"animation", SceneContent::Animations},
{"light", SceneContent::Lights},
{"camera", SceneContent::Cameras},
{"2D skin", SceneContent::Skins2D},
{"3D skin", SceneContent::Skins3D},
{"mesh", SceneContent::Meshes},
{"mesh levels", SceneContent::Meshes|SceneContent::MeshLevels},
{"material", SceneContent::Materials},
{"texture", SceneContent::Textures},
{"1D image", SceneContent::Images1D},
{"1D image levels", SceneContent::Images1D|SceneContent::ImageLevels},
{"2D image", SceneContent::Images2D},
{"2D image levels", SceneContent::Images2D|SceneContent::ImageLevels},
{"3D image", SceneContent::Images3D},
{"3D image levels", SceneContent::Images3D|SceneContent::ImageLevels},
};
const struct {
const char* name;
const char* except;
SceneConverterFeatures exceptFeatures;
SceneContents exceptContents;
SceneContents wantExceptContents;
} AddSupportedImporterContentsData[]{
{"except scenes", "2 scenes",
SceneConverterFeature::AddScenes, SceneContent::Scenes, {}},
{"except animations", "3 animations",
SceneConverterFeature::AddAnimations, SceneContent::Animations, {}},
{"except lights", "4 lights",
SceneConverterFeature::AddLights, SceneContent::Lights, {}},
{"except cameras", "5 cameras",
SceneConverterFeature::AddCameras, SceneContent::Cameras, {}},
{"except 2D skins", "6 2D skins",
SceneConverterFeature::AddSkins2D, SceneContent::Skins2D, {}},
{"except 3D skins", "7 3D skins",
SceneConverterFeature::AddSkins3D, SceneContent::Skins3D, {}},
{"except meshes", "8 meshes",
SceneConverterFeature::AddMeshes, SceneContent::Meshes, {}},
{"except materials", "9 materials",
SceneConverterFeature::AddMaterials, SceneContent::Materials, {}},
{"except textures", "10 textures",
SceneConverterFeature::AddTextures, SceneContent::Textures, {}},
{"except 1D images", "11 1D images",
SceneConverterFeature::AddImages1D, SceneContent::Images1D, {}},
{"except 2D images", "12 2D images",
SceneConverterFeature::AddImages2D, SceneContent::Images2D, {}},
{"except 3D images", "13 3D images",
SceneConverterFeature::AddImages3D, SceneContent::Images3D, {}},
/* Should only warn about materials not supported by the converter, not
meshes because we don't want them anyway */
{"except materials and meshes, without meshes", "9 materials",
SceneConverterFeature::AddMaterials|SceneConverterFeature::AddMeshes,
SceneContent::Materials|SceneContent::Meshes,
SceneContent::Meshes},
/* Should only warn about materials not supported by the converter, nothing
about meshes (which are available in the importer always but not
passed to the converter) */
{"except materials, without meshes", "9 materials",
SceneConverterFeature::AddMaterials, SceneContent::Materials,
SceneContent::Meshes},
};
Trade: bootstrap scene converter plugins.
6 years ago
AbstractSceneConverterTest::AbstractSceneConverterTest() {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
addTests({&AbstractSceneConverterTest::sceneContentsForImporterNone,
&AbstractSceneConverterTest::sceneContentsForImporterAll,
&AbstractSceneConverterTest::sceneContentsForImporterNotOpened,
&AbstractSceneConverterTest::sceneContentsForConverterNone,
&AbstractSceneConverterTest::sceneContentsForConverterSingleMesh,
&AbstractSceneConverterTest::sceneContentsForConverterAll,
&AbstractSceneConverterTest::featuresNone,
Trade: bootstrap scene converter plugins.
6 years ago
&AbstractSceneConverterTest::setFlags,
&AbstractSceneConverterTest::setFlagsNotImplemented,
&AbstractSceneConverterTest::thingNotSupported,
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
&AbstractSceneConverterTest::thingLevelsNotSupported,
Trade: bootstrap scene converter plugins.
6 years ago
&AbstractSceneConverterTest::convertMesh,
ShaderTools,Trade: properly test failure states of all plugin APIs. Until now, these were only transitively tested in concrete plugin implementations, meaning that if the base implementation would have an error (such as accessing a null optional), it would only get discovered when building a plugin, worst case a plugin in a completely different repo.
4 years ago
&AbstractSceneConverterTest::convertMeshFailed,
Trade: bootstrap scene converter plugins.
6 years ago
&AbstractSceneConverterTest::convertMeshNotImplemented,
&AbstractSceneConverterTest::convertMeshNonOwningDeleters,
&AbstractSceneConverterTest::convertMeshGrowableDeleters,
&AbstractSceneConverterTest::convertMeshCustomIndexDataDeleter,
&AbstractSceneConverterTest::convertMeshCustomVertexDataDeleter,
&AbstractSceneConverterTest::convertMeshCustomAttributeDataDeleter,
&AbstractSceneConverterTest::convertMeshInPlace,
ShaderTools,Trade: properly test failure states of all plugin APIs. Until now, these were only transitively tested in concrete plugin implementations, meaning that if the base implementation would have an error (such as accessing a null optional), it would only get discovered when building a plugin, worst case a plugin in a completely different repo.
4 years ago
&AbstractSceneConverterTest::convertMeshInPlaceFailed,
Trade: bootstrap scene converter plugins.
6 years ago
&AbstractSceneConverterTest::convertMeshInPlaceNotImplemented,
&AbstractSceneConverterTest::convertMeshToData,
ShaderTools,Trade: properly test failure states of all plugin APIs. Until now, these were only transitively tested in concrete plugin implementations, meaning that if the base implementation would have an error (such as accessing a null optional), it would only get discovered when building a plugin, worst case a plugin in a completely different repo.
4 years ago
&AbstractSceneConverterTest::convertMeshToDataFailed,
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
&AbstractSceneConverterTest::convertMeshToDataThroughBatch,
&AbstractSceneConverterTest::convertMeshToDataThroughBatchAddFailed,
&AbstractSceneConverterTest::convertMeshToDataThroughBatchEndFailed,
Trade: bootstrap scene converter plugins.
6 years ago
&AbstractSceneConverterTest::convertMeshToDataNotImplemented,
Trade: test growable and non-owning deleters in all SceneConverter cases.
4 years ago
&AbstractSceneConverterTest::convertMeshToDataNonOwningDeleter,
&AbstractSceneConverterTest::convertMeshToDataGrowableDeleter,
Trade: bootstrap scene converter plugins.
6 years ago
&AbstractSceneConverterTest::convertMeshToDataCustomDeleter,
&AbstractSceneConverterTest::convertMeshToFile,
ShaderTools,Trade: properly test failure states of all plugin APIs. Until now, these were only transitively tested in concrete plugin implementations, meaning that if the base implementation would have an error (such as accessing a null optional), it would only get discovered when building a plugin, worst case a plugin in a completely different repo.
4 years ago
&AbstractSceneConverterTest::convertMeshToFileFailed,
Trade: bootstrap scene converter plugins.
6 years ago
&AbstractSceneConverterTest::convertMeshToFileThroughData,
Trade: explicitly test a case with failed conversion written to a file. Too easy to forget this check, write an empty file and return true.
6 years ago
&AbstractSceneConverterTest::convertMeshToFileThroughDataFailed,
Trade: bootstrap scene converter plugins.
6 years ago
&AbstractSceneConverterTest::convertMeshToFileThroughDataNotWritable,
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
&AbstractSceneConverterTest::convertMeshToFileThroughBatch,
&AbstractSceneConverterTest::convertMeshToFileThroughBatchAddFailed,
&AbstractSceneConverterTest::convertMeshToFileThroughBatchEndFailed,
Trade: bootstrap scene converter plugins.
6 years ago
&AbstractSceneConverterTest::convertMeshToFileNotImplemented,
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
&AbstractSceneConverterTest::beginEnd,
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
&AbstractSceneConverterTest::beginFailed,
&AbstractSceneConverterTest::endFailed,
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
&AbstractSceneConverterTest::beginNotImplemented,
&AbstractSceneConverterTest::endNotImplemented,
&AbstractSceneConverterTest::beginEndData,
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
&AbstractSceneConverterTest::beginDataFailed,
&AbstractSceneConverterTest::endDataFailed,
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
&AbstractSceneConverterTest::beginDataNotImplemented,
&AbstractSceneConverterTest::endDataNotImplemented,
&AbstractSceneConverterTest::beginEndDataCustomDeleter,
&AbstractSceneConverterTest::beginEndFile,
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
&AbstractSceneConverterTest::beginFileFailed,
&AbstractSceneConverterTest::endFileFailed,
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
&AbstractSceneConverterTest::beginEndFileThroughData,
&AbstractSceneConverterTest::beginEndFileThroughDataFailed,
&AbstractSceneConverterTest::beginEndFileThroughDataNotWritable,
&AbstractSceneConverterTest::beginFileNotImplemented,
&AbstractSceneConverterTest::endFileNotImplemented,
&AbstractSceneConverterTest::abort,
&AbstractSceneConverterTest::abortNotImplemented,
Trade: implicitly abort previous conversion in all scene converter APIs. And properly test the behavior as well. While it's rare that a batch and immediate conversions would be mixed on a single converter instance, if it happens by accident it should not lead to unexpected internal state.
4 years ago
&AbstractSceneConverterTest::abortImplicitlyConvertMesh,
&AbstractSceneConverterTest::abortImplicitlyConvertMeshInPlace,
&AbstractSceneConverterTest::abortImplicitlyConvertMeshToData,
&AbstractSceneConverterTest::abortImplicitlyConvertMeshToFile,
&AbstractSceneConverterTest::abortImplicitlyBegin,
&AbstractSceneConverterTest::abortImplicitlyBeginData,
&AbstractSceneConverterTest::abortImplicitlyBeginFile,
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
&AbstractSceneConverterTest::thingNoBegin,
&AbstractSceneConverterTest::endMismatchedBegin,
&AbstractSceneConverterTest::endDataMismatchedBegin,
&AbstractSceneConverterTest::endFileMismatchedBegin,
&AbstractSceneConverterTest::addScene,
&AbstractSceneConverterTest::addSceneFailed,
&AbstractSceneConverterTest::addSceneNotImplemented,
&AbstractSceneConverterTest::setSceneFieldName,
&AbstractSceneConverterTest::setSceneFieldNameNotImplemented,
&AbstractSceneConverterTest::setSceneFieldNameNotCustom,
&AbstractSceneConverterTest::setObjectName,
&AbstractSceneConverterTest::setObjectNameNotImplemented,
&AbstractSceneConverterTest::setDefaultScene,
&AbstractSceneConverterTest::setDefaultSceneNotImplemented,
&AbstractSceneConverterTest::setDefaultSceneOutOfRange,
&AbstractSceneConverterTest::addAnimation,
&AbstractSceneConverterTest::addAnimationFailed,
&AbstractSceneConverterTest::addAnimationNotImplemented,
Trade: ability to specify custom animation target names on conversion. Added this API to the importer, forgot about the converter. Sigh.
3 years ago
&AbstractSceneConverterTest::setAnimationTrackTargetName,
&AbstractSceneConverterTest::setAnimationTrackTargetNameNotImplemented,
&AbstractSceneConverterTest::setAnimationTrackTargetNameNotCustom,
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
&AbstractSceneConverterTest::addLight,
&AbstractSceneConverterTest::addLightFailed,
&AbstractSceneConverterTest::addLightNotImplemented,
&AbstractSceneConverterTest::addCamera,
&AbstractSceneConverterTest::addCameraFailed,
&AbstractSceneConverterTest::addCameraNotImplemented,
&AbstractSceneConverterTest::addSkin2D,
&AbstractSceneConverterTest::addSkin2DFailed,
&AbstractSceneConverterTest::addSkin2DNotImplemented,
&AbstractSceneConverterTest::addSkin3D,
&AbstractSceneConverterTest::addSkin3DFailed,
&AbstractSceneConverterTest::addSkin3DNotImplemented,
&AbstractSceneConverterTest::addMesh,
&AbstractSceneConverterTest::addMeshFailed,
&AbstractSceneConverterTest::addMeshThroughConvertMesh,
&AbstractSceneConverterTest::addMeshThroughConvertMeshFailed,
&AbstractSceneConverterTest::addMeshThroughConvertMeshZeroMeshes,
&AbstractSceneConverterTest::addMeshThroughConvertMeshTwoMeshes,
&AbstractSceneConverterTest::addMeshThroughConvertMeshToData,
&AbstractSceneConverterTest::addMeshThroughConvertMeshToDataFailed,
&AbstractSceneConverterTest::addMeshThroughConvertMeshToDataZeroMeshes,
&AbstractSceneConverterTest::addMeshThroughConvertMeshToDataTwoMeshes,
&AbstractSceneConverterTest::addMeshThroughConvertMeshToFile,
&AbstractSceneConverterTest::addMeshThroughConvertMeshToFileThroughData,
&AbstractSceneConverterTest::addMeshThroughConvertMeshToFileFailed,
&AbstractSceneConverterTest::addMeshThroughConvertMeshToFileZeroMeshes,
&AbstractSceneConverterTest::addMeshThroughConvertMeshToFileTwoMeshes,
&AbstractSceneConverterTest::addMeshNotImplemented,
&AbstractSceneConverterTest::addMeshLevels,
&AbstractSceneConverterTest::addMeshLevelsFailed,
&AbstractSceneConverterTest::addMeshLevelsNoLevels,
&AbstractSceneConverterTest::addMeshLevelsNotImplemented,
Trade: allow calling setMeshAttributeName() on single-mesh converters. It's useful there as well, for example the StanfordSceneConverter implements just single-mesh conversion but is capable of having the attributes named in a custom way (although it's not implemented at the moment). Or a mesh optimization plugin can have specialized behavior for custom attributes but only if it knows what they are.
3 years ago
&AbstractSceneConverterTest::addMeshThroughLevels});
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Trade: allow calling setMeshAttributeName() on single-mesh converters. It's useful there as well, for example the StanfordSceneConverter implements just single-mesh conversion but is capable of having the attributes named in a custom way (although it's not implemented at the moment). Or a mesh optimization plugin can have specialized behavior for custom attributes but only if it knows what they are.
3 years ago
addInstancedTests({&AbstractSceneConverterTest::setMeshAttributeName},
Containers::arraySize(SetMeshAttributeData));
addTests({&AbstractSceneConverterTest::setMeshAttributeNameNotImplemented,
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
&AbstractSceneConverterTest::setMeshAttributeNameNotCustom,
&AbstractSceneConverterTest::addMaterial,
&AbstractSceneConverterTest::addMaterialFailed,
&AbstractSceneConverterTest::addMaterialNotImplemented,
&AbstractSceneConverterTest::addTexture,
&AbstractSceneConverterTest::addTextureFailed,
&AbstractSceneConverterTest::addTextureNotImplemented,
&AbstractSceneConverterTest::addImage1D,
&AbstractSceneConverterTest::addImage1DView,
&AbstractSceneConverterTest::addImage1DCompressedView,
&AbstractSceneConverterTest::addImage1DFailed,
&AbstractSceneConverterTest::addImage1DInvalidImage,
&AbstractSceneConverterTest::addImage1DNotImplemented,
&AbstractSceneConverterTest::addImage2D,
&AbstractSceneConverterTest::addImage2DView,
&AbstractSceneConverterTest::addImage2DCompressedView,
&AbstractSceneConverterTest::addImage2DFailed,
&AbstractSceneConverterTest::addImage2DZeroSize,
&AbstractSceneConverterTest::addImage2DNullptr,
&AbstractSceneConverterTest::addImage2DNotImplemented,
&AbstractSceneConverterTest::addImage3D,
&AbstractSceneConverterTest::addImage3DView,
&AbstractSceneConverterTest::addImage3DCompressedView,
&AbstractSceneConverterTest::addImage3DFailed,
&AbstractSceneConverterTest::addImage3DInvalidImage,
&AbstractSceneConverterTest::addImage3DNotImplemented,
&AbstractSceneConverterTest::addImageLevels1D,
&AbstractSceneConverterTest::addImageLevels1DView,
&AbstractSceneConverterTest::addImageLevels1DCompressedView,
&AbstractSceneConverterTest::addImageLevels1DFailed,
&AbstractSceneConverterTest::addImageLevels1DInvalidImage,
&AbstractSceneConverterTest::addImageLevels1DNotImplemented,
&AbstractSceneConverterTest::addImageLevels2D,
&AbstractSceneConverterTest::addImageLevels2DView,
&AbstractSceneConverterTest::addImageLevels2DCompressedView,
&AbstractSceneConverterTest::addImageLevels2DFailed,
&AbstractSceneConverterTest::addImageLevels2DNoLevels,
&AbstractSceneConverterTest::addImageLevels2DZeroSize,
&AbstractSceneConverterTest::addImageLevels2DNullptr,
&AbstractSceneConverterTest::addImageLevels2DInconsistentCompressed,
&AbstractSceneConverterTest::addImageLevels2DInconsistentFormat,
&AbstractSceneConverterTest::addImageLevels2DInconsistentFormatExtra,
&AbstractSceneConverterTest::addImageLevels2DInconsistentCompressedFormat,
&AbstractSceneConverterTest::addImageLevels2DInconsistentFlags,
&AbstractSceneConverterTest::addImageLevels2DNotImplemented,
&AbstractSceneConverterTest::addImageLevels3D,
&AbstractSceneConverterTest::addImageLevels3DView,
&AbstractSceneConverterTest::addImageLevels3DCompressedView,
&AbstractSceneConverterTest::addImageLevels3DFailed,
&AbstractSceneConverterTest::addImageLevels3DInvalidImage,
&AbstractSceneConverterTest::addImageLevels3DNotImplemented,
&AbstractSceneConverterTest::addImage1DThroughLevels,
&AbstractSceneConverterTest::addImage2DThroughLevels,
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
&AbstractSceneConverterTest::addImage3DThroughLevels});
addInstancedTests({&AbstractSceneConverterTest::addImporterContents},
Containers::arraySize(AddImporterContentsData));
addTests({&AbstractSceneConverterTest::addImporterContentsCustomSceneFields,
&AbstractSceneConverterTest::addImporterContentsCustomMeshAttributes});
addInstancedTests({&AbstractSceneConverterTest::addImporterContentsImportFail},
Containers::arraySize(AddImporterContentsFailData));
addInstancedTests({&AbstractSceneConverterTest::addImporterContentsConversionFail},
Containers::arraySize(AddImporterContentsFailData));
addTests({&AbstractSceneConverterTest::addImporterContentsNotConverting,
&AbstractSceneConverterTest::addImporterContentsNotOpened,
&AbstractSceneConverterTest::addImporterContentsNotSupported, &AbstractSceneConverterTest::addImporterContentsNotSupportedLevels,
&AbstractSceneConverterTest::addImporterContentsNotSupportedUncompressedImage,
&AbstractSceneConverterTest::addImporterContentsNotSupportedCompressedImage});
addInstancedTests({&AbstractSceneConverterTest::addSupportedImporterContents},
Containers::arraySize(AddSupportedImporterContentsData));
addTests({&AbstractSceneConverterTest::addSupportedImporterContentsLevels,
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Trade: bootstrap scene converter plugins.
6 years ago
&AbstractSceneConverterTest::debugFeature,
Audio,ShaderTools,Text,Trade: packed debug printing for all Feature enums.
4 years ago
&AbstractSceneConverterTest::debugFeaturePacked,
Trade: bootstrap scene converter plugins.
6 years ago
&AbstractSceneConverterTest::debugFeatures,
Audio,ShaderTools,Text,Trade: packed debug printing for all Feature enums.
4 years ago
&AbstractSceneConverterTest::debugFeaturesPacked,
ShaderTools,Trade: test printing of Feature flag supersets.
5 years ago
&AbstractSceneConverterTest::debugFeaturesSupersets,
Trade: bootstrap scene converter plugins.
6 years ago
&AbstractSceneConverterTest::debugFlag,
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
&AbstractSceneConverterTest::debugFlags,
&AbstractSceneConverterTest::debugContent,
&AbstractSceneConverterTest::debugContentPacked,
&AbstractSceneConverterTest::debugContents,
&AbstractSceneConverterTest::debugContentsPacked});
Trade: bootstrap scene converter plugins.
6 years ago
/* Create testing dir */
Trade: port to the new Utility::Path. For file opening there's no longer an unatomic pair of exists() + read(), but since Path::read() now returns an Optional, it means we can reliably distinguish between empty files and failures. While at it, also added TODOs for removal of the StringStl.h header that's needed in various places for compatibility with APIs still using STL strings.
4 years ago
Utility::Path::make(TRADE_TEST_OUTPUT_DIR);
Trade: bootstrap scene converter plugins.
6 years ago
}
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
void AbstractSceneConverterTest::sceneContentsForImporterNone() {
struct: AbstractImporter {
ImporterFeatures doFeatures() const override { return {}; }
bool doIsOpened() const override { return true; }
void doClose() override {}
} importer;
CORRADE_COMPARE(sceneContentsFor(importer), SceneContent::Names);
}
void AbstractSceneConverterTest::sceneContentsForImporterAll() {
struct: AbstractImporter {
ImporterFeatures doFeatures() const override { return {}; }
bool doIsOpened() const override { return true; }
void doClose() override {}
UnsignedInt doSceneCount() const override { return 1; }
UnsignedInt doAnimationCount() const override { return 1; }
UnsignedInt doLightCount() const override { return 1; }
UnsignedInt doCameraCount() const override { return 1; }
UnsignedInt doSkin2DCount() const override { return 1; }
UnsignedInt doSkin3DCount() const override { return 1; }
UnsignedInt doMeshCount() const override { return 1; }
UnsignedInt doMeshLevelCount(UnsignedInt) override { return 17; }
UnsignedInt doMaterialCount() const override { return 1; }
UnsignedInt doTextureCount() const override { return 1; }
UnsignedInt doImage1DCount() const override { return 1; }
UnsignedInt doImage1DLevelCount(UnsignedInt) override { return 17; }
UnsignedInt doImage2DCount() const override { return 1; }
UnsignedInt doImage2DLevelCount(UnsignedInt) override { return 17; }
UnsignedInt doImage3DCount() const override { return 1; }
UnsignedInt doImage3DLevelCount(UnsignedInt) override { return 17; }
} importer;
CORRADE_COMPARE(sceneContentsFor(importer),
SceneContent::Scenes|
SceneContent::Animations|
SceneContent::Lights|
SceneContent::Cameras|
SceneContent::Skins2D|
SceneContent::Skins3D|
SceneContent::Meshes|
SceneContent::Materials|
SceneContent::Textures|
SceneContent::Images1D|
SceneContent::Images2D|
SceneContent::Images3D|
/* No mesh or image levels, even though reported */
SceneContent::Names);
}
void AbstractSceneConverterTest::sceneContentsForImporterNotOpened() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractImporter {
ImporterFeatures doFeatures() const override { return {}; }
bool doIsOpened() const override { return false; }
void doClose() override {}
} importer;
std::ostringstream out;
Error redirectError{&out};
sceneContentsFor(importer);
CORRADE_COMPARE(out.str(), "Trade::sceneContentsFor(): the importer is not opened\n");
}
void AbstractSceneConverterTest::sceneContentsForConverterNone() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMeshInPlace;
}
} converter;
CORRADE_COMPARE(sceneContentsFor(converter), SceneContent::Names);
}
void AbstractSceneConverterTest::sceneContentsForConverterSingleMesh() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMeshToFile;
}
} converter;
CORRADE_COMPARE(sceneContentsFor(converter), SceneContent::Meshes|SceneContent::Names);
}
void AbstractSceneConverterTest::sceneContentsForConverterAll() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return
SceneConverterFeature::AddScenes|
SceneConverterFeature::AddAnimations|
SceneConverterFeature::AddLights|
SceneConverterFeature::AddCameras|
SceneConverterFeature::AddSkins2D|
SceneConverterFeature::AddSkins3D|
SceneConverterFeature::AddMeshes|
SceneConverterFeature::AddMaterials|
SceneConverterFeature::AddTextures|
SceneConverterFeature::AddImages1D|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::AddImages3D|
SceneConverterFeature::MeshLevels|
SceneConverterFeature::ImageLevels;
}
} converter;
CORRADE_COMPARE(sceneContentsFor(converter),
SceneContent::Scenes|
SceneContent::Animations|
SceneContent::Lights|
SceneContent::Cameras|
SceneContent::Skins2D|
SceneContent::Skins3D|
SceneContent::Meshes|
SceneContent::Materials|
SceneContent::Textures|
SceneContent::Images1D|
SceneContent::Images2D|
SceneContent::Images3D|
SceneContent::MeshLevels|
SceneContent::ImageLevels|
SceneContent::Names);
}
Trade: bootstrap scene converter plugins.
6 years ago
void AbstractSceneConverterTest::featuresNone() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: bootstrap scene converter plugins.
6 years ago
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override { return {}; }
} converter;
std::ostringstream out;
Error redirectError{&out};
converter.features();
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::features(): implementation reported no features\n");
}
void AbstractSceneConverterTest::setFlags() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
/* Assuming this bit is unused */
return SceneConverterFeature(1 << 7);
}
void doSetFlags(SceneConverterFlags flags) override {
_flags = flags;
}
SceneConverterFlags _flags;
} converter;
CORRADE_COMPARE(converter.flags(), SceneConverterFlags{});
CORRADE_COMPARE(converter._flags, SceneConverterFlags{});
Trade,ShaderTools: add addFlags() / clearFlags() to all plugin interfaces. There will be Flag::FlipY for images at some point, enabled by default for compatibility with existing GL code, and so it makes sense to start discouraging setFlags() as early as possible to avoid people resetting the default by accident. Also update the imageconverter, sceneconverter and shaderconverter utils to use these instead of setFlags().
5 years ago
Trade: bootstrap scene converter plugins.
6 years ago
converter.setFlags(SceneConverterFlag::Verbose);
CORRADE_COMPARE(converter.flags(), SceneConverterFlag::Verbose);
CORRADE_COMPARE(converter._flags, SceneConverterFlag::Verbose);
Trade,ShaderTools: add addFlags() / clearFlags() to all plugin interfaces. There will be Flag::FlipY for images at some point, enabled by default for compatibility with existing GL code, and so it makes sense to start discouraging setFlags() as early as possible to avoid people resetting the default by accident. Also update the imageconverter, sceneconverter and shaderconverter utils to use these instead of setFlags().
5 years ago
/** @todo use a real flag when we have more than one */
converter.addFlags(SceneConverterFlag(4));
CORRADE_COMPARE(converter.flags(), SceneConverterFlag::Verbose|SceneConverterFlag(4));
CORRADE_COMPARE(converter._flags, SceneConverterFlag::Verbose|SceneConverterFlag(4));
converter.clearFlags(SceneConverterFlag::Verbose);
CORRADE_COMPARE(converter.flags(), SceneConverterFlag(4));
CORRADE_COMPARE(converter._flags, SceneConverterFlag(4));
Trade: bootstrap scene converter plugins.
6 years ago
}
void AbstractSceneConverterTest::setFlagsNotImplemented() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
/* Assuming this bit is unused */
return SceneConverterFeature(1 << 7);
}
} converter;
CORRADE_COMPARE(converter.flags(), SceneConverterFlags{});
converter.setFlags(SceneConverterFlag::Verbose);
CORRADE_COMPARE(converter.flags(), SceneConverterFlag::Verbose);
/* Should just work, no need to implement the function */
}
void AbstractSceneConverterTest::thingNotSupported() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: bootstrap scene converter plugins.
6 years ago
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
/* Assuming this bit is unused */
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
return SceneConverterFeature(1u << 31);
Trade: bootstrap scene converter plugins.
6 years ago
}
} converter;
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
MeshData mesh{MeshPrimitive::Triangles, 0};
const char imageData[4*4]{};
ImageData1D image1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, imageData};
ImageData1D compressedImage1D{CompressedPixelFormat::Astc4x4RGBAF, 1, DataFlags{}, imageData};
ImageData2D image2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, imageData};
ImageData2D compressedImage2D{CompressedPixelFormat::Astc4x4RGBAF, {1, 1}, DataFlags{}, imageData};
ImageData3D image3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, DataFlags{}, imageData};
ImageData3D compressedImage3D{CompressedPixelFormat::Astc4x4RGBAF, {1, 1, 1}, DataFlags{}, imageData};
Trade: bootstrap scene converter plugins.
6 years ago
std::ostringstream out;
Error redirectError{&out};
converter.convert(mesh);
converter.convertInPlace(mesh);
converter.convertToData(mesh);
Trade: port to the new Utility::Path. For file opening there's no longer an unatomic pair of exists() + read(), but since Path::read() now returns an Optional, it means we can reliably distinguish between empty files and failures. While at it, also added TODOs for removal of the StringStl.h header that's needed in various places for compatibility with APIs still using STL strings.
4 years ago
converter.convertToFile(mesh, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out"));
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
converter.begin();
converter.beginData();
converter.beginFile(Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out"));
converter.add(SceneData{SceneMappingType::UnsignedInt, 0, nullptr, nullptr});
converter.setSceneFieldName({}, {});
converter.setObjectName(0, {});
converter.setDefaultScene(0);
converter.add(AnimationData{nullptr, nullptr});
Trade: ability to specify custom animation target names on conversion. Added this API to the importer, forgot about the converter. Sigh.
3 years ago
converter.setAnimationTrackTargetName({}, {});
Trade: deprecate LightData::Type in favor of LightType. Enums in classes are bad, can't forward-declare them.
3 years ago
converter.add(LightData{LightType::Point, {}, 0.0f});
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
converter.add(CameraData{CameraType::Orthographic3D, {}, 0.0f, 1.0f});
converter.add(SkinData2D{nullptr, nullptr});
converter.add(SkinData3D{nullptr, nullptr});
converter.add(mesh);
converter.add({mesh, mesh});
converter.setMeshAttributeName({}, {});
converter.add(MaterialData{{}, nullptr});
converter.add(TextureData{{}, {}, {}, {}, {}, 0});
converter.add(image1D);
converter.add(compressedImage1D);
converter.add({image1D, image1D});
converter.add({compressedImage1D, compressedImage1D});
converter.add(image2D);
converter.add(compressedImage2D);
converter.add({image2D, image2D});
converter.add({compressedImage2D, compressedImage2D});
converter.add(image3D);
converter.add(compressedImage3D);
converter.add({image3D, image3D});
converter.add({compressedImage3D, compressedImage3D});
Trade: ability to specify custom animation target names on conversion. Added this API to the importer, forgot about the converter. Sigh.
3 years ago
CORRADE_COMPARE_AS(out.str(),
Trade: bootstrap scene converter plugins.
6 years ago
"Trade::AbstractSceneConverter::convert(): mesh conversion not supported\n"
"Trade::AbstractSceneConverter::convertInPlace(): mesh conversion not supported\n"
"Trade::AbstractSceneConverter::convertToData(): mesh conversion not supported\n"
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
"Trade::AbstractSceneConverter::convertToFile(): mesh conversion not supported\n"
"Trade::AbstractSceneConverter::begin(): feature not supported\n"
"Trade::AbstractSceneConverter::beginData(): feature not supported\n"
"Trade::AbstractSceneConverter::beginFile(): feature not supported\n"
"Trade::AbstractSceneConverter::add(): scene conversion not supported\n"
"Trade::AbstractSceneConverter::setSceneFieldName(): feature not supported\n"
"Trade::AbstractSceneConverter::setObjectName(): feature not supported\n"
"Trade::AbstractSceneConverter::setDefaultScene(): feature not supported\n"
"Trade::AbstractSceneConverter::add(): animation conversion not supported\n"
Trade: ability to specify custom animation target names on conversion. Added this API to the importer, forgot about the converter. Sigh.
3 years ago
"Trade::AbstractSceneConverter::setAnimationTrackTargetName(): feature not supported\n"
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
"Trade::AbstractSceneConverter::add(): light conversion not supported\n"
"Trade::AbstractSceneConverter::add(): camera conversion not supported\n"
"Trade::AbstractSceneConverter::add(): 2D skin conversion not supported\n"
"Trade::AbstractSceneConverter::add(): 3D skin conversion not supported\n"
"Trade::AbstractSceneConverter::add(): mesh conversion not supported\n"
"Trade::AbstractSceneConverter::add(): multi-level mesh conversion not supported\n"
"Trade::AbstractSceneConverter::setMeshAttributeName(): feature not supported\n"
"Trade::AbstractSceneConverter::add(): material conversion not supported\n"
"Trade::AbstractSceneConverter::add(): texture conversion not supported\n"
"Trade::AbstractSceneConverter::add(): 1D image conversion not supported\n"
"Trade::AbstractSceneConverter::add(): compressed 1D image conversion not supported\n"
"Trade::AbstractSceneConverter::add(): multi-level 1D image conversion not supported\n"
"Trade::AbstractSceneConverter::add(): multi-level compressed 1D image conversion not supported\n"
"Trade::AbstractSceneConverter::add(): 2D image conversion not supported\n"
"Trade::AbstractSceneConverter::add(): compressed 2D image conversion not supported\n"
"Trade::AbstractSceneConverter::add(): multi-level 2D image conversion not supported\n"
"Trade::AbstractSceneConverter::add(): multi-level compressed 2D image conversion not supported\n"
"Trade::AbstractSceneConverter::add(): 3D image conversion not supported\n"
"Trade::AbstractSceneConverter::add(): compressed 3D image conversion not supported\n"
"Trade::AbstractSceneConverter::add(): multi-level 3D image conversion not supported\n"
Trade: ability to specify custom animation target names on conversion. Added this API to the importer, forgot about the converter. Sigh.
3 years ago
"Trade::AbstractSceneConverter::add(): multi-level compressed 3D image conversion not supported\n",
TestSuite::Compare::String);
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
void AbstractSceneConverterTest::thingLevelsNotSupported() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddMeshes|
SceneConverterFeature::AddImages1D|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::AddImages3D|
SceneConverterFeature::AddCompressedImages1D|
SceneConverterFeature::AddCompressedImages2D|
SceneConverterFeature::AddCompressedImages3D;
}
} converter;
MeshData mesh{MeshPrimitive::Triangles, 3};
const char imageData[4*4]{};
ImageData1D image1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, imageData};
ImageData1D compressedImage1D{CompressedPixelFormat::Astc4x4RGBAF, 1, DataFlags{}, imageData};
ImageData2D image2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, imageData};
ImageData2D compressedImage2D{CompressedPixelFormat::Astc4x4RGBAF, {1, 1}, DataFlags{}, imageData};
ImageData3D image3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, DataFlags{}, imageData};
ImageData3D compressedImage3D{CompressedPixelFormat::Astc4x4RGBAF, {1, 1, 1}, DataFlags{}, imageData};
std::ostringstream out;
Error redirectError{&out};
converter.add({mesh, mesh});
converter.add({image1D, image1D});
converter.add({compressedImage1D, compressedImage1D});
converter.add({image2D, image2D});
converter.add({compressedImage2D, compressedImage2D});
converter.add({image3D, image3D});
converter.add({compressedImage3D, compressedImage3D});
CORRADE_COMPARE(out.str(),
"Trade::AbstractSceneConverter::add(): multi-level mesh conversion not supported\n"
"Trade::AbstractSceneConverter::add(): multi-level 1D image conversion not supported\n"
"Trade::AbstractSceneConverter::add(): multi-level compressed 1D image conversion not supported\n"
"Trade::AbstractSceneConverter::add(): multi-level 2D image conversion not supported\n"
"Trade::AbstractSceneConverter::add(): multi-level compressed 2D image conversion not supported\n"
"Trade::AbstractSceneConverter::add(): multi-level 3D image conversion not supported\n"
"Trade::AbstractSceneConverter::add(): multi-level compressed 3D image conversion not supported\n");
Trade: bootstrap scene converter plugins.
6 years ago
}
void AbstractSceneConverterTest::convertMesh() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMesh; }
Containers::Optional<MeshData> doConvert(const MeshData& mesh) override {
Trade: we can use test verification macros in unrelated functions now.
4 years ago
CORRADE_COMPARE(mesh.primitive(), MeshPrimitive::Triangles);
return MeshData{MeshPrimitive::Lines, mesh.vertexCount()*2};
Trade: bootstrap scene converter plugins.
6 years ago
}
} converter;
Trade: we can use test verification macros in unrelated functions now.
4 years ago
CORRADE_VERIFY(true); /* capture correct function name */
Trade: bootstrap scene converter plugins.
6 years ago
Containers::Optional<MeshData> out = converter.convert(MeshData{MeshPrimitive::Triangles, 6});
CORRADE_VERIFY(out);
CORRADE_COMPARE(out->primitive(), MeshPrimitive::Lines);
CORRADE_COMPARE(out->vertexCount(), 12);
}
ShaderTools,Trade: properly test failure states of all plugin APIs. Until now, these were only transitively tested in concrete plugin implementations, meaning that if the base implementation would have an error (such as accessing a null optional), it would only get discovered when building a plugin, worst case a plugin in a completely different repo.
4 years ago
void AbstractSceneConverterTest::convertMeshFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMesh;
}
Containers::Optional<MeshData> doConvert(const MeshData&) override {
return {};
}
} converter;
/* The implementation is expected to print an error message on its own */
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.convert(MeshData{MeshPrimitive::Triangles, 0}));
CORRADE_COMPARE(out.str(), "");
}
Trade: bootstrap scene converter plugins.
6 years ago
void AbstractSceneConverterTest::convertMeshNotImplemented() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: bootstrap scene converter plugins.
6 years ago
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMesh; }
} converter;
std::ostringstream out;
Error redirectError{&out};
converter.convert(MeshData{MeshPrimitive::Triangles, 6});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::convert(): mesh conversion advertised but not implemented\n");
}
void AbstractSceneConverterTest::convertMeshNonOwningDeleters() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMesh; }
Containers::Optional<MeshData> doConvert(const MeshData&) override {
return MeshData{MeshPrimitive::Triangles,
Containers::Array<char>{indexData, 1, Implementation::nonOwnedArrayDeleter}, MeshIndexData{MeshIndexType::UnsignedByte, indexData},
Containers::Array<char>{nullptr, 0, Implementation::nonOwnedArrayDeleter},
meshAttributeDataNonOwningArray(attributes)};
}
char indexData[1];
MeshAttributeData attributes[1]{
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector3, nullptr}
};
} converter;
Containers::Optional<MeshData> out = converter.convert(MeshData{MeshPrimitive::Triangles, 6});
CORRADE_VERIFY(out);
CORRADE_COMPARE(static_cast<const void*>(out->indexData()), converter.indexData);
}
void AbstractSceneConverterTest::convertMeshGrowableDeleters() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMesh; }
Containers::Optional<MeshData> doConvert(const MeshData&) override {
Containers::Array<char> indexData;
Containers::arrayAppend<ArrayAllocator>(indexData, '\xab');
Containers::Array<Vector3> vertexData;
Containers::arrayAppend<ArrayAllocator>(vertexData, Vector3{});
MeshIndexData indices{MeshIndexType::UnsignedByte, indexData};
MeshAttributeData positions{MeshAttribute::Position, Containers::arrayView(vertexData)};
return MeshData{MeshPrimitive::Triangles,
std::move(indexData), indices,
Containers::arrayAllocatorCast<char, ArrayAllocator>(std::move(vertexData)), {positions}};
}
char indexData[1];
MeshAttributeData attributes[1]{
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector3, nullptr}
};
} converter;
Containers::Optional<MeshData> out = converter.convert(MeshData{MeshPrimitive::Triangles, 6});
CORRADE_VERIFY(out);
CORRADE_COMPARE(out->indexData()[0], '\xab');
CORRADE_COMPARE(out->vertexData().size(), 12);
}
void AbstractSceneConverterTest::convertMeshCustomIndexDataDeleter() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: bootstrap scene converter plugins.
6 years ago
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMesh; }
Containers::Optional<MeshData> doConvert(const MeshData&) override {
return MeshData{MeshPrimitive::Triangles, Containers::Array<char>{data, 1, [](char*, std::size_t) {}}, MeshIndexData{MeshIndexType::UnsignedByte, data}, 1};
}
char data[1];
} converter;
std::ostringstream out;
Error redirectError{&out};
converter.convert(MeshData{MeshPrimitive::Triangles, 6});
CORRADE_COMPARE(out.str(),
"Trade::AbstractSceneConverter::convert(): implementation is not allowed to use a custom Array deleter\n");
}
void AbstractSceneConverterTest::convertMeshCustomVertexDataDeleter() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: bootstrap scene converter plugins.
6 years ago
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMesh; }
Containers::Optional<MeshData> doConvert(const MeshData&) override {
return MeshData{MeshPrimitive::Triangles, Containers::Array<char>{data, 1, [](char*, std::size_t) {}}, MeshIndexData{MeshIndexType::UnsignedByte, data}, 1};
}
char data[1];
} converter;
std::ostringstream out;
Error redirectError{&out};
converter.convert(MeshData{MeshPrimitive::Triangles, 6});
CORRADE_COMPARE(out.str(),
"Trade::AbstractSceneConverter::convert(): implementation is not allowed to use a custom Array deleter\n");
}
void AbstractSceneConverterTest::convertMeshCustomAttributeDataDeleter() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: bootstrap scene converter plugins.
6 years ago
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMesh; }
Containers::Optional<MeshData> doConvert(const MeshData&) override {
return MeshData{MeshPrimitive::Triangles, Containers::Array<char>{data, 1, [](char*, std::size_t) {}}, MeshIndexData{MeshIndexType::UnsignedByte, data}, 1};
}
char data[1];
} converter;
std::ostringstream out;
Error redirectError{&out};
converter.convert(MeshData{MeshPrimitive::Triangles, 6});
CORRADE_COMPARE(out.str(),
"Trade::AbstractSceneConverter::convert(): implementation is not allowed to use a custom Array deleter\n");
}
void AbstractSceneConverterTest::convertMeshInPlace() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMeshInPlace; }
bool doConvertInPlace(MeshData& mesh) override {
auto indices = mesh.mutableIndices<UnsignedInt>();
for(std::size_t i = 0; i != indices.size()/2; ++i)
std::swap(indices[i], indices[indices.size() - i -1]);
return true;
}
} converter;
UnsignedInt indices[]{1, 2, 3, 4, 2, 0};
MeshData mesh{MeshPrimitive::Triangles,
DataFlag::Mutable, indices, MeshIndexData{indices}, 5};
CORRADE_VERIFY(converter.convertInPlace(mesh));
CORRADE_COMPARE_AS(mesh.indices<UnsignedInt>(),
Containers::arrayView<UnsignedInt>({0, 2, 4, 3, 2, 1}),
TestSuite::Compare::Container);
}
ShaderTools,Trade: properly test failure states of all plugin APIs. Until now, these were only transitively tested in concrete plugin implementations, meaning that if the base implementation would have an error (such as accessing a null optional), it would only get discovered when building a plugin, worst case a plugin in a completely different repo.
4 years ago
void AbstractSceneConverterTest::convertMeshInPlaceFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMeshInPlace;
}
bool doConvertInPlace(MeshData&) override {
return {};
}
} converter;
MeshData mesh{MeshPrimitive::Triangles, 0};
/* The implementation is expected to print an error message on its own */
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.convertInPlace(mesh));
CORRADE_COMPARE(out.str(), "");
}
Trade: bootstrap scene converter plugins.
6 years ago
void AbstractSceneConverterTest::convertMeshInPlaceNotImplemented() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: bootstrap scene converter plugins.
6 years ago
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMeshInPlace; }
} converter;
MeshData mesh{MeshPrimitive::Triangles, 3};
std::ostringstream out;
Error redirectError{&out};
converter.convertInPlace(mesh);
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::convertInPlace(): mesh conversion advertised but not implemented\n");
}
void AbstractSceneConverterTest::convertMeshToData() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMeshToData; }
ShaderTools,Trade: return Optional<Array<char>> from converter plugins. Consistently with changes done to Utility::Path, this enforces proper error handling on user side. Originally I didn't want to do this and instead wanted to have a special Array instance devoted for an error state, but that still would allow the error state be errorneously treated as a successful but empty array.
4 years ago
Containers::Optional<Containers::Array<char>> doConvertToData(const MeshData& mesh) override {
Trade: bootstrap scene converter plugins.
6 years ago
return Containers::Array<char>{nullptr, mesh.vertexCount()};
}
} converter;
Adapt remaining code to not use deprecated Optional<Array> conversion.
4 years ago
Containers::Optional<Containers::Array<char>> data = converter.convertToData(MeshData{MeshPrimitive::Triangles, 6});
CORRADE_VERIFY(data);
CORRADE_COMPARE(data->size(), 6);
Trade: bootstrap scene converter plugins.
6 years ago
}
ShaderTools,Trade: properly test failure states of all plugin APIs. Until now, these were only transitively tested in concrete plugin implementations, meaning that if the base implementation would have an error (such as accessing a null optional), it would only get discovered when building a plugin, worst case a plugin in a completely different repo.
4 years ago
void AbstractSceneConverterTest::convertMeshToDataFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMeshToData;
}
Containers::Optional<Containers::Array<char>> doConvertToData(const MeshData&) override {
return {};
}
} converter;
/* The implementation is expected to print an error message on its own */
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.convertToData(MeshData{MeshPrimitive::Triangles, 0}));
CORRADE_COMPARE(out.str(), "");
}
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
void AbstractSceneConverterTest::convertMeshToDataThroughBatch() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToData|
SceneConverterFeature::AddMeshes;
}
Containers::Optional<Containers::Array<char>> doConvertToData(const Magnum::Trade::MeshData&) override {
Test: use CORRADE_FAIL() where it makes sense. Of course I used the wrong `CORRADE_FAIL_IF(false, ...)` in a few places. Yet another confirmation it was too hard to use and a dedicated macro is needed.
4 years ago
CORRADE_FAIL("doConvertToData() should not be called");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
return {};
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginData() override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
_vertexCount = 42;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
return true;
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
bool doAdd(UnsignedInt id, const MeshData& mesh, Containers::StringView) override {
CORRADE_COMPARE(id, 0);
CORRADE_COMPARE(mesh.primitive(), MeshPrimitive::Triangles);
_vertexCount *= mesh.vertexCount();
return true;
}
Containers::Optional<Containers::Array<char>> doEndData() override {
return Containers::Array<char>{nullptr, _vertexCount};
}
std::size_t _vertexCount = 0;
} converter;
Containers::Optional<Containers::Array<char>> data = converter.convertToData(MeshData{MeshPrimitive::Triangles, 6});
CORRADE_VERIFY(!converter.isConverting());
CORRADE_VERIFY(data);
CORRADE_COMPARE(data->size(), 42*6);
}
void AbstractSceneConverterTest::convertMeshToDataThroughBatchAddFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToData|
SceneConverterFeature::AddMeshes;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginData() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const MeshData&, Containers::StringView) override {
return false;
}
Containers::Optional<Containers::Array<char>> doEndData() override {
Test: use CORRADE_FAIL() where it makes sense. Of course I used the wrong `CORRADE_FAIL_IF(false, ...)` in a few places. Yet another confirmation it was too hard to use and a dedicated macro is needed.
4 years ago
CORRADE_FAIL("doEndData() shouldn't be called");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
return {};
}
} converter;
/* The implementation is expected to print an error message on its own */
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.convertToData(MeshData{MeshPrimitive::Triangles, 6}));
CORRADE_VERIFY(!converter.isConverting());
CORRADE_COMPARE(out.str(), "");
}
void AbstractSceneConverterTest::convertMeshToDataThroughBatchEndFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToData|
SceneConverterFeature::AddMeshes;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginData() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const MeshData&, Containers::StringView) override {
return true;
}
Containers::Optional<Containers::Array<char>> doEndData() override {
return {};
}
} converter;
/* The implementation is expected to print an error message on its own */
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.convertToData(MeshData{MeshPrimitive::Triangles, 6}));
CORRADE_VERIFY(!converter.isConverting());
CORRADE_COMPARE(out.str(), "");
}
Trade: bootstrap scene converter plugins.
6 years ago
void AbstractSceneConverterTest::convertMeshToDataNotImplemented() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: bootstrap scene converter plugins.
6 years ago
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMeshToData; }
} converter;
std::ostringstream out;
Error redirectError{&out};
converter.convertToData(MeshData{MeshPrimitive::Triangles, 6});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::convertToData(): mesh conversion advertised but not implemented\n");
}
Trade: test growable and non-owning deleters in all SceneConverter cases.
4 years ago
void AbstractSceneConverterTest::convertMeshToDataNonOwningDeleter() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMeshToData; }
Containers::Optional<Containers::Array<char>> doConvertToData(const MeshData&) override {
return Containers::Array<char>{data, 5, Implementation::nonOwnedArrayDeleter};
}
char data[5]{'h', 'e', 'l', 'l', 'o'};
} converter;
Containers::Optional<Containers::Array<char>> data = converter.convertToData(MeshData{MeshPrimitive::Triangles, 6});
CORRADE_VERIFY(data);
CORRADE_COMPARE_AS(*data,
Containers::arrayView({'h', 'e', 'l', 'l', 'o'}),
TestSuite::Compare::Container);
}
void AbstractSceneConverterTest::convertMeshToDataGrowableDeleter() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMeshToData; }
Containers::Optional<Containers::Array<char>> doConvertToData(const MeshData&) override {
Containers::Array<char> out;
Containers::arrayAppend<ArrayAllocator>(out, {'h', 'e', 'l', 'l', 'o'});
doc: remove Clang 3.8 references, advertise Clang 6+ as supported. Hey, do you also remember the times where people were excited to upgrade from Clang 3.6 to 3.7, GCC 4.7 to 4.8 or Firefox 1.1 to Firefox 1.5? Not Clang 12 to 14, GCC 10 to 13 or Chrome 102 to 126.
4 years ago
/* GCC 4.8 needs extra help here */
Trade: test growable and non-owning deleters in all SceneConverter cases.
4 years ago
return Containers::optional(std::move(out));
}
} converter;
Containers::Optional<Containers::Array<char>> data = converter.convertToData(MeshData{MeshPrimitive::Triangles, 6});
CORRADE_VERIFY(data);
CORRADE_COMPARE_AS(*data,
Containers::arrayView({'h', 'e', 'l', 'l', 'o'}),
TestSuite::Compare::Container);
}
Trade: bootstrap scene converter plugins.
6 years ago
void AbstractSceneConverterTest::convertMeshToDataCustomDeleter() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: bootstrap scene converter plugins.
6 years ago
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMeshToData; }
ShaderTools,Trade: return Optional<Array<char>> from converter plugins. Consistently with changes done to Utility::Path, this enforces proper error handling on user side. Originally I didn't want to do this and instead wanted to have a special Array instance devoted for an error state, but that still would allow the error state be errorneously treated as a successful but empty array.
4 years ago
Containers::Optional<Containers::Array<char>> doConvertToData(const MeshData&) override {
Trade: bootstrap scene converter plugins.
6 years ago
return Containers::Array<char>{data, 1, [](char*, std::size_t) {}};
}
char data[1];
} converter;
std::ostringstream out;
Error redirectError{&out};
converter.convertToData(MeshData{MeshPrimitive::Triangles, 6});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::convertToData(): implementation is not allowed to use a custom Array deleter\n");
}
void AbstractSceneConverterTest::convertMeshToFile() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMeshToFile; }
Trade: reverse AbstractSceneConverter::convertToFile() argument order. It should be input first, output second, like with all other APIs. I remember I was trying something else here, but that didn't really make sense in the end. Also took that opportunity to get rid of one std::string. The original signature is a deprecated alias to the new one and will be removed in a future release.
5 years ago
bool doConvertToFile(const MeshData& mesh, Containers::StringView filename) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
return Utility::Path::write(filename, Containers::arrayView({char(mesh.vertexCount())}));
Trade: bootstrap scene converter plugins.
6 years ago
}
} converter;
Trade: I'm too old for this much needless code duplication.
6 years ago
/* Remove previous file, if any */
Trade: port to the new Utility::Path. For file opening there's no longer an unatomic pair of exists() + read(), but since Path::read() now returns an Optional, it means we can reliably distinguish between empty files and failures. While at it, also added TODOs for removal of the StringStl.h header that's needed in various places for compatibility with APIs still using STL strings.
4 years ago
Containers::String filename = Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out");
if(Utility::Path::exists(filename))
CORRADE_VERIFY(Utility::Path::remove(filename));
Trade: I'm too old for this much needless code duplication.
6 years ago
Trade: reverse AbstractSceneConverter::convertToFile() argument order. It should be input first, output second, like with all other APIs. I remember I was trying something else here, but that didn't really make sense in the end. Also took that opportunity to get rid of one std::string. The original signature is a deprecated alias to the new one and will be removed in a future release.
5 years ago
CORRADE_VERIFY(converter.convertToFile(MeshData{MeshPrimitive::Triangles, 0xef}, filename));
Trade: I'm too old for this much needless code duplication.
6 years ago
CORRADE_COMPARE_AS(filename,
Trade: bootstrap scene converter plugins.
6 years ago
"\xef", TestSuite::Compare::FileToString);
}
ShaderTools,Trade: properly test failure states of all plugin APIs. Until now, these were only transitively tested in concrete plugin implementations, meaning that if the base implementation would have an error (such as accessing a null optional), it would only get discovered when building a plugin, worst case a plugin in a completely different repo.
4 years ago
void AbstractSceneConverterTest::convertMeshToFileFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMeshToFile;
}
bool doConvertToFile(const MeshData&, Containers::StringView) override {
return false;
}
} converter;
/* The implementation is expected to print an error message on its own */
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.convertToFile(MeshData{MeshPrimitive::Triangles, 0}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out")));
CORRADE_COMPARE(out.str(), "");
}
Trade: bootstrap scene converter plugins.
6 years ago
void AbstractSceneConverterTest::convertMeshToFileThroughData() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMeshToData; }
ShaderTools,Trade: return Optional<Array<char>> from converter plugins. Consistently with changes done to Utility::Path, this enforces proper error handling on user side. Originally I didn't want to do this and instead wanted to have a special Array instance devoted for an error state, but that still would allow the error state be errorneously treated as a successful but empty array.
4 years ago
Containers::Optional<Containers::Array<char>> doConvertToData(const MeshData& mesh) override {
Trade: bootstrap scene converter plugins.
6 years ago
return Containers::array({char(mesh.vertexCount())});
}
} converter;
Trade: I'm too old for this much needless code duplication.
6 years ago
/* Remove previous file, if any */
Trade: port to the new Utility::Path. For file opening there's no longer an unatomic pair of exists() + read(), but since Path::read() now returns an Optional, it means we can reliably distinguish between empty files and failures. While at it, also added TODOs for removal of the StringStl.h header that's needed in various places for compatibility with APIs still using STL strings.
4 years ago
Containers::String filename = Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out");
if(Utility::Path::exists(filename))
CORRADE_VERIFY(Utility::Path::remove(filename));
Trade: bootstrap scene converter plugins.
6 years ago
Trade: I'm too old for this much needless code duplication.
6 years ago
/* doConvertToFile() should call doConvertToData() */
Trade: reverse AbstractSceneConverter::convertToFile() argument order. It should be input first, output second, like with all other APIs. I remember I was trying something else here, but that didn't really make sense in the end. Also took that opportunity to get rid of one std::string. The original signature is a deprecated alias to the new one and will be removed in a future release.
5 years ago
CORRADE_VERIFY(converter.convertToFile(MeshData{MeshPrimitive::Triangles, 0xef}, filename));
Trade: I'm too old for this much needless code duplication.
6 years ago
CORRADE_COMPARE_AS(filename,
Trade: bootstrap scene converter plugins.
6 years ago
"\xef", TestSuite::Compare::FileToString);
}
Trade: explicitly test a case with failed conversion written to a file. Too easy to forget this check, write an empty file and return true.
6 years ago
void AbstractSceneConverterTest::convertMeshToFileThroughDataFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMeshToData; }
ShaderTools,Trade: return Optional<Array<char>> from converter plugins. Consistently with changes done to Utility::Path, this enforces proper error handling on user side. Originally I didn't want to do this and instead wanted to have a special Array instance devoted for an error state, but that still would allow the error state be errorneously treated as a successful but empty array.
4 years ago
Containers::Optional<Containers::Array<char>> doConvertToData(const MeshData&) override {
Trade: explicitly test a case with failed conversion written to a file. Too easy to forget this check, write an empty file and return true.
6 years ago
return {};
}
} converter;
/* Remove previous file, if any */
Trade: port to the new Utility::Path. For file opening there's no longer an unatomic pair of exists() + read(), but since Path::read() now returns an Optional, it means we can reliably distinguish between empty files and failures. While at it, also added TODOs for removal of the StringStl.h header that's needed in various places for compatibility with APIs still using STL strings.
4 years ago
Containers::String filename = Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out");
if(Utility::Path::exists(filename))
CORRADE_VERIFY(Utility::Path::remove(filename));
Trade: explicitly test a case with failed conversion written to a file. Too easy to forget this check, write an empty file and return true.
6 years ago
/* Function should fail, no file should get written and no error output
should be printed (the base implementation assumes the plugin does it) */
std::ostringstream out;
Error redirectError{&out};
Trade: reverse AbstractSceneConverter::convertToFile() argument order. It should be input first, output second, like with all other APIs. I remember I was trying something else here, but that didn't really make sense in the end. Also took that opportunity to get rid of one std::string. The original signature is a deprecated alias to the new one and will be removed in a future release.
5 years ago
CORRADE_VERIFY(!converter.convertToFile(MeshData{MeshPrimitive::Triangles, 0xef}, filename));
Trade: port to the new Utility::Path. For file opening there's no longer an unatomic pair of exists() + read(), but since Path::read() now returns an Optional, it means we can reliably distinguish between empty files and failures. While at it, also added TODOs for removal of the StringStl.h header that's needed in various places for compatibility with APIs still using STL strings.
4 years ago
CORRADE_VERIFY(!Utility::Path::exists(filename));
Trade: explicitly test a case with failed conversion written to a file. Too easy to forget this check, write an empty file and return true.
6 years ago
CORRADE_COMPARE(out.str(), "");
}
Trade: bootstrap scene converter plugins.
6 years ago
void AbstractSceneConverterTest::convertMeshToFileThroughDataNotWritable() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMeshToData; }
ShaderTools,Trade: return Optional<Array<char>> from converter plugins. Consistently with changes done to Utility::Path, this enforces proper error handling on user side. Originally I didn't want to do this and instead wanted to have a special Array instance devoted for an error state, but that still would allow the error state be errorneously treated as a successful but empty array.
4 years ago
Containers::Optional<Containers::Array<char>> doConvertToData(const MeshData& mesh) override {
Trade: bootstrap scene converter plugins.
6 years ago
return Containers::array({char(mesh.vertexCount())});
}
} converter;
std::ostringstream out;
Error redirectError{&out};
Trade: reverse AbstractSceneConverter::convertToFile() argument order. It should be input first, output second, like with all other APIs. I remember I was trying something else here, but that didn't really make sense in the end. Also took that opportunity to get rid of one std::string. The original signature is a deprecated alias to the new one and will be removed in a future release.
5 years ago
CORRADE_VERIFY(!converter.convertToFile(MeshData{MeshPrimitive::Triangles, 0xef}, "/some/path/that/does/not/exist"));
Trade: minor AbstractSceneConverter test improvement.
4 years ago
/* There's an error from Path::write() before */
Adapt tests to changes in Utility::Directory error reporting. Now comparing just the message coming out of our code, ignoring the system-specific message Directory prints.
4 years ago
CORRADE_COMPARE_AS(out.str(),
Trade: minor AbstractSceneConverter test improvement.
4 years ago
"\nTrade::AbstractSceneConverter::convertToFile(): cannot write to file /some/path/that/does/not/exist\n",
Adapt tests to changes in Utility::Directory error reporting. Now comparing just the message coming out of our code, ignoring the system-specific message Directory prints.
4 years ago
TestSuite::Compare::StringHasSuffix);
Trade: bootstrap scene converter plugins.
6 years ago
}
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
void AbstractSceneConverterTest::convertMeshToFileThroughBatch() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToFile|
SceneConverterFeature::AddMeshes;
}
bool doConvertToFile(const Trade::MeshData&, Containers::StringView) override {
Test: use CORRADE_FAIL() where it makes sense. Of course I used the wrong `CORRADE_FAIL_IF(false, ...)` in a few places. Yet another confirmation it was too hard to use and a dedicated macro is needed.
4 years ago
CORRADE_FAIL("doConvertToFile() should not be called");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
return {};
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginFile(Containers::StringView filename) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
_filename = filename;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
return true;
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
bool doAdd(UnsignedInt id, const MeshData& mesh, Containers::StringView) override {
CORRADE_COMPARE(id, 0);
CORRADE_COMPARE(mesh.primitive(), MeshPrimitive::Triangles);
_vertexCount = mesh.vertexCount();
return true;
}
bool doEndFile(Containers::StringView filename) override {
CORRADE_COMPARE(filename, _filename);
return Utility::Path::write(filename, Containers::arrayView({char(_vertexCount)}));
}
std::size_t _vertexCount = 0;
Containers::StringView _filename;
} converter;
/* Remove previous file, if any */
Containers::String filename = Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out");
if(Utility::Path::exists(filename))
CORRADE_VERIFY(Utility::Path::remove(filename));
CORRADE_VERIFY(converter.convertToFile(MeshData{MeshPrimitive::Triangles, 0xfc}, filename));
CORRADE_VERIFY(!converter.isConverting());
CORRADE_COMPARE_AS(filename,
"\xfc", TestSuite::Compare::FileToString);
}
void AbstractSceneConverterTest::convertMeshToFileThroughBatchAddFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToFile|
SceneConverterFeature::AddMeshes;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginFile(Containers::StringView) override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const MeshData&, Containers::StringView) override {
return false;
}
bool doEndFile(Containers::StringView) override {
Test: use CORRADE_FAIL() where it makes sense. Of course I used the wrong `CORRADE_FAIL_IF(false, ...)` in a few places. Yet another confirmation it was too hard to use and a dedicated macro is needed.
4 years ago
CORRADE_FAIL("doEndFile() shouldn't be called");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
return {};
}
} converter;
/* The implementation is expected to print an error message on its own */
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.convertToFile(MeshData{MeshPrimitive::Triangles, 0xfc}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out")));
CORRADE_VERIFY(!converter.isConverting());
CORRADE_COMPARE(out.str(), "");
}
void AbstractSceneConverterTest::convertMeshToFileThroughBatchEndFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToFile|
SceneConverterFeature::AddMeshes;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginFile(Containers::StringView) override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const MeshData&, Containers::StringView) override {
return true;
}
bool doEndFile(Containers::StringView) override {
return {};
}
} converter;
/* The implementation is expected to print an error message on its own */
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.convertToFile(MeshData{MeshPrimitive::Triangles, 0xfc}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out")));
CORRADE_VERIFY(!converter.isConverting());
CORRADE_COMPARE(out.str(), "");
}
Trade: bootstrap scene converter plugins.
6 years ago
void AbstractSceneConverterTest::convertMeshToFileNotImplemented() {
Test: make use of CORRADE_SKIP_IF_NO_ASSERT().
4 years ago
CORRADE_SKIP_IF_NO_ASSERT();
Trade: bootstrap scene converter plugins.
6 years ago
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override { return SceneConverterFeature::ConvertMeshToFile; }
} converter;
std::ostringstream out;
Error redirectError{&out};
Trade: port to the new Utility::Path. For file opening there's no longer an unatomic pair of exists() + read(), but since Path::read() now returns an Optional, it means we can reliably distinguish between empty files and failures. While at it, also added TODOs for removal of the StringStl.h header that's needed in various places for compatibility with APIs still using STL strings.
4 years ago
converter.convertToFile(MeshData{MeshPrimitive::Triangles, 6}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out"));
Trade: bootstrap scene converter plugins.
6 years ago
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::convertToFile(): mesh conversion advertised but not implemented\n");
}
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
void AbstractSceneConverterTest::beginEnd() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(!beginCalled);
beginCalled = true;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
return true;
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
Containers::Pointer<AbstractImporter> doEnd() override {
CORRADE_VERIFY(!endCalled);
endCalled = true;
struct Importer: AbstractImporter {
ImporterFeatures doFeatures() const override { return {}; }
void doClose() override {}
bool doIsOpened() const override { return true; }
const void* doImporterState() const override {
return reinterpret_cast<const void*>(0xdeadbeef);
}
};
return Containers::Pointer<AbstractImporter>{new Importer};
}
bool beginCalled = false, endCalled = false;
} converter;
CORRADE_VERIFY(!converter.isConverting());
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(converter.beginCalled);
CORRADE_VERIFY(!converter.endCalled);
CORRADE_VERIFY(converter.isConverting());
Containers::Pointer<AbstractImporter> out = converter.end();
CORRADE_VERIFY(out);
CORRADE_COMPARE(out->importerState(), reinterpret_cast<const void*>(0xdeadbeef));
CORRADE_VERIFY(converter.endCalled);
CORRADE_VERIFY(!converter.isConverting());
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
void AbstractSceneConverterTest::beginFailed() {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return false; }
} converter;
/* The implementation is expected to print an error message on its own */
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.begin());
CORRADE_COMPARE(out.str(), "");
CORRADE_VERIFY(!converter.isConverting());
}
void AbstractSceneConverterTest::endFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple;
}
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Containers::Pointer<AbstractImporter> doEnd() override {
return nullptr;
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
/* The implementation is expected to print an error message on its own */
Trade: bootstrap scene converter plugins.
6 years ago
std::ostringstream out;
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Error redirectError{&out};
CORRADE_VERIFY(!converter.end());
CORRADE_COMPARE(out.str(), "");
Trade: bootstrap scene converter plugins.
6 years ago
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(!converter.isConverting());
Trade: bootstrap scene converter plugins.
6 years ago
}
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
void AbstractSceneConverterTest::beginNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple;
}
} converter;
Trade: bootstrap scene converter plugins.
6 years ago
std::ostringstream out;
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Error redirectError{&out};
converter.begin();
CORRADE_COMPARE(out.str(),
"Trade::AbstractSceneConverter::begin(): feature advertised but not implemented\n");
}
Trade: bootstrap scene converter plugins.
6 years ago
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
void AbstractSceneConverterTest::endNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.end();
CORRADE_COMPARE(out.str(),
"Trade::AbstractSceneConverter::end(): feature advertised but not implemented\n");
Trade: bootstrap scene converter plugins.
6 years ago
}
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
void AbstractSceneConverterTest::beginEndData() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToData;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginData() override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(!beginCalled);
beginCalled = true;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
return true;
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
Containers::Optional<Containers::Array<char>> doEndData() override {
CORRADE_VERIFY(!endCalled);
endCalled = true;
return Containers::array({'h', 'e', 'l', 'l', 'o'});
}
bool beginCalled = false, endCalled = false;
} converter;
CORRADE_VERIFY(!converter.isConverting());
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.beginData());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(converter.beginCalled);
CORRADE_VERIFY(!converter.endCalled);
CORRADE_VERIFY(converter.isConverting());
Containers::Optional<Containers::Array<char>> out = converter.endData();
CORRADE_VERIFY(out);
CORRADE_COMPARE_AS(*out,
Containers::arrayView({'h', 'e', 'l', 'l', 'o'}),
TestSuite::Compare::Container);
CORRADE_VERIFY(converter.endCalled);
CORRADE_VERIFY(!converter.isConverting());
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
void AbstractSceneConverterTest::beginDataFailed() {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToData;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginData() override { return false; }
} converter;
/* The implementation is expected to print an error message on its own */
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.beginData());
CORRADE_COMPARE(out.str(), "");
CORRADE_VERIFY(!converter.isConverting());
}
void AbstractSceneConverterTest::endDataFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToData;
}
bool doBeginData() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Containers::Optional<Containers::Array<char>> doEndData() override {
return {};
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.beginData());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
/* The implementation is expected to print an error message on its own */
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.endData());
CORRADE_COMPARE(out.str(), "");
CORRADE_VERIFY(!converter.isConverting());
}
void AbstractSceneConverterTest::beginDataNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToData;
}
} converter;
std::ostringstream out;
Error redirectError{&out};
converter.beginData();
CORRADE_COMPARE(out.str(),
"Trade::AbstractSceneConverter::beginData(): feature advertised but not implemented\n");
}
void AbstractSceneConverterTest::endDataNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToData;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginData() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.beginData());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.endData();
CORRADE_COMPARE(out.str(),
"Trade::AbstractSceneConverter::endData(): feature advertised but not implemented\n");
}
void AbstractSceneConverterTest::beginEndDataCustomDeleter() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToData;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginData() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Containers::Optional<Containers::Array<char>> doEndData() override {
return Containers::Array<char>{data, 1, [](char*, std::size_t) {}};
}
char data[1];
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.beginData());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.endData();
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::endData(): implementation is not allowed to use a custom Array deleter\n");
}
void AbstractSceneConverterTest::beginEndFile() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToFile;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginFile(Containers::StringView filename) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(!beginCalled);
beginCalled = true;
CORRADE_COMPARE(filename, "file.gltf");
filenameDataPointer = filename.data();
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
return true;
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
bool doEndFile(Containers::StringView filename) override {
CORRADE_VERIFY(!endCalled);
endCalled = true;
CORRADE_COMPARE(filename, "file.gltf");
/* The filename should stay in scope and be the same pointer */
CORRADE_COMPARE(filename.data(), filenameDataPointer);
return true;
}
bool beginCalled = false, endCalled = false;
const void* filenameDataPointer;
} converter;
CORRADE_VERIFY(!converter.isConverting());
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.beginFile("file.gltf!"_s.exceptSuffix(1)));
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(converter.beginCalled);
CORRADE_VERIFY(!converter.endCalled);
CORRADE_VERIFY(converter.isConverting());
CORRADE_VERIFY(converter.endFile());
CORRADE_VERIFY(converter.endCalled);
CORRADE_VERIFY(!converter.isConverting());
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
void AbstractSceneConverterTest::beginFileFailed() {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToFile;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginFile(Containers::StringView) override { return false; }
} converter;
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
/* The implementation is expected to print an error message on its own */
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.beginFile("file.gltf"));
CORRADE_COMPARE(out.str(), "");
CORRADE_VERIFY(!converter.isConverting());
}
void AbstractSceneConverterTest::endFileFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToFile;
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginFile(Containers::StringView) override { return true; }
bool doEndFile(Containers::StringView) override { return false; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.beginFile("file.gltf"));
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
/* The implementation is expected to print an error message on its own */
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.endFile());
CORRADE_COMPARE(out.str(), "");
CORRADE_VERIFY(!converter.isConverting());
}
void AbstractSceneConverterTest::beginEndFileThroughData() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToData;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginData() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Containers::Optional<Containers::Array<char>> doEndData() override {
return Containers::array({'h', 'e', 'l', 'l', 'o'});
}
} converter;
/* Remove previous file, if any */
Containers::String filename = Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out");
if(Utility::Path::exists(filename))
CORRADE_VERIFY(Utility::Path::remove(filename));
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.beginFile(filename));
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
/* doEndFile() should call doEndData() */
CORRADE_VERIFY(converter.endFile());
CORRADE_VERIFY(!converter.isConverting());
CORRADE_COMPARE_AS(filename, "hello", TestSuite::Compare::FileToString);
}
void AbstractSceneConverterTest::beginEndFileThroughDataFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToData;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginData() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Containers::Optional<Containers::Array<char>> doEndData() override {
return {};
}
} converter;
/* Remove previous file, if any */
Containers::String filename = Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out");
if(Utility::Path::exists(filename))
CORRADE_VERIFY(Utility::Path::remove(filename));
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.beginFile(filename));
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
/* Function should fail, no file should get written and no error output
should be printed (the base implementation assumes the plugin does it) */
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.endFile());
CORRADE_VERIFY(!converter.isConverting());
CORRADE_VERIFY(!Utility::Path::exists(filename));
CORRADE_COMPARE(out.str(), "");
}
void AbstractSceneConverterTest::beginEndFileThroughDataNotWritable() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToData;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginData() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Containers::Optional<Containers::Array<char>> doEndData() override {
return Containers::array({'h', 'e', 'l', 'l', 'o'});
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.beginFile("/some/path/that/does/not/exist"));
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
/* Function should fail, no file should get written and no error output
should be printed (the base implementation assumes the plugin does it) */
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.endFile());
CORRADE_VERIFY(!converter.isConverting());
/* There's an error from Path::write() before */
CORRADE_COMPARE_AS(out.str(),
"\nTrade::AbstractSceneConverter::endFile(): cannot write to file /some/path/that/does/not/exist\n",
TestSuite::Compare::StringHasSuffix);
}
void AbstractSceneConverterTest::beginFileNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToFile;
}
} converter;
std::ostringstream out;
Error redirectError{&out};
converter.beginFile("file.gltf");
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::beginFile(): feature advertised but not implemented\n");
}
void AbstractSceneConverterTest::endFileNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToFile;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginFile(Containers::StringView) override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.beginFile("file.gltf"));
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.endFile();
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::endFile(): feature advertised but not implemented\n");
}
void AbstractSceneConverterTest::abort() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
void doAbort() override {
CORRADE_VERIFY(!abortCalled);
abortCalled = true;
}
bool abortCalled = false;
} converter;
CORRADE_VERIFY(!converter.abortCalled);
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(!converter.abortCalled);
CORRADE_VERIFY(converter.isConverting());
converter.abort();
CORRADE_VERIFY(converter.abortCalled);
CORRADE_VERIFY(!converter.isConverting());
}
void AbstractSceneConverterTest::abortNotImplemented() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
/* This should work, there's no need for a plugin to implement this */
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(converter.isConverting());
converter.abort();
CORRADE_VERIFY(!converter.isConverting());
}
Trade: implicitly abort previous conversion in all scene converter APIs. And properly test the behavior as well. While it's rare that a batch and immediate conversions would be mixed on a single converter instance, if it happens by accident it should not lead to unexpected internal state.
4 years ago
void AbstractSceneConverterTest::abortImplicitlyConvertMesh() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMesh|
SceneConverterFeature::ConvertMultiple;
}
Containers::Optional<MeshData> doConvert(const MeshData&) override {
return MeshData{MeshPrimitive::Lines, 2};
}
void doAbort() override {
CORRADE_VERIFY(!abortCalled);
abortCalled = true;
}
bool doBegin() override { return true; }
bool abortCalled = false;
} converter;
/* Shouldn't be called if there's no previous conversion happening */
CORRADE_VERIFY(!converter.abortCalled);
CORRADE_VERIFY(converter.begin());
CORRADE_VERIFY(converter.isConverting());
CORRADE_VERIFY(!converter.abortCalled);
/* Should be called if there's a batch conversion happening and the
immediate APIs are used */
CORRADE_VERIFY(converter.convert(MeshData{MeshPrimitive::Triangles, 6}));
CORRADE_VERIFY(!converter.isConverting());
CORRADE_VERIFY(converter.abortCalled);
}
void AbstractSceneConverterTest::abortImplicitlyConvertMeshInPlace() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMeshInPlace|
SceneConverterFeature::ConvertMultiple;
}
bool doConvertInPlace(MeshData&) override {
return true;
}
void doAbort() override {
CORRADE_VERIFY(!abortCalled);
abortCalled = true;
}
bool doBegin() override { return true; }
bool abortCalled = false;
} converter;
/* Shouldn't be called if there's no previous conversion happening */
CORRADE_VERIFY(!converter.abortCalled);
CORRADE_VERIFY(converter.begin());
CORRADE_VERIFY(converter.isConverting());
CORRADE_VERIFY(!converter.abortCalled);
/* Should be called if there's a batch conversion happening and the
immediate APIs are used */
MeshData mesh{MeshPrimitive::Triangles, 6};
CORRADE_VERIFY(converter.convertInPlace(mesh));
CORRADE_VERIFY(!converter.isConverting());
CORRADE_VERIFY(converter.abortCalled);
}
void AbstractSceneConverterTest::abortImplicitlyConvertMeshToData() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMeshToData|
SceneConverterFeature::ConvertMultiple;
}
Containers::Optional<Containers::Array<char>> doConvertToData(const MeshData&) override {
return Containers::Array<char>{};
}
void doAbort() override {
CORRADE_VERIFY(!abortCalled);
abortCalled = true;
}
bool doBegin() override { return true; }
bool abortCalled = false;
} converter;
/* Shouldn't be called if there's no previous conversion happening */
CORRADE_VERIFY(!converter.abortCalled);
CORRADE_VERIFY(converter.begin());
CORRADE_VERIFY(converter.isConverting());
CORRADE_VERIFY(!converter.abortCalled);
/* Should be called if there's a batch conversion happening and the
immediate APIs are used */
CORRADE_VERIFY(converter.convertToData(MeshData{MeshPrimitive::Triangles, 6}));
CORRADE_VERIFY(!converter.isConverting());
CORRADE_VERIFY(converter.abortCalled);
}
void AbstractSceneConverterTest::abortImplicitlyConvertMeshToFile() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMeshToFile|
SceneConverterFeature::ConvertMultiple;
}
bool doConvertToFile(const MeshData&, Containers::StringView) override {
return true;
}
void doAbort() override {
CORRADE_VERIFY(!abortCalled);
abortCalled = true;
}
bool doBegin() override { return true; }
bool abortCalled = false;
} converter;
/* Shouldn't be called if there's no previous conversion happening */
CORRADE_VERIFY(!converter.abortCalled);
CORRADE_VERIFY(converter.begin());
CORRADE_VERIFY(converter.isConverting());
CORRADE_VERIFY(!converter.abortCalled);
/* Should be called if there's a batch conversion happening and the
immediate APIs are used */
CORRADE_VERIFY(converter.convertToFile(MeshData{MeshPrimitive::Triangles, 6}, Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out")));
CORRADE_VERIFY(!converter.isConverting());
CORRADE_VERIFY(converter.abortCalled);
}
void AbstractSceneConverterTest::abortImplicitlyBegin() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple;
}
void doAbort() override {
CORRADE_VERIFY(!abortCalled);
abortCalled = true;
}
bool doBegin() override { return true; }
bool abortCalled = false;
} converter;
/* Shouldn't be called if there's no previous conversion happening */
CORRADE_VERIFY(!converter.abortCalled);
CORRADE_VERIFY(converter.begin());
CORRADE_VERIFY(converter.isConverting());
CORRADE_VERIFY(!converter.abortCalled);
/* Should be called if calling begin() while another conversion is already
happening. Then, what is happening is the new conversion. */
CORRADE_VERIFY(converter.begin());
CORRADE_VERIFY(converter.isConverting());
CORRADE_VERIFY(converter.abortCalled);
}
void AbstractSceneConverterTest::abortImplicitlyBeginData() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::ConvertMultipleToData;
}
void doAbort() override {
CORRADE_VERIFY(!abortCalled);
abortCalled = true;
}
bool doBegin() override { return true; }
bool doBeginData() override { return true; }
bool abortCalled = false;
} converter;
/* Shouldn't be called if there's no previous conversion happening */
CORRADE_VERIFY(!converter.abortCalled);
CORRADE_VERIFY(converter.begin());
CORRADE_VERIFY(converter.isConverting());
CORRADE_VERIFY(!converter.abortCalled);
/* Should be called if calling beginData() while another conversion is
already happening. Then, what is happening is the new conversion. */
CORRADE_VERIFY(converter.beginData());
CORRADE_VERIFY(converter.isConverting());
CORRADE_VERIFY(converter.abortCalled);
}
void AbstractSceneConverterTest::abortImplicitlyBeginFile() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::ConvertMultipleToFile;
}
void doAbort() override {
CORRADE_VERIFY(!abortCalled);
abortCalled = true;
}
bool doBegin() override { return true; }
bool doBeginFile(Containers::StringView) override { return true; }
bool abortCalled = false;
} converter;
/* Shouldn't be called if there's no previous conversion happening */
CORRADE_VERIFY(!converter.abortCalled);
CORRADE_VERIFY(converter.begin());
CORRADE_VERIFY(converter.isConverting());
CORRADE_VERIFY(!converter.abortCalled);
/* Should be called if calling beginData() while another conversion is
already happening. Then, what is happening is the new conversion. */
CORRADE_VERIFY(converter.beginFile(Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out")));
CORRADE_VERIFY(converter.isConverting());
CORRADE_VERIFY(converter.abortCalled);
}
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
void AbstractSceneConverterTest::thingNoBegin() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::AddScenes|
SceneConverterFeature::AddAnimations|
SceneConverterFeature::AddLights|
SceneConverterFeature::AddCameras|
SceneConverterFeature::AddSkins2D|
SceneConverterFeature::AddSkins3D|
SceneConverterFeature::AddMeshes|
SceneConverterFeature::AddMaterials|
SceneConverterFeature::AddTextures|
SceneConverterFeature::AddImages1D|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::AddImages3D|
SceneConverterFeature::AddCompressedImages1D|
SceneConverterFeature::AddCompressedImages2D|
SceneConverterFeature::AddCompressedImages3D|
SceneConverterFeature::MeshLevels|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginData() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
std::ostringstream out;
Error redirectError{&out};
converter.end();
converter.endData();
converter.endFile();
converter.sceneCount();
converter.add(SceneData{SceneMappingType::UnsignedInt, 0, nullptr, nullptr});
converter.setSceneFieldName({}, {});
converter.setObjectName(0, {});
converter.setDefaultScene(0);
converter.animationCount();
converter.add(AnimationData{nullptr, nullptr});
Trade: ability to specify custom animation target names on conversion. Added this API to the importer, forgot about the converter. Sigh.
3 years ago
converter.setAnimationTrackTargetName({}, {});
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
converter.lightCount();
Trade: deprecate LightData::Type in favor of LightType. Enums in classes are bad, can't forward-declare them.
3 years ago
converter.add(LightData{LightType::Point, {}, 0.0f});
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
converter.cameraCount();
converter.add(CameraData{CameraType::Orthographic3D, {}, 0.0f, 1.0f});
converter.skin2DCount();
converter.add(SkinData2D{nullptr, nullptr});
converter.skin3DCount();
converter.add(SkinData3D{nullptr, nullptr});
converter.meshCount();
converter.add(MeshData{MeshPrimitive::Triangles, 0});
converter.add({MeshData{MeshPrimitive::Triangles, 0},
MeshData{MeshPrimitive::Triangles, 0}});
converter.setMeshAttributeName({}, {});
converter.materialCount();
converter.add(MaterialData{{}, nullptr});
converter.textureCount();
converter.add(TextureData{{}, {}, {}, {}, {}, 0});
const char imageData[4]{};
converter.image1DCount();
converter.add(ImageData1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, imageData});
converter.add({ImageData1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, imageData},
ImageData1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, imageData}});
converter.image2DCount();
converter.add(ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, imageData});
converter.add({ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, imageData},
ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, imageData}});
converter.image3DCount();
converter.add(ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, DataFlags{}, imageData});
converter.add({ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, DataFlags{}, imageData},
ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, DataFlags{}, imageData}});
CORRADE_COMPARE(out.str(),
"Trade::AbstractSceneConverter::end(): no conversion in progress\n"
"Trade::AbstractSceneConverter::endData(): no data conversion in progress\n"
"Trade::AbstractSceneConverter::endFile(): no file conversion in progress\n"
"Trade::AbstractSceneConverter::sceneCount(): no conversion in progress\n"
"Trade::AbstractSceneConverter::add(): no conversion in progress\n"
"Trade::AbstractSceneConverter::setSceneFieldName(): no conversion in progress\n"
"Trade::AbstractSceneConverter::setObjectName(): no conversion in progress\n"
"Trade::AbstractSceneConverter::setDefaultScene(): no conversion in progress\n"
"Trade::AbstractSceneConverter::animationCount(): no conversion in progress\n"
"Trade::AbstractSceneConverter::add(): no conversion in progress\n"
Trade: ability to specify custom animation target names on conversion. Added this API to the importer, forgot about the converter. Sigh.
3 years ago
"Trade::AbstractSceneConverter::setAnimationTrackTargetName(): no conversion in progress\n"
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
"Trade::AbstractSceneConverter::lightCount(): no conversion in progress\n"
"Trade::AbstractSceneConverter::add(): no conversion in progress\n"
"Trade::AbstractSceneConverter::cameraCount(): no conversion in progress\n"
"Trade::AbstractSceneConverter::add(): no conversion in progress\n"
"Trade::AbstractSceneConverter::skin2DCount(): no conversion in progress\n"
"Trade::AbstractSceneConverter::add(): no conversion in progress\n"
"Trade::AbstractSceneConverter::skin3DCount(): no conversion in progress\n"
"Trade::AbstractSceneConverter::add(): no conversion in progress\n"
"Trade::AbstractSceneConverter::meshCount(): no conversion in progress\n"
"Trade::AbstractSceneConverter::add(): no conversion in progress\n"
"Trade::AbstractSceneConverter::add(): no conversion in progress\n"
"Trade::AbstractSceneConverter::setMeshAttributeName(): no conversion in progress\n"
"Trade::AbstractSceneConverter::materialCount(): no conversion in progress\n"
"Trade::AbstractSceneConverter::add(): no conversion in progress\n"
"Trade::AbstractSceneConverter::textureCount(): no conversion in progress\n"
"Trade::AbstractSceneConverter::add(): no conversion in progress\n"
"Trade::AbstractSceneConverter::image1DCount(): no conversion in progress\n"
"Trade::AbstractSceneConverter::add(): no conversion in progress\n"
"Trade::AbstractSceneConverter::add(): no conversion in progress\n"
"Trade::AbstractSceneConverter::image2DCount(): no conversion in progress\n"
"Trade::AbstractSceneConverter::add(): no conversion in progress\n"
"Trade::AbstractSceneConverter::add(): no conversion in progress\n"
"Trade::AbstractSceneConverter::image3DCount(): no conversion in progress\n"
"Trade::AbstractSceneConverter::add(): no conversion in progress\n"
"Trade::AbstractSceneConverter::add(): no conversion in progress\n");
}
void AbstractSceneConverterTest::endMismatchedBegin() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToData;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginData() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.beginData());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.end();
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::end(): no conversion in progress\n");
}
void AbstractSceneConverterTest::endDataMismatchedBegin() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.endData();
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::endData(): no data conversion in progress\n");
}
void AbstractSceneConverterTest::endFileMismatchedBegin() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.endFile();
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::endFile(): no file conversion in progress\n");
}
void AbstractSceneConverterTest::addScene() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddScenes;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt id, const SceneData& scene, Containers::StringView name) override {
/* Scene count should not be increased before the function
returns */
CORRADE_COMPARE(id, sceneCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(scene.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.sceneCount(), 0);
CORRADE_COMPARE(converter.add(SceneData{SceneMappingType::UnsignedInt, 0, nullptr, nullptr, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.sceneCount(), 1);
CORRADE_COMPARE(converter.add(SceneData{SceneMappingType::UnsignedInt, 0, nullptr, nullptr, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.sceneCount(), 2);
}
void AbstractSceneConverterTest::addSceneFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddScenes;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const SceneData&, Containers::StringView) override {
return false;
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.sceneCount(), 0);
/* The implementation is expected to print an error message on its own */
{
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.add(SceneData{SceneMappingType::UnsignedInt, 0, nullptr, nullptr}));
CORRADE_COMPARE(out.str(), "");
}
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.sceneCount(), 0);
}
void AbstractSceneConverterTest::addSceneNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddScenes;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add(SceneData{SceneMappingType::UnsignedInt, 0, nullptr, nullptr});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): scene conversion advertised but not implemented\n");
}
void AbstractSceneConverterTest::setSceneFieldName() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddScenes;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Trade: don't unwrap custom attribute/field names when passing to do*(). Originally I thought I'd save plugins some time if I just give them the custom indices directly, without being wrapped in a SceneField / MeshAttribute enum. But in practice that didn't really save anything, made the interfaces more error-prone due to there being no concrete type anymore, and all code that delegates to nested importers or converters had to re-wrap the IDs again, which is *again* error-prone. Bumping the interface strings because this is a breaking change for the implementations. Not for users tho, there nothing changes.
3 years ago
void doSetSceneFieldName(SceneField field, Containers::StringView name) override {
CORRADE_COMPARE(field, sceneFieldCustom(1337));
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(name, "hello!");
setSceneFieldNameCalled = true;
}
bool setSceneFieldNameCalled = false;
} converter;
CORRADE_VERIFY(true); /* capture correct function name */
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
converter.setSceneFieldName(sceneFieldCustom(1337), "hello!");
CORRADE_VERIFY(converter.setSceneFieldNameCalled);
}
void AbstractSceneConverterTest::setSceneFieldNameNotImplemented() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddScenes;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
/* This should work, there's no need for a plugin to implement this */
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
converter.setSceneFieldName(sceneFieldCustom(1337), "hello!");
CORRADE_VERIFY(true);
}
void AbstractSceneConverterTest::setSceneFieldNameNotCustom() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddScenes;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.setSceneFieldName(SceneField::Transformation, "hello!");
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::setSceneFieldName(): Trade::SceneField::Transformation is not custom\n");
}
void AbstractSceneConverterTest::setObjectName() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddScenes;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
void doSetObjectName(UnsignedLong object, Containers::StringView name) override {
CORRADE_COMPARE(object, 1337);
CORRADE_COMPARE(name, "hey!");
setObjectNameCalled = true;
}
bool setObjectNameCalled = false;
} converter;
CORRADE_VERIFY(true); /* capture correct function name */
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
converter.setObjectName(1337, "hey!");
CORRADE_VERIFY(converter.setObjectNameCalled);
}
void AbstractSceneConverterTest::setObjectNameNotImplemented() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddScenes;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
/* This should work, there's no need for a plugin to implement this */
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
converter.setObjectName(1337, "hey!");
CORRADE_VERIFY(true);
}
void AbstractSceneConverterTest::setDefaultScene() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddScenes;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const SceneData&, Containers::StringView) override {
return true;
}
void doSetDefaultScene(UnsignedInt id) override {
CORRADE_COMPARE(id, 2);
setDefaultSceneCalled = true;
}
bool setDefaultSceneCalled = false;
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(converter.add(SceneData{SceneMappingType::UnsignedInt, 0, nullptr, nullptr}));
CORRADE_VERIFY(converter.add(SceneData{SceneMappingType::UnsignedInt, 0, nullptr, nullptr}));
CORRADE_COMPARE(converter.add(SceneData{SceneMappingType::UnsignedInt, 0, nullptr, nullptr}), 2);
converter.setDefaultScene(2);
CORRADE_VERIFY(converter.setDefaultSceneCalled);
}
void AbstractSceneConverterTest::setDefaultSceneNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddScenes;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const SceneData&, Containers::StringView) override {
return true;
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(converter.add(SceneData{SceneMappingType::UnsignedInt, 0, nullptr, nullptr}));
CORRADE_COMPARE(converter.sceneCount(), 1);
/* This should work, there's no need for a plugin to implement this */
converter.setDefaultScene(0);
}
void AbstractSceneConverterTest::setDefaultSceneOutOfRange() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddScenes;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const SceneData&, Containers::StringView) override {
return true;
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(converter.add(SceneData{SceneMappingType::UnsignedInt, 0, nullptr, nullptr}));
CORRADE_VERIFY(converter.add(SceneData{SceneMappingType::UnsignedInt, 0, nullptr, nullptr}));
CORRADE_COMPARE(converter.sceneCount(), 2);
std::ostringstream out;
Error redirectError{&out};
converter.setDefaultScene(2);
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::setDefaultScene(): index 2 out of range for 2 scenes\n");
}
void AbstractSceneConverterTest::addAnimation() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddAnimations;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt id, const AnimationData& animation, Containers::StringView name) override {
/* Animation count should not be increased before the function
returns */
CORRADE_COMPARE(id, animationCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(animation.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.animationCount(), 0);
CORRADE_COMPARE(converter.add(AnimationData{nullptr, nullptr, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.animationCount(), 1);
CORRADE_COMPARE(converter.add(AnimationData{nullptr, nullptr, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.animationCount(), 2);
}
void AbstractSceneConverterTest::addAnimationFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddAnimations;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const AnimationData&, Containers::StringView) override {
return false;
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.animationCount(), 0);
/* The implementation is expected to print an error message on its own */
{
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.add(AnimationData{nullptr, nullptr}));
CORRADE_COMPARE(out.str(), "");
}
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.animationCount(), 0);
}
void AbstractSceneConverterTest::addAnimationNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddAnimations;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add(AnimationData{nullptr, nullptr});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): animation conversion advertised but not implemented\n");
}
Trade: ability to specify custom animation target names on conversion. Added this API to the importer, forgot about the converter. Sigh.
3 years ago
void AbstractSceneConverterTest::setAnimationTrackTargetName() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddAnimations;
}
bool doBegin() override { return true; }
void doSetAnimationTrackTargetName(AnimationTrackTarget target, Containers::StringView name) override {
CORRADE_COMPARE(target, animationTrackTargetCustom(1337));
CORRADE_COMPARE(name, "hello!");
setAnimationTrackTargetNameCalled = true;
}
bool setAnimationTrackTargetNameCalled = false;
} converter;
CORRADE_VERIFY(true); /* capture correct function name */
CORRADE_VERIFY(converter.begin());
converter.setAnimationTrackTargetName(animationTrackTargetCustom(1337), "hello!");
CORRADE_VERIFY(converter.setAnimationTrackTargetNameCalled);
}
void AbstractSceneConverterTest::setAnimationTrackTargetNameNotImplemented() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddAnimations;
}
bool doBegin() override { return true; }
} converter;
/* This should work, there's no need for a plugin to implement this */
CORRADE_VERIFY(converter.begin());
converter.setAnimationTrackTargetName(animationTrackTargetCustom(1337), "hello!");
CORRADE_VERIFY(true);
}
void AbstractSceneConverterTest::setAnimationTrackTargetNameNotCustom() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddAnimations;
}
bool doBegin() override { return true; }
} converter;
CORRADE_VERIFY(converter.begin());
std::ostringstream out;
Error redirectError{&out};
converter.setAnimationTrackTargetName(AnimationTrackTarget::Scaling2D, "hello!");
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::setAnimationTrackTargetName(): Trade::AnimationTrackTarget::Scaling2D is not custom\n");
}
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
void AbstractSceneConverterTest::addLight() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddLights;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt id, const LightData& light, Containers::StringView name) override {
/* Light count should not be increased before the function
returns */
CORRADE_COMPARE(id, lightCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(light.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.lightCount(), 0);
Trade: deprecate LightData::Type in favor of LightType. Enums in classes are bad, can't forward-declare them.
3 years ago
CORRADE_COMPARE(converter.add(LightData{LightType::Point, {}, 0.0f, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.lightCount(), 1);
Trade: deprecate LightData::Type in favor of LightType. Enums in classes are bad, can't forward-declare them.
3 years ago
CORRADE_COMPARE(converter.add(LightData{LightType::Point, {}, 0.0f, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.lightCount(), 2);
}
void AbstractSceneConverterTest::addLightFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddLights;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const LightData&, Containers::StringView) override {
return false;
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.lightCount(), 0);
/* The implementation is expected to print an error message on its own */
{
std::ostringstream out;
Error redirectError{&out};
Trade: deprecate LightData::Type in favor of LightType. Enums in classes are bad, can't forward-declare them.
3 years ago
CORRADE_VERIFY(!converter.add(LightData{LightType::Point, {}, 0.0f}));
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(out.str(), "");
}
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.lightCount(), 0);
}
void AbstractSceneConverterTest::addLightNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddLights;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
Trade: deprecate LightData::Type in favor of LightType. Enums in classes are bad, can't forward-declare them.
3 years ago
converter.add(LightData{LightType::Point, {}, 0.0f});
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): light conversion advertised but not implemented\n");
}
void AbstractSceneConverterTest::addCamera() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddCameras;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt id, const CameraData& camera, Containers::StringView name) override {
/* Camera count should not be increased before the function
returns */
CORRADE_COMPARE(id, cameraCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(camera.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.cameraCount(), 0);
CORRADE_COMPARE(converter.add(CameraData{CameraType::Orthographic3D, {}, 0.0f, 1.0f, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.cameraCount(), 1);
CORRADE_COMPARE(converter.add(CameraData{CameraType::Orthographic3D, {}, 0.0f, 1.0f, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.cameraCount(), 2);
}
void AbstractSceneConverterTest::addCameraFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddCameras;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const CameraData&, Containers::StringView) override {
return false;
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.cameraCount(), 0);
/* The implementation is expected to print an error message on its own */
{
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.add(CameraData{CameraType::Orthographic3D, {}, 0.0f, 1.0f}));
CORRADE_COMPARE(out.str(), "");
}
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.cameraCount(), 0);
}
void AbstractSceneConverterTest::addCameraNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddCameras;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add(CameraData{CameraType::Orthographic3D, {}, 0.0f, 1.0f});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): camera conversion advertised but not implemented\n");
}
void AbstractSceneConverterTest::addSkin2D() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddSkins2D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt id, const SkinData2D& skin, Containers::StringView name) override {
/* Camera count should not be increased before the function
returns */
CORRADE_COMPARE(id, skin2DCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(skin.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.skin2DCount(), 0);
CORRADE_COMPARE(converter.add(SkinData2D{nullptr, nullptr, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.skin2DCount(), 1);
CORRADE_COMPARE(converter.add(SkinData2D{nullptr, nullptr, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.skin2DCount(), 2);
}
void AbstractSceneConverterTest::addSkin2DFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddSkins2D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const SkinData2D&, Containers::StringView) override {
return false;
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.skin2DCount(), 0);
/* The implementation is expected to print an error message on its own */
{
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.add(SkinData2D{nullptr, nullptr}));
CORRADE_COMPARE(out.str(), "");
}
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.skin2DCount(), 0);
}
void AbstractSceneConverterTest::addSkin2DNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddSkins2D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add(SkinData2D{nullptr, nullptr});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): 2D skin conversion advertised but not implemented\n");
}
void AbstractSceneConverterTest::addSkin3D() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddSkins3D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt id, const SkinData3D& skin, Containers::StringView name) override {
/* Camera count should not be increased before the function
returns */
CORRADE_COMPARE(id, skin3DCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(skin.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.skin3DCount(), 0);
CORRADE_COMPARE(converter.add(SkinData3D{nullptr, nullptr, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.skin3DCount(), 1);
CORRADE_COMPARE(converter.add(SkinData3D{nullptr, nullptr, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.skin3DCount(), 2);
}
void AbstractSceneConverterTest::addSkin3DFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddSkins3D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const SkinData3D&, Containers::StringView) override {
return false;
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.skin3DCount(), 0);
/* The implementation is expected to print an error message on its own */
{
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.add(SkinData3D{nullptr, nullptr}));
CORRADE_COMPARE(out.str(), "");
}
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.skin3DCount(), 0);
}
void AbstractSceneConverterTest::addSkin3DNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddSkins3D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add(SkinData3D{nullptr, nullptr});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): 3D skin conversion advertised but not implemented\n");
}
void AbstractSceneConverterTest::addMesh() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddMeshes;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt id, const MeshData& mesh, Containers::StringView name) override {
/* Camera count should not be increased before the function
returns */
CORRADE_COMPARE(id, meshCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(mesh.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.meshCount(), 0);
CORRADE_COMPARE(converter.add(MeshData{MeshPrimitive::Triangles, 0, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.meshCount(), 1);
CORRADE_COMPARE(converter.add(MeshData{MeshPrimitive::Triangles, 0, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.meshCount(), 2);
}
void AbstractSceneConverterTest::addMeshFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddMeshes;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const MeshData&, Containers::StringView) override {
return false;
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.meshCount(), 0);
/* The implementation is expected to print an error message on its own */
{
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.add(MeshData{MeshPrimitive::Triangles, 0}));
CORRADE_COMPARE(out.str(), "");
}
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.meshCount(), 0);
}
void AbstractSceneConverterTest::addMeshThroughConvertMesh() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMesh;
}
Containers::Optional<MeshData> doConvert(const MeshData& mesh) override {
CORRADE_COMPARE(mesh.primitive(), MeshPrimitive::Triangles);
return MeshData{MeshPrimitive::Lines, mesh.vertexCount()*2};
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override {
Test: use CORRADE_FAIL() where it makes sense. Of course I used the wrong `CORRADE_FAIL_IF(false, ...)` in a few places. Yet another confirmation it was too hard to use and a dedicated macro is needed.
4 years ago
CORRADE_FAIL("doBegin() should not be called");
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
return {};
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
Containers::Pointer<AbstractImporter> doEnd() override {
Test: use CORRADE_FAIL() where it makes sense. Of course I used the wrong `CORRADE_FAIL_IF(false, ...)` in a few places. Yet another confirmation it was too hard to use and a dedicated macro is needed.
4 years ago
CORRADE_FAIL("doEnd() should not be called");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
return {};
}
bool doAdd(UnsignedInt, const Trade::MeshData&, Containers::StringView) override {
Test: use CORRADE_FAIL() where it makes sense. Of course I used the wrong `CORRADE_FAIL_IF(false, ...)` in a few places. Yet another confirmation it was too hard to use and a dedicated macro is needed.
4 years ago
CORRADE_FAIL("doAdd() should not be called");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
return {};
}
} converter;
CORRADE_VERIFY(true); /* capture correct function name */
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.meshCount(), 0);
CORRADE_COMPARE(converter.add(MeshData{MeshPrimitive::Triangles, 6}), 0);
CORRADE_COMPARE(converter.meshCount(), 1);
Containers::Pointer<AbstractImporter> importer = converter.end();
CORRADE_VERIFY(!converter.isConverting());
CORRADE_VERIFY(importer);
CORRADE_VERIFY(importer->isOpened());
CORRADE_COMPARE(importer->meshCount(), 1);
Containers::Optional<MeshData> mesh = importer->mesh(0);
CORRADE_VERIFY(mesh);
CORRADE_COMPARE(mesh->primitive(), MeshPrimitive::Lines);
CORRADE_COMPARE(mesh->vertexCount(), 12);
/* The mesh is returned only once, second time it will fail (but just an
error, not an assert */
{
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!importer->mesh(0));
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::end(): mesh can be retrieved only once from a converter with just Trade::SceneConverterFeature::ConvertMesh\n");
}
/* Verify that it's also possible to close the importer without hitting
some nasty assert */
importer->close();
CORRADE_VERIFY(!importer->isOpened());
}
void AbstractSceneConverterTest::addMeshThroughConvertMeshFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMesh;
}
Containers::Optional<MeshData> doConvert(const MeshData&) override {
return {};
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(!converter.add(MeshData{MeshPrimitive::Lines, 6}));
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.meshCount(), 0);
/* But the observable behavior is as if no mesh was added */
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.end());
CORRADE_VERIFY(!converter.isConverting());
Trade: unify AbstractSceneConverter::end*() error messages. Not sure why 4ce7d8e9f49e3fb4c6840defa60627b8178fb950 did the change just for the file variant and not all 3.
4 years ago
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::end(): the converter requires exactly one mesh, got 0\n");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
void AbstractSceneConverterTest::addMeshThroughConvertMeshZeroMeshes() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMesh;
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.end());
CORRADE_VERIFY(!converter.isConverting());
Trade: unify AbstractSceneConverter::end*() error messages. Not sure why 4ce7d8e9f49e3fb4c6840defa60627b8178fb950 did the change just for the file variant and not all 3.
4 years ago
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::end(): the converter requires exactly one mesh, got 0\n");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
void AbstractSceneConverterTest::addMeshThroughConvertMeshTwoMeshes() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMesh;
}
Containers::Optional<MeshData> doConvert(const MeshData& mesh) override {
return MeshData{MeshPrimitive::Lines, mesh.vertexCount()*2};
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.meshCount(), 0);
CORRADE_COMPARE(converter.add(MeshData{MeshPrimitive::Triangles, 6}), 0);
CORRADE_COMPARE(converter.meshCount(), 1);
{
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.add(MeshData{MeshPrimitive::Triangles, 7}));
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.meshCount(), 1);
Trade: improve messages for batch->single SceneConverter delegation.
4 years ago
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): the converter requires exactly one mesh, got 2\n");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
/* Getting the result should still work */
Containers::Pointer<AbstractImporter> out = converter.end();
CORRADE_VERIFY(!converter.isConverting());
CORRADE_VERIFY(out);
CORRADE_COMPARE(out->meshCount(), 1);
Containers::Optional<MeshData> mesh = out->mesh(0);
CORRADE_VERIFY(mesh);
CORRADE_COMPARE(mesh->primitive(), MeshPrimitive::Lines);
CORRADE_COMPARE(mesh->vertexCount(), 12);
}
void AbstractSceneConverterTest::addMeshThroughConvertMeshToData() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMeshToData;
}
Containers::Optional<Containers::Array<char>> doConvertToData(const MeshData& mesh) override {
return Containers::Array<char>{nullptr, mesh.vertexCount()};
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginData() override {
Test: use CORRADE_FAIL() where it makes sense. Of course I used the wrong `CORRADE_FAIL_IF(false, ...)` in a few places. Yet another confirmation it was too hard to use and a dedicated macro is needed.
4 years ago
CORRADE_FAIL("doBeginData() should not be called");
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
return {};
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
Containers::Optional<Containers::Array<char>> doEndData() override {
Test: use CORRADE_FAIL() where it makes sense. Of course I used the wrong `CORRADE_FAIL_IF(false, ...)` in a few places. Yet another confirmation it was too hard to use and a dedicated macro is needed.
4 years ago
CORRADE_FAIL("doEndData() should not be called");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
return {};
}
bool doAdd(UnsignedInt, const Trade::MeshData&, Containers::StringView) override {
Test: use CORRADE_FAIL() where it makes sense. Of course I used the wrong `CORRADE_FAIL_IF(false, ...)` in a few places. Yet another confirmation it was too hard to use and a dedicated macro is needed.
4 years ago
CORRADE_FAIL("doAdd() should not be called");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
return {};
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.beginData());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.meshCount(), 0);
CORRADE_COMPARE(converter.add(MeshData{MeshPrimitive::Triangles, 6}), 0);
CORRADE_COMPARE(converter.meshCount(), 1);
Containers::Optional<Containers::Array<char>> data = converter.endData();
CORRADE_VERIFY(!converter.isConverting());
CORRADE_VERIFY(data);
CORRADE_COMPARE(data->size(), 6);
}
void AbstractSceneConverterTest::addMeshThroughConvertMeshToDataFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMeshToData;
}
Containers::Optional<Containers::Array<char>> doConvertToData(const MeshData&) override {
return {};
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.beginData());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(!converter.add(MeshData{MeshPrimitive::Lines, 6}));
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.meshCount(), 0);
/* But the observable behavior is as if no mesh was added */
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.endData());
CORRADE_VERIFY(!converter.isConverting());
Trade: unify AbstractSceneConverter::end*() error messages. Not sure why 4ce7d8e9f49e3fb4c6840defa60627b8178fb950 did the change just for the file variant and not all 3.
4 years ago
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::endData(): the converter requires exactly one mesh, got 0\n");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
void AbstractSceneConverterTest::addMeshThroughConvertMeshToDataZeroMeshes() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMeshToData;
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.beginData());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.endData());
CORRADE_VERIFY(!converter.isConverting());
Trade: unify AbstractSceneConverter::end*() error messages. Not sure why 4ce7d8e9f49e3fb4c6840defa60627b8178fb950 did the change just for the file variant and not all 3.
4 years ago
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::endData(): the converter requires exactly one mesh, got 0\n");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
void AbstractSceneConverterTest::addMeshThroughConvertMeshToDataTwoMeshes() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMeshToData;
}
Containers::Optional<Containers::Array<char>> doConvertToData(const MeshData& mesh) override {
return Containers::Array<char>{nullptr, mesh.vertexCount()};
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.beginData());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.meshCount(), 0);
CORRADE_COMPARE(converter.add(MeshData{MeshPrimitive::Triangles, 6}), 0);
CORRADE_COMPARE(converter.meshCount(), 1);
{
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.add(MeshData{MeshPrimitive::Triangles, 7}));
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.meshCount(), 1);
Trade: improve messages for batch->single SceneConverter delegation.
4 years ago
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): the converter requires exactly one mesh, got 2\n");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
/* Getting the result should still work */
Containers::Optional<Containers::Array<char>> data = converter.endData();
CORRADE_VERIFY(!converter.isConverting());
CORRADE_VERIFY(data);
CORRADE_COMPARE(data->size(), 6);
}
void AbstractSceneConverterTest::addMeshThroughConvertMeshToFile() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMeshToFile;
}
bool doConvertToFile(const MeshData& mesh, Containers::StringView filename) override {
return Utility::Path::write(filename, Containers::arrayView({char(mesh.vertexCount())}));
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginFile(Containers::StringView) override {
Test: use CORRADE_FAIL() where it makes sense. Of course I used the wrong `CORRADE_FAIL_IF(false, ...)` in a few places. Yet another confirmation it was too hard to use and a dedicated macro is needed.
4 years ago
CORRADE_FAIL("doBeginFile() should not be called");
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
return {};
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
bool doEndFile(Containers::StringView) override {
Test: use CORRADE_FAIL() where it makes sense. Of course I used the wrong `CORRADE_FAIL_IF(false, ...)` in a few places. Yet another confirmation it was too hard to use and a dedicated macro is needed.
4 years ago
CORRADE_FAIL("doEndFile() should not be called");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
return {};
}
bool doAdd(UnsignedInt, const Trade::MeshData&, Containers::StringView) override {
Test: use CORRADE_FAIL() where it makes sense. Of course I used the wrong `CORRADE_FAIL_IF(false, ...)` in a few places. Yet another confirmation it was too hard to use and a dedicated macro is needed.
4 years ago
CORRADE_FAIL("doAdd() should not be called");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
return {};
}
} converter;
/* Remove previous file, if any */
Containers::String filename = Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out");
if(Utility::Path::exists(filename))
CORRADE_VERIFY(Utility::Path::remove(filename));
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.beginFile(filename));
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(!Utility::Path::exists(filename));
CORRADE_COMPARE(converter.meshCount(), 0);
CORRADE_COMPARE(converter.add(MeshData{MeshPrimitive::Triangles, 0xef}), 0);
CORRADE_COMPARE(converter.meshCount(), 1);
/* It's easier to just perform the operation right during add() than to
make a copy of the passed MeshData and do it at endFile(), so the file
exists at this point already */
CORRADE_VERIFY(Utility::Path::exists(filename));
CORRADE_VERIFY(converter.endFile());
CORRADE_VERIFY(!converter.isConverting());
CORRADE_VERIFY(Utility::Path::exists(filename));
CORRADE_COMPARE_AS(filename,
"\xef", TestSuite::Compare::FileToString);
}
void AbstractSceneConverterTest::addMeshThroughConvertMeshToFileThroughData() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMeshToData;
}
Containers::Optional<Containers::Array<char>> doConvertToData(const MeshData& mesh) override {
return Containers::array({char(mesh.vertexCount())});
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginData() override {
Test: use CORRADE_FAIL() where it makes sense. Of course I used the wrong `CORRADE_FAIL_IF(false, ...)` in a few places. Yet another confirmation it was too hard to use and a dedicated macro is needed.
4 years ago
CORRADE_FAIL("doBeginData() should not be called");
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
return {};
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
Containers::Optional<Containers::Array<char>> doEndData() override {
Test: use CORRADE_FAIL() where it makes sense. Of course I used the wrong `CORRADE_FAIL_IF(false, ...)` in a few places. Yet another confirmation it was too hard to use and a dedicated macro is needed.
4 years ago
CORRADE_FAIL("doEndData() should not be called");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
return {};
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBeginFile(Containers::StringView) override {
Test: use CORRADE_FAIL() where it makes sense. Of course I used the wrong `CORRADE_FAIL_IF(false, ...)` in a few places. Yet another confirmation it was too hard to use and a dedicated macro is needed.
4 years ago
CORRADE_FAIL("doBeginFile() should not be called");
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
return {};
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
bool doEndFile(Containers::StringView) override {
Test: use CORRADE_FAIL() where it makes sense. Of course I used the wrong `CORRADE_FAIL_IF(false, ...)` in a few places. Yet another confirmation it was too hard to use and a dedicated macro is needed.
4 years ago
CORRADE_FAIL("doEndFile() should not be called");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
return {};
}
bool doAdd(UnsignedInt, const Trade::MeshData&, Containers::StringView) override {
Test: use CORRADE_FAIL() where it makes sense. Of course I used the wrong `CORRADE_FAIL_IF(false, ...)` in a few places. Yet another confirmation it was too hard to use and a dedicated macro is needed.
4 years ago
CORRADE_FAIL("doAdd() should not be called");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
return {};
}
} converter;
/* Remove previous file, if any */
Containers::String filename = Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out");
if(Utility::Path::exists(filename))
CORRADE_VERIFY(Utility::Path::remove(filename));
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.beginFile(filename));
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(!Utility::Path::exists(filename));
CORRADE_COMPARE(converter.meshCount(), 0);
CORRADE_COMPARE(converter.add(MeshData{MeshPrimitive::Triangles, 0xef}), 0);
CORRADE_COMPARE(converter.meshCount(), 1);
/* It's easier to just perform the operation right during add() than to
make a copy of the passed MeshData and do it at the end(), so the file
exists at this point already */
CORRADE_VERIFY(Utility::Path::exists(filename));
CORRADE_VERIFY(converter.endFile());
CORRADE_VERIFY(!converter.isConverting());
CORRADE_VERIFY(Utility::Path::exists(filename));
CORRADE_COMPARE_AS(filename,
"\xef", TestSuite::Compare::FileToString);
}
void AbstractSceneConverterTest::addMeshThroughConvertMeshToFileFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMeshToFile;
}
bool doConvertToFile(const MeshData&, Containers::StringView) override {
return false;
}
} converter;
/* Remove previous file, if any */
Containers::String filename = Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out");
if(Utility::Path::exists(filename))
CORRADE_VERIFY(Utility::Path::remove(filename));
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.beginFile(filename));
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(!Utility::Path::exists(filename));
CORRADE_VERIFY(!converter.add(MeshData{MeshPrimitive::Lines, 6}));
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.meshCount(), 0);
/* But the observable behavior is as if no mesh was added */
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.endFile());
CORRADE_VERIFY(!converter.isConverting());
CORRADE_VERIFY(!Utility::Path::exists(filename));
Trade: improve messages for batch->single SceneConverter delegation.
4 years ago
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::endFile(): the converter requires exactly one mesh, got 0\n");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
void AbstractSceneConverterTest::addMeshThroughConvertMeshToFileZeroMeshes() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMeshToFile;
}
} converter;
/* Remove previous file, if any */
Containers::String filename = Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out");
if(Utility::Path::exists(filename))
CORRADE_VERIFY(Utility::Path::remove(filename));
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.beginFile(filename));
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(!Utility::Path::exists(filename));
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.endFile());
CORRADE_VERIFY(!converter.isConverting());
CORRADE_VERIFY(!Utility::Path::exists(filename));
Trade: improve messages for batch->single SceneConverter delegation.
4 years ago
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::endFile(): the converter requires exactly one mesh, got 0\n");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
void AbstractSceneConverterTest::addMeshThroughConvertMeshToFileTwoMeshes() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMeshToFile;
}
bool doConvertToFile(const MeshData& mesh, Containers::StringView filename) override {
return Utility::Path::write(filename, Containers::arrayView({char(mesh.vertexCount())}));
}
} converter;
/* Remove previous file, if any */
Containers::String filename = Utility::Path::join(TRADE_TEST_OUTPUT_DIR, "mesh.out");
if(Utility::Path::exists(filename))
CORRADE_VERIFY(Utility::Path::remove(filename));
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.beginFile(filename));
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(!Utility::Path::exists(filename));
CORRADE_COMPARE(converter.meshCount(), 0);
CORRADE_COMPARE(converter.add(MeshData{MeshPrimitive::Triangles, 0xef}), 0);
CORRADE_COMPARE(converter.meshCount(), 1);
/* It's easier to just perform the operation right during add() than to
make a copy of the passed MeshData and do it at the endFile(), so the
file exists at this point already */
CORRADE_VERIFY(Utility::Path::exists(filename));
{
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.add(MeshData{MeshPrimitive::Triangles, 0xb0}));
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.meshCount(), 1);
Trade: improve messages for batch->single SceneConverter delegation.
4 years ago
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): the converter requires exactly one mesh, got 2\n");
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
/* Getting the result should still work */
CORRADE_VERIFY(converter.endFile());
CORRADE_VERIFY(!converter.isConverting());
CORRADE_VERIFY(Utility::Path::exists(filename));
CORRADE_COMPARE_AS(filename,
"\xef", TestSuite::Compare::FileToString);
}
void AbstractSceneConverterTest::addMeshNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddMeshes;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add(MeshData{MeshPrimitive::Triangles, 0});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): mesh conversion advertised but not implemented\n");
}
void AbstractSceneConverterTest::addMeshLevels() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddMeshes|
SceneConverterFeature::MeshLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt id, const Containers::Iterable<const MeshData>& meshLevels, Containers::StringView name) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
/* Camera count should not be increased before the function
returns */
CORRADE_COMPARE(id, meshCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(meshLevels.size(), 3);
CORRADE_COMPARE(meshLevels[1].importerState(), reinterpret_cast<const void*>(0xdeadbeef));
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.meshCount(), 0);
CORRADE_COMPARE(converter.add({
MeshData{MeshPrimitive::Lines, 0},
MeshData{MeshPrimitive::Triangles, 3, reinterpret_cast<const void*>(0xdeadbeef)},
MeshData{MeshPrimitive::Faces, 0},
}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.meshCount(), 1);
CORRADE_COMPARE(converter.add({
MeshData{MeshPrimitive::Faces, 2},
MeshData{MeshPrimitive::Meshlets, 1, reinterpret_cast<const void*>(0xdeadbeef)},
MeshData{MeshPrimitive::Points, 0},
}, "hello"), 1);
CORRADE_COMPARE(converter.meshCount(), 2);
}
void AbstractSceneConverterTest::addMeshLevelsFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddMeshes|
SceneConverterFeature::MeshLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const MeshData>&, Containers::StringView) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
return false;
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.meshCount(), 0);
/* The implementation is expected to print an error message on its own */
{
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.add({
MeshData{MeshPrimitive::Triangles, 0},
MeshData{MeshPrimitive::Triangles, 0}
}));
CORRADE_COMPARE(out.str(), "");
}
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.meshCount(), 0);
}
void AbstractSceneConverterTest::addMeshLevelsNoLevels() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddMeshes|
SceneConverterFeature::MeshLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add(Containers::Iterable<const MeshData>{});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): at least one mesh level has to be specified\n");
}
void AbstractSceneConverterTest::addMeshLevelsNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddMeshes|
SceneConverterFeature::MeshLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add({
MeshData{MeshPrimitive::Triangles, 0},
MeshData{MeshPrimitive::Triangles, 0}
});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): multi-level mesh conversion advertised but not implemented\n");
}
void AbstractSceneConverterTest::addMeshThroughLevels() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddMeshes|
SceneConverterFeature::MeshLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const MeshData>& meshLevels, Containers::StringView name) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(meshLevels.size(), 1);
CORRADE_COMPARE(meshLevels[0].importerState(), reinterpret_cast<const void*>(0xdeadbeef));
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.add(MeshData{MeshPrimitive::Triangles, 0, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.meshCount(), 1);
}
void AbstractSceneConverterTest::setMeshAttributeName() {
Trade: allow calling setMeshAttributeName() on single-mesh converters. It's useful there as well, for example the StanfordSceneConverter implements just single-mesh conversion but is capable of having the attributes named in a custom way (although it's not implemented at the moment). Or a mesh optimization plugin can have specialized behavior for custom attributes but only if it knows what they are.
3 years ago
auto&& data = SetMeshAttributeData[testCaseInstanceId()];
setTestCaseDescription(data.name);
struct Converter: AbstractSceneConverter {
explicit Converter(SceneConverterFeatures features): features{features} {}
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
SceneConverterFeatures doFeatures() const override {
Trade: allow calling setMeshAttributeName() on single-mesh converters. It's useful there as well, for example the StanfordSceneConverter implements just single-mesh conversion but is capable of having the attributes named in a custom way (although it's not implemented at the moment). Or a mesh optimization plugin can have specialized behavior for custom attributes but only if it knows what they are.
3 years ago
return features;
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Trade: don't unwrap custom attribute/field names when passing to do*(). Originally I thought I'd save plugins some time if I just give them the custom indices directly, without being wrapped in a SceneField / MeshAttribute enum. But in practice that didn't really save anything, made the interfaces more error-prone due to there being no concrete type anymore, and all code that delegates to nested importers or converters had to re-wrap the IDs again, which is *again* error-prone. Bumping the interface strings because this is a breaking change for the implementations. Not for users tho, there nothing changes.
3 years ago
void doSetMeshAttributeName(MeshAttribute field, Containers::StringView name) override {
CORRADE_COMPARE(field, meshAttributeCustom(1337));
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(name, "hello!");
setMeshAttributeNameCalled = true;
}
Trade: allow calling setMeshAttributeName() on single-mesh converters. It's useful there as well, for example the StanfordSceneConverter implements just single-mesh conversion but is capable of having the attributes named in a custom way (although it's not implemented at the moment). Or a mesh optimization plugin can have specialized behavior for custom attributes but only if it knows what they are.
3 years ago
SceneConverterFeatures features;
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool setMeshAttributeNameCalled = false;
Trade: allow calling setMeshAttributeName() on single-mesh converters. It's useful there as well, for example the StanfordSceneConverter implements just single-mesh conversion but is capable of having the attributes named in a custom way (although it's not implemented at the moment). Or a mesh optimization plugin can have specialized behavior for custom attributes but only if it knows what they are.
3 years ago
} converter{data.features};
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(true); /* capture correct function name */
Trade: allow calling setMeshAttributeName() on single-mesh converters. It's useful there as well, for example the StanfordSceneConverter implements just single-mesh conversion but is capable of having the attributes named in a custom way (although it's not implemented at the moment). Or a mesh optimization plugin can have specialized behavior for custom attributes but only if it knows what they are.
3 years ago
/* Only single-mesh conversion can call the API alone */
if(data.features & SceneConverterFeature::ConvertMultiple)
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
converter.setMeshAttributeName(meshAttributeCustom(1337), "hello!");
CORRADE_VERIFY(converter.setMeshAttributeNameCalled);
}
void AbstractSceneConverterTest::setMeshAttributeNameNotImplemented() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddMeshes;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
/* This should work, there's no need for a plugin to implement this */
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
converter.setMeshAttributeName(meshAttributeCustom(1337), "hello!");
CORRADE_VERIFY(true);
}
void AbstractSceneConverterTest::setMeshAttributeNameNotCustom() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddMeshes;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.setMeshAttributeName(MeshAttribute::ObjectId, "hello!");
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::setMeshAttributeName(): Trade::MeshAttribute::ObjectId is not custom\n");
}
void AbstractSceneConverterTest::addMaterial() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddMaterials;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt id, const MaterialData& material, Containers::StringView name) override {
/* Camera count should not be increased before the function
returns */
CORRADE_COMPARE(id, materialCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(material.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.materialCount(), 0);
CORRADE_COMPARE(converter.add(MaterialData{{}, nullptr, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.materialCount(), 1);
CORRADE_COMPARE(converter.add(MaterialData{{}, nullptr, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.materialCount(), 2);
}
void AbstractSceneConverterTest::addMaterialFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddMaterials;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const MaterialData&, Containers::StringView) override {
return false;
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.materialCount(), 0);
/* The implementation is expected to print an error message on its own */
{
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.add(MaterialData{{}, nullptr}));
CORRADE_COMPARE(out.str(), "");
}
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.materialCount(), 0);
}
void AbstractSceneConverterTest::addMaterialNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddMaterials;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add(MaterialData{{}, nullptr});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): material conversion advertised but not implemented\n");
}
void AbstractSceneConverterTest::addTexture() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddTextures;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt id, const TextureData& texture, Containers::StringView name) override {
/* Camera count should not be increased before the function
returns */
CORRADE_COMPARE(id, textureCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(texture.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.textureCount(), 0);
CORRADE_COMPARE(converter.add(TextureData{{}, {}, {}, {}, {}, 0, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.textureCount(), 1);
CORRADE_COMPARE(converter.add(TextureData{{}, {}, {}, {}, {}, 0, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.textureCount(), 2);
}
void AbstractSceneConverterTest::addTextureFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddTextures;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const TextureData&, Containers::StringView) override {
return false;
}
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.textureCount(), 0);
/* The implementation is expected to print an error message on its own */
{
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.add(TextureData{{}, {}, {}, {}, {}, 0}));
CORRADE_COMPARE(out.str(), "");
}
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.textureCount(), 0);
}
void AbstractSceneConverterTest::addTextureNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddTextures;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add(TextureData{{}, {}, {}, {}, {}, 0});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): texture conversion advertised but not implemented\n");
}
void AbstractSceneConverterTest::addImage1D() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages1D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt id, const ImageData1D& image, Containers::StringView name) override {
/* Camera count should not be increased before the function
returns */
CORRADE_COMPARE(id, image1DCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(image.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image1DCount(), 0);
CORRADE_COMPARE(converter.add(ImageData1D{PixelFormat::RGBA8Unorm, 1, {}, imageData, ImageFlags1D{}, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image1DCount(), 1);
CORRADE_COMPARE(converter.add(ImageData1D{PixelFormat::RGBA8Unorm, 1, {}, imageData, ImageFlags1D{}, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.image1DCount(), 2);
}
void AbstractSceneConverterTest::addImage1DView() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages1D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const ImageData1D& image, Containers::StringView name) override {
CORRADE_COMPARE(name, "hello");
CORRADE_VERIFY(!image.isCompressed());
CORRADE_COMPARE(image.storage().alignment(), 2);
CORRADE_COMPARE(image.format(), PixelFormat::RG8Snorm);
CORRADE_COMPARE(image.size(), 3);
Trade: properly propagate image view flags in AbstractSceneConverter. This happened because I made an early implementation of the batch AbstractSceneConverter APIs, stashed it away, then implemented image flags and then continued working on the stash, unaware that it's outdated.
4 years ago
CORRADE_COMPARE(image.flags(), ImageFlags1D{});
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(image.data());
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[6]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image1DCount(), 0);
CORRADE_COMPARE(converter.add(ImageView1D{
PixelStorage{}.setAlignment(2),
PixelFormat::RG8Snorm, 3, imageData}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image1DCount(), 1);
}
void AbstractSceneConverterTest::addImage1DCompressedView() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddCompressedImages1D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const ImageData1D& image, Containers::StringView name) override {
CORRADE_COMPARE(name, "hello");
CORRADE_VERIFY(image.isCompressed());
CORRADE_COMPARE(image.compressedStorage().compressedBlockSize(), Vector3i{3});
CORRADE_COMPARE(image.compressedFormat(), CompressedPixelFormat::Astc3x3x3RGBASrgb);
CORRADE_COMPARE(image.size(), 3);
Trade: properly propagate image view flags in AbstractSceneConverter. This happened because I made an early implementation of the batch AbstractSceneConverter APIs, stashed it away, then implemented image flags and then continued working on the stash, unaware that it's outdated.
4 years ago
CORRADE_COMPARE(image.flags(), ImageFlags1D{});
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(image.data());
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[4*4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image1DCount(), 0);
CORRADE_COMPARE(converter.add(CompressedImageView1D{
CompressedPixelStorage{}.setCompressedBlockSize({3, 3, 3}),
CompressedPixelFormat::Astc3x3x3RGBASrgb, 3, imageData}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image1DCount(), 1);
}
void AbstractSceneConverterTest::addImage1DFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages1D|
SceneConverterFeature::AddCompressedImages1D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const ImageData1D&, Containers::StringView) override {
return false;
}
} converter;
const char imageData[4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image1DCount(), 0);
/* The implementation is expected to print an error message on its own */
{
std::ostringstream out;
Error redirectError{&out};
/* Testing all three variants to "fake" coverage for the name-less
overloads as well */
CORRADE_VERIFY(!converter.add(ImageData1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, imageData}));
CORRADE_VERIFY(!converter.add(ImageView1D{PixelFormat::RGBA8Unorm, 1, imageData}));
CORRADE_VERIFY(!converter.add(CompressedImageView1D{CompressedPixelFormat::Astc4x4RGBAUnorm, 1, imageData}));
CORRADE_COMPARE(out.str(), "");
}
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.image1DCount(), 0);
}
void AbstractSceneConverterTest::addImage1DInvalidImage() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages1D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add(ImageData1D{PixelFormat::RGBA8Unorm, {}, nullptr});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): can't add image with a zero size: Vector(0)\n");
}
void AbstractSceneConverterTest::addImage1DNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages1D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
const char imageData[4]{};
std::ostringstream out;
Error redirectError{&out};
converter.add(ImageData1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, imageData});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): 1D image conversion advertised but not implemented\n");
}
void AbstractSceneConverterTest::addImage2D() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages2D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt id, const ImageData2D& image, Containers::StringView name) override {
/* Camera count should not be increased before the function
returns */
CORRADE_COMPARE(id, image2DCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(image.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image2DCount(), 0);
CORRADE_COMPARE(converter.add(ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, {}, imageData, ImageFlags2D{}, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image2DCount(), 1);
CORRADE_COMPARE(converter.add(ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, {}, imageData, ImageFlags2D{}, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.image2DCount(), 2);
}
void AbstractSceneConverterTest::addImage2DView() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages2D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const ImageData2D& image, Containers::StringView name) override {
CORRADE_COMPARE(name, "hello");
CORRADE_VERIFY(!image.isCompressed());
CORRADE_COMPARE(image.storage().alignment(), 2);
CORRADE_COMPARE(image.format(), PixelFormat::RG8Snorm);
CORRADE_COMPARE(image.size(), (Vector2i{3, 1}));
Trade: properly propagate image view flags in AbstractSceneConverter. This happened because I made an early implementation of the batch AbstractSceneConverter APIs, stashed it away, then implemented image flags and then continued working on the stash, unaware that it's outdated.
4 years ago
CORRADE_COMPARE(image.flags(), ImageFlag2D::Array);
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(image.data());
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[6]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image2DCount(), 0);
CORRADE_COMPARE(converter.add(ImageView2D{
PixelStorage{}.setAlignment(2),
Trade: properly propagate image view flags in AbstractSceneConverter. This happened because I made an early implementation of the batch AbstractSceneConverter APIs, stashed it away, then implemented image flags and then continued working on the stash, unaware that it's outdated.
4 years ago
PixelFormat::RG8Snorm, {3, 1}, imageData, ImageFlag2D::Array},
"hello"), 0);
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image2DCount(), 1);
}
void AbstractSceneConverterTest::addImage2DCompressedView() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddCompressedImages2D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const ImageData2D& image, Containers::StringView name) override {
CORRADE_COMPARE(name, "hello");
CORRADE_VERIFY(image.isCompressed());
CORRADE_COMPARE(image.compressedStorage().compressedBlockSize(), Vector3i{3});
CORRADE_COMPARE(image.compressedFormat(), CompressedPixelFormat::Astc3x3x3RGBASrgb);
CORRADE_COMPARE(image.size(), (Vector2i{3, 2}));
Trade: properly propagate image view flags in AbstractSceneConverter. This happened because I made an early implementation of the batch AbstractSceneConverter APIs, stashed it away, then implemented image flags and then continued working on the stash, unaware that it's outdated.
4 years ago
CORRADE_COMPARE(image.flags(), ImageFlag2D::Array);
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(image.data());
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[4*4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image2DCount(), 0);
CORRADE_COMPARE(converter.add(CompressedImageView2D{
CompressedPixelStorage{}.setCompressedBlockSize({3, 3, 3}),
Trade: properly propagate image view flags in AbstractSceneConverter. This happened because I made an early implementation of the batch AbstractSceneConverter APIs, stashed it away, then implemented image flags and then continued working on the stash, unaware that it's outdated.
4 years ago
CompressedPixelFormat::Astc3x3x3RGBASrgb, {3, 2}, imageData,
ImageFlag2D::Array}, "hello"), 0);
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image2DCount(), 1);
}
void AbstractSceneConverterTest::addImage2DFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::AddCompressedImages2D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const ImageData2D&, Containers::StringView) override {
return false;
}
} converter;
const char imageData[4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image2DCount(), 0);
/* The implementation is expected to print an error message on its own */
{
std::ostringstream out;
Error redirectError{&out};
/* Testing all three variants to "fake" coverage for the name-less
overloads as well */
CORRADE_VERIFY(!converter.add(ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, imageData}));
CORRADE_VERIFY(!converter.add(ImageView2D{PixelFormat::RGBA8Unorm, {1, 1}, imageData}));
CORRADE_VERIFY(!converter.add(CompressedImageView2D{CompressedPixelFormat::Astc4x4RGBAUnorm, {1, 1}, imageData}));
CORRADE_COMPARE(out.str(), "");
}
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.image2DCount(), 0);
}
void AbstractSceneConverterTest::addImage2DZeroSize() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages2D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
const char imageData[16]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add(ImageData2D{PixelFormat::RGBA8Unorm, {4, 0}, DataFlags{}, imageData});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): can't add image with a zero size: Vector(4, 0)\n");
}
void AbstractSceneConverterTest::addImage2DNullptr() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages2D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add(ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, {nullptr, 4}});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): can't add image with a nullptr view\n");
}
void AbstractSceneConverterTest::addImage2DNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages2D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
const char imageData[4]{};
std::ostringstream out;
Error redirectError{&out};
converter.add(ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, imageData});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): 2D image conversion advertised but not implemented\n");
}
void AbstractSceneConverterTest::addImage3D() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages3D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt id, const ImageData3D& image, Containers::StringView name) override {
/* Camera count should not be increased before the function
returns */
CORRADE_COMPARE(id, image3DCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(image.importerState(), reinterpret_cast<const void*>(0xdeadbeef));
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image3DCount(), 0);
CORRADE_COMPARE(converter.add(ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, {}, imageData, ImageFlags3D{}, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image3DCount(), 1);
CORRADE_COMPARE(converter.add(ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, {}, imageData, ImageFlags3D{}, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 1);
CORRADE_COMPARE(converter.image3DCount(), 2);
}
void AbstractSceneConverterTest::addImage3DView() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages3D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const ImageData3D& image, Containers::StringView name) override {
CORRADE_COMPARE(name, "hello");
CORRADE_VERIFY(!image.isCompressed());
CORRADE_COMPARE(image.storage().alignment(), 2);
CORRADE_COMPARE(image.format(), PixelFormat::RG8Snorm);
CORRADE_COMPARE(image.size(), (Vector3i{1, 3, 1}));
Trade: properly propagate image view flags in AbstractSceneConverter. This happened because I made an early implementation of the batch AbstractSceneConverter APIs, stashed it away, then implemented image flags and then continued working on the stash, unaware that it's outdated.
4 years ago
CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(image.data());
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[6]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image3DCount(), 0);
CORRADE_COMPARE(converter.add(ImageView3D{
PixelStorage{}.setAlignment(2),
Trade: properly propagate image view flags in AbstractSceneConverter. This happened because I made an early implementation of the batch AbstractSceneConverter APIs, stashed it away, then implemented image flags and then continued working on the stash, unaware that it's outdated.
4 years ago
PixelFormat::RG8Snorm, {1, 3, 1}, imageData, ImageFlag3D::Array},
"hello"), 0);
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image3DCount(), 1);
}
void AbstractSceneConverterTest::addImage3DCompressedView() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddCompressedImages3D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const ImageData3D& image, Containers::StringView name) override {
CORRADE_COMPARE(name, "hello");
CORRADE_VERIFY(image.isCompressed());
CORRADE_COMPARE(image.compressedStorage().compressedBlockSize(), Vector3i{3});
CORRADE_COMPARE(image.compressedFormat(), CompressedPixelFormat::Astc3x3x3RGBASrgb);
CORRADE_COMPARE(image.size(), (Vector3i{1, 3, 1}));
Trade: properly propagate image view flags in AbstractSceneConverter. This happened because I made an early implementation of the batch AbstractSceneConverter APIs, stashed it away, then implemented image flags and then continued working on the stash, unaware that it's outdated.
4 years ago
CORRADE_COMPARE(image.flags(), ImageFlag3D::Array);
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(image.data());
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[4*4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image3DCount(), 0);
CORRADE_COMPARE(converter.add(CompressedImageView3D{
CompressedPixelStorage{}.setCompressedBlockSize({3, 3, 3}),
Trade: properly propagate image view flags in AbstractSceneConverter. This happened because I made an early implementation of the batch AbstractSceneConverter APIs, stashed it away, then implemented image flags and then continued working on the stash, unaware that it's outdated.
4 years ago
CompressedPixelFormat::Astc3x3x3RGBASrgb, {1, 3, 1}, imageData,
ImageFlag3D::Array}, "hello"), 0);
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image3DCount(), 1);
}
void AbstractSceneConverterTest::addImage3DFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages3D|
SceneConverterFeature::AddCompressedImages3D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
bool doAdd(UnsignedInt, const ImageData3D&, Containers::StringView) override {
return false;
}
} converter;
const char imageData[4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image3DCount(), 0);
/* The implementation is expected to print an error message on its own */
{
std::ostringstream out;
Error redirectError{&out};
/* Testing all three variants to "fake" coverage for the name-less
overloads as well */
CORRADE_VERIFY(!converter.add(ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, DataFlags{}, imageData}));
CORRADE_VERIFY(!converter.add(ImageView3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, imageData}));
CORRADE_VERIFY(!converter.add(CompressedImageView3D{CompressedPixelFormat::Astc4x4RGBAUnorm, {1, 1, 1}, imageData}));
CORRADE_COMPARE(out.str(), "");
}
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.image3DCount(), 0);
}
void AbstractSceneConverterTest::addImage3DInvalidImage() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages3D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add(ImageData3D{PixelFormat::RGBA8Unorm, {}, nullptr});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): can't add image with a zero size: Vector(0, 0, 0)\n");
}
void AbstractSceneConverterTest::addImage3DNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages3D;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
const char imageData[4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add(ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, DataFlags{}, imageData});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): 3D image conversion advertised but not implemented\n");
}
void AbstractSceneConverterTest::addImageLevels1D() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages1D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt id, const Containers::Iterable<const ImageData1D>& imageLevels, Containers::StringView name) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
/* Camera count should not be increased before the function
returns */
CORRADE_COMPARE(id, image1DCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(imageLevels.size(), 3);
CORRADE_COMPARE(imageLevels[1].importerState(), reinterpret_cast<const void*>(0xdeadbeef));
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[4*4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image1DCount(), 0);
CORRADE_COMPARE(converter.add({
/* Arbitrary dimensions should be fine */
ImageData1D{PixelFormat::RGBA8Unorm, 4, DataFlags{}, imageData},
ImageData1D{PixelFormat::RGBA8Unorm, 2, DataFlags{}, imageData, ImageFlags1D{}, reinterpret_cast<const void*>(0xdeadbeef)},
ImageData1D{PixelFormat::RGBA8Unorm, 3, DataFlags{}, imageData}
}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image1DCount(), 1);
CORRADE_COMPARE(converter.add({
ImageData1D{PixelFormat::RGBA8Unorm, 2, DataFlags{}, imageData},
ImageData1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, imageData, ImageFlags1D{}, reinterpret_cast<const void*>(0xdeadbeef)},
ImageData1D{PixelFormat::RGBA8Unorm, 4, DataFlags{}, imageData}
}, "hello"), 1);
CORRADE_COMPARE(converter.image1DCount(), 2);
}
void AbstractSceneConverterTest::addImageLevels1DView() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages1D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData1D>& imageLevels, Containers::StringView name) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(imageLevels.size(), 2);
CORRADE_VERIFY(!imageLevels[1].isCompressed());
CORRADE_COMPARE(imageLevels[1].storage().alignment(), 2);
CORRADE_COMPARE(imageLevels[1].format(), PixelFormat::RG8Snorm);
CORRADE_COMPARE(imageLevels[1].size(), 3);
Trade: properly propagate image view flags in AbstractSceneConverter. This happened because I made an early implementation of the batch AbstractSceneConverter APIs, stashed it away, then implemented image flags and then continued working on the stash, unaware that it's outdated.
4 years ago
CORRADE_COMPARE(imageLevels[1].flags(), ImageFlags1D{});
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(imageLevels[1].data());
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[6]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image1DCount(), 0);
CORRADE_COMPARE(converter.add({
ImageView1D{PixelFormat::RG8Snorm, 1, imageData},
ImageView1D{PixelStorage{}.setAlignment(2), PixelFormat::RG8Snorm, 3, imageData}
}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image1DCount(), 1);
}
void AbstractSceneConverterTest::addImageLevels1DCompressedView() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddCompressedImages1D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData1D>& imageLevels, Containers::StringView name) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(imageLevels.size(), 2);
CORRADE_VERIFY(imageLevels[1].isCompressed());
CORRADE_COMPARE(imageLevels[1].compressedStorage().compressedBlockSize(), Vector3i{3});
CORRADE_COMPARE(imageLevels[1].compressedFormat(), CompressedPixelFormat::Astc3x3x3RGBASrgb);
CORRADE_COMPARE(imageLevels[1].size(), 3);
Trade: properly propagate image view flags in AbstractSceneConverter. This happened because I made an early implementation of the batch AbstractSceneConverter APIs, stashed it away, then implemented image flags and then continued working on the stash, unaware that it's outdated.
4 years ago
CORRADE_COMPARE(imageLevels[1].flags(), ImageFlags1D{});
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(imageLevels[1].data());
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[6]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image1DCount(), 0);
CORRADE_COMPARE(converter.add({
CompressedImageView1D{CompressedPixelFormat::Astc3x3x3RGBASrgb, 1, imageData},
CompressedImageView1D{CompressedPixelStorage{}.setCompressedBlockSize({3, 3, 3}), CompressedPixelFormat::Astc3x3x3RGBASrgb, 3, imageData}
}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image1DCount(), 1);
}
void AbstractSceneConverterTest::addImageLevels1DFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages1D|
SceneConverterFeature::AddCompressedImages1D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData1D>&, Containers::StringView) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
return false;
}
} converter;
const char imageData[4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image1DCount(), 0);
/* The implementation is expected to print an error message on its own */
{
std::ostringstream out;
Error redirectError{&out};
/* Testing all three variants to "fake" coverage for the name-less
overloads as well */
CORRADE_VERIFY(!converter.add({
ImageData1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, imageData},
ImageData1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, imageData}
}));
CORRADE_VERIFY(!converter.add({
ImageView1D{PixelFormat::RGBA8Unorm, 1, imageData},
ImageView1D{PixelFormat::RGBA8Unorm, 1, imageData},
}));
CORRADE_VERIFY(!converter.add({
CompressedImageView1D{CompressedPixelFormat::Astc4x4RGBAUnorm, 1, imageData},
CompressedImageView1D{CompressedPixelFormat::Astc4x4RGBAUnorm, 1, imageData},
}));
CORRADE_COMPARE(out.str(), "");
}
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.image1DCount(), 0);
}
void AbstractSceneConverterTest::addImageLevels1DInvalidImage() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages1D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add(std::initializer_list<Containers::AnyReference<const ImageData1D>>{});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): at least one image level has to be specified\n");
}
void AbstractSceneConverterTest::addImageLevels1DNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages1D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
const char imageData[4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add({
ImageData1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, imageData},
ImageData1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, imageData}
});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): multi-level 1D image conversion advertised but not implemented\n");
}
void AbstractSceneConverterTest::addImageLevels2D() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt id, const Containers::Iterable<const ImageData2D>& imageLevels, Containers::StringView name) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
/* Camera count should not be increased before the function
returns */
CORRADE_COMPARE(id, image2DCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(imageLevels.size(), 3);
CORRADE_COMPARE(imageLevels[1].importerState(), reinterpret_cast<const void*>(0xdeadbeef));
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[4*4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image2DCount(), 0);
CORRADE_COMPARE(converter.add({
/* Arbitrary dimensions should be fine */
ImageData2D{PixelFormat::RGBA8Unorm, {4, 1}, DataFlags{}, imageData},
ImageData2D{PixelFormat::RGBA8Unorm, {2, 2}, DataFlags{}, imageData, ImageFlags2D{}, reinterpret_cast<const void*>(0xdeadbeef)},
ImageData2D{PixelFormat::RGBA8Unorm, {1, 3}, DataFlags{}, imageData}
}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image2DCount(), 1);
CORRADE_COMPARE(converter.add({
ImageData2D{PixelFormat::RGBA8Unorm, {2, 2}, DataFlags{}, imageData},
ImageData2D{PixelFormat::RGBA8Unorm, {1, 3}, DataFlags{}, imageData, ImageFlags2D{}, reinterpret_cast<const void*>(0xdeadbeef)},
ImageData2D{PixelFormat::RGBA8Unorm, {4, 1}, DataFlags{}, imageData}
}, "hello"), 1);
CORRADE_COMPARE(converter.image2DCount(), 2);
}
void AbstractSceneConverterTest::addImageLevels2DView() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData2D>& imageLevels, Containers::StringView name) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(imageLevels.size(), 2);
CORRADE_VERIFY(!imageLevels[1].isCompressed());
CORRADE_COMPARE(imageLevels[1].storage().alignment(), 2);
CORRADE_COMPARE(imageLevels[1].format(), PixelFormat::RG8Snorm);
CORRADE_COMPARE(imageLevels[1].size(), (Vector2i{1, 3}));
Trade: properly propagate image view flags in AbstractSceneConverter. This happened because I made an early implementation of the batch AbstractSceneConverter APIs, stashed it away, then implemented image flags and then continued working on the stash, unaware that it's outdated.
4 years ago
CORRADE_COMPARE(imageLevels[1].flags(), ImageFlag2D::Array);
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(imageLevels[1].data());
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[6]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image2DCount(), 0);
CORRADE_COMPARE(converter.add({
Trade: properly propagate image view flags in AbstractSceneConverter. This happened because I made an early implementation of the batch AbstractSceneConverter APIs, stashed it away, then implemented image flags and then continued working on the stash, unaware that it's outdated.
4 years ago
ImageView2D{PixelFormat::RG8Snorm, {1, 1}, imageData, ImageFlag2D::Array},
ImageView2D{PixelStorage{}.setAlignment(2), PixelFormat::RG8Snorm, {1, 3}, imageData, ImageFlag2D::Array}
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image2DCount(), 1);
}
void AbstractSceneConverterTest::addImageLevels2DCompressedView() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddCompressedImages2D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData2D>& imageLevels, Containers::StringView name) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(imageLevels.size(), 2);
CORRADE_VERIFY(imageLevels[1].isCompressed());
CORRADE_COMPARE(imageLevels[1].compressedStorage().compressedBlockSize(), Vector3i{3});
CORRADE_COMPARE(imageLevels[1].compressedFormat(), CompressedPixelFormat::Astc3x3x3RGBASrgb);
CORRADE_COMPARE(imageLevels[1].size(), (Vector2i{3, 1}));
Trade: properly propagate image view flags in AbstractSceneConverter. This happened because I made an early implementation of the batch AbstractSceneConverter APIs, stashed it away, then implemented image flags and then continued working on the stash, unaware that it's outdated.
4 years ago
CORRADE_COMPARE(imageLevels[1].flags(), ImageFlag2D::Array);
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(imageLevels[1].data());
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[6]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image2DCount(), 0);
CORRADE_COMPARE(converter.add({
Trade: properly propagate image view flags in AbstractSceneConverter. This happened because I made an early implementation of the batch AbstractSceneConverter APIs, stashed it away, then implemented image flags and then continued working on the stash, unaware that it's outdated.
4 years ago
CompressedImageView2D{CompressedPixelFormat::Astc3x3x3RGBASrgb, {1, 1}, imageData, ImageFlag2D::Array},
CompressedImageView2D{CompressedPixelStorage{}.setCompressedBlockSize({3, 3, 3}), CompressedPixelFormat::Astc3x3x3RGBASrgb, {3, 1}, imageData, ImageFlag2D::Array}
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image2DCount(), 1);
}
void AbstractSceneConverterTest::addImageLevels2DFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::AddCompressedImages2D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData2D>&, Containers::StringView) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
return false;
}
} converter;
const char imageData[4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image2DCount(), 0);
/* The implementation is expected to print an error message on its own */
{
std::ostringstream out;
Error redirectError{&out};
/* Testing all three variants to "fake" coverage for the name-less
overloads as well */
CORRADE_VERIFY(!converter.add({
ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, imageData},
ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, imageData}
}));
CORRADE_VERIFY(!converter.add({
ImageView2D{PixelFormat::RGBA8Unorm, {1, 1}, imageData},
ImageView2D{PixelFormat::RGBA8Unorm, {1, 1}, imageData}
}));
CORRADE_VERIFY(!converter.add({
CompressedImageView2D{CompressedPixelFormat::Astc4x4RGBAUnorm, {1, 1}, imageData},
CompressedImageView2D{CompressedPixelFormat::Astc4x4RGBAUnorm, {1, 1}, imageData}
}));
CORRADE_COMPARE(out.str(), "");
}
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.image2DCount(), 0);
}
void AbstractSceneConverterTest::addImageLevels2DNoLevels() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add(std::initializer_list<Containers::AnyReference<const ImageData2D>>{});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): at least one image level has to be specified\n");
}
void AbstractSceneConverterTest::addImageLevels2DZeroSize() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
const char imageData[4*4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add({
ImageData2D{PixelFormat::RGBA8Unorm, {2, 2}, DataFlags{}, imageData},
ImageData2D{PixelFormat::RGBA8Unorm, {4, 0}, DataFlags{}, imageData}
});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): can't add image level 1 with a zero size: Vector(4, 0)\n");
}
void AbstractSceneConverterTest::addImageLevels2DNullptr() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
const char imageData[4*4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add({
ImageData2D{PixelFormat::RGBA8Unorm, {2, 2}, DataFlags{}, imageData},
ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, {nullptr, 4}}
});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): can't add image level 1 with a nullptr view\n");
}
void AbstractSceneConverterTest::addImageLevels2DInconsistentCompressed() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
const char imageData[4*4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
ImageData2D a{PixelFormat::RGBA8Unorm, {2, 2}, DataFlags{}, imageData};
ImageData2D b{CompressedPixelFormat::Astc10x10RGBAF, {1, 1}, DataFlags{}, imageData};
std::ostringstream out;
Error redirectError{&out};
converter.add({a, b});
converter.add({b, b, a});
CORRADE_COMPARE(out.str(),
"Trade::AbstractSceneConverter::add(): image level 1 is compressed but previous aren't\n"
"Trade::AbstractSceneConverter::add(): image level 2 is not compressed but previous are\n");
}
void AbstractSceneConverterTest::addImageLevels2DInconsistentFormat() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
const char imageData[4*4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add({
ImageData2D{PixelFormat::RGBA8Unorm, {2, 2}, DataFlags{}, imageData},
ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, imageData},
ImageData2D{PixelFormat::RGBA8Srgb, {4, 1}, DataFlags{}, imageData}
});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): image levels don't have the same format, expected PixelFormat::RGBA8Unorm but got PixelFormat::RGBA8Srgb for level 2\n");
}
void AbstractSceneConverterTest::addImageLevels2DInconsistentFormatExtra() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
const char imageData[4*4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add({
ImageData2D{PixelStorage{}, 252, 1037, 4, {2, 2}, DataFlags{}, imageData},
ImageData2D{PixelStorage{}, 252, 1037, 4, {1, 1}, DataFlags{}, imageData},
ImageData2D{PixelStorage{}, 252, 4467, 4, {4, 1}, DataFlags{}, imageData}
});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): image levels don't have the same extra format field, expected 1037 but got 4467 for level 2\n");
}
void AbstractSceneConverterTest::addImageLevels2DInconsistentCompressedFormat() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
const char imageData[4*4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add({
ImageData2D{CompressedPixelFormat::Bc1RGBAUnorm, {2, 2}, DataFlags{}, imageData},
ImageData2D{CompressedPixelFormat::Bc1RGBAUnorm, {1, 1}, DataFlags{}, imageData},
ImageData2D{CompressedPixelFormat::Bc1RGBASrgb, {4, 1}, DataFlags{}, imageData}
});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): image levels don't have the same format, expected CompressedPixelFormat::Bc1RGBAUnorm but got CompressedPixelFormat::Bc1RGBASrgb for level 2\n");
}
void AbstractSceneConverterTest::addImageLevels2DInconsistentFlags() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
const char imageData[4*4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add({
ImageData2D{PixelFormat::RGBA8Unorm, {2, 2}, DataFlags{}, imageData, ImageFlag2D::Array},
ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, imageData, ImageFlag2D::Array},
ImageData2D{PixelFormat::RGBA8Unorm, {4, 1}, DataFlags{}, imageData}
});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): image levels don't have the same flags, expected ImageFlag2D::Array but got ImageFlags2D{} for level 2\n");
}
void AbstractSceneConverterTest::addImageLevels2DNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
const char imageData[4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add({
ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, imageData},
ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, imageData}
});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): multi-level 2D image conversion advertised but not implemented\n");
}
void AbstractSceneConverterTest::addImageLevels3D() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages3D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt id, const Containers::Iterable<const ImageData3D>& imageLevels, Containers::StringView name) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
/* Camera count should not be increased before the function
returns */
CORRADE_COMPARE(id, image3DCount());
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(imageLevels.size(), 3);
CORRADE_COMPARE(imageLevels[1].importerState(), reinterpret_cast<const void*>(0xdeadbeef));
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[4*4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image3DCount(), 0);
CORRADE_COMPARE(converter.add({
/* Arbitrary dimensions should be fine */
ImageData3D{PixelFormat::RGBA8Unorm, {4, 1, 1}, DataFlags{}, imageData},
ImageData3D{PixelFormat::RGBA8Unorm, {2, 2, 1}, DataFlags{}, imageData, ImageFlags3D{}, reinterpret_cast<const void*>(0xdeadbeef)},
ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 3}, DataFlags{}, imageData}
}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image3DCount(), 1);
CORRADE_COMPARE(converter.add({
ImageData3D{PixelFormat::RGBA8Unorm, {2, 1, 2}, DataFlags{}, imageData},
ImageData3D{PixelFormat::RGBA8Unorm, {1, 3, 1}, DataFlags{}, imageData, ImageFlags3D{}, reinterpret_cast<const void*>(0xdeadbeef)},
ImageData3D{PixelFormat::RGBA8Unorm, {1, 4, 1}, DataFlags{}, imageData}
}, "hello"), 1);
CORRADE_COMPARE(converter.image3DCount(), 2);
}
void AbstractSceneConverterTest::addImageLevels3DView() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages3D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData3D>& imageLevels, Containers::StringView name) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(imageLevels.size(), 2);
CORRADE_VERIFY(!imageLevels[1].isCompressed());
CORRADE_COMPARE(imageLevels[1].storage().alignment(), 2);
CORRADE_COMPARE(imageLevels[1].format(), PixelFormat::RG8Snorm);
CORRADE_COMPARE(imageLevels[1].size(), (Vector3i{1, 3, 1}));
Trade: properly propagate image view flags in AbstractSceneConverter. This happened because I made an early implementation of the batch AbstractSceneConverter APIs, stashed it away, then implemented image flags and then continued working on the stash, unaware that it's outdated.
4 years ago
CORRADE_COMPARE(imageLevels[1].flags(), ImageFlag3D::Array);
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(imageLevels[1].data());
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[6]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image3DCount(), 0);
CORRADE_COMPARE(converter.add({
Trade: properly propagate image view flags in AbstractSceneConverter. This happened because I made an early implementation of the batch AbstractSceneConverter APIs, stashed it away, then implemented image flags and then continued working on the stash, unaware that it's outdated.
4 years ago
ImageView3D{PixelFormat::RG8Snorm, {1, 1, 1}, imageData, ImageFlag3D::Array},
ImageView3D{PixelStorage{}.setAlignment(2), PixelFormat::RG8Snorm, {1, 3, 1}, imageData, ImageFlag3D::Array}
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image3DCount(), 1);
}
void AbstractSceneConverterTest::addImageLevels3DCompressedView() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddCompressedImages3D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData3D>& imageLevels, Containers::StringView name) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(imageLevels.size(), 2);
CORRADE_VERIFY(imageLevels[1].isCompressed());
CORRADE_COMPARE(imageLevels[1].compressedStorage().compressedBlockSize(), Vector3i{3});
CORRADE_COMPARE(imageLevels[1].compressedFormat(), CompressedPixelFormat::Astc3x3x3RGBASrgb);
CORRADE_COMPARE(imageLevels[1].size(), (Vector3i{3, 1, 1}));
Trade: properly propagate image view flags in AbstractSceneConverter. This happened because I made an early implementation of the batch AbstractSceneConverter APIs, stashed it away, then implemented image flags and then continued working on the stash, unaware that it's outdated.
4 years ago
CORRADE_COMPARE(imageLevels[1].flags(), ImageFlag3D::Array);
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_VERIFY(imageLevels[1].data());
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[6]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image3DCount(), 0);
CORRADE_COMPARE(converter.add({
Trade: properly propagate image view flags in AbstractSceneConverter. This happened because I made an early implementation of the batch AbstractSceneConverter APIs, stashed it away, then implemented image flags and then continued working on the stash, unaware that it's outdated.
4 years ago
CompressedImageView3D{CompressedPixelFormat::Astc3x3x3RGBASrgb, {1, 1, 1}, imageData, ImageFlag3D::Array},
CompressedImageView3D{CompressedPixelStorage{}.setCompressedBlockSize({3, 3, 3}), CompressedPixelFormat::Astc3x3x3RGBASrgb, {3, 1, 1}, imageData, ImageFlag3D::Array}
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image3DCount(), 1);
}
void AbstractSceneConverterTest::addImageLevels3DFailed() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages3D|
SceneConverterFeature::AddCompressedImages3D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData3D>&, Containers::StringView) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
return false;
}
} converter;
const char imageData[4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.image3DCount(), 0);
/* The implementation is expected to print an error message on its own */
{
std::ostringstream out;
Error redirectError{&out};
/* Testing all three variants to "fake" coverage for the name-less
overloads as well */
CORRADE_VERIFY(!converter.add({
ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, DataFlags{}, imageData},
ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, DataFlags{}, imageData}
}));
CORRADE_VERIFY(!converter.add({
ImageView3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, imageData},
ImageView3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, imageData}
}));
CORRADE_VERIFY(!converter.add({
CompressedImageView3D{CompressedPixelFormat::Astc4x4RGBAUnorm, {1, 1, 1}, imageData},
CompressedImageView3D{CompressedPixelFormat::Astc4x4RGBAUnorm, {1, 1, 1}, imageData}
}));
CORRADE_COMPARE(out.str(), "");
}
/* It shouldn't abort the whole process */
CORRADE_VERIFY(converter.isConverting());
CORRADE_COMPARE(converter.image3DCount(), 0);
}
void AbstractSceneConverterTest::addImageLevels3DInvalidImage() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages3D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add(std::initializer_list<Containers::AnyReference<const ImageData3D>>{});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): at least one image level has to be specified\n");
}
void AbstractSceneConverterTest::addImageLevels3DNotImplemented() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages3D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
} converter;
const char imageData[4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
std::ostringstream out;
Error redirectError{&out};
converter.add({
ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, DataFlags{}, imageData},
ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, DataFlags{}, imageData}
});
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::add(): multi-level 3D image conversion advertised but not implemented\n");
}
void AbstractSceneConverterTest::addImage1DThroughLevels() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages1D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData1D>& imageLevels, Containers::StringView name) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(imageLevels.size(), 1);
CORRADE_COMPARE(imageLevels[0].importerState(), reinterpret_cast<const void*>(0xdeadbeef));
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.add(ImageData1D{PixelFormat::RGBA8Unorm, 1, {}, imageData, ImageFlags1D{}, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image1DCount(), 1);
}
void AbstractSceneConverterTest::addImage2DThroughLevels() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData2D>& imageLevels, Containers::StringView name) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(imageLevels.size(), 1);
CORRADE_COMPARE(imageLevels[0].importerState(), reinterpret_cast<const void*>(0xdeadbeef));
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.add(ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, {}, imageData, ImageFlags2D{}, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image2DCount(), 1);
}
void AbstractSceneConverterTest::addImage3DThroughLevels() {
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultiple|
SceneConverterFeature::AddImages3D|
SceneConverterFeature::ImageLevels;
}
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
bool doBegin() override { return true; }
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData3D>& imageLevels, Containers::StringView name) override {
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(name, "hello");
CORRADE_COMPARE(imageLevels.size(), 1);
CORRADE_COMPARE(imageLevels[0].importerState(), reinterpret_cast<const void*>(0xdeadbeef));
addCalled = true;
return true;
}
bool addCalled = false;
} converter;
const char imageData[4]{};
Trade: AbstractSceneConverter::begin*() should have a way to fail. Initially I thought there was no reason for this to fail, but then realized AnySceneConverter would need it. And also any other plugin relying on something external that might fail during initialization -- there's no other moment after plugin instantiation where it could signalize a failure, and deferring that to the first add() call, whichever would it be, is really not a sane idea.
4 years ago
CORRADE_VERIFY(converter.begin());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
CORRADE_COMPARE(converter.add(ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, {}, imageData, ImageFlags3D{}, reinterpret_cast<const void*>(0xdeadbeef)}, "hello"), 0);
CORRADE_VERIFY(converter.addCalled);
CORRADE_COMPARE(converter.image3DCount(), 1);
}
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
void AbstractSceneConverterTest::addImporterContents() {
auto&& data = AddImporterContentsData[testCaseInstanceId()];
setTestCaseDescription(data.name);
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
struct Importer: AbstractImporter {
explicit Importer(SceneContents contents): contents{contents} {}
ImporterFeatures doFeatures() const override { return {}; }
bool doIsOpened() const override { return true; }
void doClose() override {}
UnsignedLong doObjectCount() const override {
/* Counts are queried unconditionally in an assert, so can't
really check anything here. Returning 0 would be
counterproductive, the addImporterContentsImportFail() case
tests that the right *Count() gets called. */
return 3;
}
Containers::String doObjectName(UnsignedLong id) override {
CORRADE_VERIFY(contents & SceneContent::Names);
return Utility::format("Object {}", id);
}
UnsignedInt doSceneCount() const override {
/* Counts are queried unconditionally in an assert, so can't
really check anything here. Returning 0 would be
counterproductive, the addImporterContentsImportFail() case
tests that the right *Count() gets called. */
return 2;
}
Int doDefaultScene() const override {
CORRADE_VERIFY(contents & SceneContent::Scenes);
return 1;
}
Containers::String doSceneName(UnsignedInt id) override {
CORRADE_VERIFY(contents & SceneContent::Names);
return Utility::format("Scene {}", id);
}
Containers::Optional<SceneData> doScene(UnsignedInt id) override {
return SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {}, reinterpret_cast<const void*>(0x5ce00000 + id)};
}
UnsignedInt doAnimationCount() const override {
/* Counts are queried unconditionally in an assert, so can't
really check anything here. Returning 0 would be
counterproductive, the addImporterContentsImportFail() case
tests that the right *Count() gets called. */
return 2;
}
Containers::String doAnimationName(UnsignedInt id) override {
CORRADE_VERIFY(contents & SceneContent::Names);
return Utility::format("Animation {}", id);
}
Containers::Optional<AnimationData> doAnimation(UnsignedInt id) override {
return AnimationData{nullptr, {}, reinterpret_cast<const void*>(0x40100000 + id)};
}
UnsignedInt doLightCount() const override {
/* Counts are queried unconditionally in an assert, so can't
really check anything here. Returning 0 would be
counterproductive, the addImporterContentsImportFail() case
tests that the right *Count() gets called. */
return 2;
}
Containers::String doLightName(UnsignedInt id) override {
CORRADE_VERIFY(contents & SceneContent::Names);
return Utility::format("Light {}", id);
}
Containers::Optional<LightData> doLight(UnsignedInt id) override {
Trade: deprecate LightData::Type in favor of LightType. Enums in classes are bad, can't forward-declare them.
3 years ago
return LightData{LightType::Point, {}, {}, reinterpret_cast<const void*>(0x11600000 + id)};
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
}
UnsignedInt doCameraCount() const override {
/* Counts are queried unconditionally in an assert, so can't
really check anything here. Returning 0 would be
counterproductive, the addImporterContentsImportFail() case
tests that the right *Count() gets called. */
return 2;
}
Containers::String doCameraName(UnsignedInt id) override {
CORRADE_VERIFY(contents & SceneContent::Names);
return Utility::format("Camera {}", id);
}
Containers::Optional<CameraData> doCamera(UnsignedInt id) override {
return CameraData{CameraType::Orthographic2D, {}, 0.0f, 0.0f, reinterpret_cast<const void*>(0xca0e0000 + id)};
}
UnsignedInt doSkin2DCount() const override {
/* Counts are queried unconditionally in an assert, so can't
really check anything here. Returning 0 would be
counterproductive, the addImporterContentsImportFail() case
tests that the right *Count() gets called. */
return 2;
}
Containers::String doSkin2DName(UnsignedInt id) override {
CORRADE_VERIFY(contents & SceneContent::Names);
return Utility::format("2D skin {}", id);
}
Containers::Optional<SkinData2D> doSkin2D(UnsignedInt id) override {
return SkinData2D{{}, {}, reinterpret_cast<const void*>(0x50102d00 + id)};
}
UnsignedInt doSkin3DCount() const override {
/* Counts are queried unconditionally in an assert, so can't
really check anything here. Returning 0 would be
counterproductive, the addImporterContentsImportFail() case
tests that the right *Count() gets called. */
return 2;
}
Containers::String doSkin3DName(UnsignedInt id) override {
CORRADE_VERIFY(contents & SceneContent::Names);
return Utility::format("3D skin {}", id);
}
Containers::Optional<SkinData3D> doSkin3D(UnsignedInt id) override {
return SkinData3D{{}, {}, reinterpret_cast<const void*>(0x50103d00 + id)};
}
UnsignedInt doMeshCount() const override {
/* Counts are queried unconditionally in an assert, so can't
really check anything here. Returning 0 would be
counterproductive, the addImporterContentsImportFail() case
tests that the right *Count() gets called. */
return 2;
}
UnsignedInt doMeshLevelCount(UnsignedInt id) override {
CORRADE_VERIFY(contents & SceneContent::MeshLevels);
return id == 1 ? 3 : 1;
}
Containers::String doMeshName(UnsignedInt id) override {
CORRADE_VERIFY(contents & SceneContent::Names);
return Utility::format("Mesh {}", id);
}
Containers::Optional<MeshData> doMesh(UnsignedInt id, UnsignedInt level) override {
return MeshData{{}, 0, reinterpret_cast<const void*>(0x0e500000 + id + level*16)};
}
UnsignedInt doMaterialCount() const override {
/* Counts are queried unconditionally in an assert, so can't
really check anything here. Returning 0 would be
counterproductive, the addImporterContentsImportFail() case
tests that the right *Count() gets called. */
return 2;
}
Containers::String doMaterialName(UnsignedInt id) override {
CORRADE_VERIFY(contents & SceneContent::Names);
return Utility::format("Material {}", id);
}
Containers::Optional<MaterialData> doMaterial(UnsignedInt id) override {
return MaterialData{{}, {}, reinterpret_cast<const void*>(0x0a7e0000 + id)};
}
UnsignedInt doTextureCount() const override {
/* Counts are queried unconditionally in an assert, so can't
really check anything here. Returning 0 would be
counterproductive, the addImporterContentsImportFail() case
tests that the right *Count() gets called. */
return 2;
}
Containers::String doTextureName(UnsignedInt id) override {
CORRADE_VERIFY(contents & SceneContent::Names);
return Utility::format("Texture {}", id);
}
Containers::Optional<TextureData> doTexture(UnsignedInt id) override {
return TextureData{TextureType::Texture1D, SamplerFilter::Nearest, SamplerFilter::Nearest, SamplerMipmap::Nearest, SamplerWrapping::ClampToEdge, 0, reinterpret_cast<const void*>(0x7e070000 + id)};
}
UnsignedInt doImage1DCount() const override {
/* Counts are queried unconditionally in an assert, so can't
really check anything here. Returning 0 would be
counterproductive, the addImporterContentsImportFail() case
tests that the right *Count() gets called. */
return 2;
}
UnsignedInt doImage1DLevelCount(UnsignedInt id) override {
CORRADE_VERIFY(contents & SceneContent::ImageLevels);
return id == 1 ? 4 : 1;
}
Containers::String doImage1DName(UnsignedInt id) override {
CORRADE_VERIFY(contents & SceneContent::Names);
return Utility::format("1D image {}", id);
}
Containers::Optional<ImageData1D> doImage1D(UnsignedInt id, UnsignedInt level) override {
return ImageData1D{PixelFormat::RGBA8Unorm, 1, {}, "yes", {}, reinterpret_cast<const void*>(0x10a91d00 + id + level*16)};
}
UnsignedInt doImage2DCount() const override {
/* Counts are queried unconditionally in an assert, so can't
really check anything here. Returning 0 would be
counterproductive, the addImporterContentsImportFail() case
tests that the right *Count() gets called. */
return 2;
}
UnsignedInt doImage2DLevelCount(UnsignedInt id) override {
CORRADE_VERIFY(contents & SceneContent::ImageLevels);
return id == 0 ? 3 : 1;
}
Containers::String doImage2DName(UnsignedInt id) override {
CORRADE_VERIFY(contents & SceneContent::Names);
return Utility::format("2D image {}", id);
}
Containers::Optional<ImageData2D> doImage2D(UnsignedInt id, UnsignedInt level) override {
return ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, {}, "yes", {}, reinterpret_cast<const void*>(0x10a92d00 + id + level*16)};
}
UnsignedInt doImage3DCount() const override {
/* Counts are queried unconditionally in an assert, so can't
really check anything here. Returning 0 would be
counterproductive, the addImporterContentsImportFail() case
tests that the right *Count() gets called. */
return 2;
}
UnsignedInt doImage3DLevelCount(UnsignedInt id) override {
CORRADE_VERIFY(contents & SceneContent::ImageLevels);
return id == 1 ? 2 : 1;
}
Containers::String doImage3DName(UnsignedInt id) override {
CORRADE_VERIFY(contents & SceneContent::Names);
return Utility::format("3D image {}", id);
}
Containers::Optional<ImageData3D> doImage3D(UnsignedInt id, UnsignedInt level) override {
return ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, {}, "yes", {}, reinterpret_cast<const void*>(0x10a93d00 + id + level*16)};
}
SceneContents contents;
} importer{data.contents};
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return
SceneConverterFeature::ConvertMultipleToData|
SceneConverterFeature::AddScenes|
SceneConverterFeature::AddAnimations|
SceneConverterFeature::AddLights|
SceneConverterFeature::AddCameras|
SceneConverterFeature::AddSkins2D|
SceneConverterFeature::AddSkins3D|
SceneConverterFeature::AddMeshes|
SceneConverterFeature::AddMaterials|
SceneConverterFeature::AddTextures|
SceneConverterFeature::AddImages1D|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::AddImages3D|
SceneConverterFeature::MeshLevels|
SceneConverterFeature::ImageLevels;
}
bool doBeginData() override { return true; }
void doSetObjectName(UnsignedLong id, Containers::StringView name) override {
Debug{} << "Setting object" << id << "name to" << name;
}
bool doAdd(UnsignedInt id, const SceneData& data, Containers::StringView name) override {
Debug{} << "Adding scene" << id << "named" << name << "with" << data.importerState();
return true;
}
void doSetDefaultScene(UnsignedInt id) override {
Debug{} << "Setting default scene to" << id;
}
bool doAdd(UnsignedInt id, const AnimationData& data, Containers::StringView name) override {
Debug{} << "Adding animation" << id << "named" << name << "with" << data.importerState();
return true;
}
bool doAdd(UnsignedInt id, const LightData& data, Containers::StringView name) override {
Debug{} << "Adding light" << id << "named" << name << "with" << data.importerState();
return true;
}
bool doAdd(UnsignedInt id, const CameraData& data, Containers::StringView name) override {
Debug{} << "Adding camera" << id << "named" << name << "with" << data.importerState();
return true;
}
bool doAdd(UnsignedInt id, const SkinData2D& data, Containers::StringView name) override {
Debug{} << "Adding 2D skin" << id << "named" << name << "with" << data.importerState();
return true;
}
bool doAdd(UnsignedInt id, const SkinData3D& data, Containers::StringView name) override {
Debug{} << "Adding 3D skin" << id << "named" << name << "with" << data.importerState();
return true;
}
bool doAdd(UnsignedInt id, const MeshData& data, Containers::StringView name) override {
Debug{} << "Adding mesh" << id << "named" << name << "with" << data.importerState();
return true;
}
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt id, const Containers::Iterable<const MeshData>& levels, Containers::StringView name) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
for(std::size_t i = 0; i != levels.size(); ++i)
Debug{} << "Adding mesh" << id << "level" << i << "named" << name << "with" << levels[i].importerState();
return true;
}
bool doAdd(UnsignedInt id, const MaterialData& data, Containers::StringView name) override {
Debug{} << "Adding material" << id << "named" << name << "with" << data.importerState();
return true;
}
bool doAdd(UnsignedInt id, const TextureData& data, Containers::StringView name) override {
Debug{} << "Adding texture" << id << "named" << name << "with" << data.importerState();
return true;
}
bool doAdd(UnsignedInt id, const ImageData1D& data, Containers::StringView name) override {
Debug{} << "Adding 1D image" << id << "named" << name << "with" << data.importerState();
return true;
}
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt id, const Containers::Iterable<const ImageData1D>& levels, Containers::StringView name) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
for(std::size_t i = 0; i != levels.size(); ++i)
Debug{} << "Adding 1D image" << id << "level" << i << "named" << name << "with" << levels[i].importerState();
return true;
}
bool doAdd(UnsignedInt id, const ImageData2D& data, Containers::StringView name) override {
Debug{} << "Adding 2D image" << id << "named" << name << "with" << data.importerState();
return true;
}
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt id, const Containers::Iterable<const ImageData2D>& levels, Containers::StringView name) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
for(std::size_t i = 0; i != levels.size(); ++i)
Debug{} << "Adding 2D image" << id << "level" << i << "named" << name << "with" << levels[i].importerState();
return true;
}
bool doAdd(UnsignedInt id, const ImageData3D& data, Containers::StringView name) override {
Debug{} << "Adding 3D image" << id << "named" << name << "with" << data.importerState();
return true;
}
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt id, const Containers::Iterable<const ImageData3D>& levels, Containers::StringView name) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
for(std::size_t i = 0; i != levels.size(); ++i)
Debug{} << "Adding 3D image" << id << "level" << i << "named" << name << "with" << levels[i].importerState();
return true;
}
} converter;
Trade: add verbose output for SceneConverter::addImporterContents(). Because otherwise it's impossible to know the progress when converting a file with 1700 4K PNG textures.
4 years ago
converter.addFlags(data.flags);
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
CORRADE_VERIFY(converter.beginData());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Audio,ShaderTools,Text,Trade: packed debug printing for all Feature enums.
4 years ago
std::ostringstream out;
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
Debug redirectOutput{&out};
CORRADE_VERIFY(converter.addImporterContents(importer, data.contents));
CORRADE_COMPARE(out.str(), data.expected);
Audio,ShaderTools,Text,Trade: packed debug printing for all Feature enums.
4 years ago
}
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
void AbstractSceneConverterTest::addImporterContentsCustomSceneFields() {
struct: AbstractImporter {
ImporterFeatures doFeatures() const override { return {}; }
bool doIsOpened() const override { return true; }
void doClose() override {}
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
UnsignedInt doSceneCount() const override {
return 3;
}
Containers::Optional<SceneData> doScene(UnsignedInt id) override {
if(id == 1 || id == 2)
return SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {
SceneFieldData{SceneField::Translation, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Vector3, nullptr},
SceneFieldData{sceneFieldCustom(34977), SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Vector2b, nullptr},
SceneFieldData{SceneField::Scaling, SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Vector3, nullptr},
SceneFieldData{sceneFieldCustom(5266), SceneMappingType::UnsignedInt, nullptr, SceneFieldType::Pointer, nullptr},
}};
return SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {}};
}
Trade: don't unwrap custom attribute/field names when passing to do*(). Originally I thought I'd save plugins some time if I just give them the custom indices directly, without being wrapped in a SceneField / MeshAttribute enum. But in practice that didn't really save anything, made the interfaces more error-prone due to there being no concrete type anymore, and all code that delegates to nested importers or converters had to re-wrap the IDs again, which is *again* error-prone. Bumping the interface strings because this is a breaking change for the implementations. Not for users tho, there nothing changes.
3 years ago
Containers::String doSceneFieldName(SceneField name) override {
Trade,SceneTools: use lowercase in custom field / attribute name tests. Custom material attributes are enforced to start with a lowercase letter, so I think it makes sense to be consistent and use the same for custom scene fields and mesh attributes as well. It's not enforced in any way but the tests should reflect that choice so new code that gets written based on these inherits that practice.
3 years ago
if(name == sceneFieldCustom(34977)) return "offsetSmall";
if(name == sceneFieldCustom(5266)) return "valueData";
Test: use CORRADE_FAIL() where it makes sense. Of course I used the wrong `CORRADE_FAIL_IF(false, ...)` in a few places. Yet another confirmation it was too hard to use and a dedicated macro is needed.
4 years ago
CORRADE_FAIL("This should not be reached");
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
CORRADE_INTERNAL_ASSERT_UNREACHABLE();
}
} importer;
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return
SceneConverterFeature::ConvertMultipleToData|
SceneConverterFeature::AddScenes;
}
bool doBeginData() override { return true; }
bool doAdd(UnsignedInt, const SceneData&, Containers::StringView) override {
Debug{} << "Adding scene";
return true;
}
Trade: don't unwrap custom attribute/field names when passing to do*(). Originally I thought I'd save plugins some time if I just give them the custom indices directly, without being wrapped in a SceneField / MeshAttribute enum. But in practice that didn't really save anything, made the interfaces more error-prone due to there being no concrete type anymore, and all code that delegates to nested importers or converters had to re-wrap the IDs again, which is *again* error-prone. Bumping the interface strings because this is a breaking change for the implementations. Not for users tho, there nothing changes.
3 years ago
void doSetSceneFieldName(SceneField field, Containers::StringView name) override {
Debug{} << "Setting field" << sceneFieldCustom(field) << "name to" << name;
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
}
} converter;
CORRADE_VERIFY(converter.beginData());
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Audio,ShaderTools,Text,Trade: packed debug printing for all Feature enums.
4 years ago
std::ostringstream out;
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
Debug redirectOutput{&out};
CORRADE_VERIFY(converter.addImporterContents(importer));
/* No error message, the importer is expected to print that on its own */
CORRADE_COMPARE(out.str(),
"Adding scene\n"
/** @todo cache the names to avoid querying repeatedly */
Trade,SceneTools: use lowercase in custom field / attribute name tests. Custom material attributes are enforced to start with a lowercase letter, so I think it makes sense to be consistent and use the same for custom scene fields and mesh attributes as well. It's not enforced in any way but the tests should reflect that choice so new code that gets written based on these inherits that practice.
3 years ago
"Setting field 34977 name to offsetSmall\n"
"Setting field 5266 name to valueData\n"
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding scene\n"
Trade,SceneTools: use lowercase in custom field / attribute name tests. Custom material attributes are enforced to start with a lowercase letter, so I think it makes sense to be consistent and use the same for custom scene fields and mesh attributes as well. It's not enforced in any way but the tests should reflect that choice so new code that gets written based on these inherits that practice.
3 years ago
"Setting field 34977 name to offsetSmall\n"
"Setting field 5266 name to valueData\n"
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding scene\n");
Audio,ShaderTools,Text,Trade: packed debug printing for all Feature enums.
4 years ago
}
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
void AbstractSceneConverterTest::addImporterContentsCustomMeshAttributes() {
struct: AbstractImporter {
ImporterFeatures doFeatures() const override { return {}; }
bool doIsOpened() const override { return true; }
void doClose() override {}
Trade: full scene conversion support in AbstractSceneConverter. Wasn't really possible to split this into multiple commits, so here's the whole thing including delegation from and to the single-mesh APIs. What's not done here and postponed for later is: - an ability to feed the whole importer to it, filtering away data that aren't supported by the converter - corresponding changes in AbstractImageConverter, where it would now primarily accept ImageData to future-proof for arbitrary extra key/value data
4 years ago
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
UnsignedInt doMeshCount() const override {
return 2;
}
UnsignedInt doMeshLevelCount(UnsignedInt) override {
return 5;
}
Containers::Optional<MeshData> doMesh(UnsignedInt id, UnsignedInt level) override {
if(id == 1 && (level == 2 || level == 3))
return MeshData{MeshPrimitive::Triangles, nullptr, {
MeshAttributeData{MeshAttribute::Position, VertexFormat::Vector3, nullptr},
MeshAttributeData{meshAttributeCustom(31977), VertexFormat::Vector2b, nullptr},
MeshAttributeData{MeshAttribute::Normal, VertexFormat::Vector3, nullptr},
MeshAttributeData{meshAttributeCustom(5266), VertexFormat::ByteNormalized, nullptr},
}};
return MeshData{MeshPrimitive::Points, 0};
}
Trade: don't unwrap custom attribute/field names when passing to do*(). Originally I thought I'd save plugins some time if I just give them the custom indices directly, without being wrapped in a SceneField / MeshAttribute enum. But in practice that didn't really save anything, made the interfaces more error-prone due to there being no concrete type anymore, and all code that delegates to nested importers or converters had to re-wrap the IDs again, which is *again* error-prone. Bumping the interface strings because this is a breaking change for the implementations. Not for users tho, there nothing changes.
3 years ago
Containers::String doMeshAttributeName(MeshAttribute name) override {
Trade,SceneTools: use lowercase in custom field / attribute name tests. Custom material attributes are enforced to start with a lowercase letter, so I think it makes sense to be consistent and use the same for custom scene fields and mesh attributes as well. It's not enforced in any way but the tests should reflect that choice so new code that gets written based on these inherits that practice.
3 years ago
if(name == meshAttributeCustom(31977)) return "offsetSmall";
if(name == meshAttributeCustom(5266)) return "valueData";
Test: use CORRADE_FAIL() where it makes sense. Of course I used the wrong `CORRADE_FAIL_IF(false, ...)` in a few places. Yet another confirmation it was too hard to use and a dedicated macro is needed.
4 years ago
CORRADE_FAIL("This should not be reached");
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
CORRADE_INTERNAL_ASSERT_UNREACHABLE();
}
} importer;
ShaderTools,Trade: test printing of Feature flag supersets.
5 years ago
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return
SceneConverterFeature::ConvertMultipleToData|
SceneConverterFeature::AddMeshes|
SceneConverterFeature::MeshLevels;
}
Trade: bootstrap scene converter plugins.
6 years ago
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
bool doBeginData() override { return true; }
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const MeshData>&, Containers::StringView) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
Debug{} << "Adding mesh levels";
return true;
}
Trade: don't unwrap custom attribute/field names when passing to do*(). Originally I thought I'd save plugins some time if I just give them the custom indices directly, without being wrapped in a SceneField / MeshAttribute enum. But in practice that didn't really save anything, made the interfaces more error-prone due to there being no concrete type anymore, and all code that delegates to nested importers or converters had to re-wrap the IDs again, which is *again* error-prone. Bumping the interface strings because this is a breaking change for the implementations. Not for users tho, there nothing changes.
3 years ago
void doSetMeshAttributeName(MeshAttribute attribute, Containers::StringView name) override {
Debug{} << "Setting attribute" << meshAttributeCustom(attribute) << "name to" << name;
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
}
} converter;
CORRADE_VERIFY(converter.beginData());
Trade: bootstrap scene converter plugins.
6 years ago
std::ostringstream out;
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
Debug redirectOutput{&out};
CORRADE_VERIFY(converter.addImporterContents(importer));
/* No error message, the importer is expected to print that on its own */
CORRADE_COMPARE(out.str(),
"Adding mesh levels\n"
/** @todo cache the names to avoid querying repeatedly */
Trade,SceneTools: use lowercase in custom field / attribute name tests. Custom material attributes are enforced to start with a lowercase letter, so I think it makes sense to be consistent and use the same for custom scene fields and mesh attributes as well. It's not enforced in any way but the tests should reflect that choice so new code that gets written based on these inherits that practice.
3 years ago
"Setting attribute 31977 name to offsetSmall\n"
"Setting attribute 5266 name to valueData\n"
"Setting attribute 31977 name to offsetSmall\n"
"Setting attribute 5266 name to valueData\n"
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
"Adding mesh levels\n");
}
Trade: bootstrap scene converter plugins.
6 years ago
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
void AbstractSceneConverterTest::addImporterContentsImportFail() {
auto&& data = AddImporterContentsFailData[testCaseInstanceId()];
setTestCaseDescription(data.name);
struct Importer: AbstractImporter {
explicit Importer(SceneContents contents): contents{contents} {}
ImporterFeatures doFeatures() const override { return {}; }
bool doIsOpened() const override { return true; }
void doClose() override {}
UnsignedInt doSceneCount() const override {
return contents & SceneContent::Scenes ? 4 : 0;
}
Containers::Optional<SceneData> doScene(UnsignedInt id) override {
if(id == 2) return {};
return SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {}};
}
UnsignedInt doAnimationCount() const override {
return contents & SceneContent::Animations ? 4 : 0;
}
Containers::Optional<AnimationData> doAnimation(UnsignedInt id) override {
if(id == 2) return {};
return AnimationData{nullptr, {}};
}
UnsignedInt doLightCount() const override {
return contents & SceneContent::Lights ? 4 : 0;
}
Containers::Optional<LightData> doLight(UnsignedInt id) override {
if(id == 2) return {};
Trade: deprecate LightData::Type in favor of LightType. Enums in classes are bad, can't forward-declare them.
3 years ago
return LightData{LightType::Point, {}, {}};
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
}
UnsignedInt doCameraCount() const override {
return contents & SceneContent::Cameras ? 4 : 0;
}
Containers::Optional<CameraData> doCamera(UnsignedInt id) override {
if(id == 2) return {};
return CameraData{CameraType::Orthographic2D, {}, 0.0f, 0.0f};
}
UnsignedInt doSkin2DCount() const override {
return contents & SceneContent::Skins2D ? 4 : 0;
}
Containers::Optional<SkinData2D> doSkin2D(UnsignedInt id) override {
if(id == 2) return {};
return SkinData2D{{}, {}};
}
UnsignedInt doSkin3DCount() const override {
return contents & SceneContent::Skins3D ? 4 : 0;
}
Containers::Optional<SkinData3D> doSkin3D(UnsignedInt id) override {
if(id == 2) return {};
return SkinData3D{{}, {}};
}
UnsignedInt doMeshCount() const override {
return contents & SceneContent::Meshes ? 4 : 0;
}
UnsignedInt doMeshLevelCount(UnsignedInt) override {
return contents & SceneContent::MeshLevels ? 5 : 1;
}
Containers::Optional<MeshData> doMesh(UnsignedInt id, UnsignedInt level) override {
if(id == 2) {
if(contents & SceneContent::MeshLevels) {
if(level == 3) return {};
} else return {};
}
return MeshData{{}, 0};
}
UnsignedInt doMaterialCount() const override {
return contents & SceneContent::Materials ? 4 : 0;
}
Containers::Optional<MaterialData> doMaterial(UnsignedInt id) override {
if(id == 2) return {};
return MaterialData{{}, {}};
}
UnsignedInt doTextureCount() const override {
return contents & SceneContent::Textures ? 4 : 0;
}
Containers::Optional<TextureData> doTexture(UnsignedInt id) override {
if(id == 2) return {};
return TextureData{TextureType::Texture1D, SamplerFilter::Nearest, SamplerFilter::Nearest, SamplerMipmap::Nearest, SamplerWrapping::ClampToEdge, 0};
}
UnsignedInt doImage1DCount() const override {
return contents & SceneContent::Images1D ? 4 : 0;
}
UnsignedInt doImage1DLevelCount(UnsignedInt) override {
return contents & SceneContent::ImageLevels ? 5 : 1;
}
Containers::Optional<ImageData1D> doImage1D(UnsignedInt id, UnsignedInt level) override {
if(id == 2) {
if(contents & SceneContent::ImageLevels) {
if(level == 3) return {};
} else return {};
}
return ImageData1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, "yes"};
}
UnsignedInt doImage2DCount() const override {
return contents & SceneContent::Images2D ? 4 : 0;
}
UnsignedInt doImage2DLevelCount(UnsignedInt) override {
return contents & SceneContent::ImageLevels ? 5 : 1;
}
Containers::Optional<ImageData2D> doImage2D(UnsignedInt id, UnsignedInt level) override {
if(id == 2) {
if(contents & SceneContent::ImageLevels) {
if(level == 3) return {};
} else return {};
}
return ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, "yes"};
}
UnsignedInt doImage3DCount() const override {
return contents & SceneContent::Images3D ? 4 : 0;
}
UnsignedInt doImage3DLevelCount(UnsignedInt) override {
return contents & SceneContent::ImageLevels ? 5 : 1;
}
Containers::Optional<ImageData3D> doImage3D(UnsignedInt id, UnsignedInt level) override {
if(id == 2) {
if(contents & SceneContent::ImageLevels) {
if(level == 3) return {};
} else return {};
}
return ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, DataFlags{}, "yes"};
}
SceneContents contents;
} importer{data.contents};
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return
SceneConverterFeature::ConvertMultipleToData|
SceneConverterFeature::AddScenes|
SceneConverterFeature::AddAnimations|
SceneConverterFeature::AddLights|
SceneConverterFeature::AddCameras|
SceneConverterFeature::AddSkins2D|
SceneConverterFeature::AddSkins3D|
SceneConverterFeature::AddMeshes|
SceneConverterFeature::AddMaterials|
SceneConverterFeature::AddTextures|
SceneConverterFeature::AddImages1D|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::AddImages3D|
SceneConverterFeature::MeshLevels|
SceneConverterFeature::ImageLevels;
}
bool doBeginData() override { return true; }
bool doAdd(UnsignedInt, const SceneData&, Containers::StringView) override {
Debug{} << "Adding scene";
return true;
}
bool doAdd(UnsignedInt, const AnimationData&, Containers::StringView) override {
Debug{} << "Adding animation";
return true;
}
bool doAdd(UnsignedInt, const LightData&, Containers::StringView) override {
Debug{} << "Adding light";
return true;
}
bool doAdd(UnsignedInt, const CameraData&, Containers::StringView) override {
Debug{} << "Adding camera";
return true;
}
bool doAdd(UnsignedInt, const SkinData2D&, Containers::StringView) override {
Debug{} << "Adding 2D skin";
return true;
}
bool doAdd(UnsignedInt, const SkinData3D&, Containers::StringView) override {
Debug{} << "Adding 3D skin";
return true;
}
bool doAdd(UnsignedInt, const MeshData&, Containers::StringView) override {
Debug{} << "Adding mesh";
return true;
}
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const MeshData>&, Containers::StringView) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
Debug{} << "Adding mesh levels";
return true;
}
bool doAdd(UnsignedInt, const MaterialData&, Containers::StringView) override {
Debug{} << "Adding material";
return true;
}
bool doAdd(UnsignedInt, const TextureData&, Containers::StringView) override {
Debug{} << "Adding texture";
return true;
}
bool doAdd(UnsignedInt, const ImageData1D&, Containers::StringView) override {
Debug{} << "Adding 1D image";
return true;
}
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData1D>&, Containers::StringView) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
Debug{} << "Adding 1D image levels";
return true;
}
bool doAdd(UnsignedInt, const ImageData2D&, Containers::StringView) override {
Debug{} << "Adding 2D image";
return true;
}
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData2D>&, Containers::StringView) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
Debug{} << "Adding 2D image levels";
return true;
}
bool doAdd(UnsignedInt, const ImageData3D&, Containers::StringView) override {
Debug{} << "Adding 3D image";
return true;
}
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData3D>&, Containers::StringView) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
Debug{} << "Adding 3D image levels";
return true;
}
} converter;
CORRADE_VERIFY(converter.beginData());
std::ostringstream out;
Debug redirectOutput{&out};
Error redirectError{&out};
CORRADE_VERIFY(!converter.addImporterContents(importer, data.contents));
/* No error message, the importer is expected to print that on its own */
CORRADE_COMPARE(out.str(), Utility::format(
"Adding {0}\n"
"Adding {0}\n", data.name));
}
void AbstractSceneConverterTest::addImporterContentsConversionFail() {
auto&& data = AddImporterContentsFailData[testCaseInstanceId()];
setTestCaseDescription(data.name);
struct: AbstractImporter {
ImporterFeatures doFeatures() const override { return {}; }
bool doIsOpened() const override { return true; }
void doClose() override {}
UnsignedInt doSceneCount() const override {
return 4;
}
Containers::Optional<SceneData> doScene(UnsignedInt) override {
return SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {}};
}
UnsignedInt doAnimationCount() const override {
return 4;
}
Containers::Optional<AnimationData> doAnimation(UnsignedInt) override {
return AnimationData{nullptr, {}};
}
UnsignedInt doLightCount() const override {
return 4;
}
Containers::Optional<LightData> doLight(UnsignedInt) override {
Trade: deprecate LightData::Type in favor of LightType. Enums in classes are bad, can't forward-declare them.
3 years ago
return LightData{LightType::Point, {}, {}};
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
}
UnsignedInt doCameraCount() const override {
return 4;
}
Containers::Optional<CameraData> doCamera(UnsignedInt) override {
return CameraData{CameraType::Orthographic2D, {}, 0.0f, 0.0f};
}
UnsignedInt doSkin2DCount() const override {
return 4;
}
Containers::Optional<SkinData2D> doSkin2D(UnsignedInt) override {
return SkinData2D{{}, {}};
}
UnsignedInt doSkin3DCount() const override {
return 4;
}
Containers::Optional<SkinData3D> doSkin3D(UnsignedInt) override {
return SkinData3D{{}, {}};
}
UnsignedInt doMeshCount() const override {
return 4;
}
UnsignedInt doMeshLevelCount(UnsignedInt) override {
return 5;
}
Containers::Optional<MeshData> doMesh(UnsignedInt, UnsignedInt) override {
return MeshData{{}, 0};
}
UnsignedInt doMaterialCount() const override {
return 4;
}
Containers::Optional<MaterialData> doMaterial(UnsignedInt) override {
return MaterialData{{}, {}};
}
UnsignedInt doTextureCount() const override {
return 4;
}
Containers::Optional<TextureData> doTexture(UnsignedInt) override {
return TextureData{TextureType::Texture1D, SamplerFilter::Nearest, SamplerFilter::Nearest, SamplerMipmap::Nearest, SamplerWrapping::ClampToEdge, 0};
}
UnsignedInt doImage1DCount() const override {
return 4;
}
UnsignedInt doImage1DLevelCount(UnsignedInt) override {
return 5;
}
Containers::Optional<ImageData1D> doImage1D(UnsignedInt, UnsignedInt) override {
return ImageData1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, "yes"};
}
UnsignedInt doImage2DCount() const override {
return 4;
}
UnsignedInt doImage2DLevelCount(UnsignedInt) override {
return 5;
}
Containers::Optional<ImageData2D> doImage2D(UnsignedInt, UnsignedInt) override {
return ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, "yes"};
}
UnsignedInt doImage3DCount() const override {
return 4;
}
UnsignedInt doImage3DLevelCount(UnsignedInt) override {
return 5;
}
Containers::Optional<ImageData3D> doImage3D(UnsignedInt, UnsignedInt) override {
return ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, DataFlags{}, "yes"};
}
} importer;
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return
SceneConverterFeature::ConvertMultipleToData|
SceneConverterFeature::AddScenes|
SceneConverterFeature::AddAnimations|
SceneConverterFeature::AddLights|
SceneConverterFeature::AddCameras|
SceneConverterFeature::AddSkins2D|
SceneConverterFeature::AddSkins3D|
SceneConverterFeature::AddMeshes|
SceneConverterFeature::AddMaterials|
SceneConverterFeature::AddTextures|
SceneConverterFeature::AddImages1D|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::AddImages3D|
SceneConverterFeature::MeshLevels|
SceneConverterFeature::ImageLevels;
}
bool doBeginData() override { return true; }
bool doAdd(UnsignedInt id, const SceneData&, Containers::StringView) override {
if(id == 2) return false;
Debug{} << "Adding scene";
return true;
}
bool doAdd(UnsignedInt id, const AnimationData&, Containers::StringView) override {
if(id == 2) return false;
Debug{} << "Adding animation";
return true;
}
bool doAdd(UnsignedInt id, const LightData&, Containers::StringView) override {
if(id == 2) return false;
Debug{} << "Adding light";
return true;
}
bool doAdd(UnsignedInt id, const CameraData&, Containers::StringView) override {
if(id == 2) return false;
Debug{} << "Adding camera";
return true;
}
bool doAdd(UnsignedInt id, const SkinData2D&, Containers::StringView) override {
if(id == 2) return false;
Debug{} << "Adding 2D skin";
return true;
}
bool doAdd(UnsignedInt id, const SkinData3D&, Containers::StringView) override {
if(id == 2) return false;
Debug{} << "Adding 3D skin";
return true;
}
bool doAdd(UnsignedInt id, const MeshData&, Containers::StringView) override {
if(id == 2) return false;
Debug{} << "Adding mesh";
return true;
}
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt id, const Containers::Iterable<const MeshData>&, Containers::StringView) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
if(id == 2) return false;
Debug{} << "Adding mesh levels";
return true;
}
bool doAdd(UnsignedInt id, const MaterialData&, Containers::StringView) override {
if(id == 2) return false;
Debug{} << "Adding material";
return true;
}
bool doAdd(UnsignedInt id, const TextureData&, Containers::StringView) override {
if(id == 2) return false;
Debug{} << "Adding texture";
return true;
}
bool doAdd(UnsignedInt id, const ImageData1D&, Containers::StringView) override {
if(id == 2) return false;
Debug{} << "Adding 1D image";
return true;
}
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt id, const Containers::Iterable<const ImageData1D>&, Containers::StringView) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
if(id == 2) return false;
Debug{} << "Adding 1D image levels";
return true;
}
bool doAdd(UnsignedInt id, const ImageData2D&, Containers::StringView) override {
if(id == 2) return false;
Debug{} << "Adding 2D image";
return true;
}
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt id, const Containers::Iterable<const ImageData2D>&, Containers::StringView) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
if(id == 2) return false;
Debug{} << "Adding 2D image levels";
return true;
}
bool doAdd(UnsignedInt id, const ImageData3D&, Containers::StringView) override {
if(id == 2) return false;
Debug{} << "Adding 3D image";
return true;
}
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt id, const Containers::Iterable<const ImageData3D>&, Containers::StringView) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
if(id == 2) return false;
Debug{} << "Adding 3D image levels";
return true;
}
} converter;
CORRADE_VERIFY(converter.beginData());
std::ostringstream out;
Debug redirectOutput{&out};
Error redirectError{&out};
CORRADE_VERIFY(!converter.addImporterContents(importer, data.contents));
/* No error message, the importer is expected to print that on its own */
CORRADE_COMPARE(out.str(), Utility::format(
"Adding {0}\n"
"Adding {0}\n", data.name));
}
void AbstractSceneConverterTest::addImporterContentsNotConverting() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractImporter {
ImporterFeatures doFeatures() const override { return {}; }
bool doIsOpened() const override { return true; }
void doClose() override {}
} importer;
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToData;
}
} converter;
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.addImporterContents(importer, {}));
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::addImporterContents(): no conversion in progress\n");
}
void AbstractSceneConverterTest::addImporterContentsNotOpened() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractImporter {
ImporterFeatures doFeatures() const override { return {}; }
bool doIsOpened() const override { return false; }
void doClose() override {}
} importer;
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToData;
}
bool doBeginData() override { return true; }
} converter;
CORRADE_VERIFY(converter.beginData());
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter.addImporterContents(importer));
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::addImporterContents(): the importer is not opened\n");
}
void AbstractSceneConverterTest::addImporterContentsNotSupported() {
CORRADE_SKIP_IF_NO_ASSERT();
struct: AbstractImporter {
ImporterFeatures doFeatures() const override { return {}; }
bool doIsOpened() const override { return true; }
void doClose() override {}
UnsignedInt doCameraCount() const override { return 2; }
UnsignedInt doLightCount() const override { return 4; }
UnsignedInt doMeshCount() const override { return 3; }
UnsignedInt doMaterialCount() const override { return 3; }
} importer;
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToData|
SceneConverterFeature::AddCameras|
SceneConverterFeature::AddMaterials;
}
bool doBeginData() override { return true; }
} converter;
CORRADE_VERIFY(converter.beginData());
std::ostringstream out;
Error redirectError{&out};
/* Scenes (which are not present in the input) should not be part of the
error, materials are in the input and supported, meshes and lights are
in the input but not supported so these should be printed */
CORRADE_VERIFY(!converter.addImporterContents(importer, SceneContent::Scenes|SceneContent::Cameras|SceneContent::Meshes|SceneContent::Lights));
CORRADE_COMPARE(out.str(), "Trade::AbstractSceneConverter::addImporterContents(): unsupported contents Lights|Meshes\n");
}
void AbstractSceneConverterTest::addImporterContentsNotSupportedLevels() {
struct: AbstractImporter {
ImporterFeatures doFeatures() const override { return {}; }
bool doIsOpened() const override { return true; }
void doClose() override {}
UnsignedInt doMeshCount() const override { return 4; }
UnsignedInt doMeshLevelCount(UnsignedInt id) override {
return id == 2 ? 5 : 1;
}
Containers::Optional<MeshData> doMesh(UnsignedInt, UnsignedInt) override {
return MeshData{{}, 0};
}
UnsignedInt doImage1DCount() const override { return 4; }
UnsignedInt doImage1DLevelCount(UnsignedInt id) override {
return id == 2 ? 2 : 1;
}
Containers::Optional<ImageData1D> doImage1D(UnsignedInt, UnsignedInt) override {
return ImageData1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, "yes"};
}
UnsignedInt doImage2DCount() const override { return 4; }
UnsignedInt doImage2DLevelCount(UnsignedInt id) override {
return id == 2 ? 3 : 1;
}
Containers::Optional<ImageData2D> doImage2D(UnsignedInt, UnsignedInt) override {
return ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, "yes"};
}
UnsignedInt doImage3DCount() const override { return 4; }
UnsignedInt doImage3DLevelCount(UnsignedInt id) override {
return id == 2 ? 4 : 1;
}
Containers::Optional<ImageData3D> doImage3D(UnsignedInt, UnsignedInt) override {
return ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, DataFlags{}, "yes"};
}
} importer;
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToData|
SceneConverterFeature::AddMeshes|
SceneConverterFeature::AddImages1D|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::AddImages3D;
}
bool doBeginData() override { return true; }
bool doAdd(UnsignedInt, const MeshData&, Containers::StringView) override {
Debug{} << "Adding mesh";
return true;
}
bool doAdd(UnsignedInt, const ImageData1D&, Containers::StringView) override {
Debug{} << "Adding 1D image";
return true;
}
bool doAdd(UnsignedInt, const ImageData2D&, Containers::StringView) override {
Debug{} << "Adding 2D image";
return true;
}
bool doAdd(UnsignedInt, const ImageData3D&, Containers::StringView) override {
Debug{} << "Adding 3D image";
return true;
}
} converter;
CORRADE_VERIFY(converter.beginData());
std::ostringstream out;
Debug redirectOutput{&out};
Error redirectError{&out};
CORRADE_VERIFY(!converter.addImporterContents(importer, SceneContent::Meshes|SceneContent::MeshLevels));
CORRADE_VERIFY(!converter.addImporterContents(importer, SceneContent::Images1D|SceneContent::ImageLevels));
CORRADE_VERIFY(!converter.addImporterContents(importer, SceneContent::Images2D|SceneContent::ImageLevels));
CORRADE_VERIFY(!converter.addImporterContents(importer, SceneContent::Images3D|SceneContent::ImageLevels));
CORRADE_COMPARE(out.str(),
"Adding mesh\n"
"Adding mesh\n"
"Trade::AbstractSceneConverter::addImporterContents(): mesh 2 contains 5 levels but the converter doesn't support Trade::SceneConverterFeature::MeshLevels\n"
"Adding 1D image\n"
"Adding 1D image\n"
"Trade::AbstractSceneConverter::addImporterContents(): 1D image 2 contains 2 levels but the converter doesn't support Trade::SceneConverterFeature::ImageLevels\n"
"Adding 2D image\n"
"Adding 2D image\n"
"Trade::AbstractSceneConverter::addImporterContents(): 2D image 2 contains 3 levels but the converter doesn't support Trade::SceneConverterFeature::ImageLevels\n"
"Adding 3D image\n"
"Adding 3D image\n"
"Trade::AbstractSceneConverter::addImporterContents(): 3D image 2 contains 4 levels but the converter doesn't support Trade::SceneConverterFeature::ImageLevels\n");
}
void AbstractSceneConverterTest::addImporterContentsNotSupportedUncompressedImage() {
struct: AbstractImporter {
ImporterFeatures doFeatures() const override { return {}; }
bool doIsOpened() const override { return true; }
void doClose() override {}
UnsignedInt doImage1DCount() const override { return 4; }
UnsignedInt doImage1DLevelCount(UnsignedInt) override { return 3; }
Containers::Optional<ImageData1D> doImage1D(UnsignedInt id, UnsignedInt level) override {
return id == 2 && level == 1 ?
ImageData1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, "yes"} :
ImageData1D{CompressedPixelFormat::Bc1RGBUnorm, 1, DataFlags{}, "hello!!"};
}
UnsignedInt doImage2DCount() const override { return 5; }
UnsignedInt doImage2DLevelCount(UnsignedInt) override { return 4; }
Containers::Optional<ImageData2D> doImage2D(UnsignedInt id, UnsignedInt level) override {
return id == 3 && level == 2 ?
ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, "yes"} :
ImageData2D{CompressedPixelFormat::Bc1RGBUnorm, {1, 1}, DataFlags{}, "hello!!"};
}
UnsignedInt doImage3DCount() const override { return 6; }
UnsignedInt doImage3DLevelCount(UnsignedInt) override { return 5; }
Containers::Optional<ImageData3D> doImage3D(UnsignedInt id, UnsignedInt level) override {
return id == 4 && level == 3 ?
ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, DataFlags{}, "yes"} :
ImageData3D{CompressedPixelFormat::Bc1RGBUnorm, {1, 1, 1}, DataFlags{}, "hello!!"};
}
} importer;
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToData|
SceneConverterFeature::AddCompressedImages1D|
SceneConverterFeature::AddCompressedImages2D|
SceneConverterFeature::AddCompressedImages3D|
SceneConverterFeature::ImageLevels;
}
bool doBeginData() override { return true; }
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const Trade::ImageData1D>&, Containers::StringView) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
Debug{} << "Added 1D image";
return true;
}
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const Trade::ImageData2D>&, Containers::StringView) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
Debug{} << "Added 2D image";
return true;
}
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const Trade::ImageData3D>&, Containers::StringView) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
Debug{} << "Added 3D image";
return true;
}
} converter;
CORRADE_VERIFY(converter.beginData());
std::ostringstream out;
Debug redirectOutput{&out};
Error redirectError{&out};
CORRADE_VERIFY(!converter.addImporterContents(importer, SceneContent::Images1D|SceneContent::ImageLevels));
CORRADE_VERIFY(!converter.addImporterContents(importer, SceneContent::Images2D|SceneContent::ImageLevels));
CORRADE_VERIFY(!converter.addImporterContents(importer, SceneContent::Images3D|SceneContent::ImageLevels));
CORRADE_COMPARE(out.str(),
"Added 1D image\n"
"Added 1D image\n"
"Trade::AbstractSceneConverter::addImporterContents(): 1D image 2 level 1 is uncompressed but the converter doesn't support Trade::SceneConverterFeature::AddImages1D\n"
"Added 2D image\n"
"Added 2D image\n"
"Added 2D image\n"
"Trade::AbstractSceneConverter::addImporterContents(): 2D image 3 level 2 is uncompressed but the converter doesn't support Trade::SceneConverterFeature::AddImages2D\n"
"Added 3D image\n"
"Added 3D image\n"
"Added 3D image\n"
"Added 3D image\n"
"Trade::AbstractSceneConverter::addImporterContents(): 3D image 4 level 3 is uncompressed but the converter doesn't support Trade::SceneConverterFeature::AddImages3D\n");
}
void AbstractSceneConverterTest::addImporterContentsNotSupportedCompressedImage() {
struct: AbstractImporter {
ImporterFeatures doFeatures() const override { return {}; }
bool doIsOpened() const override { return true; }
void doClose() override {}
UnsignedInt doImage1DCount() const override { return 4; }
UnsignedInt doImage1DLevelCount(UnsignedInt) override { return 3; }
Containers::Optional<ImageData1D> doImage1D(UnsignedInt id, UnsignedInt level) override {
return id == 2 && level == 1 ?
ImageData1D{CompressedPixelFormat::Bc1RGBUnorm, 1, DataFlags{}, "hello!!"} :
ImageData1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, "yes"};
}
UnsignedInt doImage2DCount() const override { return 5; }
UnsignedInt doImage2DLevelCount(UnsignedInt) override { return 4; }
Containers::Optional<ImageData2D> doImage2D(UnsignedInt id, UnsignedInt level) override {
return id == 3 && level == 2 ?
ImageData2D{CompressedPixelFormat::Bc1RGBUnorm, {1, 1}, DataFlags{}, "hello!!"} :
ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, "yes"};
}
UnsignedInt doImage3DCount() const override { return 6; }
UnsignedInt doImage3DLevelCount(UnsignedInt) override { return 5; }
Containers::Optional<ImageData3D> doImage3D(UnsignedInt id, UnsignedInt level) override {
return id == 4 && level == 3 ?
ImageData3D{CompressedPixelFormat::Bc1RGBUnorm, {1, 1, 1}, DataFlags{}, "hello!!"} :
ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, DataFlags{}, "yes"};
}
} importer;
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return SceneConverterFeature::ConvertMultipleToData|
SceneConverterFeature::AddImages1D|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::AddImages3D|
SceneConverterFeature::ImageLevels;
}
bool doBeginData() override { return true; }
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const Trade::ImageData1D>&, Containers::StringView) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
Debug{} << "Added 1D image";
return true;
}
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const Trade::ImageData2D>&, Containers::StringView) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
Debug{} << "Added 2D image";
return true;
}
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const Trade::ImageData3D>&, Containers::StringView) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
Debug{} << "Added 3D image";
return true;
}
} converter;
CORRADE_VERIFY(converter.beginData());
std::ostringstream out;
Debug redirectOutput{&out};
Error redirectError{&out};
CORRADE_VERIFY(!converter.addImporterContents(importer, SceneContent::Images1D|SceneContent::ImageLevels));
CORRADE_VERIFY(!converter.addImporterContents(importer, SceneContent::Images2D|SceneContent::ImageLevels));
CORRADE_VERIFY(!converter.addImporterContents(importer, SceneContent::Images3D|SceneContent::ImageLevels));
CORRADE_COMPARE(out.str(),
"Added 1D image\n"
"Added 1D image\n"
"Trade::AbstractSceneConverter::addImporterContents(): 1D image 2 level 1 is compressed but the converter doesn't support Trade::SceneConverterFeature::AddCompressedImages1D\n"
"Added 2D image\n"
"Added 2D image\n"
"Added 2D image\n"
"Trade::AbstractSceneConverter::addImporterContents(): 2D image 3 level 2 is compressed but the converter doesn't support Trade::SceneConverterFeature::AddCompressedImages2D\n"
"Added 3D image\n"
"Added 3D image\n"
"Added 3D image\n"
"Added 3D image\n"
"Trade::AbstractSceneConverter::addImporterContents(): 3D image 4 level 3 is compressed but the converter doesn't support Trade::SceneConverterFeature::AddCompressedImages3D\n");
}
void AbstractSceneConverterTest::addSupportedImporterContents() {
auto&& data = AddSupportedImporterContentsData[testCaseInstanceId()];
setTestCaseDescription(data.name);
struct: AbstractImporter {
ImporterFeatures doFeatures() const override { return {}; }
bool doIsOpened() const override { return true; }
void doClose() override {}
UnsignedInt doSceneCount() const override { return 2; }
Containers::Optional<SceneData> doScene(UnsignedInt) override {
return SceneData{SceneMappingType::UnsignedInt, 0, nullptr, {}};
}
UnsignedInt doAnimationCount() const override { return 3; }
Containers::Optional<AnimationData> doAnimation(UnsignedInt) override {
return AnimationData{nullptr, {}};
}
UnsignedInt doLightCount() const override { return 4; }
Containers::Optional<LightData> doLight(UnsignedInt) override {
Trade: deprecate LightData::Type in favor of LightType. Enums in classes are bad, can't forward-declare them.
3 years ago
return LightData{LightType::Point, {}, {}};
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
}
UnsignedInt doCameraCount() const override { return 5; }
Containers::Optional<CameraData> doCamera(UnsignedInt) override {
return CameraData{CameraType::Orthographic2D, {}, 0.0f, 0.0f};
}
UnsignedInt doSkin2DCount() const override { return 6; }
Containers::Optional<SkinData2D> doSkin2D(UnsignedInt) override {
return SkinData2D{{}, {}};
}
UnsignedInt doSkin3DCount() const override { return 7; }
Containers::Optional<SkinData3D> doSkin3D(UnsignedInt) override {
return SkinData3D{{}, {}};
}
UnsignedInt doMeshCount() const override { return 8; }
UnsignedInt doMeshLevelCount(UnsignedInt) override {
return 5;
}
Containers::Optional<MeshData> doMesh(UnsignedInt, UnsignedInt) override {
return MeshData{{}, 0};
}
UnsignedInt doMaterialCount() const override { return 9; }
Containers::Optional<MaterialData> doMaterial(UnsignedInt) override {
return MaterialData{{}, {}};
}
UnsignedInt doTextureCount() const override { return 10; }
Containers::Optional<TextureData> doTexture(UnsignedInt) override {
return TextureData{TextureType::Texture1D, SamplerFilter::Nearest, SamplerFilter::Nearest, SamplerMipmap::Nearest, SamplerWrapping::ClampToEdge, 0};
}
UnsignedInt doImage1DCount() const override { return 11; }
UnsignedInt doImage1DLevelCount(UnsignedInt) override {
return 5;
}
Containers::Optional<ImageData1D> doImage1D(UnsignedInt, UnsignedInt) override {
return ImageData1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, "yes"};
}
UnsignedInt doImage2DCount() const override { return 12; }
UnsignedInt doImage2DLevelCount(UnsignedInt) override {
return 5;
}
Containers::Optional<ImageData2D> doImage2D(UnsignedInt, UnsignedInt) override {
return ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, "yes"};
}
UnsignedInt doImage3DCount() const override { return 13; }
UnsignedInt doImage3DLevelCount(UnsignedInt) override {
return 5;
}
Containers::Optional<ImageData3D> doImage3D(UnsignedInt, UnsignedInt) override {
return ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, DataFlags{}, "yes"};
}
} importer;
struct Converter: AbstractSceneConverter {
explicit Converter(SceneConverterFeatures except): except{except} {}
SceneConverterFeatures doFeatures() const override {
return ~except &
(SceneConverterFeature::ConvertMultipleToData|
SceneConverterFeature::AddScenes|
SceneConverterFeature::AddAnimations|
SceneConverterFeature::AddLights|
SceneConverterFeature::AddCameras|
SceneConverterFeature::AddSkins2D|
SceneConverterFeature::AddSkins3D|
SceneConverterFeature::AddMeshes|
SceneConverterFeature::AddMaterials|
SceneConverterFeature::AddTextures|
SceneConverterFeature::AddImages1D|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::AddImages3D|
SceneConverterFeature::MeshLevels|
SceneConverterFeature::ImageLevels);
}
bool doBeginData() override { return true; }
bool doAdd(UnsignedInt, const SceneData&, Containers::StringView) override {
return true;
}
bool doAdd(UnsignedInt, const AnimationData&, Containers::StringView) override {
return true;
}
bool doAdd(UnsignedInt, const LightData&, Containers::StringView) override {
return true;
}
bool doAdd(UnsignedInt, const CameraData&, Containers::StringView) override {
return true;
}
bool doAdd(UnsignedInt, const SkinData2D&, Containers::StringView) override {
return true;
}
bool doAdd(UnsignedInt, const SkinData3D&, Containers::StringView) override {
return true;
}
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const MeshData>&, Containers::StringView) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
return true;
}
bool doAdd(UnsignedInt, const MaterialData&, Containers::StringView) override {
return true;
}
bool doAdd(UnsignedInt, const TextureData&, Containers::StringView) override {
return true;
}
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData1D>&, Containers::StringView) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
return true;
}
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData2D>&, Containers::StringView) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
return true;
}
Don't take an Iterable by value. It's four pointers, twice as much as what would be acceptable. Not sure why this happened, maybe because all those cases used an ArrayView before and so I just changed the type without considering the difference in its size? Unfortunately this change also means a bump in the plugin interface string, thus all scene converter plugins have to be updated as well.
4 years ago
bool doAdd(UnsignedInt, const Containers::Iterable<const ImageData3D>&, Containers::StringView) override {
Trade: ability to feed the whole importer into a scene converter. Makes a lot of use cases significantly simpler -- apart from the trivial "convert an OBJ to a glTF" scenario, many processing steps are about passing most data through but only doing a pass on meshes, or images, or materials. And this simplifies that use case quite a lot. This is only "driver" code, with no new interfaces for the plugins. For them it still looks like all data, their names and related metadata were added one by one. Also, a suprisingly large amount of code for this feature.
4 years ago
return true;
}
SceneConverterFeatures except;
} converter{data.exceptFeatures};
CORRADE_VERIFY(converter.beginData());
std::ostringstream out;
Warning redirectWarning{&out};
CORRADE_VERIFY(converter.addSupportedImporterContents(importer, ~data.wantExceptContents));
CORRADE_COMPARE(out.str(), Utility::formatString(
"Trade::AbstractSceneConverter::addSupportedImporterContents(): ignoring {} not supported by the converter\n", data.except));
/* All data except the one unsupported should be added */
const SceneContents expectedConvertedExceptContents = data.exceptContents| data.wantExceptContents;
CORRADE_COMPARE(converter.sceneCount(),
expectedConvertedExceptContents & SceneContent::Scenes ? 0 : importer.sceneCount());
CORRADE_COMPARE(converter.animationCount(),
expectedConvertedExceptContents & SceneContent::Animations ? 0 : importer.animationCount());
CORRADE_COMPARE(converter.lightCount(),
expectedConvertedExceptContents & SceneContent::Lights ? 0 : importer.lightCount());
CORRADE_COMPARE(converter.cameraCount(),
expectedConvertedExceptContents & SceneContent::Cameras ? 0 : importer.cameraCount());
CORRADE_COMPARE(converter.skin2DCount(),
expectedConvertedExceptContents & SceneContent::Skins2D ? 0 : importer.skin2DCount());
CORRADE_COMPARE(converter.skin3DCount(),
expectedConvertedExceptContents & SceneContent::Skins3D ? 0 : importer.skin3DCount());
CORRADE_COMPARE(converter.meshCount(),
expectedConvertedExceptContents & SceneContent::Meshes ? 0 : importer.meshCount());
CORRADE_COMPARE(converter.materialCount(),
expectedConvertedExceptContents & SceneContent::Materials ? 0 : importer.materialCount());
CORRADE_COMPARE(converter.textureCount(),
expectedConvertedExceptContents & SceneContent::Textures ? 0 : importer.textureCount());
CORRADE_COMPARE(converter.image1DCount(),
expectedConvertedExceptContents & SceneContent::Images1D ? 0 : importer.image1DCount());
CORRADE_COMPARE(converter.image2DCount(),
expectedConvertedExceptContents & SceneContent::Images2D ? 0 : importer.image2DCount());
CORRADE_COMPARE(converter.image3DCount(),
expectedConvertedExceptContents & SceneContent::Images3D ? 0 : importer.image3DCount());
}
void AbstractSceneConverterTest::addSupportedImporterContentsLevels() {
/* Similar to addImporterContentsNotSupportedLevels(), but not failing */
struct: AbstractImporter {
ImporterFeatures doFeatures() const override { return {}; }
bool doIsOpened() const override { return true; }
void doClose() override {}
UnsignedInt doMeshCount() const override { return 4; }
UnsignedInt doMeshLevelCount(UnsignedInt id) override {
return id == 2 ? 5 : 1;
}
Containers::Optional<MeshData> doMesh(UnsignedInt, UnsignedInt) override {
return MeshData{{}, 0};
}
UnsignedInt doImage1DCount() const override { return 5; }
UnsignedInt doImage1DLevelCount(UnsignedInt id) override {
return id == 3 ? 6 : 1;
}
Containers::Optional<ImageData1D> doImage1D(UnsignedInt, UnsignedInt) override {
return ImageData1D{PixelFormat::RGBA8Unorm, 1, DataFlags{}, "yes"};
}
UnsignedInt doImage2DCount() const override { return 6; }
UnsignedInt doImage2DLevelCount(UnsignedInt id) override {
return id == 4 ? 7 : 1;
}
Containers::Optional<ImageData2D> doImage2D(UnsignedInt, UnsignedInt) override {
return ImageData2D{PixelFormat::RGBA8Unorm, {1, 1}, DataFlags{}, "yes"};
}
UnsignedInt doImage3DCount() const override { return 7; }
UnsignedInt doImage3DLevelCount(UnsignedInt id) override {
return id == 5 ? 8 : 1;
}
Containers::Optional<ImageData3D> doImage3D(UnsignedInt, UnsignedInt) override {
return ImageData3D{PixelFormat::RGBA8Unorm, {1, 1, 1}, DataFlags{}, "yes"};
}
} importer;
struct: AbstractSceneConverter {
SceneConverterFeatures doFeatures() const override {
return
SceneConverterFeature::ConvertMultipleToData|
SceneConverterFeature::AddMeshes|
SceneConverterFeature::AddImages1D|
SceneConverterFeature::AddImages2D|
SceneConverterFeature::AddImages3D;
}
bool doBeginData() override { return true; }
bool doAdd(UnsignedInt, const MeshData&, Containers::StringView) override {
return true;
}
bool doAdd(UnsignedInt, const ImageData1D&, Containers::StringView) override {
return true;
}
bool doAdd(UnsignedInt, const ImageData2D&, Containers::StringView) override {
return true;
}
bool doAdd(UnsignedInt, const ImageData3D&, Containers::StringView) override {
return true;
}
SceneConverterFeatures except;
} converter;
CORRADE_VERIFY(converter.beginData());
std::ostringstream out;
Warning redirectWarning{&out};
CORRADE_VERIFY(converter.addSupportedImporterContents(importer));
CORRADE_COMPARE(out.str(),
"Trade::AbstractSceneConverter::addSupportedImporterContents(): ignoring extra 4 levels of mesh 2 not supported by the converter\n"
"Trade::AbstractSceneConverter::addSupportedImporterContents(): ignoring extra 5 levels of 1D image 3 not supported by the converter\n"
"Trade::AbstractSceneConverter::addSupportedImporterContents(): ignoring extra 6 levels of 2D image 4 not supported by the converter\n"
"Trade::AbstractSceneConverter::addSupportedImporterContents(): ignoring extra 7 levels of 3D image 5 not supported by the converter\n");
/* All data should be added, just not the extra levels */
CORRADE_COMPARE(converter.meshCount(), importer.meshCount());
CORRADE_COMPARE(converter.image1DCount(), importer.image1DCount());
CORRADE_COMPARE(converter.image2DCount(), importer.image2DCount());
CORRADE_COMPARE(converter.image3DCount(), importer.image3DCount());
}
void AbstractSceneConverterTest::debugFeature() {
std::ostringstream out;
Debug{&out} << SceneConverterFeature::ConvertMeshInPlace << SceneConverterFeature(0xdeaddead);
CORRADE_COMPARE(out.str(), "Trade::SceneConverterFeature::ConvertMeshInPlace Trade::SceneConverterFeature(0xdeaddead)\n");
}
void AbstractSceneConverterTest::debugFeaturePacked() {
std::ostringstream out;
/* Last is not packed, ones before should not make any flags persistent */
Debug{&out} << Debug::packed << SceneConverterFeature::ConvertMeshInPlace << Debug::packed << SceneConverterFeature(0xdeaddead) << SceneConverterFeature::AddCameras;
CORRADE_COMPARE(out.str(), "ConvertMeshInPlace 0xdeaddead Trade::SceneConverterFeature::AddCameras\n");
}
void AbstractSceneConverterTest::debugFeatures() {
std::ostringstream out;
Debug{&out} << (SceneConverterFeature::ConvertMesh|SceneConverterFeature::ConvertMeshToFile) << SceneConverterFeatures{};
CORRADE_COMPARE(out.str(), "Trade::SceneConverterFeature::ConvertMesh|Trade::SceneConverterFeature::ConvertMeshToFile Trade::SceneConverterFeatures{}\n");
}
void AbstractSceneConverterTest::debugFeaturesPacked() {
std::ostringstream out;
/* Last is not packed, ones before should not make any flags persistent */
Debug{&out} << Debug::packed << (SceneConverterFeature::ConvertMesh|SceneConverterFeature::ConvertMeshToFile) << Debug::packed << SceneConverterFeatures{} << SceneConverterFeature::AddLights;
CORRADE_COMPARE(out.str(), "ConvertMesh|ConvertMeshToFile {} Trade::SceneConverterFeature::AddLights\n");
}
void AbstractSceneConverterTest::debugFeaturesSupersets() {
/* ConvertMeshToData is a superset of ConvertMeshToFile, so only one should
be printed */
{
std::ostringstream out;
Debug{&out} << (SceneConverterFeature::ConvertMeshToData|SceneConverterFeature::ConvertMeshToFile);
CORRADE_COMPARE(out.str(), "Trade::SceneConverterFeature::ConvertMeshToData\n");
/* ConvertMultipleToData is a superset of ConvertMultipleToFile, so only
one should be printed */
} {
std::ostringstream out;
Debug{&out} << (SceneConverterFeature::ConvertMultipleToData|SceneConverterFeature::ConvertMultipleToFile);
CORRADE_COMPARE(out.str(), "Trade::SceneConverterFeature::ConvertMultipleToData\n");
}
}
void AbstractSceneConverterTest::debugFlag() {
std::ostringstream out;
Debug{&out} << SceneConverterFlag::Verbose << SceneConverterFlag(0xf0);
CORRADE_COMPARE(out.str(), "Trade::SceneConverterFlag::Verbose Trade::SceneConverterFlag(0xf0)\n");
}
void AbstractSceneConverterTest::debugFlags() {
std::ostringstream out;
Debug{&out} << (SceneConverterFlag::Verbose|SceneConverterFlag(0xf0)) << SceneConverterFlags{};
CORRADE_COMPARE(out.str(), "Trade::SceneConverterFlag::Verbose|Trade::SceneConverterFlag(0xf0) Trade::SceneConverterFlags{}\n");
}
void AbstractSceneConverterTest::debugContent() {
std::ostringstream out;
Debug{&out} << SceneContent::Skins3D << SceneContent(0xdeaddead);
CORRADE_COMPARE(out.str(), "Trade::SceneContent::Skins3D Trade::SceneContent(0xdeaddead)\n");
}
void AbstractSceneConverterTest::debugContentPacked() {
std::ostringstream out;
/* Last is not packed, ones before should not make any flags persistent */
Debug{&out} << Debug::packed << SceneContent::Animations << Debug::packed << SceneContent(0xdeaddead) << SceneContent::Cameras;
CORRADE_COMPARE(out.str(), "Animations 0xdeaddead Trade::SceneContent::Cameras\n");
}
void AbstractSceneConverterTest::debugContents() {
std::ostringstream out;
Debug{&out} << (SceneContent::Animations|SceneContent::MeshLevels) << SceneConverterFeatures{};
CORRADE_COMPARE(out.str(), "Trade::SceneContent::Animations|Trade::SceneContent::MeshLevels Trade::SceneConverterFeatures{}\n");
}
void AbstractSceneConverterTest::debugContentsPacked() {
std::ostringstream out;
/* Last is not packed, ones before should not make any flags persistent */
Debug{&out} << Debug::packed << (SceneContent::Animations|SceneContent::MeshLevels) << Debug::packed << SceneConverterFeatures{} << SceneContent::Lights;
CORRADE_COMPARE(out.str(), "Animations|MeshLevels {} Trade::SceneContent::Lights\n");
Trade: bootstrap scene converter plugins.
6 years ago
}
}}}}
CORRADE_TEST_MAIN(Magnum::Trade::Test::AbstractSceneConverterTest)