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>