187 lines
2.9 KiB
C++
187 lines
2.9 KiB
C++
#include <Engine/Shader/ShaderUtils.hpp>
|
|
#include <Nazara/Core/File.hpp>
|
|
#include <Nazara/Core/StringExt.hpp>
|
|
#include <Nazara/Shader/ShaderBuilder.hpp>
|
|
#include <Nazara/Shader/ShaderLangParser.hpp>
|
|
#include <Nazara/Shader/Ast/AstSerializer.hpp>
|
|
#include <Nazara/Shader/Ast/AstCompare.hpp>
|
|
#include <Nazara/Shader/Ast/SanitizeVisitor.hpp>
|
|
#include <catch2/catch.hpp>
|
|
#include <cctype>
|
|
|
|
void ParseSerializeUnserialize(std::string_view sourceCode, bool sanitize)
|
|
{
|
|
Nz::ShaderAst::StatementPtr shader;
|
|
REQUIRE_NOTHROW(shader = Nz::ShaderLang::Parse(sourceCode));
|
|
|
|
if (sanitize)
|
|
REQUIRE_NOTHROW(shader = Nz::ShaderAst::Sanitize(*shader));
|
|
|
|
Nz::ByteArray serializedShader;
|
|
REQUIRE_NOTHROW(serializedShader = Nz::ShaderAst::SerializeShader(shader));
|
|
|
|
Nz::ByteStream byteStream(&serializedShader);
|
|
Nz::ShaderAst::StatementPtr unserializedShader;
|
|
REQUIRE_NOTHROW(unserializedShader = Nz::ShaderAst::UnserializeShader(byteStream));
|
|
|
|
CHECK(Nz::ShaderAst::Compare(*shader, *unserializedShader));
|
|
}
|
|
|
|
void ParseSerializeUnserialize(std::string_view sourceCode)
|
|
{
|
|
ParseSerializeUnserialize(sourceCode, false);
|
|
ParseSerializeUnserialize(sourceCode, true);
|
|
}
|
|
|
|
TEST_CASE("serialization", "[Shader]")
|
|
{
|
|
WHEN("serializing and unserializing a simple shader")
|
|
{
|
|
ParseSerializeUnserialize(R"(
|
|
struct Data
|
|
{
|
|
value: f32
|
|
}
|
|
|
|
struct Output
|
|
{
|
|
[location(0)] value: f32
|
|
}
|
|
|
|
external
|
|
{
|
|
[set(0), binding(0)] data: uniform[Data]
|
|
}
|
|
|
|
[entry(frag)]
|
|
fn main() -> Output
|
|
{
|
|
let output: Output;
|
|
output.value = data.value;
|
|
|
|
return output;
|
|
}
|
|
)");
|
|
}
|
|
|
|
WHEN("serializing and unserializing branches")
|
|
{
|
|
ParseSerializeUnserialize(R"(
|
|
struct inputStruct
|
|
{
|
|
value: f32
|
|
}
|
|
|
|
external
|
|
{
|
|
[set(0), binding(0)] data: uniform[inputStruct]
|
|
}
|
|
|
|
[entry(frag)]
|
|
fn main()
|
|
{
|
|
let value: f32;
|
|
if (data.value > 3.0)
|
|
value = 3.0;
|
|
else if (data.value > 2.0)
|
|
value = 2.0;
|
|
else if (data.value > 1.0)
|
|
value = 1.0;
|
|
else
|
|
value = 0.0;
|
|
}
|
|
)");
|
|
}
|
|
|
|
WHEN("serializing and unserializing consts")
|
|
{
|
|
ParseSerializeUnserialize(R"(
|
|
option UseInt: bool = false;
|
|
|
|
[cond(UseInt)]
|
|
struct inputStruct
|
|
{
|
|
value: i32
|
|
}
|
|
|
|
[cond(!UseInt)]
|
|
struct inputStruct
|
|
{
|
|
value: f32
|
|
}
|
|
|
|
external
|
|
{
|
|
[set(0), binding(0)] data: uniform[inputStruct]
|
|
}
|
|
|
|
[entry(frag)]
|
|
fn main()
|
|
{
|
|
let value: f32;
|
|
|
|
const if (UseInt)
|
|
{
|
|
value = f32(data.value);
|
|
}
|
|
else
|
|
{
|
|
value = data.value;
|
|
}
|
|
}
|
|
)");
|
|
}
|
|
|
|
WHEN("serializing and unserializing loops")
|
|
{
|
|
ParseSerializeUnserialize(R"(
|
|
struct inputStruct
|
|
{
|
|
value: array[f32, 10]
|
|
}
|
|
|
|
external
|
|
{
|
|
[set(0), binding(0)] data: uniform[inputStruct]
|
|
}
|
|
|
|
[entry(frag)]
|
|
fn main()
|
|
{
|
|
let value = 0.0;
|
|
let i = 0;
|
|
while (i < 10)
|
|
{
|
|
value += 0.1;
|
|
i += 1;
|
|
}
|
|
|
|
let x = 0;
|
|
for v in 0 -> 10
|
|
{
|
|
x += v;
|
|
}
|
|
|
|
let x = 0.0;
|
|
for v in data.value
|
|
{
|
|
x += v;
|
|
}
|
|
}
|
|
)");
|
|
}
|
|
|
|
WHEN("serializing and unserializing swizzles")
|
|
{
|
|
ParseSerializeUnserialize(R"(
|
|
[entry(frag)]
|
|
fn main()
|
|
{
|
|
let vec = vec4[f32](0.0, 1.0, 2.0, 3.0);
|
|
vec.wyxz.bra.ts.x = 0.0;
|
|
vec.zyxw.ar.xy.yx = vec2[f32](1.0, 0.0);
|
|
}
|
|
)");
|
|
}
|
|
}
|