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

Split engine to packages NazaraUtils and NZSL (#375)

Browse Source 
* Move code to NazaraUtils and NZSL packages

* Reorder includes

* Tests: Remove glslang and spirv-tools deps

* Tests: Remove glslang init

* Remove NazaraUtils tests and fix Vector4Test

* Fix Linux compilation

* Update msys2-build.yml

* Fix assimp package

* Update xmake.lua

* Update xmake.lua

* Fix shader compilation on MinGW

* Final fixes

* The final fix 2: the fix strikes back!

* Disable cache on CI

* The return of the fix™️
This commit is contained in:
Jérôme Leclercq
2022-05-25 19:36:10 +02:00
committed by GitHub
parent 3f8f1c4653
commit 03e2801dbe
483 changed files with 1139 additions and 59112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
src/ShaderNode/DataModels/BinOp.hpp
View File

@@ -7,14 +7,14 @@
#include <ShaderNode/DataTypes/FloatData.hpp>
#include <ShaderNode/DataTypes/VecData.hpp>
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
class BinOp : public ShaderNode
{
public:
BinOp(ShaderGraph& graph);
~BinOp() = default;
Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
virtual QString GetOperationString() const = 0;
@@ -33,7 +33,7 @@ class BinOp : public ShaderNode
QString validationMessage() const override;
private:
virtual void ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount) = 0;
virtual void ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount) = 0;
bool ComputePreview(QPixmap& pixmap) override;
void UpdateOutput();
@@ -45,42 +45,42 @@ class BinOp : public ShaderNode
template<typename DataType>
class BinAdd : public BinOp<DataType, Nz::ShaderAst::BinaryType::Add>
class BinAdd : public BinOp<DataType, nzsl::Ast::BinaryType::Add>
{
public:
using BinOp<DataType, Nz::ShaderAst::BinaryType::Add>::BinOp;
using BinOp<DataType, nzsl::Ast::BinaryType::Add>::BinOp;
void ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount) override;
void ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount) override;
QString GetOperationString() const final;
};
template<typename DataType>
class BinMul : public BinOp<DataType, Nz::ShaderAst::BinaryType::Multiply>
class BinMul : public BinOp<DataType, nzsl::Ast::BinaryType::Multiply>
{
public:
using BinOp<DataType, Nz::ShaderAst::BinaryType::Multiply>::BinOp;
using BinOp<DataType, nzsl::Ast::BinaryType::Multiply>::BinOp;
void ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount) override;
void ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount) override;
QString GetOperationString() const final;
};
template<typename DataType>
class BinSub : public BinOp<DataType, Nz::ShaderAst::BinaryType::Subtract>
class BinSub : public BinOp<DataType, nzsl::Ast::BinaryType::Subtract>
{
public:
using BinOp<DataType, Nz::ShaderAst::BinaryType::Subtract>::BinOp;
using BinOp<DataType, nzsl::Ast::BinaryType::Subtract>::BinOp;
void ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount) override;
void ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount) override;
QString GetOperationString() const final;
};
template<typename DataType>
class BinDiv : public BinOp<DataType, Nz::ShaderAst::BinaryType::Divide>
class BinDiv : public BinOp<DataType, nzsl::Ast::BinaryType::Divide>
{
public:
using BinOp<DataType, Nz::ShaderAst::BinaryType::Divide>::BinOp;
using BinOp<DataType, nzsl::Ast::BinaryType::Divide>::BinOp;
void ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount) override;
void ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount) override;
QString GetOperationString() const final;
};

40
src/ShaderNode/DataModels/BinOp.inl
View File

@@ -1,23 +1,23 @@
#include <ShaderNode/DataModels/BinOp.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <NZSL/ShaderBuilder.hpp>
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
BinOp<DataType, Op>::BinOp(ShaderGraph& graph) :
ShaderNode(graph)
{
UpdateOutput();
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
Nz::ShaderAst::NodePtr BinOp<DataType, Op>::BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
template<typename DataType, nzsl::Ast::BinaryType Op>
nzsl::Ast::NodePtr BinOp<DataType, Op>::BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
{
assert(count == 2);
assert(outputIndex == 0);
return Nz::ShaderBuilder::Binary(Op, std::move(expressions[0]), std::move(expressions[1]));
return nzsl::ShaderBuilder::Binary(Op, std::move(expressions[0]), std::move(expressions[1]));
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
QtNodes::NodeDataType BinOp<DataType, Op>::dataType(QtNodes::PortType /*portType*/, QtNodes::PortIndex portIndex) const
{
assert(portIndex == 0 || portIndex == 1);
@@ -25,7 +25,7 @@ QtNodes::NodeDataType BinOp<DataType, Op>::dataType(QtNodes::PortType /*portType
return DataType::Type();
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
unsigned int BinOp<DataType, Op>::nPorts(QtNodes::PortType portType) const
{
switch (portType)
@@ -39,14 +39,14 @@ unsigned int BinOp<DataType, Op>::nPorts(QtNodes::PortType portType) const
throw std::runtime_error("invalid port type");
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
std::shared_ptr<QtNodes::NodeData> BinOp<DataType, Op>::outData(QtNodes::PortIndex port)
{
assert(port == 0);
return m_output;
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
QString BinOp<DataType, Op>::portCaption(QtNodes::PortType portType, QtNodes::PortIndex portIndex) const
{
switch (portType)
@@ -79,14 +79,14 @@ QString BinOp<DataType, Op>::portCaption(QtNodes::PortType portType, QtNodes::Po
return QString{};
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
bool BinOp<DataType, Op>::portCaptionVisible(QtNodes::PortType portType, QtNodes::PortIndex portIndex) const
{
assert(portIndex == 0 || portIndex == 1);
return portType == QtNodes::PortType::In || portType == QtNodes::PortType::Out;
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
void BinOp<DataType, Op>::setInData(std::shared_ptr<QtNodes::NodeData> value, int index)
{
assert(index == 0 || index == 1);
@@ -103,7 +103,7 @@ void BinOp<DataType, Op>::setInData(std::shared_ptr<QtNodes::NodeData> value, in
UpdateOutput();
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
QtNodes::NodeValidationState BinOp<DataType, Op>::validationState() const
{
if (!m_lhs || !m_rhs)
@@ -118,7 +118,7 @@ QtNodes::NodeValidationState BinOp<DataType, Op>::validationState() const
return QtNodes::NodeValidationState::Valid;
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
QString BinOp<DataType, Op>::validationMessage() const
{
if (!m_lhs || !m_rhs)
@@ -133,7 +133,7 @@ QString BinOp<DataType, Op>::validationMessage() const
return QString();
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
bool BinOp<DataType, Op>::ComputePreview(QPixmap& pixmap)
{
if (!m_lhs || !m_rhs)
@@ -143,7 +143,7 @@ bool BinOp<DataType, Op>::ComputePreview(QPixmap& pixmap)
return true;
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
void BinOp<DataType, Op>::UpdateOutput()
{
if (validationState() != QtNodes::NodeValidationState::Valid)
@@ -154,7 +154,7 @@ void BinOp<DataType, Op>::UpdateOutput()
m_output = std::make_shared<DataType>();
m_output->preview = PreviewValues(1, 1);
m_output->preview.Fill(Nz::Vector4f::Zero());
m_output->preview.Fill(nzsl::Vector4f(0.f, 0.f, 0.f, 0.f));
return;
}
@@ -186,7 +186,7 @@ void BinOp<DataType, Op>::UpdateOutput()
}
template<typename DataType>
void BinAdd<DataType>::ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount)
void BinAdd<DataType>::ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount)
{
for (std::size_t i = 0; i < pixelCount; ++i)
output[i] = left[i] + right[i];
@@ -199,7 +199,7 @@ QString BinAdd<DataType>::GetOperationString() const
}
template<typename DataType>
void BinMul<DataType>::ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount)
void BinMul<DataType>::ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount)
{
for (std::size_t i = 0; i < pixelCount; ++i)
output[i] = left[i] * right[i];
@@ -212,7 +212,7 @@ QString BinMul<DataType>::GetOperationString() const
}
template<typename DataType>
void BinSub<DataType>::ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount)
void BinSub<DataType>::ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount)
{
for (std::size_t i = 0; i < pixelCount; ++i)
output[i] = left[i] - right[i];
@@ -225,7 +225,7 @@ QString BinSub<DataType>::GetOperationString() const
}
template<typename DataType>
void BinDiv<DataType>::ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount)
void BinDiv<DataType>::ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount)
{
for (std::size_t i = 0; i < pixelCount; ++i)
output[i] = left[i] / right[i];

8
src/ShaderNode/DataModels/BoolValue.cpp
View File

@@ -1,6 +1,6 @@
#include <ShaderNode/DataModels/BoolValue.hpp>
#include <ShaderNode/DataTypes/BoolData.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <NZSL/ShaderBuilder.hpp>
#include <QtWidgets/QCheckBox>
#include <cassert>
@@ -53,7 +53,7 @@ std::shared_ptr<QtNodes::NodeData> BoolValue::outData(QtNodes::PortIndex port)
float c = (m_value) ? 1.f : 0.f;
auto out = std::make_shared<BoolData>();
out->preview(0, 0) = Nz::Vector4f(c, c, c, 1.f);
out->preview(0, 0) = nzsl::Vector4f(c, c, c, 1.f);
return out;
}
@@ -89,12 +89,12 @@ void BoolValue::BuildNodeEdition(QFormLayout* layout)
layout->addRow(tr("Value"), checkbox);
}
Nz::ShaderAst::NodePtr BoolValue::BuildNode(Nz::ShaderAst::ExpressionPtr* /*expressions*/, std::size_t count, std::size_t outputIndex) const
nzsl::Ast::NodePtr BoolValue::BuildNode(nzsl::Ast::ExpressionPtr* /*expressions*/, std::size_t count, std::size_t outputIndex) const
{
assert(count == 0);
assert(outputIndex == 0);
return Nz::ShaderBuilder::Constant(m_value);
return nzsl::ShaderBuilder::Constant(m_value);
}
bool BoolValue::ComputePreview(QPixmap& pixmap)

2
src/ShaderNode/DataModels/BoolValue.hpp
View File

@@ -17,7 +17,7 @@ class BoolValue : public ShaderNode
BoolValue(ShaderGraph& graph);
~BoolValue() = default;
Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
void BuildNodeEdition(QFormLayout* layout) override;
QString caption() const override;

11
src/ShaderNode/DataModels/BufferField.cpp
View File

@@ -1,11 +1,11 @@
#include <ShaderNode/DataModels/BufferField.hpp>
#include <Nazara/Core/CallOnExit.hpp>
#include <Nazara/Utils/CallOnExit.hpp>
#include <ShaderNode/ShaderGraph.hpp>
#include <ShaderNode/DataTypes/BoolData.hpp>
#include <ShaderNode/DataTypes/FloatData.hpp>
#include <ShaderNode/DataTypes/Matrix4Data.hpp>
#include <ShaderNode/DataTypes/VecData.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <NZSL/ShaderBuilder.hpp>
#include <QtWidgets/QComboBox>
#include <QtWidgets/QFormLayout>
#include <iostream>
@@ -49,7 +49,7 @@ ShaderNode(graph)
UpdatePreview();
}
Nz::ShaderAst::NodePtr BufferField::BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
nzsl::Ast::NodePtr BufferField::BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
{
assert(count == 0);
assert(outputIndex == 0);
@@ -65,7 +65,7 @@ Nz::ShaderAst::NodePtr BufferField::BuildNode(Nz::ShaderAst::ExpressionPtr* expr
assert(m_currentFieldIndex);
const CurrentField& currentField = *m_currentFieldIndex;
Nz::ShaderAst::ExpressionPtr sourceExpr = Nz::ShaderBuilder::Identifier(bufferEntry.name);
nzsl::Ast::ExpressionPtr sourceExpr = nzsl::ShaderBuilder::Identifier(bufferEntry.name);
std::vector<std::string> memberIdentifiers;
memberIdentifiers.reserve(currentField.nestedFields.size() + 1);
@@ -89,8 +89,7 @@ Nz::ShaderAst::NodePtr BufferField::BuildNode(Nz::ShaderAst::ExpressionPtr* expr
memberIdentifiers.push_back(memberEntry.name);
using namespace Nz;
return ShaderBuilder::AccessMember(std::move(sourceExpr), std::move(memberIdentifiers));
return nzsl::ShaderBuilder::AccessMember(std::move(sourceExpr), std::move(memberIdentifiers));
}
unsigned int BufferField::nPorts(QtNodes::PortType portType) const

2
src/ShaderNode/DataModels/BufferField.hpp
View File

@@ -15,7 +15,7 @@ class BufferField : public ShaderNode
BufferField(ShaderGraph& graph);
~BufferField() = default;
Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
void BuildNodeEdition(QFormLayout* layout) override;
QString caption() const override { return "BufferField"; }

2
src/ShaderNode/DataModels/Cast.hpp
View File

@@ -17,7 +17,7 @@ class CastVec : public ShaderNode
CastVec(ShaderGraph& graph);
~CastVec() = default;
Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const;
nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const;
void BuildNodeEdition(QFormLayout* layout) override;
QString caption() const override;

18
src/ShaderNode/DataModels/Cast.inl
View File

@@ -1,5 +1,5 @@
#include <ShaderNode/DataModels/Cast.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <NZSL/ShaderBuilder.hpp>
#include <QtWidgets/QDoubleSpinBox>
#include <QtWidgets/QFormLayout>
#include <QtCore/QJsonArray>
@@ -18,7 +18,7 @@ ShaderNode(graph)
}
template<std::size_t ToComponentCount>
Nz::ShaderAst::NodePtr CastVec<ToComponentCount>::BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
nzsl::Ast::NodePtr CastVec<ToComponentCount>::BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
{
assert(m_input);
assert(count == 1);
@@ -30,12 +30,12 @@ Nz::ShaderAst::NodePtr CastVec<ToComponentCount>::BuildNode(Nz::ShaderAst::Expre
{
std::size_t overflowComponentCount = ToComponentCount - fromComponentCount;
std::vector<Nz::ShaderAst::ExpressionPtr> params;
std::vector<nzsl::Ast::ExpressionPtr> params;
params.emplace_back(std::move(expressions[0]));
for (std::size_t i = 0; i < overflowComponentCount; ++i)
params.emplace_back(Nz::ShaderBuilder::Constant(m_overflowComponents[i]));
params.emplace_back(nzsl::ShaderBuilder::Constant(m_overflowComponents[i]));
return Nz::ShaderBuilder::Cast(Nz::ShaderAst::ExpressionType{ Nz::ShaderAst::VectorType{ ToComponentCount, Nz::ShaderAst::PrimitiveType::Float32 } }, std::move(params));
return nzsl::ShaderBuilder::Cast(nzsl::Ast::ExpressionType{ nzsl::Ast::VectorType{ ToComponentCount, nzsl::Ast::PrimitiveType::Float32 } }, std::move(params));
}
else if (ToComponentCount < fromComponentCount)
{
@@ -46,7 +46,7 @@ Nz::ShaderAst::NodePtr CastVec<ToComponentCount>::BuildNode(Nz::ShaderAst::Expre
return std::apply([&](auto... components)
{
std::initializer_list<Nz::UInt32> componentList{ components... };
return Nz::ShaderBuilder::Swizzle(std::move(expressions[0]), componentList);
return nzsl::ShaderBuilder::Swizzle(std::move(expressions[0]), componentList);
}, swizzleComponents);
}
else
@@ -187,7 +187,7 @@ void CastVec<ToComponentCount>::UpdateOutput()
if (!m_input)
{
m_output->preview = PreviewValues(1, 1);
m_output->preview(0, 0) = Nz::Vector4f::Zero();
m_output->preview(0, 0) = nzsl::Vector4f(0.f, 0.f, 0.f, 0.f);
return;
}
@@ -208,9 +208,9 @@ void CastVec<ToComponentCount>::UpdateOutput()
{
for (std::size_t x = 0; x < inputWidth; ++x)
{
Nz::Vector4f color = input(x, y);
nzsl::Vector4f color = input(x, y);
float* colorPtr = &color.x;
float* colorPtr = &color[0];
for (std::size_t i = 0; i < overflowComponentCount; ++i)
*colorPtr++ = m_overflowComponents[i];

42
src/ShaderNode/DataModels/CompOp.hpp
View File

@@ -8,14 +8,14 @@
#include <ShaderNode/DataTypes/FloatData.hpp>
#include <ShaderNode/DataTypes/VecData.hpp>
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
class CompOp : public ShaderNode
{
public:
CompOp(ShaderGraph& graph);
~CompOp() = default;
Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
virtual QString GetOperationString() const = 0;
@@ -34,7 +34,7 @@ class CompOp : public ShaderNode
QString validationMessage() const override;
private:
virtual void ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount) = 0;
virtual void ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount) = 0;
bool ComputePreview(QPixmap& pixmap) override;
void UpdateOutput();
@@ -46,62 +46,62 @@ class CompOp : public ShaderNode
template<typename DataType>
class CompEq : public CompOp<DataType, Nz::ShaderAst::BinaryType::CompEq>
class CompEq : public CompOp<DataType, nzsl::Ast::BinaryType::CompEq>
{
public:
using CompOp<DataType, Nz::ShaderAst::BinaryType::CompEq>::CompOp;
using CompOp<DataType, nzsl::Ast::BinaryType::CompEq>::CompOp;
void ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount) override;
void ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount) override;
QString GetOperationString() const final;
};
template<typename DataType>
class CompGe : public CompOp<DataType, Nz::ShaderAst::BinaryType::CompGe>
class CompGe : public CompOp<DataType, nzsl::Ast::BinaryType::CompGe>
{
public:
using CompOp<DataType, Nz::ShaderAst::BinaryType::CompGe>::CompOp;
using CompOp<DataType, nzsl::Ast::BinaryType::CompGe>::CompOp;
void ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount) override;
void ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount) override;
QString GetOperationString() const final;
};
template<typename DataType>
class CompGt : public CompOp<DataType, Nz::ShaderAst::BinaryType::CompGt>
class CompGt : public CompOp<DataType, nzsl::Ast::BinaryType::CompGt>
{
public:
using CompOp<DataType, Nz::ShaderAst::BinaryType::CompGt>::CompOp;
using CompOp<DataType, nzsl::Ast::BinaryType::CompGt>::CompOp;
void ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount) override;
void ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount) override;
QString GetOperationString() const final;
};
template<typename DataType>
class CompLe : public CompOp<DataType, Nz::ShaderAst::BinaryType::CompLe>
class CompLe : public CompOp<DataType, nzsl::Ast::BinaryType::CompLe>
{
public:
using CompOp<DataType, Nz::ShaderAst::BinaryType::CompLe>::CompOp;
using CompOp<DataType, nzsl::Ast::BinaryType::CompLe>::CompOp;
void ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount) override;
void ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount) override;
QString GetOperationString() const final;
};
template<typename DataType>
class CompLt : public CompOp<DataType, Nz::ShaderAst::BinaryType::CompLt>
class CompLt : public CompOp<DataType, nzsl::Ast::BinaryType::CompLt>
{
public:
using CompOp<DataType, Nz::ShaderAst::BinaryType::CompLt>::CompOp;
using CompOp<DataType, nzsl::Ast::BinaryType::CompLt>::CompOp;
void ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount) override;
void ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount) override;
QString GetOperationString() const final;
};
template<typename DataType>
class CompNe : public CompOp<DataType, Nz::ShaderAst::BinaryType::CompNe>
class CompNe : public CompOp<DataType, nzsl::Ast::BinaryType::CompNe>
{
public:
using CompOp<DataType, Nz::ShaderAst::BinaryType::CompNe>::CompOp;
using CompOp<DataType, nzsl::Ast::BinaryType::CompNe>::CompOp;
void ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount) override;
void ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount) override;
QString GetOperationString() const final;
};

