sid/NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Renderer: Rename enums

Browse Source 
ExpressionType => BasicType
ShaderAst::Type => ShaderExpressionType
This commit is contained in:
Jérôme Leclercq
2020-07-16 18:34:58 +02:00
parent c7a8091e68
commit 1d2fb88198
26 changed files with 210 additions and 184 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/Nazara/OpenGLRenderer/Wrapper/Context.cpp
View File

@@ -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;
}

7
src/Nazara/OpenGLRenderer/Wrapper/Win32/WGLContext.cpp
View File

@@ -67,6 +67,13 @@ namespace Nz::GL
void WGLContext::EnableVerticalSync(bool enabled)
{
if (wglSwapIntervalEXT)
{
if (!SetCurrentContext(this))
return;
wglSwapIntervalEXT(enabled);
}
}
void WGLContext::SwapBuffers()

30
src/Nazara/Renderer/GlslWriter.cpp
View File

@@ -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;

8
src/Nazara/Renderer/ShaderAst.cpp
View File

@@ -7,7 +7,7 @@
namespace Nz
{
void ShaderAst::AddFunction(std::string name, ShaderNodes::StatementPtr statement, std::vector<FunctionParameter> parameters, ShaderNodes::ExpressionType returnType)
void ShaderAst::AddFunction(std::string name, ShaderNodes::StatementPtr statement, std::vector<FunctionParameter> 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<std::size_t> locationIndex)
void ShaderAst::AddInput(std::string name, ShaderExpressionType type, std::optional<std::size_t> 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<std::size_t> locationIndex)
void ShaderAst::AddOutput(std::string name, ShaderExpressionType type, std::optional<std::size_t> 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<std::size_t> bindingIndex, std::optional<ShaderNodes::MemoryLayout> memoryLayout)
void ShaderAst::AddUniform(std::string name, ShaderExpressionType type, std::optional<std::size_t> bindingIndex, std::optional<ShaderNodes::MemoryLayout> memoryLayout)
{
auto& uniformEntry = m_uniforms.emplace_back();
uniformEntry.bindingIndex = std::move(bindingIndex);

32
src/Nazara/Renderer/ShaderNodes.cpp
View File

@@ -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<ExpressionType>(std::max(UnderlyingCast(left->GetExpressionType()), UnderlyingCast(right->GetExpressionType())));
exprType = static_cast<BasicType>(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<ExpressionType>(UnderlyingCast(GetComponentType(expression->GetExpressionType())) + componentCount - 1);
return static_cast<BasicType>(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)

26
src/Nazara/Renderer/ShaderSerializer.cpp
View File

@@ -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<decltype(arg)>;
if constexpr (std::is_same_v<T, ShaderNodes::ExpressionType>)
if constexpr (std::is_same_v<T, ShaderNodes::BasicType>)
{
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<std::size_t> 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<std::size_t> 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<std::size_t> binding;
std::optional<ShaderNodes::MemoryLayout> 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<ShaderAst::FunctionParameter> 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;

44
src/Nazara/Renderer/ShaderValidator.cpp
View File

@@ -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:

14
src/ShaderNode/DataModels/InputValue.cpp
View File

@@ -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();

16
src/ShaderNode/DataModels/OutputValue.cpp
View File

@@ -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:

4
src/ShaderNode/DataModels/TextureValue.cpp
View File

@@ -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);

8
src/ShaderNode/DataTypes/VecData.cpp
View File

@@ -2,13 +2,13 @@
#include <cassert>
#include <stdexcept>
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;
}

12
src/ShaderNode/DataTypes/VecData.hpp
View File

@@ -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<std::size_t N> constexpr Nz::ShaderNodes::ExpressionType VecExpressionType = VecExpressionTypeHelper<N>::template ExpressionType;
template<std::size_t N> constexpr Nz::ShaderNodes::BasicType VecExpressionType = VecExpressionTypeHelper<N>::template ExpressionType;
struct VecTypeDummy {};

12
src/ShaderNode/Widgets/MainWindow.cpp
View File

@@ -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);