mirror of https://github.com/mosra/magnum.git
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.
1936 lines
94 KiB
1936 lines
94 KiB
/* |
|
This file is part of Magnum. |
|
|
|
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, |
|
2020, 2021, 2022 Vladimír Vondruš <mosra@centrum.cz> |
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a |
|
copy of this software and associated documentation files (the "Software"), |
|
to deal in the Software without restriction, including without limitation |
|
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|
and/or sell copies of the Software, and to permit persons to whom the |
|
Software is furnished to do so, subject to the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be included |
|
in all copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
|
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|
DEALINGS IN THE SOFTWARE. |
|
*/ |
|
|
|
#include <sstream> |
|
#include <Corrade/Containers/Array.h> |
|
#include <Corrade/Containers/Optional.h> |
|
#include <Corrade/Containers/Pair.h> |
|
#include <Corrade/Containers/String.h> |
|
#include <Corrade/Containers/StringStl.h> |
|
#include <Corrade/PluginManager/Manager.h> |
|
#include <Corrade/TestSuite/Tester.h> |
|
#include <Corrade/Utility/ConfigurationGroup.h> |
|
#include <Corrade/Utility/DebugStl.h> |
|
#include <Corrade/Utility/FormatStl.h> |
|
#include <Corrade/Utility/Path.h> |
|
|
|
#include "Magnum/ShaderTools/AbstractConverter.h" |
|
#include "Magnum/ShaderTools/Stage.h" |
|
|
|
#include "configure.h" |
|
|
|
namespace Magnum { namespace ShaderTools { namespace Test { namespace { |
|
|
|
struct AnyConverterTest: TestSuite::Tester { |
|
explicit AnyConverterTest(); |
|
|
|
void validateFile(); |
|
void validateFilePluginLoadFailed(); |
|
void validateFileUnknown(); |
|
void validateFileNotSupported(); |
|
void validateFilePreprocessNotSupported(); |
|
void validateFilePropagateFlags(); |
|
void validateFilePropagateInputVersion(); |
|
void validateFilePropagateOutputVersion(); |
|
void validateFilePropagatePreprocess(); |
|
void validateFilePropagateConfiguration(); |
|
void validateFilePropagateConfigurationUnknown(); |
|
|
|
void validateData(); |
|
void validateDataPluginLoadFailed(); |
|
void validateDataNoFormatSet(); |
|
void validateDataNotSupported(); |
|
void validateDataPreprocessNotSupported(); |
|
void validateDataPropagateFlags(); |
|
void validateDataPropagateInputVersion(); |
|
void validateDataPropagateOutputVersion(); |
|
void validateDataPropagatePreprocess(); |
|
void validateDataPropagateConfiguration(); |
|
void validateDataPropagateConfigurationUnknown(); |
|
|
|
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(); |
|
void convertFileToFilePropagateConfiguration(); |
|
void convertFileToFilePropagateConfigurationUnknown(); |
|
|
|
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(); |
|
void convertFileToDataPropagateConfiguration(); |
|
void convertFileToDataPropagateConfigurationUnknown(); |
|
|
|
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(); |
|
void convertDataToDataPropagateConfiguration(); |
|
void convertDataToDataPropagateConfigurationUnknown(); |
|
|
|
void detectValidate(); |
|
void detectValidateExplicitFormat(); |
|
void detectConvert(); |
|
void detectConvertExplicitFormat(); |
|
|
|
/* 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() { |
|
addTests({&AnyConverterTest::validateFile, |
|
&AnyConverterTest::validateFilePluginLoadFailed, |
|
&AnyConverterTest::validateFileUnknown, |
|
&AnyConverterTest::validateFileNotSupported, |
|
&AnyConverterTest::validateFilePreprocessNotSupported, |
|
&AnyConverterTest::validateFilePropagateFlags, |
|
&AnyConverterTest::validateFilePropagateInputVersion, |
|
&AnyConverterTest::validateFilePropagateOutputVersion, |
|
&AnyConverterTest::validateFilePropagatePreprocess, |
|
&AnyConverterTest::validateFilePropagateConfiguration, |
|
&AnyConverterTest::validateFilePropagateConfigurationUnknown, |
|
|
|
&AnyConverterTest::validateData, |
|
&AnyConverterTest::validateDataPluginLoadFailed, |
|
&AnyConverterTest::validateDataNoFormatSet, |
|
&AnyConverterTest::validateDataNotSupported, |
|
&AnyConverterTest::validateDataPreprocessNotSupported, |
|
&AnyConverterTest::validateDataPropagateFlags, |
|
&AnyConverterTest::validateDataPropagateInputVersion, |
|
&AnyConverterTest::validateDataPropagateOutputVersion, |
|
&AnyConverterTest::validateDataPropagatePreprocess, |
|
&AnyConverterTest::validateDataPropagateConfiguration, |
|
&AnyConverterTest::validateDataPropagateConfigurationUnknown, |
|
|
|
&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, |
|
&AnyConverterTest::convertFileToFilePropagateConfiguration, |
|
&AnyConverterTest::convertFileToFilePropagateConfigurationUnknown, |
|
|
|
&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, |
|
&AnyConverterTest::convertFileToDataPropagateConfiguration, |
|
&AnyConverterTest::convertFileToDataPropagateConfigurationUnknown, |
|
|
|
&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, |
|
&AnyConverterTest::convertDataToDataPropagateOptimization, |
|
&AnyConverterTest::convertDataToDataPropagateConfiguration, |
|
&AnyConverterTest::convertDataToDataPropagateConfigurationUnknown}); |
|
|
|
addInstancedTests({&AnyConverterTest::detectValidate}, |
|
Containers::arraySize(DetectValidateData)); |
|
|
|
addTests({&AnyConverterTest::detectValidateExplicitFormat}); |
|
|
|
addInstancedTests({&AnyConverterTest::detectConvert}, |
|
Containers::arraySize(DetectConvertData)); |
|
|
|
addTests({&AnyConverterTest::detectConvertExplicitFormat}); |
|
|
|
/* 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 */ |
|
CORRADE_INTERNAL_ASSERT_OUTPUT(Utility::Path::make(ANYSHADERCONVERTER_TEST_OUTPUT_DIR)); |
|
} |
|
|
|
void AnyConverterTest::validateFile() { |
|
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"); |
|
|
|
Containers::String filename = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"); |
|
|
|
/* Make it print a warning so we know it's doing something */ |
|
CORRADE_COMPARE(converter->validateFile(Stage::Fragment, filename), |
|
Containers::pair(true, Utility::format("WARNING: {}:10: 'reserved__identifier' : identifiers containing consecutive underscores (\"__\") are reserved", filename))); |
|
} |
|
|
|
void AnyConverterTest::validateFilePluginLoadFailed() { |
|
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter"); |
|
|
|
std::ostringstream out; |
|
Error redirectError{&out}; |
|
CORRADE_COMPARE(converter->validateFile({}, "file.glsl"), |
|
Containers::pair(false, Containers::String{})); |
|
#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() { |
|
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter"); |
|
|
|
std::ostringstream out; |
|
Error redirectError{&out}; |
|
CORRADE_COMPARE(converter->validateFile({}, "dead.cg"), |
|
Containers::pair(false, Containers::String{})); |
|
CORRADE_COMPARE(out.str(), "ShaderTools::AnyConverter::validateFile(): cannot determine the format of dead.cg\n"); |
|
} |
|
|
|
void AnyConverterTest::validateFileNotSupported() { |
|
CORRADE_SKIP("No plugin that would support just validation exists."); |
|
} |
|
|
|
void AnyConverterTest::validateFilePreprocessNotSupported() { |
|
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}; |
|
CORRADE_COMPARE(converter->validateFile({}, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv")), |
|
Containers::pair(false, Containers::String{})); |
|
CORRADE_COMPARE(out.str(), |
|
"ShaderTools::AnyConverter::validateFile(): SpirvToolsShaderConverter does not support preprocessing\n"); |
|
} |
|
|
|
void AnyConverterTest::validateFilePropagateFlags() { |
|
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"); |
|
|
|
Containers::String filename = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"); |
|
|
|
/* 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), |
|
Containers::pair(false, Utility::format("WARNING: {}:10: 'reserved__identifier' : identifiers containing consecutive underscores (\"__\") are reserved", filename))); |
|
CORRADE_COMPARE(out.str(), |
|
"ShaderTools::AnyConverter::validateFile(): using GlslShaderConverter (provided by GlslangShaderConverter)\n"); |
|
} |
|
|
|
void AnyConverterTest::validateFilePropagateInputVersion() { |
|
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}; |
|
CORRADE_COMPARE(converter->validateFile(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")), |
|
Containers::pair(false, Containers::String{})); |
|
CORRADE_COMPARE(out.str(), |
|
"ShaderTools::GlslangConverter::validateData(): input format version should be one of supported GLSL #version strings but got 100\n"); |
|
} |
|
|
|
void AnyConverterTest::validateFilePropagateOutputVersion() { |
|
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->setOutputFormat(Format::Glsl, "opengl4.0"); |
|
|
|
std::ostringstream out; |
|
Error redirectError{&out}; |
|
CORRADE_COMPARE(converter->validateFile(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")), |
|
Containers::pair(false, Containers::String{})); |
|
CORRADE_COMPARE(out.str(), |
|
"ShaderTools::GlslangConverter::validateData(): output format should be Spirv or Unspecified but got ShaderTools::Format::Glsl\n"); |
|
} |
|
|
|
void AnyConverterTest::validateFilePropagatePreprocess() { |
|
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"); |
|
|
|
Containers::String filename = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.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"} |
|
}); |
|
|
|
CORRADE_COMPARE(converter->validateFile(Stage::Fragment, filename), |
|
Containers::pair(true, Utility::format("WARNING: {}:10: 'different__but_also_wrong' : identifiers containing consecutive underscores (\"__\") are reserved", filename))); |
|
} |
|
|
|
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"); |
|
|
|
Containers::String filename = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "version-not-first.glsl"); |
|
|
|
{ |
|
CORRADE_COMPARE(converter->validateFile(Stage::Fragment, filename), |
|
Containers::pair(false, Utility::format("ERROR: {}:2: '#version' : must occur first in shader \nERROR: 1 compilation errors. No code generated.", filename))); |
|
} { |
|
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), |
|
Containers::pair(true, Containers::String{"WARNING: 0:0: '#version' : Illegal to have non-comment, non-whitespace tokens before #version"})); |
|
} |
|
} |
|
|
|
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}; |
|
CORRADE_COMPARE(converter->validateFile(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")), |
|
Containers::pair(false, Containers::String{})); |
|
CORRADE_COMPARE(out.str(), |
|
"ShaderTools::AnyConverter::validateFile(): option noSuchOption not recognized by GlslangShaderConverter\n"); |
|
} |
|
|
|
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 */ |
|
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), |
|
Containers::pair(true, Containers::String{"WARNING: 0:10: 'reserved__identifier' : identifiers containing consecutive underscores (\"__\") are reserved"})); |
|
} |
|
|
|
void AnyConverterTest::validateDataPluginLoadFailed() { |
|
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter"); |
|
|
|
converter->setInputFormat(Format::Glsl); |
|
|
|
std::ostringstream out; |
|
Error redirectError{&out}; |
|
CORRADE_COMPARE(converter->validateData({}, {}), |
|
Containers::pair(false, Containers::String{})); |
|
#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"), |
|
Containers::pair(false, Containers::String{})); |
|
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"} |
|
}); |
|
|
|
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv")); |
|
CORRADE_VERIFY(data); |
|
|
|
std::ostringstream out; |
|
Error redirectError{&out}; |
|
CORRADE_COMPARE(converter->validateData({}, *data), |
|
Containers::pair(false, Containers::String{})); |
|
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); |
|
|
|
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")); |
|
CORRADE_VERIFY(data); |
|
|
|
std::ostringstream out; |
|
Debug redirectDebug{&out}; |
|
CORRADE_COMPARE(converter->validateData(Stage::Fragment, *data), |
|
Containers::pair(false, Containers::String{"WARNING: 0:10: 'reserved__identifier' : identifiers containing consecutive underscores (\"__\") are reserved"})); |
|
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"); |
|
|
|
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")); |
|
CORRADE_VERIFY(data); |
|
|
|
std::ostringstream out; |
|
Error redirectError{&out}; |
|
CORRADE_COMPARE(converter->validateData(Stage::Fragment, *data), |
|
Containers::pair(false, Containers::String{})); |
|
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"); |
|
|
|
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")); |
|
CORRADE_VERIFY(data); |
|
|
|
std::ostringstream out; |
|
Error redirectError{&out}; |
|
CORRADE_COMPARE(converter->validateData(Stage::Fragment, *data), |
|
Containers::pair(false, Containers::String{})); |
|
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"} |
|
}); |
|
|
|
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), |
|
Containers::pair(true, Containers::String{"WARNING: 0:10: 'different__but_also_wrong' : identifiers containing consecutive underscores (\"__\") are reserved"})); |
|
} |
|
|
|
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); |
|
|
|
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "version-not-first.glsl")); |
|
CORRADE_VERIFY(data); |
|
|
|
{ |
|
CORRADE_COMPARE(converter->validateData(Stage::Fragment, *data), |
|
Containers::pair(false, Containers::String{"ERROR: 0:2: '#version' : must occur first in shader \nERROR: 1 compilation errors. No code generated."})); |
|
} { |
|
converter->configuration().setValue("permissive", true); |
|
/* Lol stupid thing, apparently it has two differently worded messages |
|
for the same thing? Dumpster fire. */ |
|
CORRADE_COMPARE(converter->validateData(Stage::Fragment, *data), |
|
Containers::pair(true, Utility::format("WARNING: 0:0: '#version' : Illegal to have non-comment, non-whitespace tokens before #version"))); |
|
} |
|
} |
|
|
|
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"}}); |
|
|
|
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")); |
|
CORRADE_VERIFY(data); |
|
|
|
std::ostringstream out; |
|
Warning redirectWarning{&out}; |
|
CORRADE_COMPARE(converter->validateData(Stage::Fragment, *data), |
|
Containers::pair(false, Containers::String{})); |
|
CORRADE_COMPARE(out.str(), |
|
"ShaderTools::AnyConverter::validateData(): option noSuchOption not recognized by GlslangShaderConverter\n"); |
|
} |
|
|
|
void AnyConverterTest::convertFileToFile() { |
|
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"); |
|
|
|
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)); |
|
|
|
/* 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)); |
|
CORRADE_VERIFY(Utility::Path::exists(outputFilename)); |
|
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::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() { |
|
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"); |
|
} |
|
|
|
void AnyConverterTest::convertFileToFileUnknownOutput() { |
|
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"); |
|
} |
|
|
|
void AnyConverterTest::convertFileToFileNotSupported() { |
|
CORRADE_SKIP("No plugin that would support just conversion exists."); |
|
} |
|
|
|
void AnyConverterTest::convertFileToFilePreprocessNotSupported() { |
|
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}; |
|
CORRADE_VERIFY(!converter->convertFileToFile({}, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv"), |
|
Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spvasm"))); |
|
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); |
|
CORRADE_VERIFY(!converter->convertFileToFile({}, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv"), |
|
Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spvasm"))); |
|
CORRADE_COMPARE(out.str(), |
|
"ShaderTools::AnyConverter::convertFileToFile(): SpirvToolsShaderConverter does not support preprocessing\n"); |
|
} |
|
|
|
void AnyConverterTest::convertFileToFileDebugInfoNotSupported() { |
|
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}; |
|
CORRADE_VERIFY(!converter->convertFileToFile({}, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv"), |
|
Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spvasm"))); |
|
/** @todo it once may support that, in which case we need to find another |
|
victim */ |
|
CORRADE_COMPARE(out.str(), |
|
"ShaderTools::AnyConverter::convertFileToFile(): SpirvToolsShaderConverter does not support controlling debug info output\n"); |
|
} |
|
|
|
void AnyConverterTest::convertFileToFileOptimizationNotSupported() { |
|
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}; |
|
CORRADE_VERIFY(!converter->convertFileToFile({}, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"), |
|
Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spv"))); |
|
/** @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"); |
|
} |
|
|
|
void AnyConverterTest::convertFileToFilePropagateFlags() { |
|
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"); |
|
|
|
Containers::String filename = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"); |
|
|
|
/* 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->convertFileToFile(Stage::Fragment, filename, Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spv"))); |
|
CORRADE_COMPARE(out.str(), Utility::formatString( |
|
"ShaderTools::AnyConverter::convertFileToFile(): 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::convertFileToFilePropagateInputVersion() { |
|
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}; |
|
CORRADE_VERIFY(!converter->convertFileToFile(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"), Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spv"))); |
|
CORRADE_COMPARE(out.str(), |
|
"ShaderTools::GlslangConverter::convertDataToData(): input format version should be one of supported GLSL #version strings but got 100\n"); |
|
} |
|
|
|
void AnyConverterTest::convertFileToFilePropagateOutputVersion() { |
|
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}; |
|
CORRADE_VERIFY(!converter->convertFileToFile(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"), Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spv"))); |
|
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::convertFileToFilePropagatePreprocess() { |
|
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"} |
|
}); |
|
|
|
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)); |
|
|
|
/* 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)); |
|
CORRADE_VERIFY(Utility::Path::exists(outputFilename)); |
|
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::convertFileToFilePropagateDebugInfo() { |
|
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}; |
|
CORRADE_VERIFY(!converter->convertFileToFile(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"), Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spv"))); |
|
CORRADE_COMPARE(out.str(), |
|
"ShaderTools::GlslangConverter::convertDataToData(): debug info level should be 0, 1 or empty but got 2\n"); |
|
} |
|
|
|
void AnyConverterTest::convertFileToFilePropagateOptimization() { |
|
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}; |
|
CORRADE_VERIFY(!converter->convertFileToFile(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv"), Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.spv"))); |
|
CORRADE_COMPARE(out.str(), |
|
"ShaderTools::SpirvToolsConverter::convertDataToData(): optimization level should be 0, 1, s, legalizeHlsl or empty but got 2\n"); |
|
} |
|
|
|
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"); |
|
|
|
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"); |
|
|
|
{ |
|
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}; |
|
CORRADE_VERIFY(converter->convertFileToFile(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"), Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.glsl"))); |
|
CORRADE_COMPARE(out.str(), |
|
"ShaderTools::AnyConverter::convertFileToFile(): option noSuchOption not recognized by GlslangShaderConverter\n"); |
|
} |
|
|
|
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); |
|
|
|
Containers::String inputFilename = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"); |
|
|
|
/* 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}; |
|
CORRADE_VERIFY(!converter->convertFileToData({}, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv"))); |
|
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); |
|
CORRADE_VERIFY(!converter->convertFileToData({}, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv"))); |
|
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}; |
|
CORRADE_VERIFY(!converter->convertFileToData({}, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv"))); |
|
/** @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}; |
|
CORRADE_VERIFY(!converter->convertFileToData({}, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"))); |
|
/** @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"); |
|
|
|
Containers::String filename = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.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); |
|
|
|
/* 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}; |
|
CORRADE_VERIFY(!converter->convertFileToData(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"))); |
|
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}; |
|
CORRADE_VERIFY(!converter->convertFileToData(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"))); |
|
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"} |
|
}); |
|
|
|
Containers::String inputFilename = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"); |
|
|
|
/* 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}; |
|
CORRADE_VERIFY(!converter->convertFileToData(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"))); |
|
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}; |
|
CORRADE_VERIFY(!converter->convertFileToData(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv"))); |
|
CORRADE_COMPARE(out.str(), |
|
"ShaderTools::SpirvToolsConverter::convertDataToData(): optimization level should be 0, 1, s, legalizeHlsl or empty but got 2\n"); |
|
} |
|
|
|
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); |
|
|
|
Containers::String input = Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "version-not-first.glsl"); |
|
|
|
{ |
|
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}; |
|
CORRADE_VERIFY(converter->convertFileToData(Stage::Fragment, Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl"))); |
|
CORRADE_COMPARE(out.str(), |
|
"ShaderTools::AnyConverter::convertFileToData(): option noSuchOption not recognized by GlslangShaderConverter\n"); |
|
} |
|
|
|
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); |
|
|
|
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")); |
|
CORRADE_VERIFY(data); |
|
|
|
/* Make it print a warning so we know it's doing something */ |
|
std::ostringstream out; |
|
Warning redirectWarning{&out}; |
|
CORRADE_VERIFY(converter->convertDataToData(Stage::Fragment, *data)); |
|
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"} |
|
}); |
|
|
|
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv")); |
|
CORRADE_VERIFY(data); |
|
|
|
std::ostringstream out; |
|
Error redirectError{&out}; |
|
CORRADE_VERIFY(!converter->convertDataToData({}, *data)); |
|
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); |
|
CORRADE_VERIFY(!converter->convertDataToData({}, *data)); |
|
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"); |
|
|
|
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv")); |
|
CORRADE_VERIFY(data); |
|
|
|
std::ostringstream out; |
|
Error redirectError{&out}; |
|
CORRADE_VERIFY(!converter->convertDataToData({}, *data)); |
|
/** @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"); |
|
|
|
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")); |
|
CORRADE_VERIFY(data); |
|
|
|
std::ostringstream out; |
|
Error redirectError{&out}; |
|
CORRADE_VERIFY(!converter->convertDataToData({}, *data)); |
|
/** @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); |
|
|
|
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")); |
|
CORRADE_VERIFY(data); |
|
|
|
/* 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->convertDataToData(Stage::Fragment, *data)); |
|
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); |
|
|
|
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")); |
|
CORRADE_VERIFY(data); |
|
|
|
/* 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}; |
|
CORRADE_VERIFY(!converter->convertDataToData(Stage::Fragment, *data)); |
|
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"); |
|
|
|
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")); |
|
CORRADE_VERIFY(data); |
|
|
|
/* 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}; |
|
CORRADE_VERIFY(!converter->convertDataToData(Stage::Fragment, *data)); |
|
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"} |
|
}); |
|
|
|
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")); |
|
CORRADE_VERIFY(data); |
|
|
|
/* Make it print a warning so we know it's doing something */ |
|
std::ostringstream out; |
|
Warning redirectWarning{&out}; |
|
CORRADE_VERIFY(converter->convertDataToData(Stage::Fragment, *data)); |
|
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"); |
|
|
|
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")); |
|
CORRADE_VERIFY(data); |
|
|
|
/* 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}; |
|
CORRADE_VERIFY(!converter->convertDataToData(Stage::Fragment, *data)); |
|
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"); |
|
|
|
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.spv")); |
|
CORRADE_VERIFY(data); |
|
|
|
/* 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}; |
|
CORRADE_VERIFY(!converter->convertDataToData(Stage::Fragment, *data)); |
|
CORRADE_COMPARE(out.str(), |
|
"ShaderTools::SpirvToolsConverter::convertDataToData(): optimization level should be 0, 1, s, legalizeHlsl or empty but got 2\n"); |
|
} |
|
|
|
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); |
|
|
|
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "version-not-first.glsl")); |
|
CORRADE_VERIFY(data); |
|
|
|
{ |
|
std::ostringstream out; |
|
Error redirectError{&out}; |
|
CORRADE_VERIFY(!converter->convertDataToData(Stage::Fragment, *data)); |
|
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}; |
|
CORRADE_VERIFY(converter->convertDataToData(Stage::Fragment, *data)); |
|
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"}}); |
|
|
|
Containers::Optional<Containers::Array<char>> data = Utility::Path::read(Utility::Path::join(ANYSHADERCONVERTER_TEST_DIR, "file.glsl")); |
|
CORRADE_VERIFY(data); |
|
|
|
std::ostringstream out; |
|
Warning redirectWarning{&out}; |
|
CORRADE_VERIFY(converter->convertDataToData(Stage::Fragment, *data)); |
|
CORRADE_COMPARE(out.str(), |
|
"ShaderTools::AnyConverter::convertDataToData(): option noSuchOption not recognized by GlslangShaderConverter\n"); |
|
} |
|
|
|
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), |
|
Containers::pair(false, Containers::String{})); |
|
#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 |
|
} |
|
|
|
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"), |
|
Containers::pair(false, Containers::String{})); |
|
#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 |
|
} |
|
|
|
void AnyConverterTest::detectConvert() { |
|
auto&& data = DetectConvertData[testCaseInstanceId()]; |
|
setTestCaseDescription(data.name); |
|
|
|
Containers::Pointer<AbstractConverter> converter = _manager.instantiate("AnyShaderConverter"); |
|
|
|
std::ostringstream out; |
|
Error redirectError{&out}; |
|
CORRADE_VERIFY(!converter->convertFileToFile({}, data.from, Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, data.to))); |
|
#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 |
|
} |
|
|
|
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}; |
|
CORRADE_VERIFY(!converter->convertFileToFile({}, "file.spv", Utility::Path::join(ANYSHADERCONVERTER_TEST_OUTPUT_DIR, "file.glsl"))); |
|
#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 |
|
} |
|
|
|
}}}} |
|
|
|
CORRADE_TEST_MAIN(Magnum::ShaderTools::Test::AnyConverterTest)
|
|
|