64
src/ShaderNode/DataModels/CompOp.inl
View File

@@ -1,23 +1,23 @@
#include <ShaderNode/DataModels/CompOp.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <NZSL/ShaderBuilder.hpp>
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
CompOp<DataType, Op>::CompOp(ShaderGraph& graph) :
ShaderNode(graph)
{
UpdateOutput();
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
Nz::ShaderAst::NodePtr CompOp<DataType, Op>::BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
template<typename DataType, nzsl::Ast::BinaryType Op>
nzsl::Ast::NodePtr CompOp<DataType, Op>::BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
{
assert(count == 2);
assert(outputIndex == 0);
return Nz::ShaderBuilder::Binary(Op, std::move(expressions[0]), std::move(expressions[1]));
return nzsl::ShaderBuilder::Binary(Op, std::move(expressions[0]), std::move(expressions[1]));
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
QtNodes::NodeDataType CompOp<DataType, Op>::dataType(QtNodes::PortType portType, QtNodes::PortIndex portIndex) const
{
switch (portType)
@@ -41,7 +41,7 @@ QtNodes::NodeDataType CompOp<DataType, Op>::dataType(QtNodes::PortType portType,
throw std::runtime_error("invalid port type");
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
unsigned int CompOp<DataType, Op>::nPorts(QtNodes::PortType portType) const
{
switch (portType)
@@ -55,14 +55,14 @@ unsigned int CompOp<DataType, Op>::nPorts(QtNodes::PortType portType) const
throw std::runtime_error("invalid port type");
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
std::shared_ptr<QtNodes::NodeData> CompOp<DataType, Op>::outData(QtNodes::PortIndex port)
{
assert(port == 0);
return m_output;
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
QString CompOp<DataType, Op>::portCaption(QtNodes::PortType portType, QtNodes::PortIndex portIndex) const
{
switch (portType)
@@ -95,14 +95,14 @@ QString CompOp<DataType, Op>::portCaption(QtNodes::PortType portType, QtNodes::P
return QString{};
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
bool CompOp<DataType, Op>::portCaptionVisible(QtNodes::PortType portType, QtNodes::PortIndex portIndex) const
{
assert(portIndex == 0 || portIndex == 1);
return portType == QtNodes::PortType::In || portType == QtNodes::PortType::Out;
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
void CompOp<DataType, Op>::setInData(std::shared_ptr<QtNodes::NodeData> value, int index)
{
assert(index == 0 || index == 1);
@@ -119,7 +119,7 @@ void CompOp<DataType, Op>::setInData(std::shared_ptr<QtNodes::NodeData> value, i
UpdateOutput();
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
QtNodes::NodeValidationState CompOp<DataType, Op>::validationState() const
{
if (!m_lhs || !m_rhs)
@@ -134,7 +134,7 @@ QtNodes::NodeValidationState CompOp<DataType, Op>::validationState() const
return QtNodes::NodeValidationState::Valid;
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
QString CompOp<DataType, Op>::validationMessage() const
{
if (!m_lhs || !m_rhs)
@@ -149,7 +149,7 @@ QString CompOp<DataType, Op>::validationMessage() const
return QString();
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
bool CompOp<DataType, Op>::ComputePreview(QPixmap& pixmap)
{
if (!m_lhs || !m_rhs)
@@ -159,14 +159,14 @@ bool CompOp<DataType, Op>::ComputePreview(QPixmap& pixmap)
return true;
}
template<typename DataType, Nz::ShaderAst::BinaryType Op>
template<typename DataType, nzsl::Ast::BinaryType Op>
void CompOp<DataType, Op>::UpdateOutput()
{
if (validationState() != QtNodes::NodeValidationState::Valid)
{
m_output = std::make_shared<BoolData>();
m_output->preview = PreviewValues(1, 1);
m_output->preview.Fill(Nz::Vector4f::Zero());
m_output->preview.Fill(nzsl::Vector4f(0.f, 0.f, 0.f, 0.f));
return;
}
@@ -195,12 +195,12 @@ void CompOp<DataType, Op>::UpdateOutput()
}
template<typename DataType>
void CompEq<DataType>::ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount)
void CompEq<DataType>::ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount)
{
for (std::size_t i = 0; i < pixelCount; ++i)
{
float r = (left[i] == right[i]) ? 1.f : 0.f;
output[i] = Nz::Vector4f(r, r, r, r);
output[i] = nzsl::Vector4f(r, r, r, r);
}
}
@@ -211,12 +211,12 @@ QString CompEq<DataType>::GetOperationString() const
}
template<typename DataType>
void CompGe<DataType>::ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount)
void CompGe<DataType>::ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount)
{
for (std::size_t i = 0; i < pixelCount; ++i)
{
float r = (left[i] >= right[i]) ? 1.f : 0.f;
output[i] = Nz::Vector4f(r, r, r, r);
float r = (left[i][0] >= right[i][0]) ? 1.f : 0.f;
output[i] = nzsl::Vector4f(r, r, r, r);
}
}
@@ -227,12 +227,12 @@ QString CompGe<DataType>::GetOperationString() const
}
template<typename DataType>
void CompGt<DataType>::ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount)
void CompGt<DataType>::ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount)
{
for (std::size_t i = 0; i < pixelCount; ++i)
{
float r = (left[i] > right[i]) ? 1.f : 0.f;
output[i] = Nz::Vector4f(r, r, r, r);
float r = (left[i][0] > right[i][0]) ? 1.f : 0.f;
output[i] = nzsl::Vector4f(r, r, r, r);
}
}
@@ -243,12 +243,12 @@ QString CompGt<DataType>::GetOperationString() const
}
template<typename DataType>
void CompLe<DataType>::ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount)
void CompLe<DataType>::ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount)
{
for (std::size_t i = 0; i < pixelCount; ++i)
{
float r = (left[i] >= right[i]) ? 1.f : 0.f;
output[i] = Nz::Vector4f(r, r, r, r);
float r = (left[i][0] <= right[i][0]) ? 1.f : 0.f;
output[i] = nzsl::Vector4f(r, r, r, r);
}
}
@@ -259,12 +259,12 @@ QString CompLe<DataType>::GetOperationString() const
}
template<typename DataType>
void CompLt<DataType>::ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount)
void CompLt<DataType>::ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount)
{
for (std::size_t i = 0; i < pixelCount; ++i)
{
float r = (left[i] > right[i]) ? 1.f : 0.f;
output[i] = Nz::Vector4f(r, r, r, r);
float r = (left[i][0] < right[i][0]) ? 1.f : 0.f;
output[i] = nzsl::Vector4f(r, r, r, r);
}
}
@@ -275,12 +275,12 @@ QString CompLt<DataType>::GetOperationString() const
}
template<typename DataType>
void CompNe<DataType>::ApplyOp(const Nz::Vector4f* left, const Nz::Vector4f* right, Nz::Vector4f* output, std::size_t pixelCount)
void CompNe<DataType>::ApplyOp(const nzsl::Vector4f* left, const nzsl::Vector4f* right, nzsl::Vector4f* output, std::size_t pixelCount)
{
for (std::size_t i = 0; i < pixelCount; ++i)
{
float r = (left[i] != right[i]) ? 1.f : 0.f;
output[i] = Nz::Vector4f(r, r, r, r);
output[i] = nzsl::Vector4f(r, r, r, r);
}
}

