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

Modules are workings \o/

Browse Source
This commit is contained in:
Jérôme Leclercq
2022-03-08 20:26:02 +01:00
parent 83d26e209e
commit be9bdc4705
29 changed files with 742 additions and 256 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
include/Nazara/Shader/Ast/AstCloner.hpp
View File

@@ -50,8 +50,11 @@ namespace Nz::ShaderAst
virtual ExpressionPtr Clone(ConditionalExpression& node);
virtual ExpressionPtr Clone(ConstantExpression& node);
virtual ExpressionPtr Clone(ConstantValueExpression& node);
virtual ExpressionPtr Clone(FunctionExpression& node);
virtual ExpressionPtr Clone(IdentifierExpression& node);
virtual ExpressionPtr Clone(IntrinsicExpression& node);
virtual ExpressionPtr Clone(IntrinsicFunctionExpression& node);
virtual ExpressionPtr Clone(StructTypeExpression& node);
virtual ExpressionPtr Clone(SwizzleExpression& node);
virtual ExpressionPtr Clone(VariableExpression& node);
virtual ExpressionPtr Clone(UnaryExpression& node);

3
include/Nazara/Shader/Ast/AstCompare.hpp
View File

@@ -42,8 +42,11 @@ namespace Nz::ShaderAst
inline bool Compare(const ConditionalExpression& lhs, const ConditionalExpression& rhs);
inline bool Compare(const ConstantExpression& lhs, const ConstantExpression& rhs);
inline bool Compare(const ConstantValueExpression& lhs, const ConstantValueExpression& rhs);
inline bool Compare(const FunctionExpression& lhs, const FunctionExpression& rhs);
inline bool Compare(const IdentifierExpression& lhs, const IdentifierExpression& rhs);
inline bool Compare(const IntrinsicExpression& lhs, const IntrinsicExpression& rhs);
inline bool Compare(const IntrinsicFunctionExpression& lhs, const IntrinsicFunctionExpression& rhs);
inline bool Compare(const StructTypeExpression& lhs, const StructTypeExpression& rhs);
inline bool Compare(const SwizzleExpression& lhs, const SwizzleExpression& rhs);
inline bool Compare(const VariableExpression& lhs, const VariableExpression& rhs);
inline bool Compare(const UnaryExpression& lhs, const UnaryExpression& rhs);

24
include/Nazara/Shader/Ast/AstCompare.inl
View File

