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

1253 lines
72 KiB
Raw Normal View History Unescape

{image,scene}converter: extract and test --info printing code. It was quite a pile, and all of it was written just once, relying only on hopefully-available model files that would hopefully touch most code paths. Which means, extremely annoying to make changes in. I extracted the code to a header that can be tested with a mocked-up importer and without having to execute the utility itself, deduplicated the image info printing code, fixed various inconsistencies (such as data/field flags sometimes denoted with superfluous "flags:" and sometimes not) and TODOs (such as 2D/3D skins, where there was no format whatsoever that would have 2D skin support, so the code couldn't get written). Now it's finally possible to easily add the remaining missing features, such as printing camera info.
4 years ago
/*
This file is part of Magnum.
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019,
2020, 2021, 2022 Vladimír Vondruš <mosra@centrum.cz>
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
{scene,image}converter: split implementation and executable tests. They're each a totally different beast and putting them into the same test file doesn't really make sense: - We want to link certain plugins statically on static builds to test certain code paths in the implementation. However this is counter-productive for the executable tests because there we are checking for plugin presence from the test with the assumption that the executable and the test have the exact same set of plugins available (or linked statically). - The executable tests are implemented on Unix only at the moment, thus it's wasteful to try to build it on any other platforms. Having it in a separate file makes it much easier to deal with.
4 years ago
#include <cstdlib>
#include <Corrade/Containers/Array.h>
#include <Corrade/Containers/Optional.h>
#include <Corrade/Containers/Pair.h>
#include <Corrade/Containers/String.h>
{image,scene}converter: use StringIterable to simplify tests. Hmm, nice.
4 years ago
#include <Corrade/Containers/StringIterable.h>
{image,scene}converter: extract and test --info printing code. It was quite a pile, and all of it was written just once, relying only on hopefully-available model files that would hopefully touch most code paths. Which means, extremely annoying to make changes in. I extracted the code to a header that can be tested with a mocked-up importer and without having to execute the utility itself, deduplicated the image info printing code, fixed various inconsistencies (such as data/field flags sometimes denoted with superfluous "flags:" and sometimes not) and TODOs (such as 2D/3D skins, where there was no format whatsoever that would have 2D skin support, so the code couldn't get written). Now it's finally possible to easily add the remaining missing features, such as printing camera info.
4 years ago
#include <Corrade/TestSuite/Tester.h>
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
#include <Corrade/TestSuite/Compare/File.h>
#include <Corrade/TestSuite/Compare/String.h>
{image,scene}converter: extract and test --info printing code. It was quite a pile, and all of it was written just once, relying only on hopefully-available model files that would hopefully touch most code paths. Which means, extremely annoying to make changes in. I extracted the code to a header that can be tested with a mocked-up importer and without having to execute the utility itself, deduplicated the image info printing code, fixed various inconsistencies (such as data/field flags sometimes denoted with superfluous "flags:" and sometimes not) and TODOs (such as 2D/3D skins, where there was no format whatsoever that would have 2D skin support, so the code couldn't get written). Now it's finally possible to easily add the remaining missing features, such as printing camera info.
4 years ago
#include <Corrade/TestSuite/Compare/StringToFile.h>
{scene,image}converter: split implementation and executable tests. They're each a totally different beast and putting them into the same test file doesn't really make sense: - We want to link certain plugins statically on static builds to test certain code paths in the implementation. However this is counter-productive for the executable tests because there we are checking for plugin presence from the test with the assumption that the executable and the test have the exact same set of plugins available (or linked statically). - The executable tests are implemented on Unix only at the moment, thus it's wasteful to try to build it on any other platforms. Having it in a separate file makes it much easier to deal with.
4 years ago
#include <Corrade/Utility/Format.h>
{image,scene}converter: extract and test --info printing code. It was quite a pile, and all of it was written just once, relying only on hopefully-available model files that would hopefully touch most code paths. Which means, extremely annoying to make changes in. I extracted the code to a header that can be tested with a mocked-up importer and without having to execute the utility itself, deduplicated the image info printing code, fixed various inconsistencies (such as data/field flags sometimes denoted with superfluous "flags:" and sometimes not) and TODOs (such as 2D/3D skins, where there was no format whatsoever that would have 2D skin support, so the code couldn't get written). Now it's finally possible to easily add the remaining missing features, such as printing camera info.
4 years ago
#include <Corrade/Utility/Path.h>
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
#include "Magnum/Trade/AbstractImageConverter.h"
{scene,image}converter: split implementation and executable tests. They're each a totally different beast and putting them into the same test file doesn't really make sense: - We want to link certain plugins statically on static builds to test certain code paths in the implementation. However this is counter-productive for the executable tests because there we are checking for plugin presence from the test with the assumption that the executable and the test have the exact same set of plugins available (or linked statically). - The executable tests are implemented on Unix only at the moment, thus it's wasteful to try to build it on any other platforms. Having it in a separate file makes it much easier to deal with.
4 years ago
#include "Magnum/Trade/AbstractImporter.h"
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
#include "Magnum/Trade/AbstractSceneConverter.h"
{image,scene}converter: extract and test --info printing code. It was quite a pile, and all of it was written just once, relying only on hopefully-available model files that would hopefully touch most code paths. Which means, extremely annoying to make changes in. I extracted the code to a header that can be tested with a mocked-up importer and without having to execute the utility itself, deduplicated the image info printing code, fixed various inconsistencies (such as data/field flags sometimes denoted with superfluous "flags:" and sometimes not) and TODOs (such as 2D/3D skins, where there was no format whatsoever that would have 2D skin support, so the code couldn't get written). Now it's finally possible to easily add the remaining missing features, such as printing camera info.
4 years ago
#include "configure.h"
namespace Magnum { namespace SceneTools { namespace Test { namespace {
struct SceneConverterTest: TestSuite::Tester {
explicit SceneConverterTest();
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
void info();
void convert();
void error();
{image,scene}converter: extract and test --info printing code. It was quite a pile, and all of it was written just once, relying only on hopefully-available model files that would hopefully touch most code paths. Which means, extremely annoying to make changes in. I extracted the code to a header that can be tested with a mocked-up importer and without having to execute the utility itself, deduplicated the image info printing code, fixed various inconsistencies (such as data/field flags sometimes denoted with superfluous "flags:" and sometimes not) and TODOs (such as 2D/3D skins, where there was no format whatsoever that would have 2D skin support, so the code couldn't get written). Now it's finally possible to easily add the remaining missing features, such as printing camera info.
4 years ago
};
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
using namespace Containers::Literals;
{image,scene}converter: extract and test --info printing code. It was quite a pile, and all of it was written just once, relying only on hopefully-available model files that would hopefully touch most code paths. Which means, extremely annoying to make changes in. I extracted the code to a header that can be tested with a mocked-up importer and without having to execute the utility itself, deduplicated the image info printing code, fixed various inconsistencies (such as data/field flags sometimes denoted with superfluous "flags:" and sometimes not) and TODOs (such as 2D/3D skins, where there was no format whatsoever that would have 2D skin support, so the code couldn't get written). Now it's finally possible to easily add the remaining missing features, such as printing camera info.
4 years ago
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
const struct {
sceneconverter: don't load the importer plugin for --info-converter. If it crashes or does some other shit, it'll cause the tool to not work at all. If it fails to load due to whatever other issue, it'll spam the output for no reason.
3 years ago
TestSuite::TestCaseDescriptionSourceLocation name;
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
Containers::Array<Containers::String> args;
sceneconverter: generalize --info test a bit. Preparing for different importers and info for plugins.
4 years ago
const char* requiresImporter;
{scene,image}converter: add --info options for plugins. Lists features, aliases as well as documented contents of the whole configuration file. Useful to not need to look up online docs when working on the command line.
4 years ago
const char* requiresConverter;
const char* requiresImageConverter;
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
const char* expected;
} InfoData[]{
{image,scene}converter: use shorter Array construction in --info tests.
3 years ago
{"importer", {InPlaceInit, {
"--info-importer", "-i", "someOption=yes"
}},
{scene,image}converter: add --info options for plugins. Lists features, aliases as well as documented contents of the whole configuration file. Useful to not need to look up online docs when working on the command line.
4 years ago
"AnySceneImporter", nullptr, nullptr,
"info-importer.txt"},
{image,scene}converter: use shorter Array construction in --info tests.
3 years ago
{"converter", {InPlaceInit, {
"-C", "AnySceneConverter", "--info-converter", "-c", "someOption=yes"
}},
{scene,image}converter: add --info options for plugins. Lists features, aliases as well as documented contents of the whole configuration file. Useful to not need to look up online docs when working on the command line.
4 years ago
nullptr, "AnySceneConverter", nullptr,
"info-converter.txt"},
{image,scene}converter: use shorter Array construction in --info tests.
3 years ago
{"converter, implicit", {InPlaceInit, {
"--info-converter", "-c", "someOption=yes"
}},
{scene,image}converter: add --info options for plugins. Lists features, aliases as well as documented contents of the whole configuration file. Useful to not need to look up online docs when working on the command line.
4 years ago
nullptr, "AnySceneConverter", nullptr,
"info-converter.txt"},
{image,scene}converter: use shorter Array construction in --info tests.
3 years ago
{"image converter", {InPlaceInit, {
"-P", "AnyImageConverter", "--info-image-converter", "-p", "someOption=yes"
}},
{scene,image}converter: add --info options for plugins. Lists features, aliases as well as documented contents of the whole configuration file. Useful to not need to look up online docs when working on the command line.
4 years ago
nullptr, nullptr, "AnyImageConverter",
"info-image-converter.txt"},
{image,scene}converter: use shorter Array construction in --info tests.
3 years ago
{"image converter, implicit", {InPlaceInit, {
"--info-image-converter", "-p", "someOption=yes"
}},
{scene,image}converter: add --info options for plugins. Lists features, aliases as well as documented contents of the whole configuration file. Useful to not need to look up online docs when working on the command line.
4 years ago
nullptr, nullptr, "AnyImageConverter",
"info-image-converter.txt"},
{image,scene}converter: use shorter Array construction in --info tests.
3 years ago
{"importer, ignored input and output", {InPlaceInit, {
"--info-importer", "input.obj", "output.ply"
}},
{scene,image}converter: add --info options for plugins. Lists features, aliases as well as documented contents of the whole configuration file. Useful to not need to look up online docs when working on the command line.
4 years ago
"AnySceneImporter", nullptr, nullptr,
"info-importer-ignored-input-output.txt"},
{image,scene}converter: use shorter Array construction in --info tests.
3 years ago
{"data", {InPlaceInit, {
"-I", "ObjImporter", "--info", Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/point.obj")
}},
{scene,image}converter: add --info options for plugins. Lists features, aliases as well as documented contents of the whole configuration file. Useful to not need to look up online docs when working on the command line.
4 years ago
"ObjImporter", nullptr, nullptr,
sceneconverter: generalize --info test a bit. Preparing for different importers and info for plugins.
4 years ago
"info-data.txt"},
{image,scene}converter: use shorter Array construction in --info tests.
3 years ago
{"data, map", {InPlaceInit, {
"--map", "-I", "ObjImporter", "--info", Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/point.obj")
}},
{scene,image}converter: add --info options for plugins. Lists features, aliases as well as documented contents of the whole configuration file. Useful to not need to look up online docs when working on the command line.
4 years ago
"ObjImporter", nullptr, nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
/** @todo change to something else once we have a plugin that can
zero-copy pass the imported data */
sceneconverter: generalize --info test a bit. Preparing for different importers and info for plugins.
4 years ago
"info-data.txt"},
{image,scene}converter: use shorter Array construction in --info tests.
3 years ago
{"data, ignored output file", {InPlaceInit, {
"-I", "ObjImporter", "--info", Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/point.obj"), "whatever.ply"
}},
{scene,image}converter: add --info options for plugins. Lists features, aliases as well as documented contents of the whole configuration file. Useful to not need to look up online docs when working on the command line.
4 years ago
"ObjImporter", nullptr, nullptr,
sceneconverter: generalize --info test a bit. Preparing for different importers and info for plugins.
4 years ago
"info-data-ignored-output.txt"}
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
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;
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
Containers::Array<Containers::String> args;
const char* requiresImporter;
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
const char* requiresImporter2;
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
const char* requiresConverter;
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
/* One for image, one for file conversion */
const char* requiresImageConverter[2];
sceneconverter: ability to apply a converter to each mesh in the scene.
4 years ago
const char* requiresMeshConverter;
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
const char* expected;
sceneconverter: recognize whole-scene converters. Just a minimal support to get single-mesh conversion working with GltfSceneConverter. The whole thing has to be subsequently reworked to not be oriented around meshes, but this is the first step.
4 years ago
const char* expected2;
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
Containers::String message;
} ConvertData[]{
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one mesh", {InPlaceInit, {
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, "StanfordSceneConverter", {}, nullptr,
sceneconverter: recognize whole-scene converters. Just a minimal support to get single-mesh conversion working with GltfSceneConverter. The whole thing has to be subsequently reworked to not be oriented around meshes, but this is the first step.
4 years ago
"quad.ply", nullptr,
{}},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one mesh, whole scene converter", {InPlaceInit, {
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, "GltfSceneConverter", {}, nullptr,
sceneconverter: recognize whole-scene converters. Just a minimal support to get single-mesh conversion working with GltfSceneConverter. The whole thing has to be subsequently reworked to not be oriented around meshes, but this is the first step.
4 years ago
"quad.gltf", "quad.bin",
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
{}},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one mesh, explicit importer and converter", {InPlaceInit, {
"-I", "ObjImporter", "-C", "StanfordSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, "StanfordSceneConverter", {}, nullptr,
sceneconverter: recognize whole-scene converters. Just a minimal support to get single-mesh conversion working with GltfSceneConverter. The whole thing has to be subsequently reworked to not be oriented around meshes, but this is the first step.
4 years ago
"quad.ply", nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
{}},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one mesh, map", {InPlaceInit, {
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, "StanfordSceneConverter", {}, nullptr,
sceneconverter: recognize whole-scene converters. Just a minimal support to get single-mesh conversion working with GltfSceneConverter. The whole thing has to be subsequently reworked to not be oriented around meshes, but this is the first step.
4 years ago
"quad.ply", nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
{}},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one mesh, options", {InPlaceInit, {
/* It's silly, but since we have option propagation tested in
AnySceneImporter / AnySceneConverter .cpp already, it's enough
to just verify the (nonexistent) options arrive there */
"-i", "nonexistentOption=13", "-c", "nonexistentConverterOption=26",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, "StanfordSceneConverter", {}, nullptr,
sceneconverter: recognize whole-scene converters. Just a minimal support to get single-mesh conversion working with GltfSceneConverter. The whole thing has to be subsequently reworked to not be oriented around meshes, but this is the first step.
4 years ago
"quad.ply", nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
"Trade::AnySceneImporter::openFile(): option nonexistentOption not recognized by ObjImporter\n"
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
"Trade::AnySceneConverter::beginFile(): option nonexistentConverterOption not recognized by StanfordSceneConverter\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one mesh, options, explicit importer and converter", {InPlaceInit, {
/* Same here, since we have option propagation tested in
Magnum/Test/ConverterUtilitiesTest.cpp already, to verify it's
getting called we can just supply nonexistent options */
"-i", "nonexistentOption=13", "-c", "nonexistentConverterOption=26",
"-I", "ObjImporter", "-C", "StanfordSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, "StanfordSceneConverter", {}, nullptr,
sceneconverter: recognize whole-scene converters. Just a minimal support to get single-mesh conversion working with GltfSceneConverter. The whole thing has to be subsequently reworked to not be oriented around meshes, but this is the first step.
4 years ago
"quad.ply", nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
"Option nonexistentOption not recognized by ObjImporter\n"
"Option nonexistentConverterOption not recognized by StanfordSceneConverter\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"two meshes + scene", {InPlaceInit, {
/* Removing the generator identifier to have the file fully roundtrip */
"-c", "generator=",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/two-quads.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/two-quads.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "GltfSceneConverter", {}, nullptr,
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
/* There should be a minimal difference compared to the original */
"two-quads.gltf", "two-quads.bin",
{}},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"concatenate meshes without a scene", {InPlaceInit, {
"--concatenate-meshes",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/two-triangles.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad-duplicates.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, "StanfordSceneConverter", {}, nullptr,
sceneconverter: recognize whole-scene converters. Just a minimal support to get single-mesh conversion working with GltfSceneConverter. The whole thing has to be subsequently reworked to not be oriented around meshes, but this is the first step.
4 years ago
"quad-duplicates.ply", nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
{}},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"concatenate meshes with a scene", {InPlaceInit, {
"--concatenate-meshes",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/two-triangles-transformed.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad-duplicates.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "StanfordSceneConverter", {}, nullptr,
sceneconverter: recognize whole-scene converters. Just a minimal support to get single-mesh conversion working with GltfSceneConverter. The whole thing has to be subsequently reworked to not be oriented around meshes, but this is the first step.
4 years ago
"quad-duplicates.ply", nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
{}},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"concatenate meshes with a scene but no default scene", {InPlaceInit, {
"--concatenate-meshes",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/two-triangles-transformed-no-default-scene.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad-duplicates.ply")
}},
sceneconverter: adapt tests to GltfImporter and SceneConverter changes.
4 years ago
"GltfImporter", nullptr, "StanfordSceneConverter", {}, nullptr,
"quad-duplicates.ply", nullptr,
{}},
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
/** @todo drop --mesh once it's not needed anymore again, then add a
multi-mesh variant */
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one mesh, filter mesh attributes", {InPlaceInit, {
/* Only 0 gets picked from here, others ignored */
"--mesh", "0", "--only-mesh-attributes", "17,0,25-36",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad-normals-texcoords.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, "StanfordSceneConverter", {}, nullptr,
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
"quad.ply", nullptr,
{}},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"concatenate meshes, filter mesh attributes", {InPlaceInit, {
"--concatenate-meshes", "--only-mesh-attributes", "17,0,25-36",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad-normals-texcoords.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, "StanfordSceneConverter", {}, nullptr,
sceneconverter: recognize whole-scene converters. Just a minimal support to get single-mesh conversion working with GltfSceneConverter. The whole thing has to be subsequently reworked to not be oriented around meshes, but this is the first step.
4 years ago
"quad.ply", nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
{}},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one implicit mesh, remove vertex duplicates", {InPlaceInit, {
"--remove-duplicate-vertices",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad-duplicates.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, "StanfordSceneConverter", {}, nullptr,
sceneconverter: recognize whole-scene converters. Just a minimal support to get single-mesh conversion working with GltfSceneConverter. The whole thing has to be subsequently reworked to not be oriented around meshes, but this is the first step.
4 years ago
"quad.ply", nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
{}},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one implicit mesh, remove duplicate vertices, verbose", {InPlaceInit, {
/* Forcing the importer and converter to avoid AnySceneImporter /
AnySceneConverter delegation messages */
"--remove-duplicate-vertices", "-v", "-I", "ObjImporter", "-C", "StanfordSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad-duplicates.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, "StanfordSceneConverter", {}, nullptr,
sceneconverter: recognize whole-scene converters. Just a minimal support to get single-mesh conversion working with GltfSceneConverter. The whole thing has to be subsequently reworked to not be oriented around meshes, but this is the first step.
4 years ago
"quad.ply", nullptr,
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
"Mesh 0 duplicate removal: 6 -> 4 vertices\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one selected mesh, remove duplicate vertices, verbose", {InPlaceInit, {
/* Forcing the importer and converter to avoid AnySceneImporter /
AnySceneConverter delegation messages */
"--mesh", "1", "--remove-duplicate-vertices", "-v",
"-I", "GltfImporter", "-C", "StanfordSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/two-quads-duplicates.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "StanfordSceneConverter", {}, nullptr,
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
/* The second mesh in the glTF is deliberately the same as in
quad-duplicates.obj, so this produces the same file */
"quad.ply", nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
"Duplicate removal: 6 -> 4 vertices\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"two meshes + scene, remove duplicate vertices, verbose", {InPlaceInit, {
/* Forcing the importer and converter to avoid AnySceneImporter /
AnySceneConverter delegation messages */
"--remove-duplicate-vertices", "-v", "-I", "GltfImporter", "-C", "GltfSceneConverter",
/* Removing the generator identifier for a smaller file */
"-c", "generator=",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/two-quads-duplicates.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/two-quads.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "GltfSceneConverter", {}, nullptr,
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
/* There should be a minimal difference compared to the original */
"two-quads.gltf", "two-quads.bin",
"Mesh 0 duplicate removal: 5 -> 4 vertices\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
"Mesh 1 duplicate removal: 6 -> 4 vertices\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding scene 0 out of 1\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one implicit mesh, remove duplicate vertices fuzzy", {InPlaceInit, {
"--remove-duplicate-vertices-fuzzy", "1.0e-1",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad-duplicates-fuzzy.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, "StanfordSceneConverter", {}, nullptr,
sceneconverter: recognize whole-scene converters. Just a minimal support to get single-mesh conversion working with GltfSceneConverter. The whole thing has to be subsequently reworked to not be oriented around meshes, but this is the first step.
4 years ago
"quad.ply", nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
{}},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one implicit mesh, remove duplicate vertices fuzzy, verbose", {InPlaceInit, {
/* Forcing the importer and converter to avoid AnySceneImporter /
AnySceneConverter delegation messages */
"--remove-duplicate-vertices-fuzzy", "1.0e-1", "-v",
"-I", "ObjImporter", "-C", "StanfordSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad-duplicates-fuzzy.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, "StanfordSceneConverter", {}, nullptr,
sceneconverter: recognize whole-scene converters. Just a minimal support to get single-mesh conversion working with GltfSceneConverter. The whole thing has to be subsequently reworked to not be oriented around meshes, but this is the first step.
4 years ago
"quad.ply", nullptr,
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
"Mesh 0 fuzzy duplicate removal: 6 -> 4 vertices\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one selected mesh, remove duplicate vertices fuzzy, verbose", {InPlaceInit, {
/* Forcing the importer and converter to avoid AnySceneImporter /
AnySceneConverter delegation messages */
"--mesh 1", "--remove-duplicate-vertices-fuzzy", "1.0e-1", "-v",
"-I", "GltfImporter", "-C", "StanfordSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/two-quads-duplicates-fuzzy.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "StanfordSceneConverter", {}, nullptr,
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
/* The second mesh in the glTF is deliberately the same as in
quad-duplicates-fuzzy.obj, so this produces the same file */
"quad.ply", nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
"Fuzzy duplicate removal: 6 -> 4 vertices\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"two meshes + scene, remove duplicate vertices fuzzy, verbose", {InPlaceInit, {
/* Forcing the importer and converter to avoid AnySceneImporter /
AnySceneConverter delegation messages */
"--remove-duplicate-vertices-fuzzy", "1.0e-1", "-v",
"-I", "GltfImporter", "-C", "GltfSceneConverter",
/* Removing the generator identifier for a smaller file */
"-c", "generator=",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/two-quads-duplicates-fuzzy.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/two-quads.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "GltfSceneConverter", {}, nullptr,
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
"two-quads.gltf", "two-quads.bin",
"Mesh 0 fuzzy duplicate removal: 5 -> 4 vertices\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
"Mesh 1 fuzzy duplicate removal: 6 -> 4 vertices\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding scene 0 out of 1\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one implicit mesh, two converters", {InPlaceInit, {
/* Not removing the generator identifier in this case as we want to
test passing no options */
"-C", "MeshOptimizerSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad-strip.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "GltfSceneConverter", {}, nullptr,
sceneconverter: properly test that converters get chained together. What was there didn't really check that the output of one converter was used as input for the next one. Especially with the upcoming rework for full scene conversion that could lead to dangerous regressions.
4 years ago
"quad.gltf", "quad.bin",
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
{}},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one implicit mesh, two converters, explicit last", {InPlaceInit, {
/* Not removing the generator identifier in this case as we want to
test passing no options */
"-C", "MeshOptimizerSceneConverter", "-C", "GltfSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad-strip.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "GltfSceneConverter", {}, nullptr,
sceneconverter: properly test that converters get chained together. What was there didn't really check that the output of one converter was used as input for the next one. Especially with the upcoming rework for full scene conversion that could lead to dangerous regressions.
4 years ago
"quad.gltf", "quad.bin",
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
{}},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one implicit mesh, two converters, verbose", {InPlaceInit, {
/* Not removing the generator identifier in this case as we want to
test passing no options */
"-C", "MeshOptimizerSceneConverter", "-v",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad-strip.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "GltfSceneConverter", {}, nullptr,
sceneconverter: properly test that converters get chained together. What was there didn't really check that the output of one converter was used as input for the next one. Especially with the upcoming rework for full scene conversion that could lead to dangerous regressions.
4 years ago
"quad.gltf", "quad.bin",
/* While this looks like a no-op in the output, it converts a
triangle strip to indexed triangles, which verifies that the output
of MeshOptimizerSceneConverter got actually passed further and not
discarded */
"Trade::AnySceneImporter::openFile(): using GltfImporter\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 mesh 0 out of 1\n"
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
"Trade::MeshOptimizerSceneConverter::convert(): processing stats:\n"
" vertex cache:\n"
" 4 -> 4 transformed vertices\n"
" 1 -> 1 executed warps\n"
" ACMR 2 -> 2\n"
" ATVR 1 -> 1\n"
" vertex fetch:\n"
" 64 -> 64 bytes fetched\n"
" overfetch 1.33333 -> 1.33333\n"
" overdraw:\n"
" 65536 -> 65536 shaded pixels\n"
" 65536 -> 65536 covered pixels\n"
" overdraw 1 -> 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
"Trade::AnySceneConverter::beginFile(): using GltfSceneConverter\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding mesh 0 out of 1\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one implicit mesh, two converters, explicit last, verbose", {InPlaceInit, {
"-C", "MeshOptimizerSceneConverter", "-C", "GltfSceneConverter", "-v",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad-strip.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "GltfSceneConverter", {}, nullptr,
sceneconverter: properly test that converters get chained together. What was there didn't really check that the output of one converter was used as input for the next one. Especially with the upcoming rework for full scene conversion that could lead to dangerous regressions.
4 years ago
"quad.gltf", "quad.bin",
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
/* As the importers and converters are specified explicitly, there's
no messages from AnySceneConverter, OTOH as we have more than one -C
option the verbose output includes a progress info */
sceneconverter: properly test that converters get chained together. What was there didn't really check that the output of one converter was used as input for the next one. Especially with the upcoming rework for full scene conversion that could lead to dangerous regressions.
4 years ago
"Trade::AnySceneImporter::openFile(): using GltfImporter\n"
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
"Processing (1/2) with MeshOptimizerSceneConverter...\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 mesh 0 out of 1\n"
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
"Trade::MeshOptimizerSceneConverter::convert(): processing stats:\n"
" vertex cache:\n"
" 4 -> 4 transformed vertices\n"
" 1 -> 1 executed warps\n"
" ACMR 2 -> 2\n"
" ATVR 1 -> 1\n"
" vertex fetch:\n"
" 64 -> 64 bytes fetched\n"
" overfetch 1.33333 -> 1.33333\n"
" overdraw:\n"
" 65536 -> 65536 shaded pixels\n"
" 65536 -> 65536 covered pixels\n"
" overdraw 1 -> 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
"Saving output (2/2) with GltfSceneConverter...\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding mesh 0 out of 1\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one implicit mesh, two converters, options for the first only", {InPlaceInit, {
"-C", "MeshOptimizerSceneConverter",
"-c", "nonexistentMeshOptimizerOption=yes",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad-strip.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "GltfSceneConverter", {}, nullptr,
sceneconverter: recognize whole-scene converters. Just a minimal support to get single-mesh conversion working with GltfSceneConverter. The whole thing has to be subsequently reworked to not be oriented around meshes, but this is the first step.
4 years ago
"quad.ply", nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
"Option nonexistentMeshOptimizerOption not recognized by MeshOptimizerSceneConverter\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one implicit mesh, two converters, explicit last, options for the first only", {InPlaceInit, {
"-C", "MeshOptimizerSceneConverter",
"-c", "nonexistentMeshOptimizerOption=yes",
"-C", "StanfordSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad-strip.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "GltfSceneConverter", {}, nullptr,
sceneconverter: recognize whole-scene converters. Just a minimal support to get single-mesh conversion working with GltfSceneConverter. The whole thing has to be subsequently reworked to not be oriented around meshes, but this is the first step.
4 years ago
"quad.ply", nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
"Option nonexistentMeshOptimizerOption not recognized by MeshOptimizerSceneConverter\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one implicit mesh, two converters, options for both", {InPlaceInit, {
"-C", "MeshOptimizerSceneConverter",
"-c", "nonexistentMeshOptimizerOption=yes",
"-c", "nonexistentAnyConverterOption=no",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad-strip.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "GltfSceneConverter", {}, nullptr,
sceneconverter: recognize whole-scene converters. Just a minimal support to get single-mesh conversion working with GltfSceneConverter. The whole thing has to be subsequently reworked to not be oriented around meshes, but this is the first step.
4 years ago
"quad.ply", nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
"Option nonexistentMeshOptimizerOption not recognized by MeshOptimizerSceneConverter\n"
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
"Trade::AnySceneConverter::beginFile(): option nonexistentAnyConverterOption not recognized by GltfSceneConverter\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one implicit mesh, two converters, explicit last, options for both", {InPlaceInit, {
"-C", "MeshOptimizerSceneConverter",
"-c", "nonexistentMeshOptimizerOption=yes",
"-C", "StanfordSceneConverter",
"-c", "nonexistentStanfordConverterOption=no",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad-strip.gltf"), Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "GltfSceneConverter", {}, nullptr,
sceneconverter: recognize whole-scene converters. Just a minimal support to get single-mesh conversion working with GltfSceneConverter. The whole thing has to be subsequently reworked to not be oriented around meshes, but this is the first step.
4 years ago
"quad.ply", nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
"Option nonexistentMeshOptimizerOption not recognized by MeshOptimizerSceneConverter\n"
"Option nonexistentStanfordConverterOption not recognized by StanfordSceneConverter\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"one mesh, remove duplicate vertices, two converters, verbose", {InPlaceInit, {
"--remove-duplicate-vertices",
"-C", "MeshOptimizerSceneConverter", "-v",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad-duplicates.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, "StanfordSceneConverter", {}, nullptr,
sceneconverter: one more half-done corner case test.
4 years ago
"quad.ply", nullptr,
"Trade::AnySceneImporter::openFile(): using ObjImporter\n"
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
"Mesh 0 duplicate removal: 6 -> 4 vertices\n"
sceneconverter: one more half-done corner case test.
4 years ago
/** @todo this only verifies that the result of duplicate removal is
properly passed to MeshOptimizer, but not that the MeshOptimizer
output is properly passed to StanfordSceneConverter -- needs to
wait until there's a plugin which can verify that with a small
data amount */
"Trade::MeshOptimizerSceneConverter::convert(): processing stats:\n"
" vertex cache:\n"
" 4 -> 4 transformed vertices\n"
" 1 -> 1 executed warps\n"
" ACMR 2 -> 2\n"
" ATVR 1 -> 1\n"
" vertex fetch:\n"
" 64 -> 64 bytes fetched\n"
" overfetch 1.33333 -> 1.33333\n"
" overdraw:\n"
" 65536 -> 65536 shaded pixels\n"
" 65536 -> 65536 covered pixels\n"
" overdraw 1 -> 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
"Trade::AnySceneConverter::beginFile(): using StanfordSceneConverter\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding mesh 0 out of 1\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"implicit custom-processed mesh with a name and custom attributes", {InPlaceInit, {
/* Removing the generator identifier to have the file closer to the
original */
"--remove-duplicate-vertices", "-c", "generator=",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad-name-custom-attributes-duplicates.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad-name-custom-attributes.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "GltfSceneConverter", {}, nullptr,
sceneconverter: propagate names and custom attributes of processed meshes. It's done by addSupportedImporterContents() only if they aren't processed explicitly and passed directly.
4 years ago
/* The output should be mostly the same, except that there's now only 4
vertices instead of 6. The code that adds meshes manually instead of
using addSupportedImporterContents() should take care of propagating
mesh names and custom attributes as well. */
"quad-name-custom-attributes.gltf", "quad-name-custom-attributes.bin",
{}},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"selected custom-processed mesh with a name and custom attributes", {InPlaceInit, {
/* Removing the generator identifier to have the file closer to the
original */
"--mesh", "0", "--remove-duplicate-vertices", "-c", "generator=",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad-name-custom-attributes-duplicates.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad-name-custom-attributes.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "GltfSceneConverter", {}, nullptr,
sceneconverter: propagate names and custom attributes of processed meshes. It's done by addSupportedImporterContents() only if they aren't processed explicitly and passed directly.
4 years ago
/* The output should be mostly the same, except that there's now only 4
vertices instead of 6. The code that adds meshes manually instead of
using addSupportedImporterContents() should take care of propagating
mesh names and custom attributes as well. */
"quad-name-custom-attributes.gltf", "quad-name-custom-attributes.bin",
{}},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"mesh converter", {InPlaceInit, {
"-M", "MeshOptimizerSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad-strip.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "GltfSceneConverter",
{}, "MeshOptimizerSceneConverter",
sceneconverter: ability to apply a converter to each mesh in the scene.
4 years ago
/* Converts a triangle strip to indexed triangles, which verifies that
the output of MeshOptimizerSceneConverter got actually passed
further and not discarded */
"quad.gltf", "quad.bin",
{}},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"mesh converter, two meshes, verbose", {InPlaceInit, {
/* Removing the generator identifier for a smaller file */
"-I", "GltfImporter", "-C", "GltfSceneConverter", "-c", "generator=",
"-M", "MeshOptimizerSceneConverter", "-v",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/two-quads.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/two-quads.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "GltfSceneConverter",
{}, "MeshOptimizerSceneConverter",
sceneconverter: ability to apply a converter to each mesh in the scene.
4 years ago
"two-quads.gltf", "two-quads.bin",
"Processing mesh 0 with MeshOptimizerSceneConverter...\n"
"Trade::MeshOptimizerSceneConverter::convert(): processing stats:\n"
" vertex cache:\n"
" 4 -> 4 transformed vertices\n"
" 1 -> 1 executed warps\n"
" ACMR 2 -> 2\n"
" ATVR 1 -> 1\n"
" vertex fetch:\n"
" 64 -> 64 bytes fetched\n"
" overfetch 1.33333 -> 1.33333\n"
" overdraw:\n"
" 65536 -> 65536 shaded pixels\n"
" 65536 -> 65536 covered pixels\n"
" overdraw 1 -> 1\n"
"Processing mesh 1 with MeshOptimizerSceneConverter...\n"
"Trade::MeshOptimizerSceneConverter::convert(): processing stats:\n"
" vertex cache:\n"
" 4 -> 4 transformed vertices\n"
" 1 -> 1 executed warps\n"
" ACMR 2 -> 2\n"
" ATVR 1 -> 1\n"
" vertex fetch:\n"
" 64 -> 64 bytes fetched\n"
" overfetch 1.33333 -> 1.33333\n"
" overdraw:\n"
" 65536 -> 65536 shaded pixels\n"
" 65536 -> 65536 covered pixels\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
" overdraw 1 -> 1\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding scene 0 out of 1\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"two mesh converters, two options, one mesh, verbose", {InPlaceInit, {
"-I", "GltfImporter", "-C", "GltfSceneConverter",
"-M", "MeshOptimizerSceneConverter",
"-m", "nonexistentFirstOption=yes",
"-M", "MeshOptimizerSceneConverter",
"-m", "nonexistentSecondOption=yes", "-v",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/quad-strip.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "GltfSceneConverter",
{}, "MeshOptimizerSceneConverter",
sceneconverter: ability to apply a converter to each mesh in the scene.
4 years ago
"quad.gltf", "quad.bin",
"Processing mesh 0 (1/2) with MeshOptimizerSceneConverter...\n"
"Option nonexistentFirstOption not recognized by MeshOptimizerSceneConverter\n"
"Trade::MeshOptimizerSceneConverter::convert(): processing stats:\n"
" vertex cache:\n"
" 4 -> 4 transformed vertices\n"
" 1 -> 1 executed warps\n"
" ACMR 2 -> 2\n"
" ATVR 1 -> 1\n"
" vertex fetch:\n"
" 64 -> 64 bytes fetched\n"
" overfetch 1.33333 -> 1.33333\n"
" overdraw:\n"
" 65536 -> 65536 shaded pixels\n"
" 65536 -> 65536 covered pixels\n"
" overdraw 1 -> 1\n"
"Processing mesh 0 (2/2) with MeshOptimizerSceneConverter...\n"
"Option nonexistentSecondOption not recognized by MeshOptimizerSceneConverter\n"
"Trade::MeshOptimizerSceneConverter::convert(): processing stats:\n"
" vertex cache:\n"
" 4 -> 4 transformed vertices\n"
" 1 -> 1 executed warps\n"
" ACMR 2 -> 2\n"
" ATVR 1 -> 1\n"
" vertex fetch:\n"
" 64 -> 64 bytes fetched\n"
" overfetch 1.33333 -> 1.33333\n"
" overdraw:\n"
" 65536 -> 65536 shaded pixels\n"
" 65536 -> 65536 covered pixels\n"
" overdraw 1 -> 1\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"2D image converter, two images", {InPlaceInit, {
"-P", "StbResizeImageConverter", "-p", "size=\"1 1\"",
/* Removing the generator identifier for a smaller file, bundling
the images to avoid having too many files */
"-c", "bundleImages,generator=",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/images-2d.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/images-2d-1x1.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", "PngImporter", "GltfSceneConverter",
{"StbResizeImageConverter", "PngImageConverter"}, nullptr,
"images-2d-1x1.gltf", "images-2d-1x1.bin",
{}},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"2D image converter, two images, verbose", {InPlaceInit, {
"-I", "GltfImporter", "-C", "GltfSceneConverter",
"-P", "StbResizeImageConverter", "-p", "size=\"1 1\"",
/* Removing the generator identifier for a smaller file, bundling
the images to avoid having too many files */
"-c", "bundleImages,generator=", "-v",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/images-2d.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/images-2d-1x1.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", "PngImporter", "GltfSceneConverter",
{"StbResizeImageConverter", "PngImageConverter"}, nullptr,
"images-2d-1x1.gltf", "images-2d-1x1.bin",
"Trade::AnyImageImporter::openFile(): using PngImporter\n"
"Processing 2D image 0 with StbResizeImageConverter...\n"
"Trade::AnyImageImporter::openFile(): using PngImporter\n"
"Processing 2D image 1 with StbResizeImageConverter...\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"two 2D image converters, two images, verbose", {InPlaceInit, {
"-I", "GltfImporter", "-C", "GltfSceneConverter",
"-P", "StbResizeImageConverter", "-p", "size=\"2 2\"",
"-P", "StbResizeImageConverter", "-p", "size=\"1 1\"",
/* Removing the generator identifier for a smaller file, bundling
the images to avoid having too many files */
"-c", "bundleImages,generator=", "-v",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/images-2d.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/images-2d-1x1.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", "PngImporter", "GltfSceneConverter",
{"StbResizeImageConverter", "PngImageConverter"}, nullptr,
"images-2d-1x1.gltf", "images-2d-1x1.bin",
"Trade::AnyImageImporter::openFile(): using PngImporter\n"
"Processing 2D image 0 (1/2) with StbResizeImageConverter...\n"
"Processing 2D image 0 (2/2) with StbResizeImageConverter...\n"
"Trade::AnyImageImporter::openFile(): using PngImporter\n"
"Processing 2D image 1 (1/2) with StbResizeImageConverter...\n"
"Processing 2D image 1 (2/2) with StbResizeImageConverter...\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"3D image converter, two images", {InPlaceInit, {
"-i", "experimentalKhrTextureKtx",
"-P", "StbResizeImageConverter", "-p", "size=\"1 1\"",
/* Removing the generator identifier for a smaller file, bundling
the images to avoid having too many files */
"-c", "experimentalKhrTextureKtx,imageConverter=KtxImageConverter,bundleImages,generator=",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/images-3d.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/images-3d-1x1x1.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", "PngImporter", "GltfSceneConverter",
{"StbResizeImageConverter", "KtxImageConverter"}, nullptr,
"images-3d-1x1x1.gltf", "images-3d-1x1x1.bin",
{}},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"3D image converter, two images, verbose", {InPlaceInit, {
"-I", "GltfImporter", "-C", "GltfSceneConverter",
"-i", "experimentalKhrTextureKtx",
"-P", "StbResizeImageConverter", "-p", "size=\"1 1\"",
/* Removing the generator identifier for a smaller file, bundling
the images to avoid having too many files */
"-c", "experimentalKhrTextureKtx,imageConverter=KtxImageConverter,bundleImages,generator=", "-v",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/images-3d.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/images-3d-1x1x1.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", "PngImporter", "GltfSceneConverter",
{"StbResizeImageConverter", "KtxImageConverter"}, nullptr,
"images-3d-1x1x1.gltf", "images-3d-1x1x1.bin",
"Trade::AnyImageImporter::openFile(): using KtxImporter\n"
"Processing 3D image 0 with StbResizeImageConverter...\n"
"Trade::AnyImageImporter::openFile(): using KtxImporter\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
"Processing 3D image 1 with StbResizeImageConverter...\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding texture 0 out of 2\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding texture 1 out of 2\n"},
sceneconverter: implement a --phong-to-pbr option. Exposes MaterialTools::phongToPbrMetallicRoughness() that got added some time ago. Most of the code and tests is scaffolding needed for direct material import and processing outside of the addImporterContents() automagic, similar to what was already done for meshes and images. In particular, adding more material conversion options such as canonicalization or deduplication will be significantly easier now that the basics are done and tested.
3 years ago
{"Phong to PBR", {InPlaceInit, {
"-I", "UfbxImporter", "-C", "GltfSceneConverter", "--phong-to-pbr",
/* We need the file as minimal as possible, so no index buffer.
OTOH, dropping meshes altogether would also lose
node/mesh/material assignment, which is important */
"-i", "generateIndices=false",
/* Removing the generator identifier for a smaller file */
"-c", "generator=",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/materials-phong.obj"), Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/materials-pbr.gltf")
}},
"UfbxImporter", "PngImporter", "GltfSceneConverter", {"PngImageConverter", nullptr}, nullptr,
/* The file should contain also material names and everything */
"materials-pbr.gltf", nullptr,
"MaterialTools::phongToPbrMetallicRoughness(): unconvertable Trade::MaterialAttribute::AmbientColor attribute, skipping\n"
sceneconverter: adapt the test to (upcoming) UfbxImporter changes.
3 years ago
/** @todo remove this once GltfSceneConverter supports bit fields */
"Trade::GltfSceneConverter::add(): custom scene field Visibility has unsupported type Trade::SceneFieldType::Bit, skipping\n"
"Trade::GltfSceneConverter::add(): custom scene field GeometryTransformHelper has unsupported type Trade::SceneFieldType::Bit, skipping\n"},
sceneconverter: implement a --phong-to-pbr option. Exposes MaterialTools::phongToPbrMetallicRoughness() that got added some time ago. Most of the code and tests is scaffolding needed for direct material import and processing outside of the addImporterContents() automagic, similar to what was already done for meshes and images. In particular, adding more material conversion options such as canonicalization or deduplication will be significantly easier now that the basics are done and tested.
3 years ago
{"Phong to PBR, verbose", {InPlaceInit, {
/* Same as above, just with -v added */
"-I", "UfbxImporter", "-C", "GltfSceneConverter", "--phong-to-pbr",
"-i", "generateIndices=false", "-c", "generator=", "-v",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/materials-phong.obj"), Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/materials-pbr.gltf")
}},
"UfbxImporter", "PngImporter", "GltfSceneConverter", {"PngImageConverter", nullptr}, nullptr,
"materials-pbr.gltf", nullptr,
"Converting material 0 to PBR\n"
"MaterialTools::phongToPbrMetallicRoughness(): unconvertable Trade::MaterialAttribute::AmbientColor attribute, skipping\n"
"Converting material 1 to PBR\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding 2D image 0 out of 2\n"
"Trade::AnyImageImporter::openFile(): using PngImporter\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding 2D image 1 out of 2\n"
"Trade::AnyImageImporter::openFile(): using PngImporter\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding texture 0 out of 2\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding texture 1 out of 2\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding mesh 0 out of 2\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding mesh 1 out of 2\n"
"Trade::AbstractSceneConverter::addImporterContents(): adding scene 0 out of 1\n"
sceneconverter: adapt the test to (upcoming) UfbxImporter changes.
3 years ago
/** @todo remove this once GltfSceneConverter supports bit fields */
"Trade::GltfSceneConverter::add(): custom scene field Visibility has unsupported type Trade::SceneFieldType::Bit, skipping\n"
"Trade::GltfSceneConverter::add(): custom scene field GeometryTransformHelper has unsupported type Trade::SceneFieldType::Bit, skipping\n"},
sceneconverter: test also behavior with ignored contents.
3 years ago
{"data unsupported by the converter", {InPlaceInit, {
"-I", "GltfImporter", "-i", "experimentalKhrTextureKtx",
"-C", "StanfordSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/ignoring-unsupported.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.ply")
}},
"GltfImporter", "KtxImporter", "StanfordSceneConverter",
{"StbResizeImageConverter", nullptr}, nullptr,
"quad.ply", nullptr,
"Trade::AbstractSceneConverter::addSupportedImporterContents(): ignoring 1 2D images not supported by the converter\n"
"Trade::AbstractSceneConverter::addSupportedImporterContents(): ignoring 1 3D images not supported by the converter\n"
sceneconverter: implement a --phong-to-pbr option. Exposes MaterialTools::phongToPbrMetallicRoughness() that got added some time ago. Most of the code and tests is scaffolding needed for direct material import and processing outside of the addImporterContents() automagic, similar to what was already done for meshes and images. In particular, adding more material conversion options such as canonicalization or deduplication will be significantly easier now that the basics are done and tested.
3 years ago
"Trade::AbstractSceneConverter::addSupportedImporterContents(): ignoring 2 textures not supported by the converter\n"
"Trade::AbstractSceneConverter::addSupportedImporterContents(): ignoring 1 materials not supported by the converter\n"},
sceneconverter: test also behavior with ignored contents.
3 years ago
{"per-image processed images unsupported by the converter", {InPlaceInit, {
"-I", "GltfImporter", "-i", "experimentalKhrTextureKtx",
"-P", "StbResizeImageConverter", "-p", "size=\"1 1\"",
"-C", "StanfordSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/ignoring-unsupported.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.ply")
}},
"GltfImporter", "KtxImporter", "StanfordSceneConverter",
{"StbResizeImageConverter", nullptr}, nullptr,
"quad.ply", nullptr,
/* Compared to "data unsupported by the converter" these messages are
printed by sceneconverter itself, not the converter interface */
"Ignoring 1 2D images not supported by the converter\n"
"Ignoring 1 3D images not supported by the converter\n"
sceneconverter: implement a --phong-to-pbr option. Exposes MaterialTools::phongToPbrMetallicRoughness() that got added some time ago. Most of the code and tests is scaffolding needed for direct material import and processing outside of the addImporterContents() automagic, similar to what was already done for meshes and images. In particular, adding more material conversion options such as canonicalization or deduplication will be significantly easier now that the basics are done and tested.
3 years ago
"Trade::AbstractSceneConverter::addSupportedImporterContents(): ignoring 2 textures not supported by the converter\n"
"Trade::AbstractSceneConverter::addSupportedImporterContents(): ignoring 1 materials not supported by the converter\n"},
{"per-material processed materials unsupported by the converter", {InPlaceInit, {
"-I", "GltfImporter", "-i", "experimentalKhrTextureKtx",
"--phong-to-pbr", "-C", "StanfordSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/ignoring-unsupported.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/quad.ply")
}},
"GltfImporter", "KtxImporter", "StanfordSceneConverter",
{"StbResizeImageConverter", nullptr}, nullptr,
"quad.ply", nullptr,
"Trade::AbstractSceneConverter::addSupportedImporterContents(): ignoring 1 2D images not supported by the converter\n"
"Trade::AbstractSceneConverter::addSupportedImporterContents(): ignoring 1 3D images not supported by the converter\n"
"Trade::AbstractSceneConverter::addSupportedImporterContents(): ignoring 2 textures not supported by the converter\n"
/* Compared to "data unsupported by the converter" this message is
printed by sceneconverter itself, not the converter interface */
"Ignoring 1 materials not supported by the converter\n"},
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
};
const struct {
sceneconverter: correctly mark test case plugin requirements. Otherwise if the plugins fail to load due to ABI issues or whatever the test will fail (which it shouldn't).
3 years ago
TestSuite::TestCaseDescriptionSourceLocation name;
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
Containers::Array<Containers::String> args;
const char* requiresImporter;
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
const char* requiresImageImporter;
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
const char* requiresConverter;
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
const char* requiresImageConverter;
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
Containers::String message;
} ErrorData[]{
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"missing output argument", {InPlaceInit, {
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/point.obj")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
nullptr, nullptr, nullptr, nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
/* The output should be optional only for --info, required otherwise.
No need to test anything else as that's handled by Utility::Arguments
already. Testing just a prefix of the message. */
"Missing command-line argument output\nUsage:\n "},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"--mesh and --concatenate-meshes", {InPlaceInit, {
"--mesh", "0", "--concatenate-meshes", "a", "b"
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
nullptr, nullptr, nullptr, nullptr,
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
"The --mesh and --concatenate-meshes options are mutually exclusive\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"--mesh-level but no --mesh", {InPlaceInit, {
"--mesh-level", "0", "a", "b"
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
nullptr, nullptr, nullptr, nullptr,
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
"The --mesh-level option can only be used with --mesh\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"--only-mesh-attributes but no --mesh", {InPlaceInit, {
"--only-mesh-attributes", "0", "a", "b"
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
nullptr, nullptr, nullptr, nullptr,
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
"The --only-mesh-attributes option can only be used with --mesh or --concatenate-meshes\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"can't load importer plugin", {InPlaceInit, {
/* Override also the plugin directory for consistent output */
"--plugin-dir", "nonexistent", "-I", "NonexistentImporter", "whatever.obj",
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
nullptr, nullptr, nullptr, nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
"PluginManager::Manager::load(): plugin NonexistentImporter is not static and was not found in nonexistent/importers\n"
"Available importer plugins: "},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"can't open a file", {InPlaceInit, {
"noexistent.ffs",
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"AnySceneImporter", nullptr, nullptr, nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
"Trade::AnySceneImporter::openFile(): cannot determine the format of noexistent.ffs\n"
"Cannot open file noexistent.ffs\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"can't map a file", {InPlaceInit, {
"noexistent.ffs", "--map",
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"AnySceneImporter", nullptr, nullptr, nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
"Utility::Path::mapRead(): can't open noexistent.ffs: error 2 (No such file or directory)\n"
"Cannot memory-map file noexistent.ffs\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"no meshes found for concatenation", {InPlaceInit, {
"--concatenate-meshes",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/empty.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, nullptr, nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
Utility::format("No meshes found in {}\n", Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/empty.gltf"))},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"can't import a single mesh", {InPlaceInit, {
"-I", "ObjImporter", "--mesh", "0",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/broken-mesh.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, nullptr, nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
"Trade::ObjImporter::mesh(): wrong index count for point\n"
"Cannot import the mesh\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"can't import a mesh for concatenation", {InPlaceInit, {
"-I", "ObjImporter", "--concatenate-meshes",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/broken-mesh.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, nullptr, nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
"Trade::ObjImporter::mesh(): wrong index count for point\n"
"Cannot import mesh 0\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"can't import a scene for concatenation", {InPlaceInit, {
/** @todo change to an OBJ once ObjImporter imports materials (and
thus scenes) */
"--concatenate-meshes",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/broken-scene.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, nullptr, nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
"Trade::GltfImporter::scene(): mesh index 1 in node 0 out of range for 1 meshes\n"
"Cannot import scene 0 for mesh concatenation\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"can't import a mesh for per-mesh processing", {InPlaceInit, {
"-I", "ObjImporter", "--remove-duplicate-vertices",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/broken-mesh.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, nullptr, nullptr,
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
"Trade::ObjImporter::mesh(): wrong index count for point\n"
"Cannot import mesh 0\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"invalid mesh attribute filter", {InPlaceInit, {
/** @todo drop --mesh once it's not needed anymore again */
"-I", "ObjImporter", "--mesh", "0", "--only-mesh-attributes", "LOLNEIN",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/point.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, nullptr, nullptr,
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
"Utility::parseNumberSequence(): unrecognized character L in LOLNEIN\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"can't load converter plugin", {InPlaceInit, {
"-C", "NonexistentSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/point.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, nullptr, nullptr,
sceneconverter: simplify plugin load error tests a bit. Should have realized this right at the start.
4 years ago
Utility::format("PluginManager::Manager::load(): plugin NonexistentSceneConverter is not static and was not found in {}\n"
"Available converter plugins: ", /* Just a prefix */
MAGNUM_PLUGINS_SCENECONVERTER_INSTALL_DIR)},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"file coversion begin failed", {InPlaceInit, {
"-I", "ObjImporter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/point.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.fbx")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, "AnySceneConverter", nullptr,
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
Utility::format("Trade::AnySceneConverter::beginFile(): cannot determine the format of {0}\n"
"Cannot begin conversion of file {0}\n", Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.fbx"))},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"file coversion end failed", {InPlaceInit, {
"-I", "GltfImporter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/empty.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "StanfordSceneConverter", nullptr,
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
Utility::format("Trade::AbstractSceneConverter::endFile(): the converter requires exactly one mesh, got 0\n"
"Cannot end conversion of file {0}\n", Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.ply"))},
/** @todo importer conversion begin failed, once there's a plugin for which
begin() can fail */
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"importer coversion end failed", {InPlaceInit, {
"-I", "GltfImporter",
"-C", "MeshOptimizerSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/empty.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", nullptr, "MeshOptimizerSceneConverter", nullptr,
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
"Trade::AbstractSceneConverter::end(): the converter requires exactly one mesh, got 0\n"
"Cannot end importer conversion\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"can't add importer contents", {InPlaceInit, {
"-I", "ObjImporter", "-C", "StanfordSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/broken-mesh.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, "StanfordSceneConverter", nullptr,
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
"Trade::ObjImporter::mesh(): wrong index count for point\n"
"Cannot add importer contents\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"can't add processed meshes", {InPlaceInit, {
"-I", "ObjImporter", "-C", "StanfordSceneConverter",
"--remove-duplicate-vertices",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/two-triangles.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, "StanfordSceneConverter", nullptr,
sceneconverter: initial support for whole-scene conversion. Quite boring commit message for such a FEATURE, eh?? Yes, the docs need updating at least.
4 years ago
"Trade::AbstractSceneConverter::add(): the converter requires exactly one mesh, got 2\n"
"Cannot add mesh 1\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"plugin doesn't support importer conversion", {InPlaceInit, {
/* Pass the same plugin twice, which means the first instance
should get used for a mesh-to-mesh conversion */
"-I", "ObjImporter", "-C", "StanfordSceneConverter",
"-C", "StanfordSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/point.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, "StanfordSceneConverter", nullptr,
sceneconverter: print packed feature enums in error messages.
4 years ago
"StanfordSceneConverter doesn't support importer conversion, only ConvertMeshToData\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"can't load mesh converter plugin", {InPlaceInit, {
"-M", "NonexistentSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/point.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, nullptr, nullptr,
sceneconverter: simplify plugin load error tests a bit. Should have realized this right at the start.
4 years ago
Utility::format("PluginManager::Manager::load(): plugin NonexistentSceneConverter is not static and was not found in {}\n"
"Available mesh converter plugins: ", /* Just a prefix */
MAGNUM_PLUGINS_SCENECONVERTER_INSTALL_DIR)},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"plugin doesn't support mesh conversion", {InPlaceInit, {
"-I", "ObjImporter", "-M", "StanfordSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/point.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, "StanfordSceneConverter", nullptr,
sceneconverter: ability to apply a converter to each mesh in the scene.
4 years ago
"StanfordSceneConverter doesn't support mesh conversion, only ConvertMeshToData\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"can't process a mesh", {InPlaceInit, {
"-I", "ObjImporter", "-M", "MeshOptimizerSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/point.obj"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.ply")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"ObjImporter", nullptr, "MeshOptimizerSceneConverter", nullptr,
sceneconverter: ability to apply a converter to each mesh in the scene.
4 years ago
"Trade::MeshOptimizerSceneConverter::convert(): expected a triangle mesh, got MeshPrimitive::Points\n"
"Cannot process mesh 0 with MeshOptimizerSceneConverter\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"can't import a 2D image for per-image processing", {InPlaceInit, {
"-I", "GltfImporter", "-P", "NonexistentImageConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/broken-image-2d.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.gltf")
}},
sceneconverter: check for proper plugin dependencies in the test. Now that I broke the ABI a few times this becomes rather important.
4 years ago
"GltfImporter", "PngImporter", nullptr, nullptr,
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
Utility::format("\n" /* Just a suffix */
"Trade::AbstractImporter::openFile(): cannot open file {}\n"
"Cannot import 2D image 0\n", Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/nonexistent.png"))},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"can't import a 3D image for per-image processing", {InPlaceInit, {
"-I", "GltfImporter", "-i", "experimentalKhrTextureKtx",
"-P", "NonexistentImageConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/broken-image-3d.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.gltf")
}},
sceneconverter: check for proper plugin dependencies in the test. Now that I broke the ABI a few times this becomes rather important.
4 years ago
"GltfImporter", "KtxImporter", nullptr, nullptr,
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
Utility::format("\n" /* Just a suffix */
"Trade::AbstractImporter::openFile(): cannot open file {}\n"
"Cannot import 3D image 0\n", Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/nonexistent.ktx2"))},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"can't load image converter plugin", {InPlaceInit, {
"-P", "NonexistentImageConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/images-2d.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", "PngImporter", nullptr, nullptr,
Utility::format("PluginManager::Manager::load(): plugin NonexistentImageConverter is not static and was not found in {}\n"
"Available image converter plugins: ", /* Just a prefix */
MAGNUM_PLUGINS_IMAGECONVERTER_INSTALL_DIR)},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"plugin doesn't support image conversion", {InPlaceInit, {
"-I", "GltfImporter", "-P", "PngImageConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/images-2d.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", "PngImporter", nullptr, "PngImageConverter",
"PngImageConverter doesn't support 2D image conversion, only Convert2DToData\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"plugin doesn't support compressed image conversion", {InPlaceInit, {
"-I", "GltfImporter", "-P", "StbResizeImageConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/image-dds.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.gltf")
}},
sceneconverter: check for proper plugin dependencies in the test. Now that I broke the ABI a few times this becomes rather important.
4 years ago
"GltfImporter", "DdsImporter", nullptr, "StbResizeImageConverter",
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
/** @todo add an ability to pass options to AnyImageImporter to
suppress this */
"Trade::DdsImporter::openData(): block-compressed image is assumed to be encoded with Y down and Z forward, imported data will have wrong orientation. Enable assumeYUpZBackward to suppress this warning.\n"
"StbResizeImageConverter doesn't support compressed 2D image conversion, only Convert2D|Convert3D\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"can't process a 2D image", {InPlaceInit, {
"-I", "GltfImporter", "-P", "StbResizeImageConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/images-2d.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.gltf")
}},
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"GltfImporter", "PngImporter", nullptr, "StbResizeImageConverter",
"Trade::StbResizeImageConverter::convert(): output size was not specified\n"
"Cannot process 2D image 0 with StbResizeImageConverter\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"can't process a 3D image", {InPlaceInit, {
"-I", "GltfImporter", "-i", "experimentalKhrTextureKtx",
"-P", "StbResizeImageConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/images-3d.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.gltf")
}},
sceneconverter: check for proper plugin dependencies in the test. Now that I broke the ABI a few times this becomes rather important.
4 years ago
"GltfImporter", "KtxImporter", nullptr, "StbResizeImageConverter",
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"Trade::StbResizeImageConverter::convert(): output size was not specified\n"
"Cannot process 3D image 0 with StbResizeImageConverter\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"can't add processed 2D images", {InPlaceInit, {
"-P", "StbResizeImageConverter", "-p", "size=\"1 1\"",
"-I", "GltfImporter", "-C", "GltfSceneConverter",
"-c", "imageConverter=NonexistentImageConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/images-2d.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.gltf")
}},
sceneconverter: correctly mark test case plugin requirements. Otherwise if the plugins fail to load due to ABI issues or whatever the test will fail (which it shouldn't).
3 years ago
"GltfImporter", "PngImporter", "GltfSceneConverter", "StbResizeImageConverter",
sceneconverter: improve some comments in the test.
3 years ago
"\n" /* Just a suffix */
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"Trade::GltfSceneConverter::add(): can't load NonexistentImageConverter for image conversion\n"
"Cannot add 2D image 0\n"},
sceneconverter: make the test instances easier to read. Using the InPlaceInit constructor instead of an unnecessarily verbose array<T>({...}) helper, indenting the command-line arguments so they're easier to distinguish from the rest.
3 years ago
{"can't add processed 3D images", {InPlaceInit, {
"-P", "StbResizeImageConverter", "-p", "size=\"1 1\"",
"-I", "GltfImporter", "-i", "experimentalKhrTextureKtx",
"-C", "GltfSceneConverter",
"-c", "experimentalKhrTextureKtx,imageConverter=NonexistentImageConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/images-3d.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.gltf")
}},
sceneconverter: correctly mark test case plugin requirements. Otherwise if the plugins fail to load due to ABI issues or whatever the test will fail (which it shouldn't).
3 years ago
"GltfImporter", "PngImporter", "GltfSceneConverter", "StbResizeImageConverter",
sceneconverter: improve some comments in the test.
3 years ago
"\n" /* Just a suffix */
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
"Trade::GltfSceneConverter::add(): can't load NonexistentImageConverter for image conversion\n"
"Cannot add 3D image 0\n"},
sceneconverter: verify also the unimplemented case for 1D images.
3 years ago
{"1D image processing not implemented", {InPlaceInit, {
/* Faking an image-only importer which is fine, it's failing right
after anyway; also not supplying any size to the resize plugin */
"-I" "KtxImporter", "-P" "StbResizeImageConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/1d.ktx2"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.gltf")
}},
nullptr, "KtxImporter", nullptr,
nullptr,
"Sorry, 1D image conversion is not implemented yet\n"},
sceneconverter: implement a --phong-to-pbr option. Exposes MaterialTools::phongToPbrMetallicRoughness() that got added some time ago. Most of the code and tests is scaffolding needed for direct material import and processing outside of the addImporterContents() automagic, similar to what was already done for meshes and images. In particular, adding more material conversion options such as canonicalization or deduplication will be significantly easier now that the basics are done and tested.
3 years ago
{"can't load a material for Phong to PBR conversion", {InPlaceInit, {
"-I", "GltfImporter", "--phong-to-pbr",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/broken-material.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.gltf")
}},
"GltfImporter", nullptr, nullptr,
nullptr,
"Trade::GltfImporter::material(): unrecognized alphaMode TOUGH\n"
"Cannot import material 2\n"},
{"can't add material dependencies", {InPlaceInit, {
/* --phong-to-pbr is a no-op because the input is PBR already, we
just need something that causes the materials to be added
directly */
"-I", "GltfImporter", "--phong-to-pbr",
/* Not enabling experimentalKhrTextureKtx for the converter in
order to trigger this error */
"-i", "experimentalKhrTextureKtx", "-C", "GltfSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/materials-3d.gltf"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.gltf")
}},
"GltfImporter", "KtxImporter", "GltfSceneConverter",
nullptr,
"Trade::AbstractSceneConverter::addSupportedImporterContents(): ignoring 1 3D images not supported by the converter\n"
/* Another way this could fail is that the texture is now referencing a
3D image out of bounds (because adding it failed above) */
"Trade::GltfSceneConverter::add(): 2D array textures require experimentalKhrTextureKtx to be enabled\n"
"Cannot add material dependencies\n"},
{"can't add processed material", {InPlaceInit, {
/* --phong-to-pbr is a no-op because the input is PBR already, we
just need something that causes the materials to be added
directly */
"-I", "UfbxImporter", "--phong-to-pbr",
"-C", "GltfSceneConverter",
Utility::Path::join(SCENETOOLS_TEST_DIR, "SceneConverterTestFiles/materials-separate-metalness-roughness.mtl"),
Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/whatever.gltf")
}},
"UfbxImporter", "PngImporter", "GltfSceneConverter",
nullptr,
"Trade::GltfSceneConverter::add(): unsupported R/R packing of a metallic/roughness texture\n"
"Cannot add material 1\n"}
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
};
{image,scene}converter: extract and test --info printing code. It was quite a pile, and all of it was written just once, relying only on hopefully-available model files that would hopefully touch most code paths. Which means, extremely annoying to make changes in. I extracted the code to a header that can be tested with a mocked-up importer and without having to execute the utility itself, deduplicated the image info printing code, fixed various inconsistencies (such as data/field flags sometimes denoted with superfluous "flags:" and sometimes not) and TODOs (such as 2D/3D skins, where there was no format whatsoever that would have 2D skin support, so the code couldn't get written). Now it's finally possible to easily add the remaining missing features, such as printing camera info.
4 years ago
SceneConverterTest::SceneConverterTest() {
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
addInstancedTests({&SceneConverterTest::info},
Containers::arraySize(InfoData));
addInstancedTests({&SceneConverterTest::convert},
Containers::arraySize(ConvertData));
addInstancedTests({&SceneConverterTest::error},
Containers::arraySize(ErrorData));
/* Create output dir, if doesn't already exist */
Utility::Path::make(Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles"));
{image,scene}converter: extract and test --info printing code. It was quite a pile, and all of it was written just once, relying only on hopefully-available model files that would hopefully touch most code paths. Which means, extremely annoying to make changes in. I extracted the code to a header that can be tested with a mocked-up importer and without having to execute the utility itself, deduplicated the image info printing code, fixed various inconsistencies (such as data/field flags sometimes denoted with superfluous "flags:" and sometimes not) and TODOs (such as 2D/3D skins, where there was no format whatsoever that would have 2D skin support, so the code couldn't get written). Now it's finally possible to easily add the remaining missing features, such as printing camera info.
4 years ago
}
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
namespace {
#ifdef SCENECONVERTER_EXECUTABLE_FILENAME
{image,scene}converter: use StringIterable to simplify tests. Hmm, nice.
4 years ago
Containers::Pair<bool, Containers::String> call(const Containers::StringIterable& arguments) {
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
const Containers::String outputFilename = Utility::Path::join(SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles/output.txt");
/** @todo clean up once Utility::System::execute() with output redirection
exists */
{image,scene}converter: use StringIterable to simplify tests. Hmm, nice.
4 years ago
/* Implicitly pass the plugin directory override */
const bool success = std::system(Utility::format("{} --plugin-dir {} {} > {} 2>&1",
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
SCENECONVERTER_EXECUTABLE_FILENAME,
{image,scene}converter: use StringIterable to simplify tests. Hmm, nice.
4 years ago
MAGNUM_PLUGINS_INSTALL_DIR,
" "_s.join(arguments), /** @todo handle space escaping here? */
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
outputFilename
).data()) == 0;
const Containers::Optional<Containers::String> output = Utility::Path::readString(outputFilename);
CORRADE_VERIFY(output);
return {success, std::move(*output)};
}
#endif
}
void SceneConverterTest::info() {
auto&& data = InfoData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef SCENECONVERTER_EXECUTABLE_FILENAME
CORRADE_SKIP("magnum-sceneconverter not built, can't test");
#else
/* Check if required plugins can be loaded. Catches also ABI and interface
mismatch errors. */
PluginManager::Manager<Trade::AbstractImporter> importerManager{MAGNUM_PLUGINS_IMPORTER_INSTALL_DIR};
{scene,image}converter: add --info options for plugins. Lists features, aliases as well as documented contents of the whole configuration file. Useful to not need to look up online docs when working on the command line.
4 years ago
PluginManager::Manager<Trade::AbstractImageConverter> imageConverterManager{MAGNUM_PLUGINS_IMAGECONVERTER_INSTALL_DIR};
PluginManager::Manager<Trade::AbstractSceneConverter> converterManager{MAGNUM_PLUGINS_SCENECONVERTER_INSTALL_DIR};
sceneconverter: generalize --info test a bit. Preparing for different importers and info for plugins.
4 years ago
if(data.requiresImporter && !(importerManager.load(data.requiresImporter) & PluginManager::LoadState::Loaded))
CORRADE_SKIP(data.requiresImporter << "plugin can't be loaded.");
{scene,image}converter: add --info options for plugins. Lists features, aliases as well as documented contents of the whole configuration file. Useful to not need to look up online docs when working on the command line.
4 years ago
if(data.requiresConverter && !(converterManager.load(data.requiresConverter) & PluginManager::LoadState::Loaded))
CORRADE_SKIP(data.requiresConverter << "plugin can't be loaded.");
if(data.requiresImageConverter && !(imageConverterManager.load(data.requiresImageConverter) & PluginManager::LoadState::Loaded))
CORRADE_SKIP(data.requiresImageConverter << "plugin can't be loaded.");
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
CORRADE_VERIFY(true); /* capture correct function name */
sceneconverter: generalize --info test a bit. Preparing for different importers and info for plugins.
4 years ago
Containers::Pair<bool, Containers::String> output = call(data.args);
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
CORRADE_COMPARE_AS(output.second(),
Utility::Path::join({SCENETOOLS_TEST_DIR, "SceneConverterTestFiles", data.expected}),
TestSuite::Compare::StringToFile);
CORRADE_VERIFY(output.first());
#endif
}
void SceneConverterTest::convert() {
auto&& data = ConvertData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef SCENECONVERTER_EXECUTABLE_FILENAME
CORRADE_SKIP("magnum-sceneconverter not built, can't test");
#else
/* Check if required plugins can be loaded. Catches also ABI and interface
mismatch errors. */
PluginManager::Manager<Trade::AbstractImporter> importerManager{MAGNUM_PLUGINS_IMPORTER_INSTALL_DIR};
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
PluginManager::Manager<Trade::AbstractImageConverter> imageConverterManager{MAGNUM_PLUGINS_IMAGECONVERTER_INSTALL_DIR};
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
PluginManager::Manager<Trade::AbstractSceneConverter> converterManager{MAGNUM_PLUGINS_SCENECONVERTER_INSTALL_DIR};
if(data.requiresImporter && !(importerManager.load(data.requiresImporter) & PluginManager::LoadState::Loaded))
CORRADE_SKIP(data.requiresImporter << "plugin can't be loaded.");
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
if(data.requiresImporter2 && !(importerManager.load(data.requiresImporter2) & PluginManager::LoadState::Loaded))
CORRADE_SKIP(data.requiresImporter2 << "plugin can't be loaded.");
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
if(data.requiresConverter && !(converterManager.load(data.requiresConverter) & PluginManager::LoadState::Loaded))
CORRADE_SKIP(data.requiresConverter << "plugin can't be loaded.");
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
if(data.requiresImageConverter[0] && !(imageConverterManager.load(data.requiresImageConverter[0]) & PluginManager::LoadState::Loaded))
CORRADE_SKIP(data.requiresImageConverter[0] << "plugin can't be loaded.");
if(data.requiresImageConverter[1] && !(imageConverterManager.load(data.requiresImageConverter[1]) & PluginManager::LoadState::Loaded))
CORRADE_SKIP(data.requiresImageConverter[1] << "plugin can't be loaded.");
sceneconverter: ability to apply a converter to each mesh in the scene.
4 years ago
if(data.requiresMeshConverter && !(converterManager.load(data.requiresMeshConverter) & PluginManager::LoadState::Loaded))
CORRADE_SKIP(data.requiresMeshConverter << "plugin can't be loaded.");
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
/* AnySceneImporter, AnyImageImporter & AnySceneConverter are required
implicitly for simplicity */
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
if(!(importerManager.load("AnySceneImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnySceneImporter plugin can't be loaded.");
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
if(!(importerManager.load("AnyImageImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter plugin can't be loaded.");
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
if(!(converterManager.load("AnySceneConverter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnySceneConverter plugin can't be loaded.");
CORRADE_VERIFY(true); /* capture correct function name */
Containers::Pair<bool, Containers::String> output = call(data.args);
CORRADE_COMPARE(output.second(), data.message);
CORRADE_VERIFY(output.first());
CORRADE_COMPARE_AS(Utility::Path::join({SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles", data.expected}),
Utility::Path::join({SCENETOOLS_TEST_DIR, "SceneConverterTestFiles", data.expected}),
TestSuite::Compare::File);
sceneconverter: recognize whole-scene converters. Just a minimal support to get single-mesh conversion working with GltfSceneConverter. The whole thing has to be subsequently reworked to not be oriented around meshes, but this is the first step.
4 years ago
if(data.expected2) CORRADE_COMPARE_AS(Utility::Path::join({SCENETOOLS_TEST_OUTPUT_DIR, "SceneConverterTestFiles", data.expected2}),
Utility::Path::join({SCENETOOLS_TEST_DIR, "SceneConverterTestFiles", data.expected2}),
TestSuite::Compare::File);
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
#endif
}
void SceneConverterTest::error() {
auto&& data = ErrorData[testCaseInstanceId()];
setTestCaseDescription(data.name);
#ifndef SCENECONVERTER_EXECUTABLE_FILENAME
CORRADE_SKIP("magnum-sceneconverter not built, can't test");
#else
/* Check if required plugins can be loaded. Catches also ABI and interface
mismatch errors. */
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
PluginManager::Manager<Trade::AbstractImporter> importerManager{MAGNUM_PLUGINS_IMPORTER_INSTALL_DIR};
PluginManager::Manager<Trade::AbstractImageConverter> imageConverterManager{MAGNUM_PLUGINS_IMAGECONVERTER_INSTALL_DIR};
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
PluginManager::Manager<Trade::AbstractSceneConverter> converterManager{MAGNUM_PLUGINS_SCENECONVERTER_INSTALL_DIR};
if(data.requiresImporter && !(importerManager.load(data.requiresImporter) & PluginManager::LoadState::Loaded))
CORRADE_SKIP(data.requiresImporter << "plugin can't be loaded.");
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
if(data.requiresImageImporter && !(importerManager.load(data.requiresImageImporter) & PluginManager::LoadState::Loaded))
CORRADE_SKIP(data.requiresImageImporter << "plugin can't be loaded.");
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
if(data.requiresConverter && !(converterManager.load(data.requiresConverter) & PluginManager::LoadState::Loaded))
CORRADE_SKIP(data.requiresConverter << "plugin can't be loaded.");
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
if(data.requiresImageConverter && !(imageConverterManager.load(data.requiresImageConverter) & PluginManager::LoadState::Loaded))
CORRADE_SKIP(data.requiresImageConverter << "plugin can't be loaded.");
/* AnyImageImporter is required implicitly for simplicity if any importer
is required */
if(data.requiresImageImporter && !(importerManager.load("AnyImageImporter") & PluginManager::LoadState::Loaded))
CORRADE_SKIP("AnyImageImporter plugin can't be loaded.");
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
CORRADE_VERIFY(true); /* capture correct function name */
Containers::Pair<bool, Containers::String> output = call(data.args);
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
/* If the message begins with a \n, assume it's just a suffix */
if(data.message.hasPrefix('\n'))
CORRADE_COMPARE_AS(output.second(),
data.message,
TestSuite::Compare::StringHasSuffix);
/* If it ends with a \n, assume it's the whole message */
else if(data.message.hasSuffix('\n'))
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
CORRADE_COMPARE(output.second(), data.message);
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
/* Otherwise it's just a prefix */
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
else
CORRADE_COMPARE_AS(output.second(),
sceneconverter: ability to apply a converter to each image in the scene.
4 years ago
data.message,
TestSuite::Compare::StringHasPrefix);
sceneconverter: fully cover with tests. I'm going to add quite a few features to this one, and doing that without any regression tests whatsoever would be a misery. Same needs to eventually be done for the imageconverter and other utils. No bugs found here, fortunately, except for one message update -- otherwise the verbose output would contain (1/2) but never (2/2) which may be confusing. At the moment the testing is done only on Unix -- originally I wanted to postpone this until something like Utility::System::execute() is implemented, with proper argument escaping and output redirection, but I simply DO NOT HAVE TIME to do that properly now. So instead it's calling into std::system(), assumes there is no whitespace in the arguments, and assumes a Unix shell with stdout/stderr redirection to a file. Ugly and probably way slower than necessary, but works.
4 years ago
/* It should return a non-zero code */
CORRADE_VERIFY(!output.first());
#endif
}
{image,scene}converter: extract and test --info printing code. It was quite a pile, and all of it was written just once, relying only on hopefully-available model files that would hopefully touch most code paths. Which means, extremely annoying to make changes in. I extracted the code to a header that can be tested with a mocked-up importer and without having to execute the utility itself, deduplicated the image info printing code, fixed various inconsistencies (such as data/field flags sometimes denoted with superfluous "flags:" and sometimes not) and TODOs (such as 2D/3D skins, where there was no format whatsoever that would have 2D skin support, so the code couldn't get written). Now it's finally possible to easily add the remaining missing features, such as printing camera info.
4 years ago
}}}}
CORRADE_TEST_MAIN(Magnum::SceneTools::Test::SceneConverterTest)