8
src/ShaderNode/DataModels/ConditionalExpression.cpp
View File

@@ -1,11 +1,11 @@
#include <ShaderNode/DataModels/ConditionalExpression.hpp>
#include <Nazara/Core/CallOnExit.hpp>
#include <Nazara/Utils/CallOnExit.hpp>
#include <ShaderNode/ShaderGraph.hpp>
#include <ShaderNode/DataTypes/BoolData.hpp>
#include <ShaderNode/DataTypes/FloatData.hpp>
#include <ShaderNode/DataTypes/Matrix4Data.hpp>
#include <ShaderNode/DataTypes/VecData.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <NZSL/ShaderBuilder.hpp>
#include <QtWidgets/QComboBox>
#include <QtWidgets/QFormLayout>
#include <iostream>
@@ -35,7 +35,7 @@ ShaderNode(graph)
UpdatePreview();
}
Nz::ShaderAst::NodePtr ConditionalExpression::BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
nzsl::Ast::NodePtr ConditionalExpression::BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
{
assert(count == 2);
assert(outputIndex == 0);
@@ -46,7 +46,7 @@ Nz::ShaderAst::NodePtr ConditionalExpression::BuildNode(Nz::ShaderAst::Expressio
const ShaderGraph& graph = GetGraph();
const auto& optionEntry = graph.GetOption(*m_currentOptionIndex);
return Nz::ShaderBuilder::ConditionalExpression(Nz::ShaderBuilder::Identifier(optionEntry.name), std::move(expressions[0]), std::move(expressions[1]));
return nzsl::ShaderBuilder::ConditionalExpression(nzsl::ShaderBuilder::Identifier(optionEntry.name), std::move(expressions[0]), std::move(expressions[1]));
}
QString ConditionalExpression::caption() const

2
src/ShaderNode/DataModels/ConditionalExpression.hpp
View File

@@ -15,7 +15,7 @@ class ConditionalExpression : public ShaderNode
ConditionalExpression(ShaderGraph& graph);
~ConditionalExpression() = default;
Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
void BuildNodeEdition(QFormLayout* layout) override;
QString caption() const override;

8
src/ShaderNode/DataModels/Discard.cpp
View File

@@ -1,5 +1,5 @@
#include <ShaderNode/DataModels/Discard.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <NZSL/ShaderBuilder.hpp>
#include <ShaderNode/ShaderGraph.hpp>
#include <ShaderNode/DataTypes/BoolData.hpp>
#include <ShaderNode/DataTypes/FloatData.hpp>
@@ -16,14 +16,14 @@ ShaderNode(graph)
DisableCustomVariableName();
}
Nz::ShaderAst::NodePtr Discard::BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
nzsl::Ast::NodePtr Discard::BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
{
assert(count == 1);
assert(outputIndex == 0);
using namespace Nz;
using namespace nzsl;
auto condition = ShaderBuilder::Binary(ShaderAst::BinaryType::CompEq, std::move(expressions[0]), ShaderBuilder::Constant(true));
auto condition = ShaderBuilder::Binary(nzsl::Ast::BinaryType::CompEq, std::move(expressions[0]), ShaderBuilder::Constant(true));
return ShaderBuilder::Branch(std::move(condition), ShaderBuilder::Discard());
}

2
src/ShaderNode/DataModels/Discard.hpp
View File

@@ -14,7 +14,7 @@ class Discard : public ShaderNode
public:
Discard(ShaderGraph& graph);
Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
int GetOutputOrder() const;
QString caption() const override { return "Discard"; }

8
src/ShaderNode/DataModels/FloatValue.cpp
View File

@@ -1,6 +1,6 @@
#include <ShaderNode/DataModels/FloatValue.hpp>
#include <ShaderNode/DataTypes/FloatData.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <NZSL/ShaderBuilder.hpp>
#include <cassert>
FloatValue::FloatValue(ShaderGraph& graph) :
@@ -50,7 +50,7 @@ std::shared_ptr<QtNodes::NodeData> FloatValue::outData(QtNodes::PortIndex port)
assert(port == 0);
auto out = std::make_shared<FloatData>();
out->preview(0, 0) = Nz::Vector4f(m_value, m_value, m_value, 1.f);
out->preview(0, 0) = nzsl::Vector4f(m_value, m_value, m_value, 1.f);
return out;
}
@@ -89,12 +89,12 @@ void FloatValue::BuildNodeEdition(QFormLayout* layout)
layout->addRow(tr("Value"), spinbox);
}
Nz::ShaderAst::NodePtr FloatValue::BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
nzsl::Ast::NodePtr FloatValue::BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
{
assert(count == 0);
assert(outputIndex == 0);
return Nz::ShaderBuilder::Constant(m_value);
return nzsl::ShaderBuilder::Constant(m_value);
}
bool FloatValue::ComputePreview(QPixmap& pixmap)

2
src/ShaderNode/DataModels/FloatValue.hpp
View File

@@ -17,7 +17,7 @@ class FloatValue : public ShaderNode
FloatValue(ShaderGraph& graph);
~FloatValue() = default;
Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
void BuildNodeEdition(QFormLayout* layout) override;
QString caption() const override;

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