@@ -342,6 +342,14 @@ namespace Nz::ShaderAst
return true;
}
inline bool Compare(const FunctionExpression& lhs, const FunctionExpression& rhs)
{
if (!Compare(lhs.funcId, rhs.funcId))
return false;
return true;
}
inline bool Compare(const IdentifierExpression& lhs, const IdentifierExpression& rhs)
{
if (!Compare(lhs.identifier, rhs.identifier))
@@ -361,6 +369,22 @@ namespace Nz::ShaderAst
return true;
}
inline bool Compare(const IntrinsicFunctionExpression& lhs, const IntrinsicFunctionExpression& rhs)
{
if (!Compare(lhs.intrinsicId, rhs.intrinsicId))
return false;
return true;
}
inline bool Compare(const StructTypeExpression& lhs, const StructTypeExpression& rhs)
{
if (!Compare(lhs.structTypeId, rhs.structTypeId))
return false;
return true;
}
inline bool Compare(const SwizzleExpression& lhs, const SwizzleExpression& rhs)
{
if (!Compare(lhs.componentCount, rhs.componentCount))

3
include/Nazara/Shader/Ast/AstNodeList.hpp
View File

@@ -38,8 +38,11 @@ NAZARA_SHADERAST_EXPRESSION(CastExpression)
NAZARA_SHADERAST_EXPRESSION(ConditionalExpression)
NAZARA_SHADERAST_EXPRESSION(ConstantExpression)
NAZARA_SHADERAST_EXPRESSION(ConstantValueExpression)
NAZARA_SHADERAST_EXPRESSION(FunctionExpression)
NAZARA_SHADERAST_EXPRESSION(IdentifierExpression)
NAZARA_SHADERAST_EXPRESSION(IntrinsicExpression)
NAZARA_SHADERAST_EXPRESSION(IntrinsicFunctionExpression)
NAZARA_SHADERAST_EXPRESSION(StructTypeExpression)
NAZARA_SHADERAST_EXPRESSION(SwizzleExpression)
NAZARA_SHADERAST_EXPRESSION(VariableExpression)
NAZARA_SHADERAST_EXPRESSION(UnaryExpression)

3
include/Nazara/Shader/Ast/AstRecursiveVisitor.hpp
View File

@@ -30,8 +30,11 @@ namespace Nz::ShaderAst
void Visit(ConditionalExpression& node) override;
void Visit(ConstantValueExpression& node) override;
void Visit(ConstantExpression& node) override;
void Visit(FunctionExpression& node) override;
void Visit(IdentifierExpression& node) override;
void Visit(IntrinsicExpression& node) override;
void Visit(IntrinsicFunctionExpression& node) override;
void Visit(StructTypeExpression& node) override;
void Visit(SwizzleExpression& node) override;
void Visit(VariableExpression& node) override;
void Visit(UnaryExpression& node) override;

3
include/Nazara/Shader/Ast/AstSerializer.hpp
View File

@@ -33,8 +33,11 @@ namespace Nz::ShaderAst
void Serialize(ConstantExpression& node);
void Serialize(ConditionalExpression& node);
void Serialize(ConstantValueExpression& node);
void Serialize(FunctionExpression& node);
void Serialize(IdentifierExpression& node);
void Serialize(IntrinsicExpression& node);
void Serialize(IntrinsicFunctionExpression& node);
void Serialize(StructTypeExpression& node);
void Serialize(SwizzleExpression& node);
void Serialize(VariableExpression& node);
void Serialize(UnaryExpression& node);

3
include/Nazara/Shader/Ast/AstUtils.hpp
View File

@@ -41,8 +41,11 @@ namespace Nz::ShaderAst
void Visit(ConditionalExpression& node) override;
void Visit(ConstantValueExpression& node) override;
void Visit(ConstantExpression& node) override;
void Visit(FunctionExpression& node) override;
void Visit(IdentifierExpression& node) override;
void Visit(IntrinsicExpression& node) override;
void Visit(IntrinsicFunctionExpression& node) override;
void Visit(StructTypeExpression& node) override;
void Visit(SwizzleExpression& node) override;
void Visit(VariableExpression& node) override;
void Visit(UnaryExpression& node) override;

3
include/Nazara/Shader/Ast/EliminateUnusedPassVisitor.inl
View File

@@ -16,6 +16,9 @@ namespace Nz::ShaderAst
inline ModulePtr EliminateUnusedPass(const Module& shaderModule, const DependencyCheckerVisitor::Config& config)
{
DependencyCheckerVisitor dependencyVisitor;
for (const auto& importedModule : shaderModule.importedModules)
dependencyVisitor.Process(*importedModule.module->rootNode, config);
dependencyVisitor.Process(*shaderModule.rootNode, config);
dependencyVisitor.Resolve();

3
include/Nazara/Shader/Ast/IndexRemapperVisitor.hpp
View File

@@ -45,7 +45,8 @@ namespace Nz::ShaderAst
StatementPtr Clone(DeclareStructStatement& node) override;
StatementPtr Clone(DeclareVariableStatement& node) override;
ExpressionPtr Clone(CallFunctionExpression& node) override;
ExpressionPtr Clone(FunctionExpression& node) override;
ExpressionPtr Clone(StructTypeExpression& node) override;
ExpressionPtr Clone(VariableExpression& node) override;
void HandleType(ExpressionValue<ExpressionType>& exprType);

24
include/Nazara/Shader/Ast/Nodes.hpp
View File

@@ -156,6 +156,14 @@ namespace Nz::ShaderAst
ShaderAst::ConstantValue value;
};
struct NAZARA_SHADER_API FunctionExpression : Expression
{
NodeType GetType() const override;
void Visit(AstExpressionVisitor& visitor) override;
std::size_t funcId;
};
struct NAZARA_SHADER_API IdentifierExpression : Expression
{
NodeType GetType() const override;
@@ -173,6 +181,22 @@ namespace Nz::ShaderAst
IntrinsicType intrinsic;
};
struct NAZARA_SHADER_API IntrinsicFunctionExpression : Expression
{
NodeType GetType() const override;
void Visit(AstExpressionVisitor& visitor) override;
std::size_t intrinsicId;
};
struct NAZARA_SHADER_API StructTypeExpression : Expression
{
NodeType GetType() const override;
void Visit(AstExpressionVisitor& visitor) override;
std::size_t structTypeId;
};
struct NAZARA_SHADER_API SwizzleExpression : Expression
{
NodeType GetType() const override;

2
include/Nazara/Shader/Ast/SanitizeVisitor.hpp
View File

@@ -108,6 +108,8 @@ namespace Nz::ShaderAst
template<typename F> const IdentifierData* FindIdentifier(const Environment& environment, const std::string_view& identifierName, F&& functor) const;
TypeParameter FindTypeParameter(const std::string_view& identifierName) const;
ExpressionPtr HandleIdentifier(const IdentifierData* identifierData);
Expression& MandatoryExpr(const ExpressionPtr& node) const;
Statement& MandatoryStatement(const StatementPtr& node) const;

2
include/Nazara/Shader/GlslWriter.hpp
View File

@@ -85,7 +85,7 @@ namespace Nz
void HandleEntryPoint(ShaderAst::DeclareFunctionStatement& node);
void HandleInOut();
void RegisterStruct(std::size_t structIndex, ShaderAst::StructDescription* desc);
void RegisterStruct(std::size_t structIndex, ShaderAst::StructDescription* desc, std::string structName);
void RegisterVariable(std::size_t varIndex, std::string varName);
void ScopeVisit(ShaderAst::Statement& node);

26
include/Nazara/Shader/LangWriter.hpp
View File

@@ -43,10 +43,12 @@ namespace Nz
struct DepthWriteAttribute;
struct EarlyFragmentTestsAttribute;
struct EntryAttribute;
struct LangVersionAttribute;
struct LayoutAttribute;
struct LocationAttribute;
struct SetAttribute;
struct UnrollAttribute;
struct UuidAttribute;
void Append(const ShaderAst::ArrayType& type);
void Append(const ShaderAst::ExpressionType& type);
@@ -68,18 +70,21 @@ namespace Nz
template<typename... Args> void AppendAttributes(bool appendLine, Args&&... params);
template<typename T> void AppendAttributesInternal(bool& first, const T& param);
template<typename T1, typename T2, typename... Rest> void AppendAttributesInternal(bool& first, const T1& firstParam, const T2& secondParam, Rest&&... params);
void AppendAttribute(BindingAttribute binding);
void AppendAttribute(BuiltinAttribute builtin);
void AppendAttribute(DepthWriteAttribute depthWrite);
void AppendAttribute(EarlyFragmentTestsAttribute earlyFragmentTests);
void AppendAttribute(EntryAttribute entry);
void AppendAttribute(LayoutAttribute layout);
void AppendAttribute(LocationAttribute location);
void AppendAttribute(SetAttribute set);
void AppendAttribute(UnrollAttribute unroll);
void AppendAttribute(BindingAttribute attribute);
void AppendAttribute(BuiltinAttribute attribute);
void AppendAttribute(DepthWriteAttribute attribute);
void AppendAttribute(EarlyFragmentTestsAttribute attribute);
void AppendAttribute(EntryAttribute attribute);
void AppendAttribute(LangVersionAttribute attribute);
void AppendAttribute(LayoutAttribute attribute);
void AppendAttribute(LocationAttribute attribute);
void AppendAttribute(SetAttribute seattributet);
void AppendAttribute(UnrollAttribute attribute);
void AppendAttribute(UuidAttribute attribute);
void AppendComment(const std::string& section);
void AppendCommentSection(const std::string& section);
void AppendHeader();
template<typename T> void AppendIdentifier(const T& map, std::size_t id);
void AppendLine(const std::string& txt = {});
template<typename... Args> void AppendLine(Args&&... params);
void AppendStatementList(std::vector<ShaderAst::StatementPtr>& statements);
@@ -88,7 +93,7 @@ namespace Nz
void LeaveScope(bool skipLine = true);
void RegisterConstant(std::size_t constantIndex, std::string constantName);
void RegisterStruct(std::size_t structIndex, ShaderAst::StructDescription* desc);
void RegisterStruct(std::size_t structIndex, std::string structName);
void RegisterVariable(std::size_t varIndex, std::string varName);
void ScopeVisit(ShaderAst::Statement& node);
@@ -104,6 +109,7 @@ namespace Nz
void Visit(ShaderAst::ConstantValueExpression& node) override;
void Visit(ShaderAst::ConstantExpression& node) override;
void Visit(ShaderAst::IntrinsicExpression& node) override;
void Visit(ShaderAst::StructTypeExpression& node) override;
void Visit(ShaderAst::SwizzleExpression& node) override;
void Visit(ShaderAst::VariableExpression& node) override;
void Visit(ShaderAst::UnaryExpression& node) override;

18
include/Nazara/Shader/ShaderBuilder.hpp
View File

@@ -127,6 +127,11 @@ namespace Nz::ShaderBuilder
inline std::unique_ptr<ShaderAst::ForEachStatement> operator()(std::string varName, ShaderAst::ExpressionPtr expression, ShaderAst::StatementPtr statement) const;
};
struct Function
{
inline std::unique_ptr<ShaderAst::FunctionExpression> operator()(std::size_t funcId) const;
};
struct Identifier
{
inline std::unique_ptr<ShaderAst::IdentifierExpression> operator()(std::string name) const;
@@ -142,6 +147,11 @@ namespace Nz::ShaderBuilder
inline std::unique_ptr<ShaderAst::IntrinsicExpression> operator()(ShaderAst::IntrinsicType intrinsicType, std::vector<ShaderAst::ExpressionPtr> parameters) const;
};
struct IntrinsicFunction
{
inline std::unique_ptr<ShaderAst::IntrinsicFunctionExpression> operator()(std::size_t intrinsicFunctionId, ShaderAst::IntrinsicType intrinsicType) const;
};
struct Multi
{
inline std::unique_ptr<ShaderAst::MultiStatement> operator()(std::vector<ShaderAst::StatementPtr> statements = {}) const;
@@ -163,6 +173,11 @@ namespace Nz::ShaderBuilder
inline std::unique_ptr<ShaderAst::ScopedStatement> operator()(ShaderAst::StatementPtr statement) const;
};
struct StructType
{
inline std::unique_ptr<ShaderAst::StructTypeExpression> operator()(std::size_t structTypeId) const;
};
struct Swizzle
{
inline std::unique_ptr<ShaderAst::SwizzleExpression> operator()(ShaderAst::ExpressionPtr expression, std::array<UInt32, 4> swizzleComponents, std::size_t componentCount) const;
@@ -206,13 +221,16 @@ namespace Nz::ShaderBuilder
constexpr Impl::NoParam<ShaderAst::DiscardStatement> Discard;
constexpr Impl::For For;
constexpr Impl::ForEach ForEach;
constexpr Impl::Function Function;
constexpr Impl::Identifier Identifier;
constexpr Impl::IntrinsicFunction IntrinsicFunction;
constexpr Impl::Import Import;
constexpr Impl::Intrinsic Intrinsic;
constexpr Impl::Multi MultiStatement;
constexpr Impl::NoParam<ShaderAst::NoOpStatement> NoOp;
constexpr Impl::Return Return;
constexpr Impl::Scoped Scoped;
constexpr Impl::StructType StructType;
constexpr Impl::Swizzle Swizzle;
constexpr Impl::Unary Unary;
constexpr Impl::Variable Variable;

31
include/Nazara/Shader/ShaderBuilder.inl
View File

@@ -315,7 +315,7 @@ namespace Nz::ShaderBuilder
return expressionStatementNode;
}
inline std::unique_ptr<ShaderAst::ForStatement> Nz::ShaderBuilder::Impl::For::operator()(std::string varName, ShaderAst::ExpressionPtr fromExpression, ShaderAst::ExpressionPtr toExpression, ShaderAst::StatementPtr statement) const
inline std::unique_ptr<ShaderAst::ForStatement> Impl::For::operator()(std::string varName, ShaderAst::ExpressionPtr fromExpression, ShaderAst::ExpressionPtr toExpression, ShaderAst::StatementPtr statement) const
{
auto forNode = std::make_unique<ShaderAst::ForStatement>();
forNode->fromExpr = std::move(fromExpression);
@@ -326,7 +326,7 @@ namespace Nz::ShaderBuilder
return forNode;
}
inline std::unique_ptr<ShaderAst::ForStatement> Nz::ShaderBuilder::Impl::For::operator()(std::string varName, ShaderAst::ExpressionPtr fromExpression, ShaderAst::ExpressionPtr toExpression, ShaderAst::ExpressionPtr stepExpression, ShaderAst::StatementPtr statement) const
inline std::unique_ptr<ShaderAst::ForStatement> Impl::For::operator()(std::string varName, ShaderAst::ExpressionPtr fromExpression, ShaderAst::ExpressionPtr toExpression, ShaderAst::ExpressionPtr stepExpression, ShaderAst::StatementPtr statement) const
{
auto forNode = std::make_unique<ShaderAst::ForStatement>();
forNode->fromExpr = std::move(fromExpression);
@@ -348,6 +348,15 @@ namespace Nz::ShaderBuilder
return forEachNode;
}
inline std::unique_ptr<ShaderAst::FunctionExpression> Impl::Function::operator()(std::size_t funcId) const
{
auto intrinsicTypeExpr = std::make_unique<ShaderAst::FunctionExpression>();
intrinsicTypeExpr->cachedExpressionType = ShaderAst::FunctionType{ funcId };
intrinsicTypeExpr->funcId = funcId;
return intrinsicTypeExpr;
}
inline std::unique_ptr<ShaderAst::IdentifierExpression> Impl::Identifier::operator()(std::string name) const
{
auto identifierNode = std::make_unique<ShaderAst::IdentifierExpression>();
@@ -373,6 +382,15 @@ namespace Nz::ShaderBuilder
return intrinsicExpression;
}
inline std::unique_ptr<ShaderAst::IntrinsicFunctionExpression> Impl::IntrinsicFunction::operator()(std::size_t intrinsicFunctionId, ShaderAst::IntrinsicType intrinsicType) const
{
auto intrinsicTypeExpr = std::make_unique<ShaderAst::IntrinsicFunctionExpression>();
intrinsicTypeExpr->cachedExpressionType = ShaderAst::IntrinsicFunctionType{ intrinsicType };
intrinsicTypeExpr->intrinsicId = intrinsicFunctionId;
return intrinsicTypeExpr;
}
inline std::unique_ptr<ShaderAst::MultiStatement> Impl::Multi::operator()(std::vector<ShaderAst::StatementPtr> statements) const
{
auto multiStatement = std::make_unique<ShaderAst::MultiStatement>();
@@ -403,6 +421,15 @@ namespace Nz::ShaderBuilder
return scopedNode;
}
inline std::unique_ptr<ShaderAst::StructTypeExpression> Impl::StructType::operator()(std::size_t structTypeId) const
{
auto structTypeExpr = std::make_unique<ShaderAst::StructTypeExpression>();
structTypeExpr->cachedExpressionType = ShaderAst::StructType{ structTypeId };
structTypeExpr->structTypeId = structTypeId;
return structTypeExpr;
}
inline std::unique_ptr<ShaderAst::SwizzleExpression> Impl::Swizzle::operator()(ShaderAst::ExpressionPtr expression, std::array<UInt32, 4> swizzleComponents, std::size_t componentCount) const
{
assert(componentCount > 0);

2
include/Nazara/Shader/ShaderLangParser.hpp
View File

@@ -86,6 +86,7 @@ namespace Nz::ShaderLang
void ParseVariableDeclaration(std::string& name, ShaderAst::ExpressionValue<ShaderAst::ExpressionType>& type, ShaderAst::ExpressionPtr& initialValue);
// Statements
ShaderAst::StatementPtr ParseAliasDeclaration();
ShaderAst::StatementPtr ParseBranchStatement();
ShaderAst::StatementPtr ParseConstStatement();
ShaderAst::StatementPtr ParseDiscardStatement();
@@ -130,6 +131,7 @@ namespace Nz::ShaderLang
std::size_t tokenIndex = 0;
ShaderAst::ModulePtr module;
const Token* tokens;
bool parsingImportedModule = false;
};
Context* m_context;

1
include/Nazara/Shader/ShaderLangTokenList.hpp
View File

@@ -12,6 +12,7 @@
#define NAZARA_SHADERLANG_TOKEN_LAST(X) NAZARA_SHADERLANG_TOKEN(X)
#endif
NAZARA_SHADERLANG_TOKEN(Alias)
NAZARA_SHADERLANG_TOKEN(Arrow)
NAZARA_SHADERLANG_TOKEN(Assign)
NAZARA_SHADERLANG_TOKEN(BoolFalse)