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

Renderer/ShaderAst: Add Swizzle

This commit is contained in:
Lynix 2017-01-15 22:04:51 +01:00
parent 832237c6d4
commit 205b8b1ba6
7 changed files with 114 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/Nazara/Renderer/GlslWriter.hpp
View File

@ -42,6 +42,7 @@ namespace Nz
void Write(const ShaderAst::NamedVariable& node) override;
void Write(const ShaderAst::NodePtr& node) override;
void Write(const ShaderAst::StatementBlock& node) override;
void Write(const ShaderAst::SwizzleOp& node) override;
private:
struct Function;

46
include/Nazara/Renderer/ShaderAst.hpp
View File

@ -54,6 +54,14 @@ namespace Nz
Void // void
};
enum class SwizzleComponent
{
First,
Second,
Third,
Fourth
};
enum class VariableType
{
Builtin,
@ -139,6 +147,19 @@ namespace Nz
VariableType kind;
};
class NAZARA_RENDERER_API BuiltinVariable : public Variable
{
public:
inline BuiltinVariable(BuiltinEntry variable, ExpressionType varType);
void Register(ShaderWriter& visitor) override;
void Visit(ShaderWriter& visitor) override;
BuiltinEntry var;
};
class NamedVariable;
using NamedVariablePtr = std::shared_ptr<NamedVariable>;
@ -154,17 +175,6 @@ namespace Nz
Nz::String name;
};
class NAZARA_RENDERER_API BuiltinVariable : public Variable
{
public:
inline BuiltinVariable(BuiltinEntry variable, ExpressionType varType);
void Register(ShaderWriter& visitor) override;
void Visit(ShaderWriter& visitor) override;
BuiltinEntry var;
};
//////////////////////////////////////////////////////////////////////////
class NAZARA_RENDERER_API AssignOp : public Expression
@ -250,6 +260,20 @@ namespace Nz
Vector4f vec4;
} values;
};
class NAZARA_RENDERER_API SwizzleOp : public Expression
{
public:
inline SwizzleOp(ExpressionPtr expressionPtr, std::initializer_list<SwizzleComponent> swizzleComponents);
ExpressionType GetExpressionType() const override;
void Register(ShaderWriter& visitor) override;
void Visit(ShaderWriter& visitor) override;
std::array<SwizzleComponent, 4> components;
std::size_t componentCount;
ExpressionPtr expression;
};
}
}

40
include/Nazara/Renderer/ShaderAst.inl
View File

@ -24,7 +24,7 @@ namespace Nz
return 4;
case ExpressionType::Mat4x4:
return 16;
return 4;
default:
return 1;
@ -38,9 +38,11 @@ namespace Nz
case ExpressionType::Float2:
case ExpressionType::Float3:
case ExpressionType::Float4:
case ExpressionType::Mat4x4:
return ExpressionType::Float1;
case ExpressionType::Mat4x4:
return ExpressionType::Float4;
default:
return type;
}
@ -63,18 +65,18 @@ namespace Nz
{
}
inline NamedVariable::NamedVariable(VariableType varKind, const Nz::String& varName, ExpressionType varType) :
Variable(varKind, varType),
name(varName)
{
}
inline BuiltinVariable::BuiltinVariable(BuiltinEntry variable, ExpressionType varType) :
Variable(VariableType::Builtin, varType),
var(variable)
{
}
inline NamedVariable::NamedVariable(VariableType varKind, const Nz::String& varName, ExpressionType varType) :
Variable(varKind, varType),
name(varName)
{
}
inline AssignOp::AssignOp(AssignType Op, VariablePtr Var, ExpressionPtr Right) :
op(Op),
variable(std::move(Var)),
@ -197,6 +199,28 @@ namespace Nz
{
values.vec4 = value;
}
inline SwizzleOp::SwizzleOp(ExpressionPtr expressionPtr, std::initializer_list<SwizzleComponent> swizzleComponents) :
componentCount(swizzleComponents.size()),
expression(expressionPtr)
{
if (componentCount > 4)
throw std::runtime_error("Cannot swizzle more than four elements");
switch (expressionPtr->GetExpressionType())
{
case ExpressionType::Float1:
case ExpressionType::Float2:
case ExpressionType::Float3:
case ExpressionType::Float4:
break;
default:
throw std::runtime_error("Cannot swizzle this type");
}
std::copy(swizzleComponents.begin(), swizzleComponents.end(), components.begin());
}
}
}

1
include/Nazara/Renderer/ShaderBuilder.hpp
View File

@ -65,6 +65,7 @@ namespace Nz { namespace ShaderBuilder
constexpr BinOpBuilder<ShaderAst::BinaryType::Multiply> Multiply;
constexpr VarBuilder<ShaderAst::VariableType::Output> Output;
constexpr VarBuilder<ShaderAst::VariableType::Parameter> Parameter;
constexpr GenBuilder<ShaderAst::SwizzleOp> Swizzle;
constexpr BinOpBuilder<ShaderAst::BinaryType::Substract> Substract;
constexpr VarBuilder<ShaderAst::VariableType::Uniform> Uniform;
constexpr VarBuilder<ShaderAst::VariableType::Variable> Variable;

1
include/Nazara/Renderer/ShaderWriter.hpp
View File

@ -36,6 +36,7 @@ namespace Nz
virtual void Write(const ShaderAst::NamedVariable& node) = 0;
virtual void Write(const ShaderAst::NodePtr& node) = 0;
virtual void Write(const ShaderAst::StatementBlock& node) = 0;
virtual void Write(const ShaderAst::SwizzleOp& node) = 0;
};
}

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

@ -278,6 +278,34 @@ namespace Nz
}
}
void GlslWriter::Write(const ShaderAst::SwizzleOp& node)
{
Write(node.expression);
Append(".");
for (std::size_t i = 0; i < node.componentCount; ++i)
{
switch (node.components[i])
{
case ShaderAst::SwizzleComponent::First:
Append("x");
break;
case ShaderAst::SwizzleComponent::Second:
Append("y");
break;
case ShaderAst::SwizzleComponent::Third:
Append("z");
break;
case ShaderAst::SwizzleComponent::Fourth:
Append("w");
break;
}
}
}
void GlslWriter::Append(ShaderAst::BuiltinEntry builtin)
{
switch (builtin)

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

@ -163,5 +163,21 @@ namespace Nz { namespace ShaderAst
{
visitor.Write(*this);
}
ExpressionType ShaderAst::SwizzleOp::GetExpressionType() const
{
return GetComponentType(expression->GetExpressionType());
}
void SwizzleOp::Register(ShaderWriter& visitor)
{
expression->Register(visitor);
}
void SwizzleOp::Visit(ShaderWriter& visitor)
{
visitor.Write(*this);
}
}
}