@@ -4,7 +4,7 @@
#include <ShaderNode/DataTypes/FloatData.hpp>
#include <ShaderNode/DataTypes/Matrix4Data.hpp>
#include <ShaderNode/DataTypes/VecData.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <NZSL/ShaderBuilder.hpp>
#include <QtWidgets/QFormLayout>
InputValue::InputValue(ShaderGraph& graph) :
@@ -109,7 +109,7 @@ void InputValue::BuildNodeEdition(QFormLayout* layout)
layout->addRow(tr("Input"), inputSelection);
}
Nz::ShaderAst::NodePtr InputValue::BuildNode(Nz::ShaderAst::ExpressionPtr* /*expressions*/, std::size_t count, std::size_t outputIndex) const
nzsl::Ast::NodePtr InputValue::BuildNode(nzsl::Ast::ExpressionPtr* /*expressions*/, std::size_t count, std::size_t outputIndex) const
{
assert(count == 0);
assert(outputIndex == 0);
@@ -118,7 +118,7 @@ Nz::ShaderAst::NodePtr InputValue::BuildNode(Nz::ShaderAst::ExpressionPtr* /*exp
throw std::runtime_error("no input");
const auto& inputEntry = GetGraph().GetInput(*m_currentInputIndex);
return Nz::ShaderBuilder::AccessMember(Nz::ShaderBuilder::Identifier("input"), { inputEntry.name });
return nzsl::ShaderBuilder::AccessMember(nzsl::ShaderBuilder::Identifier("input"), { inputEntry.name });
}
auto InputValue::dataType(QtNodes::PortType portType, QtNodes::PortIndex portIndex) const -> QtNodes::NodeDataType

2
src/ShaderNode/DataModels/InputValue.hpp
View File

@@ -19,7 +19,7 @@ class InputValue : public ShaderNode
void BuildNodeEdition(QFormLayout* layout) override;
Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
QString caption() const override { return "Input"; }
QString name() const override { return "Input"; }

16
src/ShaderNode/DataModels/Mat4BinOp.hpp
View File

@@ -6,14 +6,14 @@
#include <ShaderNode/DataModels/ShaderNode.hpp>
#include <ShaderNode/DataTypes/Matrix4Data.hpp>
template<Nz::ShaderAst::BinaryType Op>
template<nzsl::Ast::BinaryType Op>
class Mat4BinOp : public ShaderNode
{
public:
Mat4BinOp(ShaderGraph& graph);
~Mat4BinOp() = default;
Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const;
nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const;
unsigned int nPorts(QtNodes::PortType portType) const override;
@@ -35,28 +35,28 @@ class Mat4BinOp : public ShaderNode
std::shared_ptr<Matrix4Data> m_output;
};
class Mat4Add : public Mat4BinOp<Nz::ShaderAst::BinaryType::Add>
class Mat4Add : public Mat4BinOp<nzsl::Ast::BinaryType::Add>
{
public:
using Mat4BinOp<Nz::ShaderAst::BinaryType::Add>::Mat4BinOp;
using Mat4BinOp<nzsl::Ast::BinaryType::Add>::Mat4BinOp;
QString caption() const override;
QString name() const override;
};
class Mat4Mul : public Mat4BinOp<Nz::ShaderAst::BinaryType::Multiply>
class Mat4Mul : public Mat4BinOp<nzsl::Ast::BinaryType::Multiply>
{
public:
using Mat4BinOp<Nz::ShaderAst::BinaryType::Multiply>::Mat4BinOp;
using Mat4BinOp<nzsl::Ast::BinaryType::Multiply>::Mat4BinOp;
QString caption() const override;
QString name() const override;
};
class Mat4Sub : public Mat4BinOp<Nz::ShaderAst::BinaryType::Subtract>
class Mat4Sub : public Mat4BinOp<nzsl::Ast::BinaryType::Subtract>
{
public:
using Mat4BinOp<Nz::ShaderAst::BinaryType::Subtract>::Mat4BinOp;
using Mat4BinOp<nzsl::Ast::BinaryType::Subtract>::Mat4BinOp;
QString caption() const override;
QString name() const override;

26
src/ShaderNode/DataModels/Mat4BinOp.inl
View File

@@ -1,23 +1,23 @@
#include <ShaderNode/DataModels/Mat4BinOp.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <NZSL/ShaderBuilder.hpp>
template<Nz::ShaderAst::BinaryType Op>
template<nzsl::Ast::BinaryType Op>
Mat4BinOp<Op>::Mat4BinOp(ShaderGraph& graph) :
ShaderNode(graph)
{
UpdateOutput();
}
template<Nz::ShaderAst::BinaryType Op>
Nz::ShaderAst::NodePtr Mat4BinOp<Op>::BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
template<nzsl::Ast::BinaryType Op>
nzsl::Ast::NodePtr Mat4BinOp<Op>::BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
{
assert(count == 2);
assert(outputIndex == 0);
return Nz::ShaderBuilder::Binary(Op, std::move(expressions[0]), std::move(expressions[1]));
return nzsl::ShaderBuilder::Binary(Op, std::move(expressions[0]), std::move(expressions[1]));
}
template<Nz::ShaderAst::BinaryType Op>
template<nzsl::Ast::BinaryType Op>
QtNodes::NodeDataType Mat4BinOp<Op>::dataType(QtNodes::PortType /*portType*/, QtNodes::PortIndex portIndex) const
{
assert(portIndex == 0 || portIndex == 1);
@@ -25,7 +25,7 @@ QtNodes::NodeDataType Mat4BinOp<Op>::dataType(QtNodes::PortType /*portType*/, Qt
return Matrix4Data::Type();
}
template<Nz::ShaderAst::BinaryType Op>
template<nzsl::Ast::BinaryType Op>
unsigned int Mat4BinOp<Op>::nPorts(QtNodes::PortType portType) const
{
switch (portType)
@@ -39,14 +39,14 @@ unsigned int Mat4BinOp<Op>::nPorts(QtNodes::PortType portType) const
throw std::runtime_error("invalid port type");
}
template<Nz::ShaderAst::BinaryType Op>
template<nzsl::Ast::BinaryType Op>
std::shared_ptr<QtNodes::NodeData> Mat4BinOp<Op>::outData(QtNodes::PortIndex port)
{
assert(port == 0);
return m_output;
}
template<Nz::ShaderAst::BinaryType Op>
template<nzsl::Ast::BinaryType Op>
void Mat4BinOp<Op>::setInData(std::shared_ptr<QtNodes::NodeData> value, int index)
{
assert(index == 0 || index == 1);
@@ -66,7 +66,7 @@ void Mat4BinOp<Op>::setInData(std::shared_ptr<QtNodes::NodeData> value, int inde
UpdateOutput();
}
template<Nz::ShaderAst::BinaryType Op>
template<nzsl::Ast::BinaryType Op>
QtNodes::NodeValidationState Mat4BinOp<Op>::validationState() const
{
if (!m_lhs || !m_rhs)
@@ -75,7 +75,7 @@ QtNodes::NodeValidationState Mat4BinOp<Op>::validationState() const
return QtNodes::NodeValidationState::Valid;
}
template<Nz::ShaderAst::BinaryType Op>
template<nzsl::Ast::BinaryType Op>
QString Mat4BinOp<Op>::validationMessage() const
{
if (!m_lhs || !m_rhs)
@@ -84,7 +84,7 @@ QString Mat4BinOp<Op>::validationMessage() const
return QString();
}
template<Nz::ShaderAst::BinaryType Op>
template<nzsl::Ast::BinaryType Op>
bool Mat4BinOp<Op>::ComputePreview(QPixmap& pixmap)
{
if (!m_lhs || !m_rhs)
@@ -96,7 +96,7 @@ bool Mat4BinOp<Op>::ComputePreview(QPixmap& pixmap)
//return true;
}
template<Nz::ShaderAst::BinaryType Op>
template<nzsl::Ast::BinaryType Op>
void Mat4BinOp<Op>::UpdateOutput()
{
if (validationState() != QtNodes::NodeValidationState::Valid)

18
src/ShaderNode/DataModels/Mat4VecMul.cpp
View File

@@ -1,6 +1,6 @@
#include <ShaderNode/DataModels/Mat4VecMul.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <Nazara/Shader/Ast/Nodes.hpp>
#include <NZSL/ShaderBuilder.hpp>
#include <NZSL/Ast/Nodes.hpp>
Mat4VecMul::Mat4VecMul(ShaderGraph& graph) :
ShaderNode(graph)
@@ -8,12 +8,12 @@ ShaderNode(graph)
UpdateOutput();
}
Nz::ShaderAst::NodePtr Mat4VecMul::BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
nzsl::Ast::NodePtr Mat4VecMul::BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
{
assert(count == 2);
assert(outputIndex == 0);
return Nz::ShaderBuilder::Binary(Nz::ShaderAst::BinaryType::Multiply, std::move(expressions[0]), std::move(expressions[1]));
return nzsl::ShaderBuilder::Binary(nzsl::Ast::BinaryType::Multiply, std::move(expressions[0]), std::move(expressions[1]));
}
QString Mat4VecMul::caption() const
@@ -148,13 +148,13 @@ void Mat4VecMul::UpdateOutput()
{
m_output = std::make_shared<VecData>(4);
m_output->preview = PreviewValues(1, 1);
m_output->preview.Fill(Nz::Vector4f::Zero());
m_output->preview.Fill(nzsl::Vector4f(0.f, 0.f, 0.f, 0.f));
return;
}
m_output = std::make_shared<VecData>(4);
m_output->preview = PreviewValues(1, 1);
m_output->preview.Fill(Nz::Vector4f::Zero());
m_output->preview.Fill(nzsl::Vector4f(0.f, 0.f, 0.f, 0.f));
/*m_output = std::make_shared<VecData>(m_rhs->componentCount);
@@ -174,9 +174,9 @@ void Mat4VecMul::UpdateOutput()
m_output->preview = PreviewValues(maxWidth, maxHeight);
const Nz::Vector4f* left = leftResized.GetData();
const Nz::Vector4f* right = rightPreview.GetData();
Nz::Vector4f* output = m_output->preview.GetData();
const nzsl::Vector4f* left = leftResized.GetData();
const nzsl::Vector4f* right = rightPreview.GetData();
nzsl::Vector4f* output = m_output->preview.GetData();
std::size_t pixelCount = maxWidth * maxHeight;
for (std::size_t i = 0; i < pixelCount; ++i)

2
src/ShaderNode/DataModels/Mat4VecMul.hpp
View File

@@ -13,7 +13,7 @@ class Mat4VecMul : public ShaderNode
Mat4VecMul(ShaderGraph& graph);
~Mat4VecMul() = default;
Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
QString caption() const override;
QString name() const override;

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

@@ -1,5 +1,5 @@
#include <ShaderNode/DataModels/OutputValue.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <NZSL/ShaderBuilder.hpp>
#include <ShaderNode/ShaderGraph.hpp>
#include <ShaderNode/DataTypes/BoolData.hpp>
#include <ShaderNode/DataTypes/FloatData.hpp>
@@ -54,7 +54,7 @@ void OutputValue::BuildNodeEdition(QFormLayout* layout)
layout->addRow(tr("Output"), outputSelection);
}
Nz::ShaderAst::NodePtr OutputValue::BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
nzsl::Ast::NodePtr OutputValue::BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
{
assert(count == 1);
assert(outputIndex == 0);
@@ -63,10 +63,10 @@ Nz::ShaderAst::NodePtr OutputValue::BuildNode(Nz::ShaderAst::ExpressionPtr* expr
throw std::runtime_error("no output");
const auto& outputEntry = GetGraph().GetOutput(*m_currentOutputIndex);
auto output = Nz::ShaderBuilder::AccessMember(Nz::ShaderBuilder::Identifier("output"), { outputEntry.name });
auto output = nzsl::ShaderBuilder::AccessMember(nzsl::ShaderBuilder::Identifier("output"), { outputEntry.name });
using namespace Nz;
return Nz::ShaderBuilder::Assign(ShaderAst::AssignType::Simple, std::move(output), std::move(expressions[0]));
return nzsl::ShaderBuilder::Assign(nzsl::Ast::AssignType::Simple, std::move(output), std::move(expressions[0]));
}
std::shared_ptr<QtNodes::NodeData> OutputValue::outData(QtNodes::PortIndex /*port*/)

2
src/ShaderNode/DataModels/OutputValue.hpp
View File

@@ -16,7 +16,7 @@ class OutputValue : public ShaderNode
void BuildNodeEdition(QFormLayout* layout) override;
Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
QString caption() const override { return "Output"; }
QString name() const override { return "Output"; }

8
src/ShaderNode/DataModels/PositionOutputValue.cpp
View File

@@ -1,5 +1,5 @@
#include <ShaderNode/DataModels/PositionOutputValue.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <NZSL/ShaderBuilder.hpp>
#include <ShaderNode/ShaderGraph.hpp>
#include <ShaderNode/DataTypes/BoolData.hpp>
#include <ShaderNode/DataTypes/FloatData.hpp>
@@ -14,15 +14,15 @@ ShaderNode(graph)
DisableCustomVariableName();
}
Nz::ShaderAst::NodePtr PositionOutputValue::BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
nzsl::Ast::NodePtr PositionOutputValue::BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
{
using namespace Nz;
assert(count == 1);
assert(outputIndex == 0);
auto output = Nz::ShaderBuilder::AccessMember(Nz::ShaderBuilder::Identifier("output"), { "position" });
return ShaderBuilder::Assign(ShaderAst::AssignType::Simple, std::move(output), std::move(expressions[0]));
auto output = nzsl::ShaderBuilder::AccessMember(nzsl::ShaderBuilder::Identifier("output"), { "position" });
return nzsl::ShaderBuilder::Assign(nzsl::Ast::AssignType::Simple, std::move(output), std::move(expressions[0]));
}
QtNodes::NodeDataType PositionOutputValue::dataType(QtNodes::PortType portType, QtNodes::PortIndex portIndex) const

2
src/ShaderNode/DataModels/PositionOutputValue.hpp
View File

@@ -14,7 +14,7 @@ class PositionOutputValue : public ShaderNode
public:
PositionOutputValue(ShaderGraph& graph);
Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
QString caption() const override { return "PositionOutputValue"; }
QString name() const override { return "PositionOutputValue"; }

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

@@ -1,6 +1,6 @@
#include <ShaderNode/ShaderGraph.hpp>
#include <ShaderNode/DataModels/SampleTexture.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <NZSL/ShaderBuilder.hpp>
SampleTexture::SampleTexture(ShaderGraph& graph) :
ShaderNode(graph)
@@ -28,7 +28,7 @@ void SampleTexture::UpdateOutput()
if (!m_texture || !m_uv)
{
output = PreviewValues(1, 1);
output.Fill(Nz::Vector4f::Zero());
output.Fill(nzsl::Vector4f(0.f, 0.f, 0.f, 0.f));
return;
}
@@ -48,12 +48,12 @@ void SampleTexture::UpdateOutput()
{
for (std::size_t x = 0; x < uvWidth; ++x)
{
Nz::Vector4f uvValue = uv(x, y);
nzsl::Vector4f uvValue = uv(x, y);
if (textureWidth > 0 && textureHeight > 0)
output(x, y) = texturePreview.Sample(uvValue.x, uvValue.y);
output(x, y) = texturePreview.Sample(uvValue.x(), uvValue.y());
else
output(x, y) = Nz::Vector4f(0.f, 0.f, 0.f, 1.f);
output(x, y) = nzsl::Vector4f(0.f, 0.f, 0.f, 1.f);
}
}
@@ -71,18 +71,18 @@ bool SampleTexture::ComputePreview(QPixmap& pixmap)
return true;
}
Nz::ShaderAst::NodePtr SampleTexture::BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
nzsl::Ast::NodePtr SampleTexture::BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
{
assert(m_texture);
assert(m_uv);
assert(count == 2);
assert(outputIndex == 0);
std::vector<Nz::ShaderAst::ExpressionPtr> params;
std::vector<nzsl::Ast::ExpressionPtr> params;
params.push_back(std::move(expressions[0]));
params.push_back(std::move(expressions[1]));
return Nz::ShaderBuilder::Intrinsic(Nz::ShaderAst::IntrinsicType::SampleTexture, std::move(params));
return nzsl::ShaderBuilder::Intrinsic(nzsl::Ast::IntrinsicType::SampleTexture, std::move(params));
}
auto SampleTexture::dataType(QtNodes::PortType portType, QtNodes::PortIndex portIndex) const -> QtNodes::NodeDataType

2
src/ShaderNode/DataModels/SampleTexture.hpp
View File

@@ -17,7 +17,7 @@ class SampleTexture : public ShaderNode
SampleTexture(ShaderGraph& graph);
~SampleTexture() = default;
Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
QString caption() const override { return "Sample texture"; }
QString name() const override { return "SampleTexture"; }

4
src/ShaderNode/DataModels/ShaderNode.hpp
View File

@@ -4,7 +4,7 @@
#define NAZARA_SHADERNODES_SHADERNODE_HPP
#include <Nazara/Math/Vector2.hpp>
#include <Nazara/Shader/Ast/Nodes.hpp>
#include <NZSL/Ast/Nodes.hpp>
#include <nodes/NodeDataModel>
#include <QtGui/QPixmap>
#include <optional>
@@ -18,7 +18,7 @@ class ShaderNode : public QtNodes::NodeDataModel
public:
ShaderNode(ShaderGraph& graph);
virtual Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const = 0;
virtual nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const = 0;
virtual void BuildNodeEdition(QFormLayout* layout);
inline void DisablePreview();

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

