From 1d2fb88198a19dc4a6da03fee05c4332d11a9f07 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Leclercq?= Date: Thu, 16 Jul 2020 18:34:58 +0200 Subject: [PATCH] Renderer: Rename enums ExpressionType => BasicType ShaderAst::Type => ShaderExpressionType --- include/Nazara/Renderer/GlslWriter.hpp | 4 +- include/Nazara/Renderer/GlslWriter.inl | 2 +- include/Nazara/Renderer/ShaderAst.hpp | 19 ++++---- include/Nazara/Renderer/ShaderBuilder.hpp | 2 +- include/Nazara/Renderer/ShaderBuilder.inl | 8 ++-- include/Nazara/Renderer/ShaderEnums.hpp | 26 +++++------ .../Nazara/Renderer/ShaderExpressionType.hpp | 20 +++++++++ include/Nazara/Renderer/ShaderNodes.hpp | 30 ++++++------- include/Nazara/Renderer/ShaderNodes.inl | 38 ++++++++-------- include/Nazara/Renderer/ShaderSerializer.hpp | 2 +- include/Nazara/Renderer/ShaderValidator.hpp | 2 +- include/Nazara/Renderer/ShaderVariables.hpp | 14 +++--- include/Nazara/Renderer/ShaderVariables.inl | 12 ++--- src/Nazara/OpenGLRenderer/Wrapper/Context.cpp | 2 + .../Wrapper/Win32/WGLContext.cpp | 7 +++ src/Nazara/Renderer/GlslWriter.cpp | 30 ++++++------- src/Nazara/Renderer/ShaderAst.cpp | 8 ++-- src/Nazara/Renderer/ShaderNodes.cpp | 32 +++++++------- src/Nazara/Renderer/ShaderSerializer.cpp | 26 +++++------ src/Nazara/Renderer/ShaderValidator.cpp | 44 +++++++++---------- src/ShaderNode/DataModels/InputValue.cpp | 14 +++--- src/ShaderNode/DataModels/OutputValue.cpp | 16 +++---- src/ShaderNode/DataModels/TextureValue.cpp | 4 +- src/ShaderNode/DataTypes/VecData.cpp | 8 ++-- src/ShaderNode/DataTypes/VecData.hpp | 12 ++--- src/ShaderNode/Widgets/MainWindow.cpp | 12 ++--- 26 files changed, 210 insertions(+), 184 deletions(-) create mode 100644 include/Nazara/Renderer/ShaderExpressionType.hpp diff --git a/include/Nazara/Renderer/GlslWriter.hpp b/include/Nazara/Renderer/GlslWriter.hpp index 999a93c48..94ca21676 100644 --- a/include/Nazara/Renderer/GlslWriter.hpp +++ b/include/Nazara/Renderer/GlslWriter.hpp @@ -44,9 +44,9 @@ namespace Nz }; private: - void Append(ShaderAst::Type type); + void Append(ShaderExpressionType type); void Append(ShaderNodes::BuiltinEntry builtin); - void Append(ShaderNodes::ExpressionType type); + void Append(ShaderNodes::BasicType type); void Append(ShaderNodes::MemoryLayout layout); template void Append(const T& param); void AppendCommentSection(const std::string& section); diff --git a/include/Nazara/Renderer/GlslWriter.inl b/include/Nazara/Renderer/GlslWriter.inl index 9b67eaa89..e543f870f 100644 --- a/include/Nazara/Renderer/GlslWriter.inl +++ b/include/Nazara/Renderer/GlslWriter.inl @@ -86,7 +86,7 @@ namespace Nz std::visit([&](auto&& arg) { using T = std::decay_t; - if constexpr (std::is_same_v) + if constexpr (std::is_same_v) { Append(arg); Append(" "); diff --git a/include/Nazara/Renderer/ShaderAst.hpp b/include/Nazara/Renderer/ShaderAst.hpp index 4b57bbced..035aa5cce 100644 --- a/include/Nazara/Renderer/ShaderAst.hpp +++ b/include/Nazara/Renderer/ShaderAst.hpp @@ -8,11 +8,10 @@ #define NAZARA_SHADER_AST_HPP #include +#include #include #include -#include #include -#include #include namespace Nz @@ -28,16 +27,14 @@ namespace Nz struct Uniform; struct VariableBase; - using Type = std::variant; - ShaderAst() = default; ~ShaderAst() = default; - void AddFunction(std::string name, ShaderNodes::StatementPtr statement, std::vector parameters = {}, ShaderNodes::ExpressionType returnType = ShaderNodes::ExpressionType::Void); - void AddInput(std::string name, Type type, std::optional locationIndex); - void AddOutput(std::string name, Type type, std::optional locationIndex); + void AddFunction(std::string name, ShaderNodes::StatementPtr statement, std::vector parameters = {}, ShaderNodes::BasicType returnType = ShaderNodes::BasicType::Void); + void AddInput(std::string name, ShaderExpressionType type, std::optional locationIndex); + void AddOutput(std::string name, ShaderExpressionType type, std::optional locationIndex); void AddStruct(std::string name, std::vector members); - void AddUniform(std::string name, Type type, std::optional bindingIndex, std::optional memoryLayout); + void AddUniform(std::string name, ShaderExpressionType type, std::optional bindingIndex, std::optional memoryLayout); inline const Function& GetFunction(std::size_t i) const; inline std::size_t GetFunctionCount() const; @@ -58,7 +55,7 @@ namespace Nz struct VariableBase { std::string name; - Type type; + ShaderExpressionType type; }; struct FunctionParameter : VariableBase @@ -69,7 +66,7 @@ namespace Nz { std::string name; std::vector parameters; - ShaderNodes::ExpressionType returnType; + ShaderNodes::BasicType returnType; ShaderNodes::StatementPtr statement; }; @@ -93,7 +90,7 @@ namespace Nz struct StructMember { std::string name; - Type type; + ShaderExpressionType type; }; private: diff --git a/include/Nazara/Renderer/ShaderBuilder.hpp b/include/Nazara/Renderer/ShaderBuilder.hpp index cc437f45f..7d8502151 100644 --- a/include/Nazara/Renderer/ShaderBuilder.hpp +++ b/include/Nazara/Renderer/ShaderBuilder.hpp @@ -67,7 +67,7 @@ namespace Nz::ShaderBuilder constexpr BinOpBuilder Substract; constexpr GenBuilder Uniform; - template std::shared_ptr Cast(Args&&... args); + template std::shared_ptr Cast(Args&&... args); } #include diff --git a/include/Nazara/Renderer/ShaderBuilder.inl b/include/Nazara/Renderer/ShaderBuilder.inl index dda1d730b..8ef833536 100644 --- a/include/Nazara/Renderer/ShaderBuilder.inl +++ b/include/Nazara/Renderer/ShaderBuilder.inl @@ -28,21 +28,21 @@ namespace Nz::ShaderBuilder inline std::shared_ptr BuiltinBuilder::operator()(ShaderNodes::BuiltinEntry builtin) const { - ShaderNodes::ExpressionType exprType = ShaderNodes::ExpressionType::Void; + ShaderNodes::BasicType exprType = ShaderNodes::BasicType::Void; switch (builtin) { case ShaderNodes::BuiltinEntry::VertexPosition: - exprType = ShaderNodes::ExpressionType::Float4; + exprType = ShaderNodes::BasicType::Float4; break; } - NazaraAssert(exprType != ShaderNodes::ExpressionType::Void, "Unhandled builtin"); + NazaraAssert(exprType != ShaderNodes::BasicType::Void, "Unhandled builtin"); return ShaderNodes::BuiltinVariable::Build(builtin, exprType); } - template + template std::shared_ptr Cast(Args&&... args) { return ShaderNodes::Cast::Build(Type, std::forward(args)...); diff --git a/include/Nazara/Renderer/ShaderEnums.hpp b/include/Nazara/Renderer/ShaderEnums.hpp index 7a93cea7b..a9db1abe8 100644 --- a/include/Nazara/Renderer/ShaderEnums.hpp +++ b/include/Nazara/Renderer/ShaderEnums.hpp @@ -16,6 +16,19 @@ namespace Nz::ShaderNodes Simple //< = }; + enum class BasicType + { + Boolean, // bool + Float1, // float + Float2, // vec2 + Float3, // vec3 + Float4, // vec4 + Mat4x4, // mat4 + Sampler2D, // sampler2D + + Void // void + }; + enum class BinaryType { Add, //< + @@ -37,19 +50,6 @@ namespace Nz::ShaderNodes RValue }; - enum class ExpressionType - { - Boolean, // bool - Float1, // float - Float2, // vec2 - Float3, // vec3 - Float4, // vec4 - Mat4x4, // mat4 - Sampler2D, // sampler2D - - Void // void - }; - enum class IntrinsicType { CrossProduct, diff --git a/include/Nazara/Renderer/ShaderExpressionType.hpp b/include/Nazara/Renderer/ShaderExpressionType.hpp new file mode 100644 index 000000000..c937d6a10 --- /dev/null +++ b/include/Nazara/Renderer/ShaderExpressionType.hpp @@ -0,0 +1,20 @@ +// Copyright (C) 2020 Jérôme Leclercq +// This file is part of the "Nazara Engine - Renderer module" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef NAZARA_SHADER_EXPRESSIONTYPE_HPP +#define NAZARA_SHADER_EXPRESSIONTYPE_HPP + +#include +#include +#include +#include + +namespace Nz +{ + using ShaderExpressionType = std::variant; +} + +#endif // NAZARA_SHADER_EXPRESSIONTYPE_HPP diff --git a/include/Nazara/Renderer/ShaderNodes.hpp b/include/Nazara/Renderer/ShaderNodes.hpp index 659e643a3..57ff5ab60 100644 --- a/include/Nazara/Renderer/ShaderNodes.hpp +++ b/include/Nazara/Renderer/ShaderNodes.hpp @@ -38,8 +38,8 @@ namespace Nz virtual void Visit(ShaderVisitor& visitor) = 0; - static inline unsigned int GetComponentCount(ExpressionType type); - static inline ExpressionType GetComponentType(ExpressionType type); + static inline unsigned int GetComponentCount(BasicType type); + static inline BasicType GetComponentType(BasicType type); protected: inline Node(NodeType type, bool isStatement); @@ -59,7 +59,7 @@ namespace Nz inline Expression(NodeType type); virtual ExpressionCategory GetExpressionCategory() const; - virtual ExpressionType GetExpressionType() const = 0; + virtual BasicType GetExpressionType() const = 0; }; class Statement; @@ -125,7 +125,7 @@ namespace Nz inline Identifier(); ExpressionCategory GetExpressionCategory() const override; - ExpressionType GetExpressionType() const override; + BasicType GetExpressionType() const override; void Visit(ShaderVisitor& visitor) override; VariablePtr var; @@ -139,7 +139,7 @@ namespace Nz { inline AssignOp(); - ExpressionType GetExpressionType() const override; + BasicType GetExpressionType() const override; void Visit(ShaderVisitor& visitor) override; AssignType op; @@ -153,7 +153,7 @@ namespace Nz { inline BinaryOp(); - ExpressionType GetExpressionType() const override; + BasicType GetExpressionType() const override; void Visit(ShaderVisitor& visitor) override; BinaryType op; @@ -187,24 +187,24 @@ namespace Nz { inline Cast(); - ExpressionType GetExpressionType() const override; + BasicType GetExpressionType() const override; void Visit(ShaderVisitor& visitor) override; - ExpressionType exprType; + BasicType exprType; std::array expressions; - static inline std::shared_ptr Build(ExpressionType castTo, ExpressionPtr first, ExpressionPtr second = nullptr, ExpressionPtr third = nullptr, ExpressionPtr fourth = nullptr); - static inline std::shared_ptr Build(ExpressionType castTo, ExpressionPtr* expressions, std::size_t expressionCount); + static inline std::shared_ptr Build(BasicType castTo, ExpressionPtr first, ExpressionPtr second = nullptr, ExpressionPtr third = nullptr, ExpressionPtr fourth = nullptr); + static inline std::shared_ptr Build(BasicType castTo, ExpressionPtr* expressions, std::size_t expressionCount); }; struct NAZARA_RENDERER_API Constant : public Expression { inline Constant(); - ExpressionType GetExpressionType() const override; + BasicType GetExpressionType() const override; void Visit(ShaderVisitor& visitor) override; - ExpressionType exprType; + BasicType exprType; union { @@ -227,7 +227,7 @@ namespace Nz inline SwizzleOp(); ExpressionCategory GetExpressionCategory() const override; - ExpressionType GetExpressionType() const override; + BasicType GetExpressionType() const override; void Visit(ShaderVisitor& visitor) override; std::array components; @@ -243,7 +243,7 @@ namespace Nz { inline Sample2D(); - ExpressionType GetExpressionType() const override; + BasicType GetExpressionType() const override; void Visit(ShaderVisitor& visitor) override; ExpressionPtr sampler; @@ -258,7 +258,7 @@ namespace Nz { inline IntrinsicCall(); - ExpressionType GetExpressionType() const override; + BasicType GetExpressionType() const override; void Visit(ShaderVisitor& visitor) override; IntrinsicType intrinsic; diff --git a/include/Nazara/Renderer/ShaderNodes.inl b/include/Nazara/Renderer/ShaderNodes.inl index bafad38f5..31d3028ed 100644 --- a/include/Nazara/Renderer/ShaderNodes.inl +++ b/include/Nazara/Renderer/ShaderNodes.inl @@ -23,20 +23,20 @@ namespace Nz::ShaderNodes return m_isStatement; } - inline unsigned int Node::GetComponentCount(ExpressionType type) + inline unsigned int Node::GetComponentCount(BasicType type) { switch (type) { - case ExpressionType::Float2: + case BasicType::Float2: return 2; - case ExpressionType::Float3: + case BasicType::Float3: return 3; - case ExpressionType::Float4: + case BasicType::Float4: return 4; - case ExpressionType::Mat4x4: + case BasicType::Mat4x4: return 4; default: @@ -44,17 +44,17 @@ namespace Nz::ShaderNodes } } - inline ExpressionType Node::GetComponentType(ExpressionType type) + inline BasicType Node::GetComponentType(BasicType type) { switch (type) { - case ExpressionType::Float2: - case ExpressionType::Float3: - case ExpressionType::Float4: - return ExpressionType::Float1; + case BasicType::Float2: + case BasicType::Float3: + case BasicType::Float4: + return BasicType::Float1; - case ExpressionType::Mat4x4: - return ExpressionType::Float4; + case BasicType::Mat4x4: + return BasicType::Float4; default: return type; @@ -198,7 +198,7 @@ namespace Nz::ShaderNodes { } - inline std::shared_ptr Cast::Build(ExpressionType castTo, ExpressionPtr first, ExpressionPtr second, ExpressionPtr third, ExpressionPtr fourth) + inline std::shared_ptr Cast::Build(BasicType castTo, ExpressionPtr first, ExpressionPtr second, ExpressionPtr third, ExpressionPtr fourth) { auto node = std::make_shared(); node->exprType = castTo; @@ -207,7 +207,7 @@ namespace Nz::ShaderNodes return node; } - inline std::shared_ptr Cast::Build(ExpressionType castTo, ExpressionPtr* Expressions, std::size_t expressionCount) + inline std::shared_ptr Cast::Build(BasicType castTo, ExpressionPtr* Expressions, std::size_t expressionCount) { auto node = std::make_shared(); node->exprType = castTo; @@ -226,7 +226,7 @@ namespace Nz::ShaderNodes inline std::shared_ptr Constant::Build(bool value) { auto node = std::make_shared(); - node->exprType = ExpressionType::Boolean; + node->exprType = BasicType::Boolean; node->values.bool1 = value; return node; @@ -235,7 +235,7 @@ namespace Nz::ShaderNodes inline std::shared_ptr Constant::Build(float value) { auto node = std::make_shared(); - node->exprType = ExpressionType::Float1; + node->exprType = BasicType::Float1; node->values.vec1 = value; return node; @@ -244,7 +244,7 @@ namespace Nz::ShaderNodes inline std::shared_ptr Constant::Build(const Vector2f& value) { auto node = std::make_shared(); - node->exprType = ExpressionType::Float2; + node->exprType = BasicType::Float2; node->values.vec2 = value; return node; @@ -253,7 +253,7 @@ namespace Nz::ShaderNodes inline std::shared_ptr Constant::Build(const Vector3f& value) { auto node = std::make_shared(); - node->exprType = ExpressionType::Float3; + node->exprType = BasicType::Float3; node->values.vec3 = value; return node; @@ -262,7 +262,7 @@ namespace Nz::ShaderNodes inline std::shared_ptr Constant::Build(const Vector4f& value) { auto node = std::make_shared(); - node->exprType = ExpressionType::Float4; + node->exprType = BasicType::Float4; node->values.vec4 = value; return node; diff --git a/include/Nazara/Renderer/ShaderSerializer.hpp b/include/Nazara/Renderer/ShaderSerializer.hpp index f79040b2c..e4e6be7b3 100644 --- a/include/Nazara/Renderer/ShaderSerializer.hpp +++ b/include/Nazara/Renderer/ShaderSerializer.hpp @@ -103,7 +103,7 @@ namespace Nz private: bool IsWriting() const override; void Node(ShaderNodes::NodePtr& node) override; - void Type(ShaderAst::Type& type); + void Type(ShaderExpressionType& type); void Value(bool& val) override; void Value(float& val) override; void Value(std::string& val) override; diff --git a/include/Nazara/Renderer/ShaderValidator.hpp b/include/Nazara/Renderer/ShaderValidator.hpp index 3df9f4ae5..ecfea1290 100644 --- a/include/Nazara/Renderer/ShaderValidator.hpp +++ b/include/Nazara/Renderer/ShaderValidator.hpp @@ -30,7 +30,7 @@ namespace Nz const ShaderNodes::ExpressionPtr& MandatoryExpr(const ShaderNodes::ExpressionPtr& node); const ShaderNodes::NodePtr& MandatoryNode(const ShaderNodes::NodePtr& node); void TypeMustMatch(const ShaderNodes::ExpressionPtr& left, const ShaderNodes::ExpressionPtr& right); - void TypeMustMatch(const ShaderAst::Type& left, const ShaderAst::Type& right); + void TypeMustMatch(const ShaderExpressionType& left, const ShaderExpressionType& right); using ShaderVisitor::Visit; void Visit(const ShaderNodes::AssignOp& node) override; diff --git a/include/Nazara/Renderer/ShaderVariables.hpp b/include/Nazara/Renderer/ShaderVariables.hpp index 242f129db..f80386d0c 100644 --- a/include/Nazara/Renderer/ShaderVariables.hpp +++ b/include/Nazara/Renderer/ShaderVariables.hpp @@ -34,7 +34,7 @@ namespace Nz virtual VariableType GetType() const = 0; virtual void Visit(ShaderVarVisitor& visitor) = 0; - ExpressionType type; + BasicType type; }; struct BuiltinVariable; @@ -48,7 +48,7 @@ namespace Nz VariableType GetType() const override; void Visit(ShaderVarVisitor& visitor) override; - static inline std::shared_ptr Build(BuiltinEntry entry, ExpressionType varType); + static inline std::shared_ptr Build(BuiltinEntry entry, BasicType varType); }; struct NamedVariable; @@ -69,7 +69,7 @@ namespace Nz VariableType GetType() const override; void Visit(ShaderVarVisitor& visitor) override; - static inline std::shared_ptr Build(std::string varName, ExpressionType varType); + static inline std::shared_ptr Build(std::string varName, BasicType varType); }; struct LocalVariable; @@ -81,7 +81,7 @@ namespace Nz VariableType GetType() const override; void Visit(ShaderVarVisitor& visitor) override; - static inline std::shared_ptr Build(std::string varName, ExpressionType varType); + static inline std::shared_ptr Build(std::string varName, BasicType varType); }; struct OutputVariable; @@ -93,7 +93,7 @@ namespace Nz VariableType GetType() const override; void Visit(ShaderVarVisitor& visitor) override; - static inline std::shared_ptr Build(std::string varName, ExpressionType varType); + static inline std::shared_ptr Build(std::string varName, BasicType varType); }; struct ParameterVariable; @@ -105,7 +105,7 @@ namespace Nz VariableType GetType() const override; void Visit(ShaderVarVisitor& visitor) override; - static inline std::shared_ptr Build(std::string varName, ExpressionType varType); + static inline std::shared_ptr Build(std::string varName, BasicType varType); }; struct UniformVariable; @@ -117,7 +117,7 @@ namespace Nz VariableType GetType() const override; void Visit(ShaderVarVisitor& visitor) override; - static inline std::shared_ptr Build(std::string varName, ExpressionType varType); + static inline std::shared_ptr Build(std::string varName, BasicType varType); }; } } diff --git a/include/Nazara/Renderer/ShaderVariables.inl b/include/Nazara/Renderer/ShaderVariables.inl index d20c9d6ea..e01ecb33e 100644 --- a/include/Nazara/Renderer/ShaderVariables.inl +++ b/include/Nazara/Renderer/ShaderVariables.inl @@ -7,7 +7,7 @@ namespace Nz::ShaderNodes { - inline std::shared_ptr BuiltinVariable::Build(BuiltinEntry variable, ExpressionType varType) + inline std::shared_ptr BuiltinVariable::Build(BuiltinEntry variable, BasicType varType) { auto node = std::make_shared(); node->entry = variable; @@ -16,7 +16,7 @@ namespace Nz::ShaderNodes return node; } - inline std::shared_ptr InputVariable::Build(std::string varName, ExpressionType varType) + inline std::shared_ptr InputVariable::Build(std::string varName, BasicType varType) { auto node = std::make_shared(); node->name = std::move(varName); @@ -25,7 +25,7 @@ namespace Nz::ShaderNodes return node; } - inline std::shared_ptr LocalVariable::Build(std::string varName, ExpressionType varType) + inline std::shared_ptr LocalVariable::Build(std::string varName, BasicType varType) { auto node = std::make_shared(); node->name = std::move(varName); @@ -34,7 +34,7 @@ namespace Nz::ShaderNodes return node; } - inline std::shared_ptr OutputVariable::Build(std::string varName, ExpressionType varType) + inline std::shared_ptr OutputVariable::Build(std::string varName, BasicType varType) { auto node = std::make_shared(); node->name = std::move(varName); @@ -43,7 +43,7 @@ namespace Nz::ShaderNodes return node; } - inline std::shared_ptr ParameterVariable::Build(std::string varName, ExpressionType varType) + inline std::shared_ptr ParameterVariable::Build(std::string varName, BasicType varType) { auto node = std::make_shared(); node->name = std::move(varName); @@ -52,7 +52,7 @@ namespace Nz::ShaderNodes return node; } - inline std::shared_ptr UniformVariable::Build(std::string varName, ExpressionType varType) + inline std::shared_ptr UniformVariable::Build(std::string varName, BasicType varType) { auto node = std::make_shared(); node->name = std::move(varName); diff --git a/src/Nazara/OpenGLRenderer/Wrapper/Context.cpp b/src/Nazara/OpenGLRenderer/Wrapper/Context.cpp index 902f22813..2cd045504 100644 --- a/src/Nazara/OpenGLRenderer/Wrapper/Context.cpp +++ b/src/Nazara/OpenGLRenderer/Wrapper/Context.cpp @@ -278,6 +278,8 @@ namespace Nz::GL glGetIntegerv(GL_VIEWPORT, res.data()); m_state.viewport = { res[0], res[1], res[2], res[3] }; + EnableVerticalSync(false); + return true; } diff --git a/src/Nazara/OpenGLRenderer/Wrapper/Win32/WGLContext.cpp b/src/Nazara/OpenGLRenderer/Wrapper/Win32/WGLContext.cpp index e07a21294..c904a42d4 100644 --- a/src/Nazara/OpenGLRenderer/Wrapper/Win32/WGLContext.cpp +++ b/src/Nazara/OpenGLRenderer/Wrapper/Win32/WGLContext.cpp @@ -67,6 +67,13 @@ namespace Nz::GL void WGLContext::EnableVerticalSync(bool enabled) { + if (wglSwapIntervalEXT) + { + if (!SetCurrentContext(this)) + return; + + wglSwapIntervalEXT(enabled); + } } void WGLContext::SwapBuffers() diff --git a/src/Nazara/Renderer/GlslWriter.cpp b/src/Nazara/Renderer/GlslWriter.cpp index accb493b7..4dcbcd4cc 100644 --- a/src/Nazara/Renderer/GlslWriter.cpp +++ b/src/Nazara/Renderer/GlslWriter.cpp @@ -163,7 +163,7 @@ namespace Nz m_environment = std::move(environment); } - void GlslWriter::Append(ShaderAst::Type type) + void GlslWriter::Append(ShaderExpressionType type) { std::visit([&](auto&& arg) { @@ -181,32 +181,32 @@ namespace Nz } } - void GlslWriter::Append(ShaderNodes::ExpressionType type) + void GlslWriter::Append(ShaderNodes::BasicType type) { switch (type) { - case ShaderNodes::ExpressionType::Boolean: + case ShaderNodes::BasicType::Boolean: Append("bool"); break; - case ShaderNodes::ExpressionType::Float1: + case ShaderNodes::BasicType::Float1: Append("float"); break; - case ShaderNodes::ExpressionType::Float2: + case ShaderNodes::BasicType::Float2: Append("vec2"); break; - case ShaderNodes::ExpressionType::Float3: + case ShaderNodes::BasicType::Float3: Append("vec3"); break; - case ShaderNodes::ExpressionType::Float4: + case ShaderNodes::BasicType::Float4: Append("vec4"); break; - case ShaderNodes::ExpressionType::Mat4x4: + case ShaderNodes::BasicType::Mat4x4: Append("mat4"); break; - case ShaderNodes::ExpressionType::Sampler2D: + case ShaderNodes::BasicType::Sampler2D: Append("sampler2D"); break; - case ShaderNodes::ExpressionType::Void: + case ShaderNodes::BasicType::Void: Append("void"); break; } @@ -395,23 +395,23 @@ namespace Nz { switch (node.exprType) { - case ShaderNodes::ExpressionType::Boolean: + case ShaderNodes::BasicType::Boolean: Append((node.values.bool1) ? "true" : "false"); break; - case ShaderNodes::ExpressionType::Float1: + case ShaderNodes::BasicType::Float1: Append(std::to_string(node.values.vec1)); break; - case ShaderNodes::ExpressionType::Float2: + case ShaderNodes::BasicType::Float2: Append("vec2(" + std::to_string(node.values.vec2.x) + ", " + std::to_string(node.values.vec2.y) + ")"); break; - case ShaderNodes::ExpressionType::Float3: + case ShaderNodes::BasicType::Float3: Append("vec3(" + std::to_string(node.values.vec3.x) + ", " + std::to_string(node.values.vec3.y) + ", " + std::to_string(node.values.vec3.z) + ")"); break; - case ShaderNodes::ExpressionType::Float4: + case ShaderNodes::BasicType::Float4: Append("vec4(" + std::to_string(node.values.vec4.x) + ", " + std::to_string(node.values.vec4.y) + ", " + std::to_string(node.values.vec4.z) + ", " + std::to_string(node.values.vec4.w) + ")"); break; diff --git a/src/Nazara/Renderer/ShaderAst.cpp b/src/Nazara/Renderer/ShaderAst.cpp index 05d3eb94d..da009248b 100644 --- a/src/Nazara/Renderer/ShaderAst.cpp +++ b/src/Nazara/Renderer/ShaderAst.cpp @@ -7,7 +7,7 @@ namespace Nz { - void ShaderAst::AddFunction(std::string name, ShaderNodes::StatementPtr statement, std::vector parameters, ShaderNodes::ExpressionType returnType) + void ShaderAst::AddFunction(std::string name, ShaderNodes::StatementPtr statement, std::vector parameters, ShaderNodes::BasicType returnType) { auto& functionEntry = m_functions.emplace_back(); functionEntry.name = std::move(name); @@ -16,7 +16,7 @@ namespace Nz functionEntry.statement = std::move(statement); } - void ShaderAst::AddInput(std::string name, Type type, std::optional locationIndex) + void ShaderAst::AddInput(std::string name, ShaderExpressionType type, std::optional locationIndex) { auto& inputEntry = m_inputs.emplace_back(); inputEntry.name = std::move(name); @@ -24,7 +24,7 @@ namespace Nz inputEntry.type = std::move(type); } - void ShaderAst::AddOutput(std::string name, Type type, std::optional locationIndex) + void ShaderAst::AddOutput(std::string name, ShaderExpressionType type, std::optional locationIndex) { auto& outputEntry = m_outputs.emplace_back(); outputEntry.name = std::move(name); @@ -39,7 +39,7 @@ namespace Nz structEntry.members = std::move(members); } - void ShaderAst::AddUniform(std::string name, Type type, std::optional bindingIndex, std::optional memoryLayout) + void ShaderAst::AddUniform(std::string name, ShaderExpressionType type, std::optional bindingIndex, std::optional memoryLayout) { auto& uniformEntry = m_uniforms.emplace_back(); uniformEntry.bindingIndex = std::move(bindingIndex); diff --git a/src/Nazara/Renderer/ShaderNodes.cpp b/src/Nazara/Renderer/ShaderNodes.cpp index eb4f59160..57ac58ee8 100644 --- a/src/Nazara/Renderer/ShaderNodes.cpp +++ b/src/Nazara/Renderer/ShaderNodes.cpp @@ -47,7 +47,7 @@ namespace Nz::ShaderNodes return ExpressionCategory::LValue; } - ExpressionType Identifier::GetExpressionType() const + BasicType Identifier::GetExpressionType() const { assert(var); return var->type; @@ -59,7 +59,7 @@ namespace Nz::ShaderNodes } - ExpressionType AssignOp::GetExpressionType() const + BasicType AssignOp::GetExpressionType() const { return left->GetExpressionType(); } @@ -70,9 +70,9 @@ namespace Nz::ShaderNodes } - ExpressionType BinaryOp::GetExpressionType() const + BasicType BinaryOp::GetExpressionType() const { - ShaderNodes::ExpressionType exprType = ShaderNodes::ExpressionType::Void; + ShaderNodes::BasicType exprType = ShaderNodes::BasicType::Void; switch (op) { @@ -84,15 +84,15 @@ namespace Nz::ShaderNodes case ShaderNodes::BinaryType::Divide: case ShaderNodes::BinaryType::Multiply: //FIXME - exprType = static_cast(std::max(UnderlyingCast(left->GetExpressionType()), UnderlyingCast(right->GetExpressionType()))); + exprType = static_cast(std::max(UnderlyingCast(left->GetExpressionType()), UnderlyingCast(right->GetExpressionType()))); break; case ShaderNodes::BinaryType::Equality: - exprType = ExpressionType::Boolean; + exprType = BasicType::Boolean; break; } - NazaraAssert(exprType != ShaderNodes::ExpressionType::Void, "Unhandled builtin"); + NazaraAssert(exprType != ShaderNodes::BasicType::Void, "Unhandled builtin"); return exprType; } @@ -109,7 +109,7 @@ namespace Nz::ShaderNodes } - ExpressionType Constant::GetExpressionType() const + BasicType Constant::GetExpressionType() const { return exprType; } @@ -119,7 +119,7 @@ namespace Nz::ShaderNodes visitor.Visit(*this); } - ExpressionType Cast::GetExpressionType() const + BasicType Cast::GetExpressionType() const { return exprType; } @@ -135,9 +135,9 @@ namespace Nz::ShaderNodes return ExpressionCategory::LValue; } - ExpressionType SwizzleOp::GetExpressionType() const + BasicType SwizzleOp::GetExpressionType() const { - return static_cast(UnderlyingCast(GetComponentType(expression->GetExpressionType())) + componentCount - 1); + return static_cast(UnderlyingCast(GetComponentType(expression->GetExpressionType())) + componentCount - 1); } void SwizzleOp::Visit(ShaderVisitor& visitor) @@ -146,9 +146,9 @@ namespace Nz::ShaderNodes } - ExpressionType Sample2D::GetExpressionType() const + BasicType Sample2D::GetExpressionType() const { - return ExpressionType::Float4; + return BasicType::Float4; } void Sample2D::Visit(ShaderVisitor& visitor) @@ -157,7 +157,7 @@ namespace Nz::ShaderNodes } - ExpressionType IntrinsicCall::GetExpressionType() const + BasicType IntrinsicCall::GetExpressionType() const { switch (intrinsic) { @@ -165,11 +165,11 @@ namespace Nz::ShaderNodes return parameters.front()->GetExpressionType(); case IntrinsicType::DotProduct: - return ExpressionType::Float1; + return BasicType::Float1; } NazaraAssert(false, "Unhandled builtin"); - return ExpressionType::Void; + return BasicType::Void; } void IntrinsicCall::Visit(ShaderVisitor& visitor) diff --git a/src/Nazara/Renderer/ShaderSerializer.cpp b/src/Nazara/Renderer/ShaderSerializer.cpp index 9cf7c47ff..17f369037 100644 --- a/src/Nazara/Renderer/ShaderSerializer.cpp +++ b/src/Nazara/Renderer/ShaderSerializer.cpp @@ -170,23 +170,23 @@ namespace Nz switch (node.exprType) { - case ShaderNodes::ExpressionType::Boolean: + case ShaderNodes::BasicType::Boolean: Value(node.values.bool1); break; - case ShaderNodes::ExpressionType::Float1: + case ShaderNodes::BasicType::Float1: Value(node.values.vec1); break; - case ShaderNodes::ExpressionType::Float2: + case ShaderNodes::BasicType::Float2: Value(node.values.vec2); break; - case ShaderNodes::ExpressionType::Float3: + case ShaderNodes::BasicType::Float3: Value(node.values.vec3); break; - case ShaderNodes::ExpressionType::Float4: + case ShaderNodes::BasicType::Float4: Value(node.values.vec4); break; } @@ -249,12 +249,12 @@ namespace Nz { m_stream << s_magicNumber << s_currentVersion; - auto SerializeType = [&](const ShaderAst::Type& type) + auto SerializeType = [&](const ShaderExpressionType& type) { std::visit([&](auto&& arg) { using T = std::decay_t; - if constexpr (std::is_same_v) + if constexpr (std::is_same_v) { m_stream << UInt8(0); m_stream << UInt32(arg); @@ -448,7 +448,7 @@ namespace Nz for (UInt32 i = 0; i < inputCount; ++i) { std::string inputName; - ShaderAst::Type inputType; + ShaderExpressionType inputType; std::optional location; Value(inputName); @@ -463,7 +463,7 @@ namespace Nz for (UInt32 i = 0; i < outputCount; ++i) { std::string outputName; - ShaderAst::Type outputType; + ShaderExpressionType outputType; std::optional location; Value(outputName); @@ -478,7 +478,7 @@ namespace Nz for (UInt32 i = 0; i < uniformCount; ++i) { std::string name; - ShaderAst::Type type; + ShaderExpressionType type; std::optional binding; std::optional memLayout; @@ -495,7 +495,7 @@ namespace Nz for (UInt32 i = 0; i < funcCount; ++i) { std::string name; - ShaderNodes::ExpressionType retType; + ShaderNodes::BasicType retType; std::vector parameters; Value(name); @@ -560,7 +560,7 @@ namespace Nz } } - void ShaderUnserializer::Type(ShaderAst::Type& type) + void ShaderUnserializer::Type(ShaderExpressionType& type) { UInt8 typeIndex; Value(typeIndex); @@ -569,7 +569,7 @@ namespace Nz { case 0: //< Primitive { - ShaderNodes::ExpressionType exprType; + ShaderNodes::BasicType exprType; Enum(exprType); type = exprType; diff --git a/src/Nazara/Renderer/ShaderValidator.cpp b/src/Nazara/Renderer/ShaderValidator.cpp index 37eecb767..1445d4cf1 100644 --- a/src/Nazara/Renderer/ShaderValidator.cpp +++ b/src/Nazara/Renderer/ShaderValidator.cpp @@ -21,7 +21,7 @@ namespace Nz struct Local { std::string name; - ShaderNodes::ExpressionType type; + ShaderNodes::BasicType type; }; const ShaderAst::Function* currentFunction; @@ -77,7 +77,7 @@ namespace Nz return TypeMustMatch(left->GetExpressionType(), right->GetExpressionType()); } - void ShaderValidator::TypeMustMatch(const ShaderAst::Type& left, const ShaderAst::Type& right) + void ShaderValidator::TypeMustMatch(const ShaderExpressionType& left, const ShaderExpressionType& right) { if (left != right) throw AstError{ "Left expression type must match right expression type" }; @@ -101,8 +101,8 @@ namespace Nz MandatoryNode(node.left); MandatoryNode(node.right); - ShaderNodes::ExpressionType leftType = node.left->GetExpressionType(); - ShaderNodes::ExpressionType rightType = node.right->GetExpressionType(); + ShaderNodes::BasicType leftType = node.left->GetExpressionType(); + ShaderNodes::BasicType rightType = node.right->GetExpressionType(); switch (node.op) { @@ -117,31 +117,31 @@ namespace Nz { switch (leftType) { - case ShaderNodes::ExpressionType::Float1: + case ShaderNodes::BasicType::Float1: { - if (ShaderNodes::Node::GetComponentType(rightType) != ShaderNodes::ExpressionType::Float1) + if (ShaderNodes::Node::GetComponentType(rightType) != ShaderNodes::BasicType::Float1) throw AstError{ "Left expression type is not compatible with right expression type" }; break; } - case ShaderNodes::ExpressionType::Float2: - case ShaderNodes::ExpressionType::Float3: - case ShaderNodes::ExpressionType::Float4: + case ShaderNodes::BasicType::Float2: + case ShaderNodes::BasicType::Float3: + case ShaderNodes::BasicType::Float4: { - if (leftType != rightType && rightType != ShaderNodes::ExpressionType::Float1) + if (leftType != rightType && rightType != ShaderNodes::BasicType::Float1) throw AstError{ "Left expression type is not compatible with right expression type" }; break; } - case ShaderNodes::ExpressionType::Mat4x4: + case ShaderNodes::BasicType::Mat4x4: { switch (rightType) { - case ShaderNodes::ExpressionType::Float1: - case ShaderNodes::ExpressionType::Float4: - case ShaderNodes::ExpressionType::Mat4x4: + case ShaderNodes::BasicType::Float1: + case ShaderNodes::BasicType::Float4: + case ShaderNodes::BasicType::Mat4x4: break; default: @@ -318,7 +318,7 @@ namespace Nz for (auto& param : node.parameters) MandatoryNode(param); - ShaderNodes::ExpressionType type = node.parameters.front()->GetExpressionType(); + ShaderNodes::BasicType type = node.parameters.front()->GetExpressionType(); for (std::size_t i = 1; i < node.parameters.size(); ++i) { if (type != node.parameters[i]->GetExpressionType()) @@ -333,7 +333,7 @@ namespace Nz { case ShaderNodes::IntrinsicType::CrossProduct: { - if (node.parameters[0]->GetExpressionType() != ShaderNodes::ExpressionType::Float3) + if (node.parameters[0]->GetExpressionType() != ShaderNodes::BasicType::Float3) throw AstError{ "CrossProduct only works with Float3 expressions" }; break; @@ -349,10 +349,10 @@ namespace Nz void ShaderValidator::Visit(const ShaderNodes::Sample2D& node) { - if (MandatoryExpr(node.sampler)->GetExpressionType() != ShaderNodes::ExpressionType::Sampler2D) + if (MandatoryExpr(node.sampler)->GetExpressionType() != ShaderNodes::BasicType::Sampler2D) throw AstError{ "Sampler must be a Sampler2D" }; - if (MandatoryExpr(node.coordinates)->GetExpressionType() != ShaderNodes::ExpressionType::Float2) + if (MandatoryExpr(node.coordinates)->GetExpressionType() != ShaderNodes::BasicType::Float2) throw AstError{ "Coordinates must be a Float2" }; Visit(node.sampler); @@ -380,10 +380,10 @@ namespace Nz switch (MandatoryExpr(node.expression)->GetExpressionType()) { - case ShaderNodes::ExpressionType::Float1: - case ShaderNodes::ExpressionType::Float2: - case ShaderNodes::ExpressionType::Float3: - case ShaderNodes::ExpressionType::Float4: + case ShaderNodes::BasicType::Float1: + case ShaderNodes::BasicType::Float2: + case ShaderNodes::BasicType::Float3: + case ShaderNodes::BasicType::Float4: break; default: diff --git a/src/ShaderNode/DataModels/InputValue.cpp b/src/ShaderNode/DataModels/InputValue.cpp index a5a3a269b..f9337f262 100644 --- a/src/ShaderNode/DataModels/InputValue.cpp +++ b/src/ShaderNode/DataModels/InputValue.cpp @@ -116,15 +116,15 @@ Nz::ShaderNodes::ExpressionPtr InputValue::GetExpression(Nz::ShaderNodes::Expres const auto& inputEntry = GetGraph().GetInput(*m_currentInputIndex); - Nz::ShaderNodes::ExpressionType expression = [&] + Nz::ShaderNodes::BasicType expression = [&] { switch (inputEntry.type) { - case PrimitiveType::Bool: return Nz::ShaderNodes::ExpressionType::Boolean; - case PrimitiveType::Float1: return Nz::ShaderNodes::ExpressionType::Float1; - case PrimitiveType::Float2: return Nz::ShaderNodes::ExpressionType::Float2; - case PrimitiveType::Float3: return Nz::ShaderNodes::ExpressionType::Float3; - case PrimitiveType::Float4: return Nz::ShaderNodes::ExpressionType::Float4; + case PrimitiveType::Bool: return Nz::ShaderNodes::BasicType::Boolean; + case PrimitiveType::Float1: return Nz::ShaderNodes::BasicType::Float1; + case PrimitiveType::Float2: return Nz::ShaderNodes::BasicType::Float2; + case PrimitiveType::Float3: return Nz::ShaderNodes::BasicType::Float3; + case PrimitiveType::Float4: return Nz::ShaderNodes::BasicType::Float4; } assert(false); @@ -145,7 +145,7 @@ auto InputValue::dataType(QtNodes::PortType portType, QtNodes::PortIndex portInd const auto& inputEntry = GetGraph().GetInput(*m_currentInputIndex); switch (inputEntry.type) { - //case InputType::Bool: return Nz::ShaderNodes::ExpressionType::Boolean; + //case InputType::Bool: return Nz::ShaderNodes::BasicType::Boolean; case PrimitiveType::Float1: return FloatData::Type(); diff --git a/src/ShaderNode/DataModels/OutputValue.cpp b/src/ShaderNode/DataModels/OutputValue.cpp index 1f65c5953..b86c46879 100644 --- a/src/ShaderNode/DataModels/OutputValue.cpp +++ b/src/ShaderNode/DataModels/OutputValue.cpp @@ -63,15 +63,15 @@ Nz::ShaderNodes::ExpressionPtr OutputValue::GetExpression(Nz::ShaderNodes::Expre const auto& outputEntry = GetGraph().GetOutput(*m_currentOutputIndex); - Nz::ShaderNodes::ExpressionType expression = [&] + Nz::ShaderNodes::BasicType expression = [&] { switch (outputEntry.type) { - case PrimitiveType::Bool: return Nz::ShaderNodes::ExpressionType::Boolean; - case PrimitiveType::Float1: return Nz::ShaderNodes::ExpressionType::Float1; - case PrimitiveType::Float2: return Nz::ShaderNodes::ExpressionType::Float2; - case PrimitiveType::Float3: return Nz::ShaderNodes::ExpressionType::Float3; - case PrimitiveType::Float4: return Nz::ShaderNodes::ExpressionType::Float4; + case PrimitiveType::Bool: return Nz::ShaderNodes::BasicType::Boolean; + case PrimitiveType::Float1: return Nz::ShaderNodes::BasicType::Float1; + case PrimitiveType::Float2: return Nz::ShaderNodes::BasicType::Float2; + case PrimitiveType::Float3: return Nz::ShaderNodes::BasicType::Float3; + case PrimitiveType::Float4: return Nz::ShaderNodes::BasicType::Float4; } assert(false); @@ -94,8 +94,8 @@ QtNodes::NodeDataType OutputValue::dataType(QtNodes::PortType portType, QtNodes: const auto& outputEntry = GetGraph().GetOutput(*m_currentOutputIndex); switch (outputEntry.type) { - //case InOutType::Bool: return Nz::ShaderNodes::ExpressionType::Boolean; - //case InOutType::Float1: return Nz::ShaderNodes::ExpressionType::Float1; + //case InOutType::Bool: return Nz::ShaderNodes::BasicType::Boolean; + //case InOutType::Float1: return Nz::ShaderNodes::BasicType::Float1; case PrimitiveType::Float2: case PrimitiveType::Float3: case PrimitiveType::Float4: diff --git a/src/ShaderNode/DataModels/TextureValue.cpp b/src/ShaderNode/DataModels/TextureValue.cpp index 6a6402cf4..79df6de5c 100644 --- a/src/ShaderNode/DataModels/TextureValue.cpp +++ b/src/ShaderNode/DataModels/TextureValue.cpp @@ -119,11 +119,11 @@ Nz::ShaderNodes::ExpressionPtr TextureValue::GetExpression(Nz::ShaderNodes::Expr const auto& textureEntry = GetGraph().GetTexture(*m_currentTextureIndex); - Nz::ShaderNodes::ExpressionType expression = [&] + Nz::ShaderNodes::BasicType expression = [&] { switch (textureEntry.type) { - case TextureType::Sampler2D: return Nz::ShaderNodes::ExpressionType::Sampler2D; + case TextureType::Sampler2D: return Nz::ShaderNodes::BasicType::Sampler2D; } assert(false); diff --git a/src/ShaderNode/DataTypes/VecData.cpp b/src/ShaderNode/DataTypes/VecData.cpp index 2d4a38001..0402864e0 100644 --- a/src/ShaderNode/DataTypes/VecData.cpp +++ b/src/ShaderNode/DataTypes/VecData.cpp @@ -2,13 +2,13 @@ #include #include -Nz::ShaderNodes::ExpressionType VecData::GetExpressionType() const +Nz::ShaderNodes::BasicType VecData::GetExpressionType() const { switch (componentCount) { - case 2: return Nz::ShaderNodes::ExpressionType::Float2; - case 3: return Nz::ShaderNodes::ExpressionType::Float3; - case 4: return Nz::ShaderNodes::ExpressionType::Float4; + case 2: return Nz::ShaderNodes::BasicType::Float2; + case 3: return Nz::ShaderNodes::BasicType::Float3; + case 4: return Nz::ShaderNodes::BasicType::Float4; default: break; } diff --git a/src/ShaderNode/DataTypes/VecData.hpp b/src/ShaderNode/DataTypes/VecData.hpp index 3c6a8f096..7c515a12a 100644 --- a/src/ShaderNode/DataTypes/VecData.hpp +++ b/src/ShaderNode/DataTypes/VecData.hpp @@ -13,7 +13,7 @@ struct VecData : public QtNodes::NodeData inline QtNodes::NodeDataType type() const override; - Nz::ShaderNodes::ExpressionType GetExpressionType() const; + Nz::ShaderNodes::BasicType GetExpressionType() const; static inline QtNodes::NodeDataType Type(); @@ -27,28 +27,28 @@ struct VecExpressionTypeHelper; template<> struct VecExpressionTypeHelper<1> { - static constexpr Nz::ShaderNodes::ExpressionType ExpressionType = Nz::ShaderNodes::ExpressionType::Float1; + static constexpr Nz::ShaderNodes::BasicType ExpressionType = Nz::ShaderNodes::BasicType::Float1; }; template<> struct VecExpressionTypeHelper<2> { - static constexpr Nz::ShaderNodes::ExpressionType ExpressionType = Nz::ShaderNodes::ExpressionType::Float2; + static constexpr Nz::ShaderNodes::BasicType ExpressionType = Nz::ShaderNodes::BasicType::Float2; }; template<> struct VecExpressionTypeHelper<3> { - static constexpr Nz::ShaderNodes::ExpressionType ExpressionType = Nz::ShaderNodes::ExpressionType::Float3; + static constexpr Nz::ShaderNodes::BasicType ExpressionType = Nz::ShaderNodes::BasicType::Float3; }; template<> struct VecExpressionTypeHelper<4> { - static constexpr Nz::ShaderNodes::ExpressionType ExpressionType = Nz::ShaderNodes::ExpressionType::Float4; + static constexpr Nz::ShaderNodes::BasicType ExpressionType = Nz::ShaderNodes::BasicType::Float4; }; -template constexpr Nz::ShaderNodes::ExpressionType VecExpressionType = VecExpressionTypeHelper::template ExpressionType; +template constexpr Nz::ShaderNodes::BasicType VecExpressionType = VecExpressionTypeHelper::template ExpressionType; struct VecTypeDummy {}; diff --git a/src/ShaderNode/Widgets/MainWindow.cpp b/src/ShaderNode/Widgets/MainWindow.cpp index 213d190cb..813d1b5ab 100644 --- a/src/ShaderNode/Widgets/MainWindow.cpp +++ b/src/ShaderNode/Widgets/MainWindow.cpp @@ -217,11 +217,11 @@ Nz::ShaderAst MainWindow::ToShader() { switch (type) { - case PrimitiveType::Bool: return Nz::ShaderNodes::ExpressionType::Boolean; - case PrimitiveType::Float1: return Nz::ShaderNodes::ExpressionType::Float1; - case PrimitiveType::Float2: return Nz::ShaderNodes::ExpressionType::Float2; - case PrimitiveType::Float3: return Nz::ShaderNodes::ExpressionType::Float3; - case PrimitiveType::Float4: return Nz::ShaderNodes::ExpressionType::Float4; + case PrimitiveType::Bool: return Nz::ShaderNodes::BasicType::Boolean; + case PrimitiveType::Float1: return Nz::ShaderNodes::BasicType::Float1; + case PrimitiveType::Float2: return Nz::ShaderNodes::BasicType::Float2; + case PrimitiveType::Float3: return Nz::ShaderNodes::BasicType::Float3; + case PrimitiveType::Float4: return Nz::ShaderNodes::BasicType::Float4; } assert(false); @@ -232,7 +232,7 @@ Nz::ShaderAst MainWindow::ToShader() { switch (type) { - case TextureType::Sampler2D: return Nz::ShaderNodes::ExpressionType::Sampler2D; + case TextureType::Sampler2D: return Nz::ShaderNodes::BasicType::Sampler2D; } assert(false);