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.
9541 Commits
21 Branches
19 Tags
70 MiB
Tree: 7f4500d9e0
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '7f4500d9e0'
${ noResults }
magnum/src/MagnumPlugins/AnyShaderConverter/Test/AnyConverterTest.cpp

1937 lines
94 KiB
Raw Normal View History Unescape

AnyShaderConverter: new plugin.
6 years ago
/*
This file is part of Magnum.
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019,
Updated copyright year.
4 years ago
2020, 2021, 2022 Vladimír Vondruš <mosra@centrum.cz>
AnyShaderConverter: new plugin.
6 years ago
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#include <sstream>
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
#include <Corrade/Containers/Array.h>
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
#include <Corrade/Containers/Optional.h>
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
#include <Corrade/Containers/Pair.h>
AnyShaderConverter: new plugin.
6 years ago
#include <Corrade/Containers/String.h>
#include <Corrade/Containers/StringStl.h>
#include <Corrade/PluginManager/Manager.h>
#include <Corrade/TestSuite/Tester.h>
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
#include <Corrade/Utility/ConfigurationGroup.h>
AnyShaderConverter: new plugin.
6 years ago
#include <Corrade/Utility/DebugStl.h>
#include <Corrade/Utility/FormatStl.h>
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
#include <Corrade/Utility/Path.h>
AnyShaderConverter: new plugin.
6 years ago
#include "Magnum/ShaderTools/AbstractConverter.h"
ShaderTools: move the Stage enum to a dedicated header. Will be used by SPIR-V reflection APIs, which don't need the whole converter interface and all the pluginmanager stuff dragged along.
5 years ago
#include "Magnum/ShaderTools/Stage.h"
AnyShaderConverter: new plugin.
6 years ago
#include "configure.h"
namespace Magnum { namespace ShaderTools { namespace Test { namespace {
struct AnyConverterTest: TestSuite::Tester {
explicit AnyConverterTest();
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void validateFile();
void validateFilePluginLoadFailed();
void validateFileUnknown();
void validateFileNotSupported();
void validateFilePreprocessNotSupported();
void validateFilePropagateFlags();
void validateFilePropagateInputVersion();
void validateFilePropagateOutputVersion();
void validateFilePropagatePreprocess();
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
void validateFilePropagateConfiguration();
void validateFilePropagateConfigurationUnknown();
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void validateData();
void validateDataPluginLoadFailed();
void validateDataNoFormatSet();
void validateDataNotSupported();
void validateDataPreprocessNotSupported();
void validateDataPropagateFlags();
void validateDataPropagateInputVersion();
void validateDataPropagateOutputVersion();
void validateDataPropagatePreprocess();
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
void validateDataPropagateConfiguration();
void validateDataPropagateConfigurationUnknown();
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void convertFileToFile();
void convertFileToFilePluginLoadFailed();
void convertFileToFileUnknownInput();
void convertFileToFileUnknownOutput();
void convertFileToFileNotSupported();
void convertFileToFilePreprocessNotSupported();
void convertFileToFileDebugInfoNotSupported();
void convertFileToFileOptimizationNotSupported();
void convertFileToFilePropagateFlags();
void convertFileToFilePropagateInputVersion();
void convertFileToFilePropagateOutputVersion();
void convertFileToFilePropagatePreprocess();
void convertFileToFilePropagateDebugInfo();
void convertFileToFilePropagateOptimization();
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
void convertFileToFilePropagateConfiguration();
void convertFileToFilePropagateConfigurationUnknown();
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void convertFileToData();
void convertFileToDataPluginLoadFailed();
void convertFileToDataUnknown();
void convertFileToDataNoFormatSet();
void convertFileToDataNotSupported();
void convertFileToDataPreprocessNotSupported();
void convertFileToDataDebugInfoNotSupported();
void convertFileToDataOptimizationNotSupported();
void convertFileToDataPropagateFlags();
void convertFileToDataPropagateInputVersion();
void convertFileToDataPropagateOutputVersion();
void convertFileToDataPropagatePreprocess();
void convertFileToDataPropagateDebugInfo();
void convertFileToDataPropagateOptimization();
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
void convertFileToDataPropagateConfiguration();
void convertFileToDataPropagateConfigurationUnknown();
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void convertDataToData();
void convertDataToDataPluginLoadFailed();
void convertDataToDataNoInputFormatSet();
void convertDataToDataNoOutputFormatSet();
void convertDataToDataNotSupported();
void convertDataToDataPreprocessNotSupported();
void convertDataToDataDebugInfoNotSupported();
void convertDataToDataOptimizationNotSupported();
void convertDataToDataPropagateFlags();
void convertDataToDataPropagateInputVersion();
void convertDataToDataPropagateOutputVersion();
void convertDataToDataPropagatePreprocess();
void convertDataToDataPropagateDebugInfo();
void convertDataToDataPropagateOptimization();
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
void convertDataToDataPropagateConfiguration();
void convertDataToDataPropagateConfigurationUnknown();
AnyShaderConverter: new plugin.
6 years ago
void detectValidate();
AnyShaderConverter: take explicitly set formats into account. So if we convert foo.blah but explicitly tell it that it's a SPIR-V file, it actually treats it as such, instead of complaining that `blah` is not a known extension. First step towards being able to operate directly on data.
5 years ago
void detectValidateExplicitFormat();
AnyShaderConverter: new plugin.
6 years ago
void detectConvert();
AnyShaderConverter: take explicitly set formats into account. So if we convert foo.blah but explicitly tell it that it's a SPIR-V file, it actually treats it as such, instead of complaining that `blah` is not a known extension. First step towards being able to operate directly on data.
5 years ago
void detectConvertExplicitFormat();
AnyShaderConverter: new plugin.
6 years ago
/* Explicitly forbid system-wide plugin dependencies. Tests that need those
have their own manager. */
PluginManager::Manager<AbstractConverter> _manager{"nonexistent"};
};
constexpr struct {
const char* name;
const char* filename;
const char* plugin;
} DetectValidateData[]{
{"SPIR-V", "flat.spv", "SpirvShaderConverter"},
{"SPIR-V assembly uppercase", "DOOM.SPVASM", "SpirvAssemblyShaderConverter"},
{"SPIR-V assembly weird", "test.asm.rahit", "SpirvAssemblyShaderConverter"},
{"GLSL explicit", "phong.glsl", "GlslShaderConverter"},
{"GLSL implicit", "phong.frag", "GlslShaderConverter"},
};
constexpr struct {
const char* name;
const char* from;
const char* to;
const char* plugin;
} DetectConvertData[]{
{"SPIR-V to SPIR-V", "flat.spv", "optimized.spv", "SpirvShaderConverter"},
{"SPIR-V assembly to SPIR-V", "a.spvasm", "b.spv", "SpirvAssemblyToSpirvShaderConverter"},
{"SPIR-V to GLSL", "phong.frag.spv", "phong.glsl", "SpirvToGlslShaderConverter"}
};
AnyConverterTest::AnyConverterTest() {
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
addTests({&AnyConverterTest::validateFile,
&AnyConverterTest::validateFilePluginLoadFailed,
&AnyConverterTest::validateFileUnknown,
&AnyConverterTest::validateFileNotSupported,
&AnyConverterTest::validateFilePreprocessNotSupported,
&AnyConverterTest::validateFilePropagateFlags,
&AnyConverterTest::validateFilePropagateInputVersion,
&AnyConverterTest::validateFilePropagateOutputVersion,
&AnyConverterTest::validateFilePropagatePreprocess,
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
&AnyConverterTest::validateFilePropagateConfiguration,
&AnyConverterTest::validateFilePropagateConfigurationUnknown,
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
&AnyConverterTest::validateData,
&AnyConverterTest::validateDataPluginLoadFailed,
&AnyConverterTest::validateDataNoFormatSet,
&AnyConverterTest::validateDataNotSupported,
&AnyConverterTest::validateDataPreprocessNotSupported,
&AnyConverterTest::validateDataPropagateFlags,
&AnyConverterTest::validateDataPropagateInputVersion,
&AnyConverterTest::validateDataPropagateOutputVersion,
&AnyConverterTest::validateDataPropagatePreprocess,
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
&AnyConverterTest::validateDataPropagateConfiguration,
&AnyConverterTest::validateDataPropagateConfigurationUnknown,
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
&AnyConverterTest::convertFileToFile,
&AnyConverterTest::convertFileToFilePluginLoadFailed,
&AnyConverterTest::convertFileToFileUnknownInput,
&AnyConverterTest::convertFileToFileUnknownOutput,
&AnyConverterTest::convertFileToFileNotSupported,
&AnyConverterTest::convertFileToFilePreprocessNotSupported,
&AnyConverterTest::convertFileToFileDebugInfoNotSupported,
&AnyConverterTest::convertFileToFileOptimizationNotSupported,
&AnyConverterTest::convertFileToFilePropagateFlags,
&AnyConverterTest::convertFileToFilePropagateInputVersion,
&AnyConverterTest::convertFileToFilePropagateOutputVersion,
&AnyConverterTest::convertFileToFilePropagatePreprocess,
&AnyConverterTest::convertFileToFilePropagateDebugInfo,
&AnyConverterTest::convertFileToFilePropagateOptimization,
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
&AnyConverterTest::convertFileToFilePropagateConfiguration,
&AnyConverterTest::convertFileToFilePropagateConfigurationUnknown,
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
&AnyConverterTest::convertFileToData,
&AnyConverterTest::convertFileToDataPluginLoadFailed,
&AnyConverterTest::convertFileToDataUnknown,
&AnyConverterTest::convertFileToDataNoFormatSet,
&AnyConverterTest::convertFileToDataNotSupported,
&AnyConverterTest::convertFileToDataPreprocessNotSupported,
&AnyConverterTest::convertFileToDataDebugInfoNotSupported,
&AnyConverterTest::convertFileToDataOptimizationNotSupported,
&AnyConverterTest::convertFileToDataPropagateFlags,
&AnyConverterTest::convertFileToDataPropagateInputVersion,
&AnyConverterTest::convertFileToDataPropagateOutputVersion,
&AnyConverterTest::convertFileToDataPropagatePreprocess,
&AnyConverterTest::convertFileToDataPropagateDebugInfo,
&AnyConverterTest::convertFileToDataPropagateOptimization,
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
&AnyConverterTest::convertFileToDataPropagateConfiguration,
&AnyConverterTest::convertFileToDataPropagateConfigurationUnknown,
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
&AnyConverterTest::convertDataToData,
&AnyConverterTest::convertDataToDataPluginLoadFailed,
&AnyConverterTest::convertDataToDataNoInputFormatSet,
&AnyConverterTest::convertDataToDataNoOutputFormatSet,
&AnyConverterTest::convertDataToDataNotSupported,
&AnyConverterTest::convertDataToDataPreprocessNotSupported,
&AnyConverterTest::convertDataToDataDebugInfoNotSupported,
&AnyConverterTest::convertDataToDataOptimizationNotSupported,
&AnyConverterTest::convertDataToDataPropagateFlags,
&AnyConverterTest::convertDataToDataPropagateInputVersion,
&AnyConverterTest::convertDataToDataPropagateOutputVersion,
&AnyConverterTest::convertDataToDataPropagatePreprocess,
&AnyConverterTest::convertDataToDataPropagateDebugInfo,
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
&AnyConverterTest::convertDataToDataPropagateOptimization,
&AnyConverterTest::convertDataToDataPropagateConfiguration,
&AnyConverterTest::convertDataToDataPropagateConfigurationUnknown});
AnyShaderConverter: new plugin.
6 years ago
addInstancedTests({&AnyConverterTest::detectValidate},
Containers::arraySize(DetectValidateData));
AnyShaderConverter: take explicitly set formats into account. So if we convert foo.blah but explicitly tell it that it's a SPIR-V file, it actually treats it as such, instead of complaining that `blah` is not a known extension. First step towards being able to operate directly on data.
5 years ago
addTests({&AnyConverterTest::detectValidateExplicitFormat});
AnyShaderConverter: new plugin.
6 years ago
addInstancedTests({&AnyConverterTest::detectConvert},
Containers::arraySize(DetectConvertData));
AnyShaderConverter: take explicitly set formats into account. So if we convert foo.blah but explicitly tell it that it's a SPIR-V file, it actually treats it as such, instead of complaining that `blah` is not a known extension. First step towards being able to operate directly on data.
5 years ago
addTests({&AnyConverterTest::detectConvertExplicitFormat});
AnyShaderConverter: new plugin.
6 years ago
/* Load the plugin directly from the build tree. Otherwise it's static and
already loaded. */
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_INTERNAL_ASSERT_OUTPUT(_manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
/* Create the output directory if it doesn't exist yet */
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_INTERNAL_ASSERT_OUTPUT(Utility::Path::make(ANYSHADERCONVERTER_TEST_OUTPUT_DIR));
AnyShaderConverter: new plugin.
6 years ago
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::validateFile() {
AnyShaderConverter: new plugin.
6 years ago
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::String filename = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl");
AnyShaderConverter: new plugin.
6 years ago
/* Make it print a warning so we know it's doing something */
CORRADE_COMPARE(converter->validateFile(Stage::Fragment, filename),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(true, Utility::format("WARNING: {}:10: 'reserved__identifier' : identifiers containing consecutive underscores (\"__\") are reserved", filename)));
AnyShaderConverter: new plugin.
6 years ago
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::validateFilePluginLoadFailed() {
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter");
std::ostringstream out;
Error redirectError{&out};
CORRADE_COMPARE(converter->validateFile({}, "file.glsl"),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(false, Containers::String{}));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
#ifndef CORRADE_PLUGINMANAGER_NO_DYNAMIC_PLUGIN_SUPPORT
CORRADE_COMPARE(out.str(),
"PluginManager::Manager::load(): plugin GlslShaderConverter is not static and was not found in nonexistent\n"
"ShaderTools::AnyConverter::validateFile(): cannot load the GlslShaderConverter plugin\n");
#else
CORRADE_COMPARE(out.str(),
"PluginManager::Manager::load(): plugin GlslShaderConverter was not found\n"
"ShaderTools::AnyConverter::validateFile(): cannot load the GlslShaderConverter plugin\n");
#endif
}
void AnyConverterTest::validateFileUnknown() {
AnyShaderConverter: test also unknown extension for conversion. And make it return right after the first error. Also clean up some old-style code -- the redirection should be restricted to the smallest scope possible.
5 years ago
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter");
std::ostringstream out;
Error redirectError{&out};
CORRADE_COMPARE(converter->validateFile({}, "dead.cg"),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(false, Containers::String{}));
AnyShaderConverter: test also unknown extension for conversion. And make it return right after the first error. Also clean up some old-style code -- the redirection should be restricted to the smallest scope possible.
5 years ago
CORRADE_COMPARE(out.str(), "ShaderTools::AnyConverter::validateFile(): cannot determine the format of dead.cg\n");
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::validateFileNotSupported() {
AnyShaderConverter: new plugin.
6 years ago
CORRADE_SKIP("No plugin that would support just validation exists.");
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::validateFilePreprocessNotSupported() {
AnyShaderConverter: propagate preprocessor definitions.
6 years ago
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("SpirvToolsShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("SpirvToolsShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setDefinitions({
{"DEFINE", "hahahahah"}
});
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_COMPARE(converter->validateFile({}, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv")),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(false, Containers::String{}));
AnyShaderConverter: propagate preprocessor definitions.
6 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::validateFile(): SpirvToolsShaderConverter does not support preprocessing\n");
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::validateFilePropagateFlags() {
AnyShaderConverter: new plugin.
6 years ago
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::String filename = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl");
AnyShaderConverter: new plugin.
6 years ago
/* With this, the warning should turn into an error. The converter should
also print the verbose info. */
converter->setFlags(ConverterFlag::Verbose|ConverterFlag::WarningAsError);
std::ostringstream out;
Debug redirectDebug{&out};
CORRADE_COMPARE(converter->validateFile(Stage::Fragment, filename),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(false, Utility::format("WARNING: {}:10: 'reserved__identifier' : identifiers containing consecutive underscores (\"__\") are reserved", filename)));
AnyShaderConverter: new plugin.
6 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::validateFile(): using GlslShaderConverter (provided by GlslangShaderConverter)\n");
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::validateFilePropagateInputVersion() {
AnyShaderConverter: new plugin.
6 years ago
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
/* This is an invalid version. We have to supply a valid file path because
the version gets checked in doValidateData(), called from
AbstractConverter::doValidateFile() with the file contents. */
converter->setInputFormat(Format::Glsl, "100");
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_COMPARE(converter->validateFile(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(false, Containers::String{}));
AnyShaderConverter: new plugin.
6 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::GlslangConverter::validateData(): input format version should be one of supported GLSL #version strings but got 100\n");
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::validateFilePropagateOutputVersion() {
AnyShaderConverter: new plugin.
6 years ago
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
/* This is an invalid version. We have to supply a valid file path because
the version gets checked in doValidateData(), called from
AbstractConverter::doValidateFile() with the file contents. */
AnyShaderConverter: adapt test to GlslangShaderConverter changes. Format::Spirv is now allowed output format for validation.
6 years ago
converter->setOutputFormat(Format::Glsl, "opengl4.0");
AnyShaderConverter: new plugin.
6 years ago
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_COMPARE(converter->validateFile(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(false, Containers::String{}));
AnyShaderConverter: new plugin.
6 years ago
CORRADE_COMPARE(out.str(),
AnyShaderConverter: adapt test to GlslangShaderConverter changes. Format::Spirv is now allowed output format for validation.
6 years ago
"ShaderTools::GlslangConverter::validateData(): output format should be Spirv or Unspecified but got ShaderTools::Format::Glsl\n");
AnyShaderConverter: new plugin.
6 years ago
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::validateFilePropagatePreprocess() {
AnyShaderConverter: propagate preprocessor definitions.
6 years ago
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::String filename = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl");
AnyShaderConverter: propagate preprocessor definitions.
6 years ago
/* Check that undefining works properly -- if it stays defined, the source
won't compile */
converter->setDefinitions({
{"SHOULD_BE_UNDEFINED", "really"},
{"SHOULD_BE_UNDEFINED", nullptr},
{"reserved__identifier", "different__but_also_wrong"}
});
CORRADE_COMPARE(converter->validateFile(Stage::Fragment, filename),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(true, Utility::format("WARNING: {}:10: 'different__but_also_wrong' : identifiers containing consecutive underscores (\"__\") are reserved", filename)));
AnyShaderConverter: propagate preprocessor definitions.
6 years ago
}
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
void AnyConverterTest::validateFilePropagateConfiguration() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::String filename = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "version-not-first.glsl");
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
{
CORRADE_COMPARE(converter->validateFile(Stage::Fragment, filename),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(false, Utility::format("ERROR: {}:2: '#version' : must occur first in shader \nERROR: 1 compilation errors. No code generated.", filename)));
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
} {
converter->configuration().setValue("permissive", true);
/* Lol stupid thing, apparently it has two differently worded messages
for the same thing? Dumpster fire. */
CORRADE_COMPARE(converter->validateFile(Stage::Fragment, filename),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(true, Containers::String{"WARNING: 0:0: '#version' : Illegal to have non-comment, non-whitespace tokens before #version"}));
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
}
}
void AnyConverterTest::validateFilePropagateConfigurationUnknown() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->configuration().setValue("noSuchOption", "isHere");
/* So it doesn't warn about anything */
converter->setDefinitions({{"reserved__identifier", "sorry"}});
std::ostringstream out;
Warning redirectWarning{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_COMPARE(converter->validateFile(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(false, Containers::String{}));
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::validateFile(): option noSuchOption not recognized by GlslangShaderConverter\n");
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::validateData() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Glsl);
/* Make it print a warning so we know it's doing something */
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"));
CORRADE_VERIFY(data);
CORRADE_COMPARE(converter->validateData(Stage::Fragment, *data),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(true, Containers::String{"WARNING: 0:10: 'reserved__identifier' : identifiers containing consecutive underscores (\"__\") are reserved"}));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
}
void AnyConverterTest::validateDataPluginLoadFailed() {
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Glsl);
std::ostringstream out;
Error redirectError{&out};
CORRADE_COMPARE(converter->validateData({}, {}),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(false, Containers::String{}));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
#ifndef CORRADE_PLUGINMANAGER_NO_DYNAMIC_PLUGIN_SUPPORT
CORRADE_COMPARE(out.str(),
"PluginManager::Manager::load(): plugin GlslShaderConverter is not static and was not found in nonexistent\n"
"ShaderTools::AnyConverter::validateData(): cannot load the GlslShaderConverter plugin\n");
#else
CORRADE_COMPARE(out.str(),
"PluginManager::Manager::load(): plugin GlslShaderConverter was not found\n"
"ShaderTools::AnyConverter::validateData(): cannot load the GlslShaderConverter plugin\n");
#endif
}
void AnyConverterTest::validateDataNoFormatSet() {
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter");
std::ostringstream out;
Error redirectError{&out};
CORRADE_COMPARE(converter->validateData({}, "dead.cg"),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(false, Containers::String{}));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
CORRADE_COMPARE(out.str(), "ShaderTools::AnyConverter::validateData(): no input format specified\n");
}
void AnyConverterTest::validateDataNotSupported() {
CORRADE_SKIP("No plugin that would support just validation exists.");
}
void AnyConverterTest::validateDataPreprocessNotSupported() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("SpirvToolsShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("SpirvToolsShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Spirv);
converter->setDefinitions({
{"DEFINE", "hahahahah"}
});
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv"));
CORRADE_VERIFY(data);
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_COMPARE(converter->validateData({}, *data),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(false, Containers::String{}));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::validateData(): SpirvToolsShaderConverter does not support preprocessing\n");
}
void AnyConverterTest::validateDataPropagateFlags() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Glsl);
/* With this, the warning should turn into an error. The converter should
also print the verbose info. */
converter->setFlags(ConverterFlag::Verbose|ConverterFlag::WarningAsError);
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"));
CORRADE_VERIFY(data);
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
std::ostringstream out;
Debug redirectDebug{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_COMPARE(converter->validateData(Stage::Fragment, *data),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(false, Containers::String{"WARNING: 0:10: 'reserved__identifier' : identifiers containing consecutive underscores (\"__\") are reserved"}));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::validateData(): using GlslShaderConverter (provided by GlslangShaderConverter)\n");
}
void AnyConverterTest::validateDataPropagateInputVersion() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Glsl);
/* This is an invalid version. We have to supply a valid file path because
the version gets checked in doValidateData(), called from
AbstractConverter::doValidateFile() with the file contents. */
converter->setInputFormat(Format::Glsl, "100");
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"));
CORRADE_VERIFY(data);
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_COMPARE(converter->validateData(Stage::Fragment, *data),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(false, Containers::String{}));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::GlslangConverter::validateData(): input format version should be one of supported GLSL #version strings but got 100\n");
}
void AnyConverterTest::validateDataPropagateOutputVersion() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Glsl);
/* This is an invalid version. We have to supply a valid file path because
the version gets checked in doValidateData(), called from
AbstractConverter::doValidateFile() with the file contents. */
converter->setOutputFormat(Format::Glsl, "opengl4.0");
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"));
CORRADE_VERIFY(data);
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_COMPARE(converter->validateData(Stage::Fragment, *data),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(false, Containers::String{}));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::GlslangConverter::validateData(): output format should be Spirv or Unspecified but got ShaderTools::Format::Glsl\n");
}
void AnyConverterTest::validateDataPropagatePreprocess() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Glsl);
/* Check that undefining works properly -- if it stays defined, the source
won't compile */
converter->setDefinitions({
{"SHOULD_BE_UNDEFINED", "really"},
{"SHOULD_BE_UNDEFINED", nullptr},
{"reserved__identifier", "different__but_also_wrong"}
});
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"));
CORRADE_VERIFY(data);
CORRADE_COMPARE(converter->validateData(Stage::Fragment, *data),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(true, Containers::String{"WARNING: 0:10: 'different__but_also_wrong' : identifiers containing consecutive underscores (\"__\") are reserved"}));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
}
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
void AnyConverterTest::validateDataPropagateConfiguration() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Glsl);
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "version-not-first.glsl"));
CORRADE_VERIFY(data);
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
{
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_COMPARE(converter->validateData(Stage::Fragment, *data),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(false, Containers::String{"ERROR: 0:2: '#version' : must occur first in shader \nERROR: 1 compilation errors. No code generated."}));
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
} {
converter->configuration().setValue("permissive", true);
/* Lol stupid thing, apparently it has two differently worded messages
for the same thing? Dumpster fire. */
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_COMPARE(converter->validateData(Stage::Fragment, *data),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(true, Utility::format("WARNING: 0:0: '#version' : Illegal to have non-comment, non-whitespace tokens before #version")));
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
}
}
void AnyConverterTest::validateDataPropagateConfigurationUnknown() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Glsl);
converter->configuration().setValue("noSuchOption", "isHere");
/* So it doesn't warn about anything */
converter->setDefinitions({{"reserved__identifier", "sorry"}});
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"));
CORRADE_VERIFY(data);
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
std::ostringstream out;
Warning redirectWarning{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_COMPARE(converter->validateData(Stage::Fragment, *data),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(false, Containers::String{}));
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::validateData(): option noSuchOption not recognized by GlslangShaderConverter\n");
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::convertFileToFile() {
AnyShaderConverter: new plugin.
6 years ago
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::String inputFilename = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl");
Containers::String outputFilename = Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spv");
if(Utility::Path::exists(outputFilename))
CORRADE_VERIFY(Utility::Path::remove(outputFilename));
AnyShaderConverter: new plugin.
6 years ago
/* Make it print a warning so we know it's doing something */
std::ostringstream out;
Warning redirectWarning{&out};
CORRADE_VERIFY(converter->convertFileToFile(Stage::Fragment, inputFilename, outputFilename));
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(Utility::Path::exists(outputFilename));
AnyShaderConverter: new plugin.
6 years ago
CORRADE_COMPARE(out.str(), Utility::formatString(
"ShaderTools::GlslangConverter::convertDataToData(): compilation succeeded with the following message:\n"
AnyShaderConverter: propagate preprocessor definitions.
6 years ago
"WARNING: {}:10: 'reserved__identifier' : identifiers containing consecutive underscores (\"__\") are reserved\n", inputFilename));
AnyShaderConverter: new plugin.
6 years ago
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::convertFileToFilePluginLoadFailed() {
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter");
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter->convertFileToFile({}, "file.spv", "file.glsl"));
#ifndef CORRADE_PLUGINMANAGER_NO_DYNAMIC_PLUGIN_SUPPORT
CORRADE_COMPARE(out.str(),
"PluginManager::Manager::load(): plugin SpirvToGlslShaderConverter is not static and was not found in nonexistent\n"
"ShaderTools::AnyConverter::convertFileToFile(): cannot load the SpirvToGlslShaderConverter plugin\n");
#else
CORRADE_COMPARE(out.str(),
"PluginManager::Manager::load(): plugin SpirvToGlslShaderConverter was not found\n"
"ShaderTools::AnyConverter::convertFileToFile(): cannot load the SpirvToGlslShaderConverter plugin\n");
#endif
}
void AnyConverterTest::convertFileToFileUnknownInput() {
AnyShaderConverter: test also unknown extension for conversion. And make it return right after the first error. Also clean up some old-style code -- the redirection should be restricted to the smallest scope possible.
5 years ago
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter");
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter->convertFileToFile({}, "dead.cg", "whatever.osl"));
CORRADE_COMPARE(out.str(), "ShaderTools::AnyConverter::convertFileToFile(): cannot determine the format of dead.cg\n");
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::convertFileToFileUnknownOutput() {
AnyShaderConverter: test also unknown extension for conversion. And make it return right after the first error. Also clean up some old-style code -- the redirection should be restricted to the smallest scope possible.
5 years ago
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter");
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter->convertFileToFile({}, "file.spv", "whatever.osl"));
CORRADE_COMPARE(out.str(), "ShaderTools::AnyConverter::convertFileToFile(): cannot determine the format of whatever.osl\n");
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::convertFileToFileNotSupported() {
AnyShaderConverter: fart!
5 years ago
CORRADE_SKIP("No plugin that would support just conversion exists.");
AnyShaderConverter: new plugin.
6 years ago
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::convertFileToFilePreprocessNotSupported() {
AnyShaderConverter: propagate preprocessor definitions.
6 years ago
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("SpirvToolsShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("SpirvToolsShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setDefinitions({
{"DEFINE", "hahahahah"}
});
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertFileToFile({}, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv"),
Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spvasm")));
AnyShaderConverter: propagate preprocessor definitions.
6 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::convertFileToFile(): SpirvToolsShaderConverter does not support preprocessing\n");
/* It should fail for the flag as well */
out.str({});
converter->setDefinitions({});
converter->setFlags(ConverterFlag::PreprocessOnly);
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertFileToFile({}, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv"),
Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spvasm")));
AnyShaderConverter: propagate preprocessor definitions.
6 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::convertFileToFile(): SpirvToolsShaderConverter does not support preprocessing\n");
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::convertFileToFileDebugInfoNotSupported() {
AnyShaderConverter: propagate debug info level.
6 years ago
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("SpirvToolsShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("SpirvToolsShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setDebugInfoLevel("1");
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertFileToFile({}, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv"),
Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spvasm")));
AnyShaderConverter: typo!
6 years ago
/** @todo it once may support that, in which case we need to find another
AnyShaderConverter: propagate debug info level.
6 years ago
victim */
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::convertFileToFile(): SpirvToolsShaderConverter does not support controlling debug info output\n");
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::convertFileToFileOptimizationNotSupported() {
AnyShaderConverter: propagate optimization level as well. Finally a complete API... except for linking, which no plugin exposes yet so I can't test it.
6 years ago
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setOptimizationLevel("1");
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertFileToFile({}, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"),
Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spv")));
AnyShaderConverter: propagate optimization level as well. Finally a complete API... except for linking, which no plugin exposes yet so I can't test it.
6 years ago
/** @todo it once may support that, in which case we need to find another
victim */
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::convertFileToFile(): GlslangShaderConverter does not support optimization\n");
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::convertFileToFilePropagateFlags() {
AnyShaderConverter: new plugin.
6 years ago
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::String filename = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl");
AnyShaderConverter: new plugin.
6 years ago
/* With this, the warning should turn into an error. The converter should
also print the verbose info. */
converter->setFlags(ConverterFlag::Verbose|ConverterFlag::WarningAsError);
/* We have to supply a valid file path because the version gets checked in
doConvertDataToData(), called from AbstractConverter::doConvertFileToFile()
with the file contents. */
std::ostringstream out;
Debug redirectDebug{&out};
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertFileToFile(Stage::Fragment, filename, Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spv")));
AnyShaderConverter: new plugin.
6 years ago
CORRADE_COMPARE(out.str(), Utility::formatString(
"ShaderTools::AnyConverter::convertFileToFile(): using GlslToSpirvShaderConverter (provided by GlslangShaderConverter)\n"
"ShaderTools::GlslangConverter::convertDataToData(): compilation failed:\n"
AnyShaderConverter: propagate preprocessor definitions.
6 years ago
"WARNING: {}:10: 'reserved__identifier' : identifiers containing consecutive underscores (\"__\") are reserved\n", filename));
AnyShaderConverter: new plugin.
6 years ago
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::convertFileToFilePropagateInputVersion() {
AnyShaderConverter: new plugin.
6 years ago
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
/* This is an invalid version */
converter->setInputFormat(Format::Glsl, "100");
/* We have to supply a valid file path because the version gets checked in
doConvertDataToData(), called from AbstractConverter::doConvertFileToFile()
with the file contents. */
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertFileToFile(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"), Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spv")));
AnyShaderConverter: new plugin.
6 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::GlslangConverter::convertDataToData(): input format version should be one of supported GLSL #version strings but got 100\n");
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::convertFileToFilePropagateOutputVersion() {
AnyShaderConverter: new plugin.
6 years ago
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
/* This is an invalid version */
converter->setOutputFormat(Format::Spirv, "opengl4.0");
/* We have to supply a valid file path because the version gets checked in
doConvertDataToData(), called from AbstractConverter::doConvertFileToFile()
with the file contents. */
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertFileToFile(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"), Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spv")));
AnyShaderConverter: new plugin.
6 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::GlslangConverter::convertDataToData(): output format version target should be opengl4.5 or vulkanX.Y but got opengl4.0\n");
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::convertFileToFilePropagatePreprocess() {
AnyShaderConverter: propagate preprocessor definitions.
6 years ago
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
/* Check that undefining works properly -- if it stays defined, the source
won't compile */
converter->setDefinitions({
{"SHOULD_BE_UNDEFINED", "really"},
{"SHOULD_BE_UNDEFINED", nullptr},
{"reserved__identifier", "different__but_also_wrong"}
});
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::String inputFilename = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl");
Containers::String outputFilename = Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spv");
if(Utility::Path::exists(outputFilename))
CORRADE_VERIFY(Utility::Path::remove(outputFilename));
AnyShaderConverter: propagate preprocessor definitions.
6 years ago
/* Make it print a warning so we know it's doing something */
std::ostringstream out;
Warning redirectWarning{&out};
CORRADE_VERIFY(converter->convertFileToFile(Stage::Fragment, inputFilename, outputFilename));
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(Utility::Path::exists(outputFilename));
AnyShaderConverter: propagate preprocessor definitions.
6 years ago
CORRADE_COMPARE(out.str(), Utility::formatString(
"ShaderTools::GlslangConverter::convertDataToData(): compilation succeeded with the following message:\n"
"WARNING: {}:10: 'different__but_also_wrong' : identifiers containing consecutive underscores (\"__\") are reserved\n", inputFilename));
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::convertFileToFilePropagateDebugInfo() {
AnyShaderConverter: propagate debug info level.
6 years ago
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
/* This is an invalid level */
converter->setDebugInfoLevel("2");
/* We have to supply a valid file path because the version gets checked in
doConvertDataToData(), called from AbstractConverter::doConvertFileToFile()
with the file contents. */
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertFileToFile(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"), Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spv")));
AnyShaderConverter: propagate debug info level.
6 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::GlslangConverter::convertDataToData(): debug info level should be 0, 1 or empty but got 2\n");
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::convertFileToFilePropagateOptimization() {
AnyShaderConverter: propagate optimization level as well. Finally a complete API... except for linking, which no plugin exposes yet so I can't test it.
6 years ago
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("SpirvToolsShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("SpirvToolsShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
/* This is an invalid level */
converter->setOptimizationLevel("2");
/* We have to supply a valid file path because the version gets checked in
doConvertDataToData(), called from AbstractConverter::doConvertFileToFile()
with the file contents. */
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertFileToFile(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv"), Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spv")));
AnyShaderConverter: propagate optimization level as well. Finally a complete API... except for linking, which no plugin exposes yet so I can't test it.
6 years ago
CORRADE_COMPARE(out.str(),
AnyShaderConverter: adapt tests to GlslangShaderCovnerter updates.
5 years ago
"ShaderTools::SpirvToolsConverter::convertDataToData(): optimization level should be 0, 1, s, legalizeHlsl or empty but got 2\n");
AnyShaderConverter: propagate optimization level as well. Finally a complete API... except for linking, which no plugin exposes yet so I can't test it.
6 years ago
}
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
void AnyConverterTest::convertFileToFilePropagateConfiguration() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::String input = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "version-not-first.glsl");
Containers::String output = Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spv");
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
{
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter->convertFileToFile(Stage::Fragment, input, output));
CORRADE_COMPARE(out.str(),
Utility::formatString("ShaderTools::GlslangConverter::convertDataToData(): compilation failed:\nERROR: {}:2: '#version' : must occur first in shader \nERROR: 1 compilation errors. No code generated.\n", input));
} {
converter->configuration().setValue("permissive", true);
/* Lol stupid thing, apparently it has two differently worded messages
for the same thing? Dumpster fire. */
std::ostringstream out;
Warning redirectWarning{&out};
CORRADE_VERIFY(converter->convertFileToFile(Stage::Fragment, input, output));
CORRADE_COMPARE(out.str(),
"ShaderTools::GlslangConverter::convertDataToData(): compilation succeeded with the following message:\nWARNING: 0:0: '#version' : Illegal to have non-comment, non-whitespace tokens before #version\n");
}
}
void AnyConverterTest::convertFileToFilePropagateConfigurationUnknown() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->configuration().setValue("noSuchOption", "isHere");
/* So it doesn't warn about anything */
converter->setDefinitions({{"reserved__identifier", "sorry"}});
std::ostringstream out;
Warning redirectWarning{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(converter->convertFileToFile(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"), Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.glsl")));
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::convertFileToFile(): option noSuchOption not recognized by GlslangShaderConverter\n");
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::convertFileToData() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setOutputFormat(Format::Spirv);
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::String inputFilename = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl");
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
/* Make it print a warning so we know it's doing something */
std::ostringstream out;
Warning redirectWarning{&out};
CORRADE_VERIFY(converter->convertFileToData(Stage::Fragment, inputFilename));
CORRADE_COMPARE(out.str(), Utility::formatString(
"ShaderTools::GlslangConverter::convertDataToData(): compilation succeeded with the following message:\n"
"WARNING: {}:10: 'reserved__identifier' : identifiers containing consecutive underscores (\"__\") are reserved\n", inputFilename));
}
void AnyConverterTest::convertFileToDataPluginLoadFailed() {
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter");
converter->setOutputFormat(Format::Wgsl);
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter->convertFileToData({}, "file.spv"));
#ifndef CORRADE_PLUGINMANAGER_NO_DYNAMIC_PLUGIN_SUPPORT
CORRADE_COMPARE(out.str(),
"PluginManager::Manager::load(): plugin SpirvToWgslShaderConverter is not static and was not found in nonexistent\n"
"ShaderTools::AnyConverter::convertFileToData(): cannot load the SpirvToWgslShaderConverter plugin\n");
#else
CORRADE_COMPARE(out.str(),
"PluginManager::Manager::load(): plugin SpirvToWgslShaderConverter was not found\n"
"ShaderTools::AnyConverter::convertFileToData(): cannot load the SpirvToWgslShaderConverter plugin\n");
#endif
}
void AnyConverterTest::convertFileToDataUnknown() {
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter");
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter->convertFileToData({}, "dead.cg"));
CORRADE_COMPARE(out.str(), "ShaderTools::AnyConverter::convertFileToData(): cannot determine the format of dead.cg\n");
}
void AnyConverterTest::convertFileToDataNoFormatSet() {
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter");
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter->convertFileToData({}, "file.spv"));
CORRADE_COMPARE(out.str(), "ShaderTools::AnyConverter::convertFileToData(): no output format specified\n");
}
void AnyConverterTest::convertFileToDataNotSupported() {
CORRADE_SKIP("No plugin that would support just conversion exists.");
}
void AnyConverterTest::convertFileToDataPreprocessNotSupported() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("SpirvToolsShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("SpirvToolsShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setOutputFormat(Format::SpirvAssembly);
converter->setDefinitions({
{"DEFINE", "hahahahah"}
});
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertFileToData({}, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv")));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::convertFileToData(): SpirvToolsShaderConverter does not support preprocessing\n");
/* It should fail for the flag as well */
out.str({});
converter->setDefinitions({});
converter->setFlags(ConverterFlag::PreprocessOnly);
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertFileToData({}, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv")));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::convertFileToData(): SpirvToolsShaderConverter does not support preprocessing\n");
}
void AnyConverterTest::convertFileToDataDebugInfoNotSupported() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("SpirvToolsShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("SpirvToolsShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setOutputFormat(Format::SpirvAssembly);
converter->setDebugInfoLevel("1");
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertFileToData({}, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv")));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
/** @todo it once may support that, in which case we need to find another
victim */
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::convertFileToData(): SpirvToolsShaderConverter does not support controlling debug info output\n");
}
void AnyConverterTest::convertFileToDataOptimizationNotSupported() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setOutputFormat(Format::Spirv);
converter->setOptimizationLevel("1");
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertFileToData({}, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
/** @todo it once may support that, in which case we need to find another
victim */
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::convertFileToData(): GlslangShaderConverter does not support optimization\n");
}
void AnyConverterTest::convertFileToDataPropagateFlags() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::String filename = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl");
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
converter->setOutputFormat(Format::Spirv);
/* With this, the warning should turn into an error. The converter should
also print the verbose info. */
converter->setFlags(ConverterFlag::Verbose|ConverterFlag::WarningAsError);
/* We have to supply a valid file path because the version gets checked in
doConvertDataToData(), called from AbstractConverter::doConvertFileToFile()
with the file contents. */
std::ostringstream out;
Debug redirectDebug{&out};
Error redirectError{&out};
CORRADE_VERIFY(!converter->convertFileToData(Stage::Fragment, filename));
CORRADE_COMPARE(out.str(), Utility::formatString(
"ShaderTools::AnyConverter::convertFileToData(): using GlslToSpirvShaderConverter (provided by GlslangShaderConverter)\n"
"ShaderTools::GlslangConverter::convertDataToData(): compilation failed:\n"
"WARNING: {}:10: 'reserved__identifier' : identifiers containing consecutive underscores (\"__\") are reserved\n", filename));
}
void AnyConverterTest::convertFileToDataPropagateInputVersion() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
/* This is an invalid version */
converter->setInputFormat(Format::Glsl, "100");
converter->setOutputFormat(Format::Spirv);
/* We have to supply a valid file path because the version gets checked in
doConvertDataToData(), called from AbstractConverter::doConvertFileToFile()
with the file contents. */
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertFileToData(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::GlslangConverter::convertDataToData(): input format version should be one of supported GLSL #version strings but got 100\n");
}
void AnyConverterTest::convertFileToDataPropagateOutputVersion() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
/* This is an invalid version */
converter->setOutputFormat(Format::Spirv, "opengl4.0");
/* We have to supply a valid file path because the version gets checked in
doConvertDataToData(), called from AbstractConverter::doConvertFileToFile()
with the file contents. */
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertFileToData(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::GlslangConverter::convertDataToData(): output format version target should be opengl4.5 or vulkanX.Y but got opengl4.0\n");
}
void AnyConverterTest::convertFileToDataPropagatePreprocess() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setOutputFormat(Format::Spirv);
/* Check that undefining works properly -- if it stays defined, the source
won't compile */
converter->setDefinitions({
{"SHOULD_BE_UNDEFINED", "really"},
{"SHOULD_BE_UNDEFINED", nullptr},
{"reserved__identifier", "different__but_also_wrong"}
});
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::String inputFilename = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl");
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
/* Make it print a warning so we know it's doing something */
std::ostringstream out;
Warning redirectWarning{&out};
CORRADE_VERIFY(converter->convertFileToData(Stage::Fragment, inputFilename));
CORRADE_COMPARE(out.str(), Utility::formatString(
"ShaderTools::GlslangConverter::convertDataToData(): compilation succeeded with the following message:\n"
"WARNING: {}:10: 'different__but_also_wrong' : identifiers containing consecutive underscores (\"__\") are reserved\n", inputFilename));
}
void AnyConverterTest::convertFileToDataPropagateDebugInfo() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setOutputFormat(Format::Spirv);
/* This is an invalid level */
converter->setDebugInfoLevel("2");
/* We have to supply a valid file path because the version gets checked in
doConvertDataToData(), called from AbstractConverter::doConvertFileToFile()
with the file contents. */
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertFileToData(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::GlslangConverter::convertDataToData(): debug info level should be 0, 1 or empty but got 2\n");
}
void AnyConverterTest::convertFileToDataPropagateOptimization() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("SpirvToolsShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("SpirvToolsShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setOutputFormat(Format::Spirv);
/* This is an invalid level */
converter->setOptimizationLevel("2");
/* We have to supply a valid file path because the version gets checked in
doConvertDataToData(), called from AbstractConverter::doConvertFileToFile()
with the file contents. */
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertFileToData(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv")));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
CORRADE_COMPARE(out.str(),
AnyShaderConverter: adapt tests to GlslangShaderCovnerter updates.
5 years ago
"ShaderTools::SpirvToolsConverter::convertDataToData(): optimization level should be 0, 1, s, legalizeHlsl or empty but got 2\n");
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
}
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
void AnyConverterTest::convertFileToDataPropagateConfiguration() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setOutputFormat(Format::Spirv);
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::String input = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "version-not-first.glsl");
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
{
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter->convertFileToData(Stage::Fragment, input));
CORRADE_COMPARE(out.str(),
Utility::formatString("ShaderTools::GlslangConverter::convertDataToData(): compilation failed:\nERROR: {}:2: '#version' : must occur first in shader \nERROR: 1 compilation errors. No code generated.\n", input));
} {
converter->configuration().setValue("permissive", true);
/* Lol stupid thing, apparently it has two differently worded messages
for the same thing? Dumpster fire. */
std::ostringstream out;
Warning redirectWarning{&out};
CORRADE_VERIFY(converter->convertFileToData(Stage::Fragment, input));
CORRADE_COMPARE(out.str(),
"ShaderTools::GlslangConverter::convertDataToData(): compilation succeeded with the following message:\nWARNING: 0:0: '#version' : Illegal to have non-comment, non-whitespace tokens before #version\n");
}
}
void AnyConverterTest::convertFileToDataPropagateConfigurationUnknown() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setOutputFormat(Format::Spirv);
converter->configuration().setValue("noSuchOption", "isHere");
/* So it doesn't warn about anything */
converter->setDefinitions({{"reserved__identifier", "sorry"}});
std::ostringstream out;
Warning redirectWarning{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(converter->convertFileToData(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")));
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::convertFileToData(): option noSuchOption not recognized by GlslangShaderConverter\n");
}
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
void AnyConverterTest::convertDataToData() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Glsl);
converter->setOutputFormat(Format::Spirv);
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"));
CORRADE_VERIFY(data);
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
/* Make it print a warning so we know it's doing something */
std::ostringstream out;
Warning redirectWarning{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(converter->convertDataToData(Stage::Fragment, *data));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::GlslangConverter::convertDataToData(): compilation succeeded with the following message:\n"
"WARNING: 0:10: 'reserved__identifier' : identifiers containing consecutive underscores (\"__\") are reserved\n");
}
void AnyConverterTest::convertDataToDataPluginLoadFailed() {
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Hlsl);
converter->setOutputFormat(Format::Wgsl);
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter->convertDataToData({}, {}));
#ifndef CORRADE_PLUGINMANAGER_NO_DYNAMIC_PLUGIN_SUPPORT
CORRADE_COMPARE(out.str(),
"PluginManager::Manager::load(): plugin HlslToWgslShaderConverter is not static and was not found in nonexistent\n"
"ShaderTools::AnyConverter::convertDataToData(): cannot load the HlslToWgslShaderConverter plugin\n");
#else
CORRADE_COMPARE(out.str(),
"PluginManager::Manager::load(): plugin HlslToWgslShaderConverter was not found\n"
"ShaderTools::AnyConverter::convertDataToData(): cannot load the HlslToWgslShaderConverter plugin\n");
#endif
}
void AnyConverterTest::convertDataToDataNoInputFormatSet() {
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter");
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter->convertDataToData({}, {}));
CORRADE_COMPARE(out.str(), "ShaderTools::AnyConverter::convertDataToData(): no input format specified\n");
}
void AnyConverterTest::convertDataToDataNoOutputFormatSet() {
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Spirv);
std::ostringstream out;
Error redirectError{&out};
CORRADE_VERIFY(!converter->convertDataToData({}, {}));
CORRADE_COMPARE(out.str(), "ShaderTools::AnyConverter::convertDataToData(): no output format specified\n");
}
void AnyConverterTest::convertDataToDataNotSupported() {
CORRADE_SKIP("No plugin that would support just conversion exists.");
}
void AnyConverterTest::convertDataToDataPreprocessNotSupported() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("SpirvToolsShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("SpirvToolsShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Spirv);
converter->setOutputFormat(Format::SpirvAssembly);
converter->setDefinitions({
{"DEFINE", "hahahahah"}
});
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv"));
CORRADE_VERIFY(data);
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertDataToData({}, *data));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::convertDataToData(): SpirvToolsShaderConverter does not support preprocessing\n");
/* It should fail for the flag as well */
out.str({});
converter->setDefinitions({});
converter->setFlags(ConverterFlag::PreprocessOnly);
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertDataToData({}, *data));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::convertDataToData(): SpirvToolsShaderConverter does not support preprocessing\n");
}
void AnyConverterTest::convertDataToDataDebugInfoNotSupported() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("SpirvToolsShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("SpirvToolsShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Spirv);
converter->setOutputFormat(Format::SpirvAssembly);
converter->setDebugInfoLevel("1");
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv"));
CORRADE_VERIFY(data);
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertDataToData({}, *data));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
/** @todo it once may support that, in which case we need to find another
victim */
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::convertDataToData(): SpirvToolsShaderConverter does not support controlling debug info output\n");
}
void AnyConverterTest::convertDataToDataOptimizationNotSupported() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Glsl);
converter->setOutputFormat(Format::Spirv);
converter->setOptimizationLevel("1");
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"));
CORRADE_VERIFY(data);
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertDataToData({}, *data));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
/** @todo it once may support that, in which case we need to find another
victim */
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::convertDataToData(): GlslangShaderConverter does not support optimization\n");
}
void AnyConverterTest::convertDataToDataPropagateFlags() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Glsl);
converter->setOutputFormat(Format::Spirv);
/* With this, the warning should turn into an error. The converter should
also print the verbose info. */
converter->setFlags(ConverterFlag::Verbose|ConverterFlag::WarningAsError);
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"));
CORRADE_VERIFY(data);
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
/* We have to supply a valid file path because the version gets checked in
doConvertDataToData(), called from AbstractConverter::doConvertFileToFile()
with the file contents. */
std::ostringstream out;
Debug redirectDebug{&out};
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertDataToData(Stage::Fragment, *data));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::convertDataToData(): using GlslToSpirvShaderConverter (provided by GlslangShaderConverter)\n"
"ShaderTools::GlslangConverter::convertDataToData(): compilation failed:\n"
"WARNING: 0:10: 'reserved__identifier' : identifiers containing consecutive underscores (\"__\") are reserved\n");
}
void AnyConverterTest::convertDataToDataPropagateInputVersion() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
/* This is an invalid version */
converter->setInputFormat(Format::Glsl, "100");
converter->setOutputFormat(Format::Spirv);
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"));
CORRADE_VERIFY(data);
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
/* We have to supply a valid file path because the version gets checked in
doConvertDataToData(), called from AbstractConverter::doConvertFileToFile()
with the file contents. */
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertDataToData(Stage::Fragment, *data));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::GlslangConverter::convertDataToData(): input format version should be one of supported GLSL #version strings but got 100\n");
}
void AnyConverterTest::convertDataToDataPropagateOutputVersion() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Glsl);
/* This is an invalid version */
converter->setOutputFormat(Format::Spirv, "opengl4.0");
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"));
CORRADE_VERIFY(data);
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
/* We have to supply a valid file path because the version gets checked in
doConvertDataToData(), called from AbstractConverter::doConvertFileToFile()
with the file contents. */
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertDataToData(Stage::Fragment, *data));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::GlslangConverter::convertDataToData(): output format version target should be opengl4.5 or vulkanX.Y but got opengl4.0\n");
}
void AnyConverterTest::convertDataToDataPropagatePreprocess() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Glsl);
converter->setOutputFormat(Format::Spirv);
/* Check that undefining works properly -- if it stays defined, the source
won't compile */
converter->setDefinitions({
{"SHOULD_BE_UNDEFINED", "really"},
{"SHOULD_BE_UNDEFINED", nullptr},
{"reserved__identifier", "different__but_also_wrong"}
});
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"));
CORRADE_VERIFY(data);
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
/* Make it print a warning so we know it's doing something */
std::ostringstream out;
Warning redirectWarning{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(converter->convertDataToData(Stage::Fragment, *data));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::GlslangConverter::convertDataToData(): compilation succeeded with the following message:\n"
"WARNING: 0:10: 'different__but_also_wrong' : identifiers containing consecutive underscores (\"__\") are reserved\n");
}
void AnyConverterTest::convertDataToDataPropagateDebugInfo() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Glsl);
converter->setOutputFormat(Format::Spirv);
/* This is an invalid level */
converter->setDebugInfoLevel("2");
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"));
CORRADE_VERIFY(data);
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
/* We have to supply a valid file path because the version gets checked in
doConvertDataToData(), called from AbstractConverter::doConvertFileToFile()
with the file contents. */
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertDataToData(Stage::Fragment, *data));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::GlslangConverter::convertDataToData(): debug info level should be 0, 1 or empty but got 2\n");
}
void AnyConverterTest::convertDataToDataPropagateOptimization() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("SpirvToolsShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("SpirvToolsShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Spirv);
converter->setOutputFormat(Format::Spirv);
/* This is an invalid level */
converter->setOptimizationLevel("2");
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv"));
CORRADE_VERIFY(data);
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
/* We have to supply a valid file path because the version gets checked in
doConvertDataToData(), called from AbstractConverter::doConvertFileToFile()
with the file contents. */
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertDataToData(Stage::Fragment, *data));
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
CORRADE_COMPARE(out.str(),
AnyShaderConverter: adapt tests to GlslangShaderCovnerter updates.
5 years ago
"ShaderTools::SpirvToolsConverter::convertDataToData(): optimization level should be 0, 1, s, legalizeHlsl or empty but got 2\n");
AnyShaderConverter: support validating and converting data as well. Because it's possible to specify the formats explicitly it doesn't make sense not to support that. Eventually contents-based detection could be implemented as well, but I don't want to do that just yet.
5 years ago
}
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
void AnyConverterTest::convertDataToDataPropagateConfiguration() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Glsl);
converter->setOutputFormat(Format::Spirv);
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "version-not-first.glsl"));
CORRADE_VERIFY(data);
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
{
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertDataToData(Stage::Fragment, *data));
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::GlslangConverter::convertDataToData(): compilation failed:\nERROR: 0:2: '#version' : must occur first in shader \nERROR: 1 compilation errors. No code generated.\n");
} {
converter->configuration().setValue("permissive", true);
/* Lol stupid thing, apparently it has two differently worded messages
for the same thing? Dumpster fire. */
std::ostringstream out;
Warning redirectWarning{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(converter->convertDataToData(Stage::Fragment, *data));
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::GlslangConverter::convertDataToData(): compilation succeeded with the following message:\nWARNING: 0:0: '#version' : Illegal to have non-comment, non-whitespace tokens before #version\n");
}
}
void AnyConverterTest::convertDataToDataPropagateConfigurationUnknown() {
PluginManager::Manager<AbstractConverter> manager{MAGNUM_PLUGINS_SHADERCONVERTER_INSTALL_DIR};
#ifdef ANYSHADERCONVERTER_PLUGIN_FILENAME
CORRADE_VERIFY(manager.load(ANYSHADERCONVERTER_PLUGIN_FILENAME) & PluginManager::LoadState::Loaded);
#endif
if(manager.load("GlslangShaderConverter") < PluginManager::LoadState::Loaded)
CORRADE_SKIP("GlslangShaderConverter plugin can't be loaded.");
Containers::Pointer<AbstractConverter> converter = manager.instantiate("AnyShaderConverter");
converter->setInputFormat(Format::Glsl);
converter->setOutputFormat(Format::Spirv);
converter->configuration().setValue("noSuchOption", "isHere");
/* So it doesn't warn about anything */
converter->setDefinitions({{"reserved__identifier", "sorry"}});
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"));
CORRADE_VERIFY(data);
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
std::ostringstream out;
Warning redirectWarning{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(converter->convertDataToData(Stage::Fragment, *data));
Propagate configuration options in Any* plugins. Minor but very important convenience feature, especially useful when dealing with command-line apps. This now works: magnum-imageconverter a.png a.jpg -c jpegQuality=0.75 The AnyImageConverter gets the jpegQuality option and then automatically propagates it to the concrete plugin (which is either JpegImageConverter or StbImageConverter), possibly warning in case the target plugin doesn't recognize given option (i.e., doesn't list it in its default configuration). Previously the user had to always specify a concrete converter implementation using -C, which was rather annoying and nonintuitive.
5 years ago
CORRADE_COMPARE(out.str(),
"ShaderTools::AnyConverter::convertDataToData(): option noSuchOption not recognized by GlslangShaderConverter\n");
}
AnyShaderConverter: new plugin.
6 years ago
void AnyConverterTest::detectValidate() {
auto&& data = DetectValidateData[testCaseInstanceId()];
setTestCaseDescription(data.name);
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter");
std::ostringstream out;
Error redirectError{&out};
CORRADE_COMPARE(converter->validateFile({}, data.filename),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(false, Containers::String{}));
AnyShaderConverter: new plugin.
6 years ago
#ifndef CORRADE_PLUGINMANAGER_NO_DYNAMIC_PLUGIN_SUPPORT
CORRADE_COMPARE(out.str(), Utility::formatString(
"PluginManager::Manager::load(): plugin {0} is not static and was not found in nonexistent\n"
"ShaderTools::AnyConverter::validateFile(): cannot load the {0} plugin\n", data.plugin));
#else
CORRADE_COMPARE(out.str(), Utility::formatString(
"PluginManager::Manager::load(): plugin {0} was not found\n"
"ShaderTools::AnyConverter::validateFile(): cannot load the {0} plugin\n", data.plugin));
#endif
}
AnyShaderConverter: take explicitly set formats into account. So if we convert foo.blah but explicitly tell it that it's a SPIR-V file, it actually treats it as such, instead of complaining that `blah` is not a known extension. First step towards being able to operate directly on data.
5 years ago
void AnyConverterTest::detectValidateExplicitFormat() {
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter");
/* It should pick up this format and not bother with the extension */
converter->setInputFormat(Format::Hlsl);
std::ostringstream out;
Error redirectError{&out};
CORRADE_COMPARE(converter->validateFile({}, "file.spv"),
ShaderTools: port away from std::pair. Here the benefit is especially clear -- as Containers::Pair is trivially copyable with trivial types, all growable arrays can make use of std::realloc() while with the STL variant a silly constructor, copy constructor, destructor had to be used. Additionally, we no longer need to take explicit care of libc++ and MSVC STL where returning a std::pair<bool, Containers::String> as return {{}, Containers::String{..., <deleter>}}; would caused an unnecessary copy instead of a move, losing the custom deleter in the process. Yay! There's a <Corrade/Containers/PairStl.h> include for backwards compatibility purposes, but obviously it would only work for the return type of validate*() and cases where an initializer list was passed to a list-of-pairs-taking functions, and not a concretely typed ArrayView. Those functions were though mostly the linker API which isn't implemented by any plugin yet, so it shouldn't be *that* breaking to users. Neverteless, I'm trying to do this breaking change rather sooner than later to prevent pain further down the road when the Vulkan APIs and SPIR-V pipeline gets widely used.
4 years ago
Containers::pair(false, Containers::String{}));
AnyShaderConverter: take explicitly set formats into account. So if we convert foo.blah but explicitly tell it that it's a SPIR-V file, it actually treats it as such, instead of complaining that `blah` is not a known extension. First step towards being able to operate directly on data.
5 years ago
#ifndef CORRADE_PLUGINMANAGER_NO_DYNAMIC_PLUGIN_SUPPORT
CORRADE_COMPARE(out.str(),
"PluginManager::Manager::load(): plugin HlslShaderConverter is not static and was not found in nonexistent\n"
"ShaderTools::AnyConverter::validateFile(): cannot load the HlslShaderConverter plugin\n");
#else
CORRADE_COMPARE(out.str(),
"PluginManager::Manager::load(): plugin HlslShaderConverter was not found\n"
"ShaderTools::AnyConverter::validateFile(): cannot load the HlslShaderConverter plugin\n");
#endif
}
AnyShaderConverter: new plugin.
6 years ago
void AnyConverterTest::detectConvert() {
auto&& data = DetectConvertData[testCaseInstanceId()];
setTestCaseDescription(data.name);
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter");
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertFileToFile({}, data.from, Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, data.to)));
AnyShaderConverter: new plugin.
6 years ago
#ifndef CORRADE_PLUGINMANAGER_NO_DYNAMIC_PLUGIN_SUPPORT
CORRADE_COMPARE(out.str(), Utility::formatString(
"PluginManager::Manager::load(): plugin {0} is not static and was not found in nonexistent\n"
"ShaderTools::AnyConverter::convertFileToFile(): cannot load the {0} plugin\n", data.plugin));
#else
CORRADE_COMPARE(out.str(), Utility::formatString(
"PluginManager::Manager::load(): plugin {0} was not found\n"
"ShaderTools::AnyConverter::convertFileToFile(): cannot load the {0} plugin\n", data.plugin));
#endif
}
AnyShaderConverter: take explicitly set formats into account. So if we convert foo.blah but explicitly tell it that it's a SPIR-V file, it actually treats it as such, instead of complaining that `blah` is not a known extension. First step towards being able to operate directly on data.
5 years ago
void AnyConverterTest::detectConvertExplicitFormat() {
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter");
/* It should pick up this format and not bother with the extension */
converter->setInputFormat(Format::Hlsl);
converter->setOutputFormat(Format::Wgsl);
std::ostringstream out;
Error redirectError{&out};
ShaderTools: port to the new Utility::Path, including plugins, Again, exists() + read() is now an atomic and more robust Path::read(), apart from that not much interesting.
4 years ago
CORRADE_VERIFY(!converter->convertFileToFile({}, "file.spv", Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.glsl")));
AnyShaderConverter: take explicitly set formats into account. So if we convert foo.blah but explicitly tell it that it's a SPIR-V file, it actually treats it as such, instead of complaining that `blah` is not a known extension. First step towards being able to operate directly on data.
5 years ago
#ifndef CORRADE_PLUGINMANAGER_NO_DYNAMIC_PLUGIN_SUPPORT
CORRADE_COMPARE(out.str(),
"PluginManager::Manager::load(): plugin HlslToWgslShaderConverter is not static and was not found in nonexistent\n"
"ShaderTools::AnyConverter::convertFileToFile(): cannot load the HlslToWgslShaderConverter plugin\n");
#else
CORRADE_COMPARE(out.str(),
"PluginManager::Manager::load(): plugin HlslToWgslShaderConverter was not found\n"
"ShaderTools::AnyConverter::convertFileToFile(): cannot load the HlslToWgslShaderConverter plugin\n");
#endif
}
AnyShaderConverter: new plugin.
6 years ago
}}}}
CORRADE_TEST_MAIN(Magnum::ShaderTools::Test::AnyConverterTest)