@@ -2,7 +2,7 @@
#include <ShaderNode/ShaderGraph.hpp>
#include <ShaderNode/DataTypes/TextureData.hpp>
#include <ShaderNode/DataTypes/VecData.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <NZSL/ShaderBuilder.hpp>
#include <QtWidgets/QFormLayout>
TextureValue::TextureValue(ShaderGraph& graph) :
@@ -110,7 +110,7 @@ void TextureValue::BuildNodeEdition(QFormLayout* layout)
layout->addRow(tr("Texture"), textureSelection);
}
Nz::ShaderAst::NodePtr TextureValue::BuildNode(Nz::ShaderAst::ExpressionPtr* /*expressions*/, std::size_t count, std::size_t outputIndex) const
nzsl::Ast::NodePtr TextureValue::BuildNode(nzsl::Ast::ExpressionPtr* /*expressions*/, std::size_t count, std::size_t outputIndex) const
{
if (!m_currentTextureIndex)
throw std::runtime_error("invalid texture input");
@@ -119,7 +119,7 @@ Nz::ShaderAst::NodePtr TextureValue::BuildNode(Nz::ShaderAst::ExpressionPtr* /*e
assert(outputIndex == 0);
const auto& textureEntry = GetGraph().GetTexture(*m_currentTextureIndex);
return Nz::ShaderBuilder::Identifier(textureEntry.name);
return nzsl::ShaderBuilder::Identifier(textureEntry.name);
}
auto TextureValue::dataType(QtNodes::PortType portType, QtNodes::PortIndex portIndex) const -> QtNodes::NodeDataType
@@ -160,7 +160,7 @@ std::shared_ptr<QtNodes::NodeData> TextureValue::outData(QtNodes::PortIndex port
{
QColor pixelColor = previewImage.pixelColor(int(x), int(y));
textureData->preview(x, y) = Nz::Vector4f(pixelColor.redF(), pixelColor.greenF(), pixelColor.blueF(), pixelColor.alphaF());
textureData->preview(x, y) = nzsl::Vector4f(pixelColor.redF(), pixelColor.greenF(), pixelColor.blueF(), pixelColor.alphaF());
}
}

2
src/ShaderNode/DataModels/TextureValue.hpp
View File

@@ -18,7 +18,7 @@ class TextureValue : public ShaderNode
void BuildNodeEdition(QFormLayout* layout) override;
Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
QString caption() const override { return "Texture"; }
QString name() const override { return "Texture"; }

2
src/ShaderNode/DataModels/VecComposition.hpp
View File

@@ -17,7 +17,7 @@ class VecComposition : public ShaderNode
VecComposition(ShaderGraph& graph);
~VecComposition() = default;
Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
QString caption() const override;
QString name() const override;

12
src/ShaderNode/DataModels/VecComposition.inl
View File

@@ -1,5 +1,5 @@
#include <ShaderNode/DataModels/VecComposition.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <NZSL/ShaderBuilder.hpp>
#include <QtWidgets/QDoubleSpinBox>
#include <QtWidgets/QFormLayout>
#include <stdexcept>
@@ -14,16 +14,16 @@ ShaderNode(graph)
}
template<std::size_t ComponentCount>
Nz::ShaderAst::NodePtr VecComposition<ComponentCount>::BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
nzsl::Ast::NodePtr VecComposition<ComponentCount>::BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
{
assert(count == ComponentCount);
assert(outputIndex == 0);
std::vector<Nz::ShaderAst::ExpressionPtr> params;
std::vector<nzsl::Ast::ExpressionPtr> params;
for (std::size_t i = 0; i < count; ++i)
params.emplace_back(std::move(expressions[i]));
return Nz::ShaderBuilder::Cast(Nz::ShaderAst::ExpressionType{ Nz::ShaderAst::VectorType{ ComponentCount, Nz::ShaderAst::PrimitiveType::Float32 } }, std::move(params));
return nzsl::ShaderBuilder::Cast(nzsl::Ast::ExpressionType{ nzsl::Ast::VectorType{ ComponentCount, nzsl::Ast::PrimitiveType::Float32 } }, std::move(params));
}
template<std::size_t ComponentCount>
@@ -147,7 +147,7 @@ void VecComposition<ComponentCount>::UpdateOutput()
if (validationState() != QtNodes::NodeValidationState::Valid)
{
m_output->preview = PreviewValues(1, 1);
m_output->preview(0, 0) = Nz::Vector4f::Zero();
m_output->preview(0, 0) = nzsl::Vector4f(0.f, 0.f, 0.f, 0.f);
return;
}
@@ -177,7 +177,7 @@ void VecComposition<ComponentCount>::UpdateOutput()
{
for (std::size_t x = 0; x < maxInputWidth; ++x)
{
Nz::Vector4f color(0.f, 0.f, 0.f, 1.f);
nzsl::Vector4f color(0.f, 0.f, 0.f, 1.f);
for (std::size_t i = 0; i < ComponentCount; ++i)
color[i] = previewResized[i](x, y)[0];

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

@@ -1,5 +1,5 @@
#include <ShaderNode/DataModels/VecDecomposition.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <NZSL/ShaderBuilder.hpp>
#include <ShaderNode/ShaderGraph.hpp>
#include <ShaderNode/DataTypes/BoolData.hpp>
#include <ShaderNode/DataTypes/FloatData.hpp>
@@ -16,12 +16,12 @@ ShaderNode(graph)
DisableCustomVariableName();
}
Nz::ShaderAst::NodePtr VecDecomposition::BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
nzsl::Ast::NodePtr VecDecomposition::BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
{
assert(count == 1);
assert(outputIndex < m_outputs.size());
return Nz::ShaderBuilder::Swizzle(std::move(expressions[0]), { Nz::SafeCast<Nz::UInt32>(outputIndex) });
return nzsl::ShaderBuilder::Swizzle(std::move(expressions[0]), { Nz::SafeCast<Nz::UInt32>(outputIndex) });
}
QString VecDecomposition::caption() const
@@ -139,7 +139,7 @@ void VecDecomposition::UpdateOutputs()
{
auto dummy = std::make_shared<FloatData>();
dummy->preview = PreviewValues(1, 1);
dummy->preview.Fill(Nz::Vector4f::Zero());
dummy->preview.Fill(nzsl::Vector4f(0.f, 0.f, 0.f, 0.f));
m_outputs.fill(dummy);
return;
@@ -154,13 +154,13 @@ void VecDecomposition::UpdateOutputs()
m_outputs[i] = std::make_shared<FloatData>();
m_outputs[i]->preview = PreviewValues(previewWidth, previewHeight);
const Nz::Vector4f* inputData = m_input->preview.GetData();
Nz::Vector4f* outputData = m_outputs[i]->preview.GetData();
const nzsl::Vector4f* inputData = m_input->preview.GetData();
nzsl::Vector4f* outputData = m_outputs[i]->preview.GetData();
for (std::size_t j = 0; j < pixelCount; ++j)
{
const Nz::Vector4f& input = *inputData++;
const nzsl::Vector4f& input = *inputData++;
*outputData++ = Nz::Vector4f(input[i], input[i], input[i], input[i]);
*outputData++ = nzsl::Vector4f(input[i], input[i], input[i], input[i]);
}
Q_EMIT dataUpdated(i);

2
src/ShaderNode/DataModels/VecDecomposition.hpp
View File

@@ -18,7 +18,7 @@ class VecDecomposition : public ShaderNode
VecDecomposition(ShaderGraph& graph);
~VecDecomposition() = default;
Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
QString caption() const override;
QString name() const override;

18
src/ShaderNode/DataModels/VecDot.cpp
View File

@@ -1,6 +1,6 @@
#include <ShaderNode/DataModels/VecDot.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <Nazara/Shader/Ast/Nodes.hpp>
#include <NZSL/ShaderBuilder.hpp>
#include <NZSL/Ast/Nodes.hpp>
VecDot::VecDot(ShaderGraph& graph) :
ShaderNode(graph)
@@ -9,16 +9,16 @@ ShaderNode(graph)
UpdateOutput();
}
Nz::ShaderAst::NodePtr VecDot::BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
nzsl::Ast::NodePtr VecDot::BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
{
assert(count == 2);
assert(outputIndex == 0);
std::vector<Nz::ShaderAst::ExpressionPtr> params;
std::vector<nzsl::Ast::ExpressionPtr> params;
params.push_back(std::move(expressions[0]));
params.push_back(std::move(expressions[1]));
return Nz::ShaderBuilder::Intrinsic(Nz::ShaderAst::IntrinsicType::DotProduct, std::move(params));
return nzsl::ShaderBuilder::Intrinsic(nzsl::Ast::IntrinsicType::DotProduct, std::move(params));
}
QString VecDot::caption() const
@@ -126,7 +126,7 @@ void VecDot::UpdateOutput()
if (validationState() != QtNodes::NodeValidationState::Valid)
{
m_output->preview = PreviewValues(1, 1);
m_output->preview.Fill(Nz::Vector4f::Zero());
m_output->preview.Fill(nzsl::Vector4f(0.f, 0.f, 0.f, 0.f));
return;
}
@@ -146,9 +146,9 @@ void VecDot::UpdateOutput()
m_output->preview = PreviewValues(maxWidth, maxHeight);
const Nz::Vector4f* left = leftResized.GetData();
const Nz::Vector4f* right = rightPreview.GetData();
Nz::Vector4f* output = m_output->preview.GetData();
const nzsl::Vector4f* left = leftResized.GetData();
const nzsl::Vector4f* right = rightPreview.GetData();
nzsl::Vector4f* output = m_output->preview.GetData();
std::size_t pixelCount = maxWidth * maxHeight;
for (std::size_t i = 0; i < pixelCount; ++i)

2
src/ShaderNode/DataModels/VecDot.hpp
View File

@@ -13,7 +13,7 @@ class VecDot : public ShaderNode
VecDot(ShaderGraph& graph);
~VecDot() = default;
Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
QString caption() const override;
QString name() const override;

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

@@ -1,6 +1,6 @@
#include <ShaderNode/DataModels/VecFloatMul.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <Nazara/Shader/Ast/Nodes.hpp>
#include <NZSL/ShaderBuilder.hpp>
#include <NZSL/Ast/Nodes.hpp>
VecFloatMul::VecFloatMul(ShaderGraph& graph) :
ShaderNode(graph)
@@ -8,12 +8,12 @@ ShaderNode(graph)
UpdateOutput();
}
Nz::ShaderAst::NodePtr VecFloatMul::BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
nzsl::Ast::NodePtr VecFloatMul::BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const
{
assert(count == 2);
assert(outputIndex == 0);
return Nz::ShaderBuilder::Binary(Nz::ShaderAst::BinaryType::Multiply, std::move(expressions[0]), std::move(expressions[1]));
return nzsl::ShaderBuilder::Binary(nzsl::Ast::BinaryType::Multiply, std::move(expressions[0]), std::move(expressions[1]));
}
QString VecFloatMul::caption() const
@@ -142,7 +142,7 @@ void VecFloatMul::UpdateOutput()
{
m_output = std::make_shared<VecData>(4);
m_output->preview = PreviewValues(1, 1);
m_output->preview.Fill(Nz::Vector4f::Zero());
m_output->preview.Fill(nzsl::Vector4f(0.f, 0.f, 0.f, 0.f));
return;
}
@@ -164,9 +164,9 @@ void VecFloatMul::UpdateOutput()
m_output->preview = PreviewValues(maxWidth, maxHeight);
const Nz::Vector4f* left = leftResized.GetData();
const Nz::Vector4f* right = rightPreview.GetData();
Nz::Vector4f* output = m_output->preview.GetData();
const nzsl::Vector4f* left = leftResized.GetData();
const nzsl::Vector4f* right = rightPreview.GetData();
nzsl::Vector4f* output = m_output->preview.GetData();
std::size_t pixelCount = maxWidth * maxHeight;
for (std::size_t i = 0; i < pixelCount; ++i)

2
src/ShaderNode/DataModels/VecFloatMul.hpp
View File

@@ -13,7 +13,7 @@ class VecFloatMul : public ShaderNode
VecFloatMul(ShaderGraph& graph);
~VecFloatMul() = default;
Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
QString caption() const override;
QString name() const override;

2
src/ShaderNode/DataModels/VecValue.hpp
View File

@@ -18,7 +18,7 @@ class VecValue : public ShaderNode
VecValue(ShaderGraph& graph);
~VecValue() = default;
Nz::ShaderAst::NodePtr BuildNode(Nz::ShaderAst::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
nzsl::Ast::NodePtr BuildNode(nzsl::Ast::ExpressionPtr* expressions, std::size_t count, std::size_t outputIndex) const override;
void BuildNodeEdition(QFormLayout* layout) override;
QString caption() const override;

14
src/ShaderNode/DataModels/VecValue.inl
View File

@@ -1,6 +1,6 @@
#include <ShaderNode/DataModels/VecValue.hpp>
#include <Nazara/Core/Algorithm.hpp>
#include <Nazara/Shader/ShaderBuilder.hpp>
#include <NZSL/ShaderBuilder.hpp>
#include <ShaderNode/DataTypes/VecData.hpp>
#include <QtCore/QJsonArray>
#include <array>
@@ -12,12 +12,8 @@ ShaderNode(graph)
{
static_assert(ComponentCount <= s_vectorComponents.size());
std::array<float, ComponentCount> defaultValues;
for (std::size_t i = 0; i < ComponentCount; ++i)
defaultValues[i] = (i == 3) ? 1.f : 0.f;
m_value.Set(defaultValues.data());
m_value[i] = (i == 3) ? 1.f : 0.f;
UpdatePreview();
}
@@ -70,7 +66,7 @@ std::shared_ptr<QtNodes::NodeData> VecValue<ComponentCount>::outData(QtNodes::Po
values[i] = m_value[i];
out->preview = PreviewValues(1, 1);
out->preview(0, 0) = Nz::Vector4f(values[0], values[1], values[2], values[3]);
out->preview(0, 0) = nzsl::Vector4f(values[0], values[1], values[2], values[3]);
return out;
}
@@ -127,12 +123,12 @@ void VecValue<ComponentCount>::BuildNodeEdition(QFormLayout* layout)
}
template<std::size_t ComponentCount>
Nz::ShaderAst::NodePtr VecValue<ComponentCount>::BuildNode(Nz::ShaderAst::ExpressionPtr* /*expressions*/, std::size_t count, std::size_t outputIndex) const
nzsl::Ast::NodePtr VecValue<ComponentCount>::BuildNode(nzsl::Ast::ExpressionPtr* /*expressions*/, std::size_t count, std::size_t outputIndex) const
{
assert(count == 0);
assert(outputIndex == 0);
return Nz::ShaderBuilder::Constant(m_value);
return nzsl::ShaderBuilder::Constant(m_value);
}
template<std::size_t ComponentCount>

2
src/ShaderNode/DataTypes/BoolData.inl
View File

@@ -3,5 +3,5 @@
inline BoolData::BoolData() :
preview(1, 1)
{
preview(0, 0) = Nz::Vector4f(1.f, 1.f, 1.f, 0.f);
preview(0, 0) = nzsl::Vector4f(1.f, 1.f, 1.f, 0.f);
}

2
src/ShaderNode/DataTypes/FloatData.inl
View File

@@ -3,5 +3,5 @@
inline FloatData::FloatData() :
preview(1, 1)
{
preview(0, 0) = Nz::Vector4f(1.f, 1.f, 1.f, 0.f);
preview(0, 0) = nzsl::Vector4f(1.f, 1.f, 1.f, 0.f);
}

2
src/ShaderNode/DataTypes/Matrix4Data.hpp
View File

@@ -3,7 +3,7 @@
#ifndef NAZARA_SHADERNODES_MATRIXDATA_HPP
#define NAZARA_SHADERNODES_MATRIXDATA_HPP
#include <Nazara/Shader/Ast/Nodes.hpp>
#include <NZSL/Ast/Nodes.hpp>
#include <ShaderNode/Previews/PreviewValues.hpp>
#include <nodes/NodeData>

2
src/ShaderNode/DataTypes/TextureData.hpp
View File

@@ -4,7 +4,7 @@
#define NAZARA_SHADERNODES_TEXTUREDATA_HPP
#include <ShaderNode/Previews/PreviewValues.hpp>
#include <Nazara/Shader/Ast/Nodes.hpp>
#include <NZSL/Ast/Nodes.hpp>
#include <nodes/NodeData>
struct TextureData : public QtNodes::NodeData

2
src/ShaderNode/DataTypes/TextureData.inl
View File

@@ -3,5 +3,5 @@
inline TextureData::TextureData() :
preview(64, 64)
{
preview.Fill(Nz::Vector4f(1.f, 1.f, 1.f, 0.f));
preview.Fill(nzsl::Vector4f(1.f, 1.f, 1.f, 0.f));
}

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

@@ -3,8 +3,11 @@
#ifndef NAZARA_SHADERNODES_VECDATA_HPP
#define NAZARA_SHADERNODES_VECDATA_HPP
#include <Nazara/Shader/Ast/Nodes.hpp>
#include <Nazara/Math/Vector2.hpp>
#include <Nazara/Math/Vector3.hpp>
#include <Nazara/Math/Vector4.hpp>
#include <ShaderNode/Previews/PreviewValues.hpp>
#include <NZSL/Ast/Nodes.hpp>
#include <nodes/NodeData>
struct VecData : public QtNodes::NodeData
@@ -19,43 +22,7 @@ struct VecData : public QtNodes::NodeData
PreviewValues preview;
};
struct VecTypeDummy {};
template<std::size_t N>
struct VecTypeHelper;
template<>
struct VecTypeHelper<0>
{
using Type = VecTypeDummy;
};
template<>
struct VecTypeHelper<1>
{
using Type = std::array<float, 1>; //< To allow [0]
};
template<>
struct VecTypeHelper<2>
{
using Type = Nz::Vector2f;
};
template<>
struct VecTypeHelper<3>
{
using Type = Nz::Vector3f;
};
template<>
struct VecTypeHelper<4>
{
using Type = Nz::Vector4f;
};
template<std::size_t N> using VecType = typename VecTypeHelper<N>::Type;
template<std::size_t N> using VecType = nzsl::Vector<float, N>;
constexpr std::array<char, 4> s_vectorComponents = { 'X', 'Y', 'Z', 'W' };

2
src/ShaderNode/DataTypes/VecData.inl
View File

@@ -4,7 +4,7 @@ inline VecData::VecData(std::size_t ComponentCount) :
componentCount(ComponentCount),
preview(64, 64)
{
preview.Fill(Nz::Vector4f(1.f, 1.f, 1.f, 0.f));
preview.Fill(nzsl::Vector4f(1.f, 1.f, 1.f, 0.f));
}
inline QtNodes::NodeDataType VecData::type() const

20
src/ShaderNode/Previews/PreviewValues.cpp
View File

@@ -13,7 +13,7 @@ m_width(width)
m_values.resize(m_width * m_height); //< RGBA
}
void PreviewValues::Fill(const Nz::Vector4f& value)
void PreviewValues::Fill(const nzsl::Vector4f& value)
{
std::fill(m_values.begin(), m_values.end(), value);
}
@@ -24,7 +24,7 @@ QImage PreviewValues::GenerateImage() const
Nz::UInt8* ptr = preview.bits();
const Nz::Vector4f* src = m_values.data();
const nzsl::Vector4f* src = m_values.data();
for (std::size_t i = 0; i < m_values.size(); ++i)
{
for (std::size_t y = 0; y < 4; ++y)
@@ -52,7 +52,7 @@ PreviewValues PreviewValues::Resized(std::size_t newWidth, std::size_t newHeight
return resizedPreview;
}
Nz::Vector4f PreviewValues::Sample(float u, float v) const
nzsl::Vector4f PreviewValues::Sample(float u, float v) const
{
// Bilinear filtering
float x = std::clamp(u * m_width, 0.f, m_width - 1.f);
@@ -64,7 +64,7 @@ Nz::Vector4f PreviewValues::Sample(float u, float v) const
float dX = x - iX;
float dY = y - iY;
auto ColorAt = [&](std::size_t x, std::size_t y) -> Nz::Vector4f
auto ColorAt = [&](std::size_t x, std::size_t y) -> nzsl::Vector4f
{
x = std::min(x, m_width - 1);
y = std::min(y, m_height - 1);
@@ -72,22 +72,22 @@ Nz::Vector4f PreviewValues::Sample(float u, float v) const
return m_values[y * m_width + x];
};
Nz::Vector4f d00 = ColorAt(iX, iY);
Nz::Vector4f d10 = ColorAt(iX + 1, iY);
Nz::Vector4f d01 = ColorAt(iX, iY + 1);
Nz::Vector4f d11 = ColorAt(iX + 1, iY + 1);
nzsl::Vector4f d00 = ColorAt(iX, iY);
nzsl::Vector4f d10 = ColorAt(iX + 1, iY);
nzsl::Vector4f d01 = ColorAt(iX, iY + 1);
nzsl::Vector4f d11 = ColorAt(iX + 1, iY + 1);
return Nz::Lerp(Nz::Lerp(d00, d10, dX), Nz::Lerp(d01, d11, dX), dY);
}
Nz::Vector4f& PreviewValues::operator()(std::size_t x, std::size_t y)
nzsl::Vector4f& PreviewValues::operator()(std::size_t x, std::size_t y)
{
assert(x < m_width);
assert(y < m_height);
return m_values[y * m_width + x];
}
Nz::Vector4f PreviewValues::operator()(std::size_t x, std::size_t y) const
nzsl::Vector4f PreviewValues::operator()(std::size_t x, std::size_t y) const
{
assert(x < m_width);
assert(y < m_height);

16
src/ShaderNode/Previews/PreviewValues.hpp
View File

@@ -4,8 +4,8 @@
#define NAZARA_SHADERNODES_PREVIEWVALUES_HPP
#include <Nazara/Prerequisites.hpp>
#include <Nazara/Math/Vector4.hpp>
#include <ShaderNode/Enums.hpp>
#include <NZSL/Vector.hpp>
#include <array>
#include <vector>
@@ -20,21 +20,21 @@ class PreviewValues
PreviewValues(PreviewValues&&) = default;
~PreviewValues() = default;
void Fill(const Nz::Vector4f& value);
void Fill(const nzsl::Vector4f& value);
QImage GenerateImage() const;
inline Nz::Vector4f* GetData();
inline const Nz::Vector4f* GetData() const;
inline nzsl::Vector4f* GetData();
inline const nzsl::Vector4f* GetData() const;
inline std::size_t GetHeight() const;
inline std::size_t GetWidth() const;
PreviewValues Resized(std::size_t newWidth, std::size_t newHeight) const;
Nz::Vector4f Sample(float u, float v) const;
nzsl::Vector4f Sample(float u, float v) const;
Nz::Vector4f& operator()(std::size_t x, std::size_t y);
Nz::Vector4f operator()(std::size_t x, std::size_t y) const;
nzsl::Vector4f& operator()(std::size_t x, std::size_t y);
nzsl::Vector4f operator()(std::size_t x, std::size_t y) const;
PreviewValues& operator=(const PreviewValues&) = default;
PreviewValues& operator=(PreviewValues&&) = default;
@@ -42,7 +42,7 @@ class PreviewValues
private:
std::size_t m_height;
std::size_t m_width;
std::vector<Nz::Vector4f> m_values;
std::vector<nzsl::Vector4f> m_values;
};
#include <ShaderNode/Previews/PreviewValues.inl>

4
src/ShaderNode/Previews/PreviewValues.inl
View File

@@ -1,11 +1,11 @@
#include <ShaderNode/Previews/PreviewValues.hpp>
inline Nz::Vector4f* PreviewValues::GetData()
inline nzsl::Vector4f* PreviewValues::GetData()
{
return m_values.data();
}
inline const Nz::Vector4f* PreviewValues::GetData() const
inline const nzsl::Vector4f* PreviewValues::GetData() const
{
return m_values.data();
}

4
src/ShaderNode/Previews/QuadPreview.cpp
View File

@@ -6,7 +6,7 @@ PreviewValues QuadPreview::GetPreview(InputRole role, std::size_t roleIndex) con
if (role != InputRole::TexCoord)
{
PreviewValues dummy(1, 1);
dummy(0, 0) = Nz::Vector4f::Zero();
dummy(0, 0) = nzsl::Vector4f(0.f, 0.f, 0.f, 0.f);
return dummy;
}
@@ -19,7 +19,7 @@ PreviewValues QuadPreview::GetPreview(InputRole role, std::size_t roleIndex) con
for (std::size_t y = 0; y < uv.GetHeight(); ++y)
{
for (std::size_t x = 0; x < uv.GetWidth(); ++x)
uv(x, y) = Nz::Vector4f(x * invWidth, y * invHeight, 0.f, 1.f);
uv(x, y) = nzsl::Vector4f(x * invWidth, y * invHeight, 0.f, 1.f);
}
return uv;

120
src/ShaderNode/ShaderGraph.cpp
View File

@@ -1,9 +1,9 @@
#include <ShaderNode/ShaderGraph.hpp>
#include <Nazara/Core/Algorithm.hpp>
#include <Nazara/Core/StackArray.hpp>
#include <Nazara/Shader/Ast/AstCloner.hpp>
#include <Nazara/Shader/Ast/AstUtils.hpp>
#include <Nazara/Shader/Ast/ExpressionType.hpp>
#include <Nazara/Utils/StackArray.hpp>
#include <NZSL/Ast/Cloner.hpp>
#include <NZSL/Ast/Utils.hpp>
#include <NZSL/Ast/ExpressionType.hpp>
#include <ShaderNode/DataModels/BinOp.hpp>
#include <ShaderNode/DataModels/BoolValue.hpp>
#include <ShaderNode/DataModels/BufferField.hpp>
@@ -452,19 +452,19 @@ QJsonObject ShaderGraph::Save()
return sceneJson;
}
Nz::ShaderAst::ModulePtr ShaderGraph::ToModule() const
nzsl::Ast::ModulePtr ShaderGraph::ToModule() const
{
Nz::ShaderAst::ModulePtr shaderModule = std::make_shared<Nz::ShaderAst::Module>(100);
nzsl::Ast::ModulePtr shaderModule = std::make_shared<nzsl::Ast::Module>(100);
// Declare all options
for (const auto& option : m_options)
shaderModule->rootNode->statements.push_back(Nz::ShaderBuilder::DeclareOption(option.name, Nz::ShaderAst::ExpressionType{ Nz::ShaderAst::PrimitiveType::Boolean }));
shaderModule->rootNode->statements.push_back(nzsl::ShaderBuilder::DeclareOption(option.name, nzsl::Ast::ExpressionType{ nzsl::Ast::PrimitiveType::Boolean }));
// Declare all structures
for (const auto& structInfo : m_structs)
{
Nz::ShaderAst::StructDescription structDesc;
structDesc.layout = Nz::StructLayout::Std140;
nzsl::Ast::StructDescription structDesc;
structDesc.layout = nzsl::StructLayout::Std140;
structDesc.name = structInfo.name;
for (const auto& memberInfo : structInfo.members)
@@ -474,11 +474,11 @@ Nz::ShaderAst::ModulePtr ShaderGraph::ToModule() const
structMember.type = ToShaderExpressionType(memberInfo.type);
}
shaderModule->rootNode->statements.push_back(Nz::ShaderBuilder::DeclareStruct(std::move(structDesc), false));
shaderModule->rootNode->statements.push_back(nzsl::ShaderBuilder::DeclareStruct(std::move(structDesc), false));
}
// External block
auto external = std::make_unique<Nz::ShaderAst::DeclareExternalStatement>();
auto external = std::make_unique<nzsl::Ast::DeclareExternalStatement>();
for (const auto& buffer : m_buffers)
{
@@ -491,7 +491,7 @@ Nz::ShaderAst::ModulePtr ShaderGraph::ToModule() const
extVar.bindingIndex = buffer.bindingIndex;
extVar.bindingSet = buffer.setIndex;
extVar.name = buffer.name;
extVar.type = Nz::ShaderAst::ExpressionPtr{ Nz::ShaderBuilder::Identifier(structInfo.name) };
extVar.type = nzsl::Ast::ExpressionPtr{ nzsl::ShaderBuilder::Identifier(structInfo.name) };
}
for (const auto& texture : m_textures)
@@ -509,7 +509,7 @@ Nz::ShaderAst::ModulePtr ShaderGraph::ToModule() const
// Inputs / outputs
if (!m_inputs.empty())
{
Nz::ShaderAst::StructDescription structDesc;
nzsl::Ast::StructDescription structDesc;
structDesc.name = "InputData";
for (const auto& input : m_inputs)
@@ -520,12 +520,12 @@ Nz::ShaderAst::ModulePtr ShaderGraph::ToModule() const
structMember.locationIndex = input.locationIndex;
}
shaderModule->rootNode->statements.push_back(Nz::ShaderBuilder::DeclareStruct(std::move(structDesc), false));
shaderModule->rootNode->statements.push_back(nzsl::ShaderBuilder::DeclareStruct(std::move(structDesc), false));
}
if (!m_outputs.empty())
{
Nz::ShaderAst::StructDescription structDesc;
nzsl::Ast::StructDescription structDesc;
structDesc.name = "OutputData";
for (const auto& output : m_outputs)
@@ -539,12 +539,12 @@ Nz::ShaderAst::ModulePtr ShaderGraph::ToModule() const
if (m_type == ShaderType::Vertex)
{
auto& position = structDesc.members.emplace_back();
position.builtin = Nz::ShaderAst::BuiltinEntry::VertexPosition;
position.builtin = nzsl::Ast::BuiltinEntry::VertexPosition;
position.name = "position";
position.type = Nz::ShaderAst::ExpressionType{ Nz::ShaderAst::VectorType{ 4, Nz::ShaderAst::PrimitiveType::Float32 } };
position.type = nzsl::Ast::ExpressionType{ nzsl::Ast::VectorType{ 4, nzsl::Ast::PrimitiveType::Float32 } };
}
shaderModule->rootNode->statements.push_back(Nz::ShaderBuilder::DeclareStruct(std::move(structDesc), false));
shaderModule->rootNode->statements.push_back(nzsl::ShaderBuilder::DeclareStruct(std::move(structDesc), false));
}
// Functions
@@ -553,9 +553,9 @@ Nz::ShaderAst::ModulePtr ShaderGraph::ToModule() const
return shaderModule;
}
Nz::ShaderAst::ExpressionValue<Nz::ShaderAst::ExpressionType> ShaderGraph::ToShaderExpressionType(const std::variant<PrimitiveType, std::size_t>& type) const
nzsl::Ast::ExpressionValue<nzsl::Ast::ExpressionType> ShaderGraph::ToShaderExpressionType(const std::variant<PrimitiveType, std::size_t>& type) const
{
return std::visit([&](auto&& arg) -> Nz::ShaderAst::ExpressionValue<Nz::ShaderAst::ExpressionType>
return std::visit([&](auto&& arg) -> nzsl::Ast::ExpressionValue<nzsl::Ast::ExpressionType>
{
using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, PrimitiveType>)
@@ -564,7 +564,7 @@ Nz::ShaderAst::ExpressionValue<Nz::ShaderAst::ExpressionType> ShaderGraph::ToSha
{
assert(arg < m_structs.size());
const auto& s = m_structs[arg];
return Nz::ShaderAst::ExpressionPtr{ Nz::ShaderBuilder::Identifier(s.name) };
return nzsl::Ast::ExpressionPtr{ nzsl::ShaderBuilder::Identifier(s.name) };
}
else
static_assert(Nz::AlwaysFalse<T>::value, "non-exhaustive visitor");
@@ -685,42 +685,42 @@ QtNodes::NodeDataType ShaderGraph::ToNodeDataType(PrimitiveType type)
throw std::runtime_error("Unhandled input type");
}
Nz::ShaderAst::ExpressionType ShaderGraph::ToShaderExpressionType(PrimitiveType type)
nzsl::Ast::ExpressionType ShaderGraph::ToShaderExpressionType(PrimitiveType type)
{
switch (type)
{
case PrimitiveType::Bool: return Nz::ShaderAst::PrimitiveType::Boolean;
case PrimitiveType::Float1: return Nz::ShaderAst::PrimitiveType::Float32;
case PrimitiveType::Float2: return Nz::ShaderAst::VectorType{ 2, Nz::ShaderAst::PrimitiveType::Float32 };
case PrimitiveType::Float3: return Nz::ShaderAst::VectorType{ 3, Nz::ShaderAst::PrimitiveType::Float32 };
case PrimitiveType::Float4: return Nz::ShaderAst::VectorType{ 4, Nz::ShaderAst::PrimitiveType::Float32 };
case PrimitiveType::Mat4x4: return Nz::ShaderAst::MatrixType{ 4, 4, Nz::ShaderAst::PrimitiveType::Float32 };
case PrimitiveType::Bool: return nzsl::Ast::PrimitiveType::Boolean;
case PrimitiveType::Float1: return nzsl::Ast::PrimitiveType::Float32;
case PrimitiveType::Float2: return nzsl::Ast::VectorType{ 2, nzsl::Ast::PrimitiveType::Float32 };
case PrimitiveType::Float3: return nzsl::Ast::VectorType{ 3, nzsl::Ast::PrimitiveType::Float32 };
case PrimitiveType::Float4: return nzsl::Ast::VectorType{ 4, nzsl::Ast::PrimitiveType::Float32 };
case PrimitiveType::Mat4x4: return nzsl::Ast::MatrixType{ 4, 4, nzsl::Ast::PrimitiveType::Float32 };
}
assert(false);
throw std::runtime_error("Unhandled primitive type");
}
Nz::ShaderAst::ExpressionType ShaderGraph::ToShaderExpressionType(TextureType type)
nzsl::Ast::ExpressionType ShaderGraph::ToShaderExpressionType(TextureType type)
{
switch (type)
{
case TextureType::Sampler2D: return Nz::ShaderAst::SamplerType{ Nz::ImageType::E2D, Nz::ShaderAst::PrimitiveType::Float32 };
case TextureType::Sampler2D: return nzsl::Ast::SamplerType{ nzsl::ImageType::E2D, nzsl::Ast::PrimitiveType::Float32 };
}
assert(false);
throw std::runtime_error("Unhandled texture type");
}
Nz::ShaderStageType ShaderGraph::ToShaderStageType(ShaderType type)
nzsl::ShaderStageType ShaderGraph::ToShaderStageType(ShaderType type)
{
switch (type)
{
case ShaderType::NotSet:
throw std::runtime_error("Invalid shader type");
case ShaderType::Fragment: return Nz::ShaderStageType::Fragment;
case ShaderType::Vertex: return Nz::ShaderStageType::Vertex;
case ShaderType::Fragment: return nzsl::ShaderStageType::Fragment;
case ShaderType::Vertex: return nzsl::ShaderStageType::Vertex;
}
assert(false);
@@ -802,23 +802,23 @@ std::shared_ptr<QtNodes::DataModelRegistry> ShaderGraph::BuildRegistry()
return registry;
}
std::unique_ptr<Nz::ShaderAst::DeclareFunctionStatement> ShaderGraph::ToFunction() const
std::unique_ptr<nzsl::Ast::DeclareFunctionStatement> ShaderGraph::ToFunction() const
{
std::vector<Nz::ShaderAst::StatementPtr> statements;
std::vector<nzsl::Ast::StatementPtr> statements;
std::vector<Nz::ShaderAst::DeclareFunctionStatement::Parameter> parameters;
std::vector<nzsl::Ast::DeclareFunctionStatement::Parameter> parameters;
if (!m_inputs.empty())
{
auto& parameter = parameters.emplace_back();
parameter.name = "input";
parameter.type = Nz::ShaderAst::ExpressionPtr{ Nz::ShaderBuilder::Identifier("InputData") };
parameter.type = nzsl::Ast::ExpressionPtr{ nzsl::ShaderBuilder::Identifier("InputData") };
}
Nz::ShaderAst::ExpressionPtr returnType;
nzsl::Ast::ExpressionPtr returnType;
if (!m_outputs.empty())
{
returnType = Nz::ShaderBuilder::Identifier("OutputData");
statements.push_back(Nz::ShaderBuilder::DeclareVariable("output", Nz::ShaderAst::Clone(*returnType), nullptr));
returnType = nzsl::ShaderBuilder::Identifier("OutputData");
statements.push_back(nzsl::ShaderBuilder::DeclareVariable("output", nzsl::Ast::Clone(*returnType), nullptr));
}
using Key = QPair<QUuid, std::size_t>;
@@ -860,13 +860,13 @@ std::unique_ptr<Nz::ShaderAst::DeclareFunctionStatement> ShaderGraph::ToFunction
}
});
std::map<Key, Nz::ShaderAst::ExpressionPtr> variableExpressions;
std::map<Key, nzsl::Ast::ExpressionPtr> variableExpressions;
unsigned int varCount = 0;
std::unordered_set<std::string> usedVariableNames;
std::function<Nz::ShaderAst::NodePtr(QtNodes::Node*, std::size_t portIndex)> HandleNode;
HandleNode = [&](QtNodes::Node* node, std::size_t portIndex) -> Nz::ShaderAst::NodePtr
std::function<nzsl::Ast::NodePtr(QtNodes::Node*, std::size_t portIndex)> HandleNode;
HandleNode = [&](QtNodes::Node* node, std::size_t portIndex) -> nzsl::Ast::NodePtr
{
ShaderNode* shaderNode = static_cast<ShaderNode*>(node->nodeDataModel());
if (shaderNode->validationState() != QtNodes::NodeValidationState::Valid)
@@ -874,13 +874,13 @@ std::unique_ptr<Nz::ShaderAst::DeclareFunctionStatement> ShaderGraph::ToFunction
qDebug() << shaderNode->name() << node->id();
if (auto it = variableExpressions.find(BuildKey(node->id(), portIndex)); it != variableExpressions.end())
return Nz::ShaderAst::Clone(*it->second);
return nzsl::Ast::Clone(*it->second);
auto it = usageCount.find(BuildKey(node->id(), portIndex));
assert(it != usageCount.end());
std::size_t inputCount = shaderNode->nPorts(QtNodes::PortType::In);
Nz::StackArray<Nz::ShaderAst::ExpressionPtr> expressions = NazaraStackArray(Nz::ShaderAst::ExpressionPtr, inputCount);
Nz::StackArray<nzsl::Ast::ExpressionPtr> expressions = NazaraStackArray(nzsl::Ast::ExpressionPtr, inputCount);
std::size_t i = 0;
for (const auto& connectionSet : node->nodeState().getEntries(QtNodes::PortType::In))
@@ -888,26 +888,26 @@ std::unique_ptr<Nz::ShaderAst::DeclareFunctionStatement> ShaderGraph::ToFunction
for (const auto& [uuid, conn] : connectionSet)
{
assert(i < expressions.size());
Nz::ShaderAst::NodePtr inputNode = HandleNode(conn->getNode(QtNodes::PortType::Out), conn->getPortIndex(QtNodes::PortType::Out));
if (!Nz::ShaderAst::IsExpression(inputNode->GetType()))
nzsl::Ast::NodePtr inputNode = HandleNode(conn->getNode(QtNodes::PortType::Out), conn->getPortIndex(QtNodes::PortType::Out));
if (!nzsl::Ast::IsExpression(inputNode->GetType()))
throw std::runtime_error("unexpected statement");
expressions[i] = Nz::StaticUniquePointerCast<Nz::ShaderAst::Expression>(std::move(inputNode));
expressions[i] = Nz::StaticUniquePointerCast<nzsl::Ast::Expression>(std::move(inputNode));
i++;
}
}
auto astNode = shaderNode->BuildNode(expressions.data(), expressions.size(), portIndex);
if (!Nz::ShaderAst::IsExpression(astNode->GetType()))
if (!nzsl::Ast::IsExpression(astNode->GetType()))
return astNode;
Nz::ShaderAst::ExpressionPtr expression = Nz::StaticUniquePointerCast<Nz::ShaderAst::Expression>(std::move(astNode));
nzsl::Ast::ExpressionPtr expression = Nz::StaticUniquePointerCast<nzsl::Ast::Expression>(std::move(astNode));
const std::string& variableName = shaderNode->GetVariableName();
if (it->second > 1 || !variableName.empty())
{
Nz::ShaderAst::ExpressionPtr varExpression;
if (Nz::ShaderAst::GetExpressionCategory(*expression) == Nz::ShaderAst::ExpressionCategory::RValue)
nzsl::Ast::ExpressionPtr varExpression;
if (nzsl::Ast::GetExpressionCategory(*expression) == nzsl::Ast::ExpressionCategory::RValue)
{
std::string name;
if (variableName.empty())
@@ -920,14 +920,14 @@ std::unique_ptr<Nz::ShaderAst::DeclareFunctionStatement> ShaderGraph::ToFunction
usedVariableNames.insert(name);
statements.emplace_back(Nz::ShaderBuilder::DeclareVariable(name, std::move(expression)));
statements.emplace_back(nzsl::ShaderBuilder::DeclareVariable(name, std::move(expression)));
varExpression = Nz::ShaderBuilder::Identifier(name);
varExpression = nzsl::ShaderBuilder::Identifier(name);
}
else
varExpression = std::move(expression);
variableExpressions[BuildKey(node->id(), portIndex)] = Nz::ShaderAst::Clone(*varExpression);
variableExpressions[BuildKey(node->id(), portIndex)] = nzsl::Ast::Clone(*varExpression);
return varExpression;
}
@@ -946,14 +946,14 @@ std::unique_ptr<Nz::ShaderAst::DeclareFunctionStatement> ShaderGraph::ToFunction
for (QtNodes::Node* node : outputNodes)
{
auto astNode = HandleNode(node, 0);
if (!Nz::ShaderAst::IsStatement(astNode->GetType()))
statements.emplace_back(Nz::ShaderBuilder::ExpressionStatement(Nz::StaticUniquePointerCast<Nz::ShaderAst::Expression>(std::move(astNode))));
if (!nzsl::Ast::IsStatement(astNode->GetType()))
statements.emplace_back(nzsl::ShaderBuilder::ExpressionStatement(Nz::StaticUniquePointerCast<nzsl::Ast::Expression>(std::move(astNode))));
else
statements.emplace_back(Nz::StaticUniquePointerCast<Nz::ShaderAst::Statement>(std::move(astNode)));
statements.emplace_back(Nz::StaticUniquePointerCast<nzsl::Ast::Statement>(std::move(astNode)));
}
if (!m_outputs.empty())
statements.push_back(Nz::ShaderBuilder::Return(Nz::ShaderBuilder::Identifier("output")));
statements.push_back(nzsl::ShaderBuilder::Return(nzsl::ShaderBuilder::Identifier("output")));
return Nz::ShaderBuilder::DeclareFunction(ToShaderStageType(m_type), "main", std::move(parameters), std::move(statements), std::move(returnType));
return nzsl::ShaderBuilder::DeclareFunction(ToShaderStageType(m_type), "main", std::move(parameters), std::move(statements), std::move(returnType));
}

16
src/ShaderNode/ShaderGraph.hpp
View File

@@ -3,9 +3,9 @@
#ifndef NAZARA_SHADERNODES_SHADERGRAPH_HPP
#define NAZARA_SHADERNODES_SHADERGRAPH_HPP
#include <Nazara/Core/Signal.hpp>
#include <Nazara/Utils/Signal.hpp>
#include <Nazara/Utility/Enums.hpp>
#include <Nazara/Shader/Ast/Module.hpp>
#include <NZSL/Ast/Module.hpp>
#include <nodes/FlowScene>
#include <ShaderNode/Enums.hpp>
#include <ShaderNode/Previews/PreviewModel.hpp>
@@ -67,8 +67,8 @@ class ShaderGraph
void Load(const QJsonObject& data);
QJsonObject Save();
Nz::ShaderAst::ModulePtr ToModule() const;
Nz::ShaderAst::ExpressionValue<Nz::ShaderAst::ExpressionType> ToShaderExpressionType(const std::variant<PrimitiveType, std::size_t>& type) const;
nzsl::Ast::ModulePtr ToModule() const;
nzsl::Ast::ExpressionValue<nzsl::Ast::ExpressionType> ToShaderExpressionType(const std::variant<PrimitiveType, std::size_t>& type) const;
void UpdateBuffer(std::size_t bufferIndex, std::string name, BufferType bufferType, std::size_t structIndex, std::size_t setIndex, std::size_t bindingIndex);
void UpdateOption(std::size_t optionIndex, std::string option);
@@ -148,13 +148,13 @@ class ShaderGraph
NazaraSignal(OnTypeUpdated, ShaderGraph*);
static QtNodes::NodeDataType ToNodeDataType(PrimitiveType type);
static Nz::ShaderAst::ExpressionType ToShaderExpressionType(PrimitiveType type);
static Nz::ShaderAst::ExpressionType ToShaderExpressionType(TextureType type);
static Nz::ShaderStageType ToShaderStageType(ShaderType type);
static nzsl::Ast::ExpressionType ToShaderExpressionType(PrimitiveType type);
static nzsl::Ast::ExpressionType ToShaderExpressionType(TextureType type);
static nzsl::ShaderStageType ToShaderStageType(ShaderType type);
private:
std::shared_ptr<QtNodes::DataModelRegistry> BuildRegistry();
std::unique_ptr<Nz::ShaderAst::DeclareFunctionStatement> ToFunction() const;
std::unique_ptr<nzsl::Ast::DeclareFunctionStatement> ToFunction() const;
mutable std::optional<QtNodes::FlowScene> m_flowScene;
std::vector<BufferEntry> m_buffers;

38
src/ShaderNode/Widgets/CodeOutputWidget.cpp
View File

@@ -1,11 +1,11 @@
#include <ShaderNode/Widgets/CodeOutputWidget.hpp>
#include <Nazara/Shader/GlslWriter.hpp>
#include <Nazara/Shader/LangWriter.hpp>
#include <Nazara/Shader/Ast/AstConstantPropagationVisitor.hpp>
#include <Nazara/Shader/Ast/EliminateUnusedPassVisitor.hpp>
#include <Nazara/Shader/Ast/SanitizeVisitor.hpp>
#include <Nazara/Shader/SpirvPrinter.hpp>
#include <Nazara/Shader/SpirvWriter.hpp>
#include <NZSL/GlslWriter.hpp>
#include <NZSL/LangWriter.hpp>
#include <NZSL/Ast/ConstantPropagationVisitor.hpp>
#include <NZSL/Ast/EliminateUnusedPassVisitor.hpp>
#include <NZSL/Ast/SanitizeVisitor.hpp>
#include <NZSL/SpirvPrinter.hpp>
#include <NZSL/SpirvWriter.hpp>
#include <ShaderNode/ShaderGraph.hpp>
#include <QtWidgets/QCheckBox>
#include <QtWidgets/QComboBox>
@@ -56,7 +56,7 @@ void CodeOutputWidget::Refresh()
{
try
{
Nz::ShaderWriter::States states;
nzsl::ShaderWriter::States states;
for (std::size_t i = 0; i < m_shaderGraph.GetOptionCount(); ++i)
{
@@ -64,18 +64,18 @@ void CodeOutputWidget::Refresh()
states.optionValues[Nz::CRC32(option.name)] = m_shaderGraph.IsOptionEnabled(i);
}
Nz::ShaderAst::ModulePtr shaderModule = m_shaderGraph.ToModule();
nzsl::Ast::ModulePtr shaderModule = m_shaderGraph.ToModule();
if (m_optimisationCheckbox->isChecked())
{
Nz::ShaderAst::SanitizeVisitor::Options sanitizeOptions;
nzsl::Ast::SanitizeVisitor::Options sanitizeOptions;
sanitizeOptions.optionValues = states.optionValues;
shaderModule = Nz::ShaderAst::Sanitize(*shaderModule, sanitizeOptions);
shaderModule = nzsl::Ast::Sanitize(*shaderModule, sanitizeOptions);
Nz::ShaderAst::AstConstantPropagationVisitor optimiser;
shaderModule = Nz::ShaderAst::PropagateConstants(*shaderModule);
shaderModule = Nz::ShaderAst::EliminateUnusedPass(*shaderModule);
nzsl::Ast::ConstantPropagationVisitor optimiser;
shaderModule = nzsl::Ast::PropagateConstants(*shaderModule);
shaderModule = nzsl::Ast::EliminateUnusedPass(*shaderModule);
}
std::string output;
@@ -84,31 +84,31 @@ void CodeOutputWidget::Refresh()
{
case OutputLanguage::GLSL:
{
Nz::GlslWriter::BindingMapping bindingMapping;
nzsl::GlslWriter::BindingMapping bindingMapping;
for (const auto& buffer : m_shaderGraph.GetBuffers())
bindingMapping.emplace(Nz::UInt64(buffer.setIndex) << 32 | Nz::UInt64(buffer.bindingIndex), bindingMapping.size());
for (const auto& texture : m_shaderGraph.GetTextures())
bindingMapping.emplace(Nz::UInt64(texture.setIndex) << 32 | Nz::UInt64(texture.bindingIndex), bindingMapping.size());
Nz::GlslWriter writer;
nzsl::GlslWriter writer;
output = writer.Generate(ShaderGraph::ToShaderStageType(m_shaderGraph.GetType()), *shaderModule, bindingMapping, states);
break;
}
case OutputLanguage::NZSL:
{
Nz::LangWriter writer;
nzsl::LangWriter writer;
output = writer.Generate(*shaderModule, states);
break;
}
case OutputLanguage::SpirV:
{
Nz::SpirvWriter writer;
nzsl::SpirvWriter writer;
std::vector<std::uint32_t> spirv = writer.Generate(*shaderModule, states);
Nz::SpirvPrinter printer;
nzsl::SpirvPrinter printer;
output = printer.Print(spirv.data(), spirv.size());
break;
}

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

@@ -1,7 +1,7 @@
#include <ShaderNode/Widgets/MainWindow.hpp>
#include <Nazara/Core/File.hpp>
#include <Nazara/Shader/GlslWriter.hpp>
#include <Nazara/Shader/Ast/AstSerializer.hpp>
#include <NZSL/GlslWriter.hpp>
#include <NZSL/Ast/AstSerializer.hpp>
#include <ShaderNode/ShaderGraph.hpp>
#include <ShaderNode/Widgets/BufferEditor.hpp>
#include <ShaderNode/Widgets/CodeOutputWidget.hpp>
@@ -183,15 +183,19 @@ void MainWindow::OnCompile()
{
auto shaderModule = m_shaderGraph.ToModule();
QString fileName = QFileDialog::getSaveFileName(nullptr, tr("Save shader"), QString(), tr("Shader Files (*.shader)"));
QString fileName = QFileDialog::getSaveFileName(nullptr, tr("Save shader"), QString(), tr("Shader Files (*.nzslb)"));
if (fileName.isEmpty())
return;
if (!fileName.endsWith("shader", Qt::CaseInsensitive))
fileName += ".shader";
if (!fileName.endsWith("nzslb", Qt::CaseInsensitive))
fileName += ".nzslb";
Nz::File file(fileName.toStdString(), Nz::OpenMode::WriteOnly);
file.Write(Nz::ShaderAst::SerializeShader(shaderModule));
nzsl::Serializer serializer;
nzsl::Ast::SerializeShader(serializer, shaderModule);
const std::vector<std::uint8_t>& data = serializer.GetData();
file.Write(data.data(), data.size());
}
catch (const std::exception& e)
{