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

Shader: Replace select_opt by const_select

This commit is contained in:
Jérôme Leclercq 2021-07-08 10:53:11 +02:00
parent 838063c8b6
commit d3e0d8a39f
21 changed files with 69 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
bin/resources/deferred_frag.nzsl
View File

@ -56,15 +56,23 @@ struct OutputData
[entry(frag)]
fn main(input: InputData) -> OutputData
{
let textureColor = select_opt(HAS_DIFFUSE_TEXTURE, MaterialDiffuseMap.Sample(input.vertUV) * settings.DiffuseColor, settings.DiffuseColor);
let alpha = select_opt(HAS_ALPHA_TEXTURE, MaterialAlphaMap.Sample(input.vertUV).x * textureColor.w, 1.0);
/*if ((select_opt(ALPHA_TEST, var0.w < settings.AlphaThreshold, false)) == (true))
let diffuseColor = settings.DiffuseColor;
const if (HAS_DIFFUSE_TEXTURE)
// TODO: diffuseColor *= MaterialDiffuseMap.Sample(input.uv)
diffuseColor = diffuseColor * MaterialDiffuseMap.Sample(input.uv);
const if (HAS_ALPHA_TEXTURE)
// TODO: diffuseColor.w *= MaterialAlphaMap.Sample(input.uv)).x
diffuseColor = vec4<f32>(diffuseColor.x, diffuseColor.y, diffuseColor.z, (MaterialAlphaMap.Sample(input.uv)).x * diffuseColor.w);
const if (ALPHA_TEST)
{
discard;
}*/
if (diffuseColor.w < settings.AlphaThreshold)
discard;
}
let output: OutputData;
output.diffuseMap = textureColor;
output.diffuseMap = diffuseColor;
output.normalMap = vec4<f32>((vec3<f32>(1.0, 1.0, 1.0) + input.vertNormal) * 0.5, 1.0);
output.positionMap = vec4<f32>(input.vertPos, 1.0);
return output;

2
examples/RenderTest/main.cpp
View File

@ -58,7 +58,7 @@ fn main(fragIn: VertOut) -> FragOut
let lightFactor = dot(fragIn.normal, lightDir);
let fragOut: FragOut;
fragOut.color = lightFactor * tex.Sample(fragIn.uv) * select_opt(red, vec4<f32>(1.0, 0.0, 0.0, 1.0), vec4<f32>(1.0, 1.0, 1.0, 1.0));
fragOut.color = lightFactor * tex.Sample(fragIn.uv) * const_select(red, vec4<f32>(1.0, 0.0, 0.0, 1.0), vec4<f32>(1.0, 1.0, 1.0, 1.0));
return fragOut;
}

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

@ -50,7 +50,6 @@ namespace Nz::ShaderAst
virtual ExpressionPtr Clone(ConstantExpression& node);
virtual ExpressionPtr Clone(IdentifierExpression& node);
virtual ExpressionPtr Clone(IntrinsicExpression& node);
virtual ExpressionPtr Clone(SelectOptionExpression& node);
virtual ExpressionPtr Clone(SwizzleExpression& node);
virtual ExpressionPtr Clone(VariableExpression& node);
virtual ExpressionPtr Clone(UnaryExpression& node);

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

@ -38,7 +38,6 @@ NAZARA_SHADERAST_EXPRESSION(ConstantExpression)
NAZARA_SHADERAST_EXPRESSION(ConstantIndexExpression)
NAZARA_SHADERAST_EXPRESSION(IdentifierExpression)
NAZARA_SHADERAST_EXPRESSION(IntrinsicExpression)
NAZARA_SHADERAST_EXPRESSION(SelectOptionExpression)
NAZARA_SHADERAST_EXPRESSION(SwizzleExpression)
NAZARA_SHADERAST_EXPRESSION(VariableExpression)
NAZARA_SHADERAST_EXPRESSION(UnaryExpression)

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

@ -32,7 +32,6 @@ namespace Nz::ShaderAst
void Visit(ConstantIndexExpression& node) override;
void Visit(IdentifierExpression& node) override;
void Visit(IntrinsicExpression& node) override;
void Visit(SelectOptionExpression& node) override;
void Visit(SwizzleExpression& node) override;
void Visit(VariableExpression& node) override;
void Visit(UnaryExpression& node) override;

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

@ -35,7 +35,6 @@ namespace Nz::ShaderAst
void Serialize(ConstantExpression& node);
void Serialize(IdentifierExpression& node);
void Serialize(IntrinsicExpression& node);
void Serialize(SelectOptionExpression& node);
void Serialize(SwizzleExpression& node);
void Serialize(VariableExpression& node);
void Serialize(UnaryExpression& node);

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

@ -43,7 +43,6 @@ namespace Nz::ShaderAst
void Visit(ConstantIndexExpression& node) override;
void Visit(IdentifierExpression& node) override;
void Visit(IntrinsicExpression& node) override;
void Visit(SelectOptionExpression& node) override;
void Visit(SwizzleExpression& node) override;
void Visit(VariableExpression& node) override;
void Visit(UnaryExpression& node) override;

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

@ -173,16 +173,6 @@ namespace Nz::ShaderAst
std::vector<ExpressionPtr> parameters;
};
struct NAZARA_SHADER_API SelectOptionExpression : Expression
{
NodeType GetType() const override;
void Visit(AstExpressionVisitor& visitor) override;
std::string optionName;
ExpressionPtr falsePath;
ExpressionPtr truePath;
};
struct NAZARA_SHADER_API SwizzleExpression : Expression
{
NodeType GetType() const override;

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

@ -58,7 +58,6 @@ namespace Nz::ShaderAst
ExpressionPtr Clone(ConstantIndexExpression& node) override;
ExpressionPtr Clone(IdentifierExpression& node) override;
ExpressionPtr Clone(IntrinsicExpression& node) override;
ExpressionPtr Clone(SelectOptionExpression& node) override;
ExpressionPtr Clone(SwizzleExpression& node) override;
ExpressionPtr Clone(UnaryExpression& node) override;
ExpressionPtr Clone(VariableExpression& node) override;

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

@ -131,11 +131,6 @@ namespace Nz::ShaderBuilder
inline std::unique_ptr<ShaderAst::ReturnStatement> operator()(ShaderAst::ExpressionPtr expr = nullptr) const;
};
struct SelectOption
{
inline std::unique_ptr<ShaderAst::SelectOptionExpression> operator()(std::string optionName, ShaderAst::ExpressionPtr truePath, ShaderAst::ExpressionPtr falsePath) const;
};
struct Swizzle
{
inline std::unique_ptr<ShaderAst::SwizzleExpression> operator()(ShaderAst::ExpressionPtr expression, std::vector<ShaderAst::SwizzleComponent> swizzleComponents) const;
@ -170,7 +165,6 @@ namespace Nz::ShaderBuilder
constexpr Impl::Multi MultiStatement;
constexpr Impl::NoParam<ShaderAst::NoOpStatement> NoOp;
constexpr Impl::Return Return;
constexpr Impl::SelectOption SelectOption;
constexpr Impl::Swizzle Swizzle;
constexpr Impl::Unary Unary;
}

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

@ -277,16 +277,6 @@ namespace Nz::ShaderBuilder
return returnNode;
}
inline std::unique_ptr<ShaderAst::SelectOptionExpression> Impl::SelectOption::operator()(std::string optionName, ShaderAst::ExpressionPtr truePath, ShaderAst::ExpressionPtr falsePath) const
{
auto selectOptNode = std::make_unique<ShaderAst::SelectOptionExpression>();
selectOptNode->optionName = std::move(optionName);
selectOptNode->falsePath = std::move(falsePath);
selectOptNode->truePath = std::move(truePath);
return selectOptNode;
}
inline std::unique_ptr<ShaderAst::SwizzleExpression> Impl::Swizzle::operator()(ShaderAst::ExpressionPtr expression, std::vector<ShaderAst::SwizzleComponent> swizzleComponents) const
{
auto swizzleNode = std::make_unique<ShaderAst::SwizzleExpression>();

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

@ -101,6 +101,7 @@ namespace Nz::ShaderLang
// Expressions
ShaderAst::ExpressionPtr ParseBinOpRhs(int exprPrecedence, ShaderAst::ExpressionPtr lhs);
ShaderAst::ExpressionPtr ParseConstSelectExpression();
ShaderAst::ExpressionPtr ParseExpression();
ShaderAst::ExpressionPtr ParseFloatingPointExpression();
ShaderAst::ExpressionPtr ParseIdentifier();
@ -108,7 +109,6 @@ namespace Nz::ShaderLang
std::vector<ShaderAst::ExpressionPtr> ParseParameters();
ShaderAst::ExpressionPtr ParseParenthesisExpression();
ShaderAst::ExpressionPtr ParsePrimaryExpression();
ShaderAst::ExpressionPtr ParseSelectOptExpression();
ShaderAst::ExpressionPtr ParseVariableAssignation();
ShaderAst::AttributeType ParseIdentifierAsAttributeType();

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

@ -19,6 +19,7 @@ NAZARA_SHADERLANG_TOKEN(ClosingSquareBracket)
NAZARA_SHADERLANG_TOKEN(Colon)
NAZARA_SHADERLANG_TOKEN(Comma)
NAZARA_SHADERLANG_TOKEN(Const)
NAZARA_SHADERLANG_TOKEN(ConstSelect)
NAZARA_SHADERLANG_TOKEN(Discard)
NAZARA_SHADERLANG_TOKEN(Divide)
NAZARA_SHADERLANG_TOKEN(Dot)
@ -49,7 +50,6 @@ NAZARA_SHADERLANG_TOKEN(OpenParenthesis)
NAZARA_SHADERLANG_TOKEN(Option)
NAZARA_SHADERLANG_TOKEN(Semicolon)
NAZARA_SHADERLANG_TOKEN(Return)
NAZARA_SHADERLANG_TOKEN(SelectOpt)
NAZARA_SHADERLANG_TOKEN(Struct)
#undef NAZARA_SHADERLANG_TOKEN

21
src/Nazara/Graphics/Resources/Shaders/basicmaterial.nzsl
View File

@ -55,13 +55,22 @@ struct FragOut
[entry(frag)]
fn main(input: FragIn) -> FragOut
{
let diffuseColor = settings.DiffuseColor;
const if (HAS_DIFFUSE_TEXTURE)
// TODO: diffuseColor *= MaterialDiffuseMap.Sample(input.uv)
diffuseColor = diffuseColor * MaterialDiffuseMap.Sample(input.uv);
const if (HAS_ALPHA_TEXTURE)
// TODO: diffuseColor.w *= MaterialAlphaMap.Sample(input.uv)).x
diffuseColor = vec4<f32>(diffuseColor.x, diffuseColor.y, diffuseColor.z, ((MaterialAlphaMap.Sample(input.uv)).x) * diffuseColor.w);
const if (ALPHA_TEST)
{
if (diffuseColor.w < settings.AlphaThreshold)
discard;
}
let output: FragOut;
let diffuseColor = select_opt(HAS_DIFFUSE_TEXTURE, MaterialDiffuseMap.Sample(input.uv) * settings.DiffuseColor, settings.DiffuseColor);
let diffuseColor = select_opt(HAS_ALPHA_TEXTURE, vec4<f32>(diffuseColor.x, diffuseColor.y, diffuseColor.z, ((MaterialAlphaMap.Sample(input.uv)).x) * diffuseColor.w), diffuseColor);
if (select_opt(ALPHA_TEST, diffuseColor.w < settings.AlphaThreshold, false))
discard;
output.RenderTarget0 = diffuseColor;
return output;
}

12
src/Nazara/Shader/Ast/AstCloner.cpp
View File

@ -347,18 +347,6 @@ namespace Nz::ShaderAst
return clone;
}
ExpressionPtr AstCloner::Clone(SelectOptionExpression& node)
{
auto clone = std::make_unique<SelectOptionExpression>();
clone->optionName = node.optionName;
clone->falsePath = CloneExpression(node.falsePath);
clone->truePath = CloneExpression(node.truePath);
clone->cachedExpressionType = node.cachedExpressionType;
return clone;
}
ExpressionPtr AstCloner::Clone(SwizzleExpression& node)
{
auto clone = std::make_unique<SwizzleExpression>();

6
src/Nazara/Shader/Ast/AstRecursiveVisitor.cpp
View File

@ -83,12 +83,6 @@ namespace Nz::ShaderAst
param->Visit(*this);
}
void AstRecursiveVisitor::Visit(SelectOptionExpression& node)
{
node.truePath->Visit(*this);
node.falsePath->Visit(*this);
}
void AstRecursiveVisitor::Visit(SwizzleExpression& node)
{
node.expression->Visit(*this);

7
src/Nazara/Shader/Ast/AstSerializer.cpp
View File

@ -170,13 +170,6 @@ namespace Nz::ShaderAst
Node(param);
}
void AstSerializerBase::Serialize(SelectOptionExpression& node)
{
Value(node.optionName);
Node(node.truePath);
Node(node.falsePath);
}
void AstSerializerBase::Serialize(SwizzleExpression& node)
{
SizeT(node.componentCount);

14
src/Nazara/Shader/Ast/AstUtils.cpp
View File

@ -82,20 +82,6 @@ namespace Nz::ShaderAst
m_expressionCategory = ExpressionCategory::RValue;
}
void ShaderAstValueCategory::Visit(SelectOptionExpression& node)
{
node.truePath->Visit(*this);
ExpressionCategory trueExprCategory = m_expressionCategory;
node.falsePath->Visit(*this);
ExpressionCategory falseExprCategory = m_expressionCategory;
if (trueExprCategory == ExpressionCategory::RValue || falseExprCategory == ExpressionCategory::RValue)
m_expressionCategory = ExpressionCategory::RValue;
else
m_expressionCategory = ExpressionCategory::LValue;
}
void ShaderAstValueCategory::Visit(SwizzleExpression& node)
{
node.expression->Visit(*this);

21
src/Nazara/Shader/Ast/SanitizeVisitor.cpp
View File

@ -632,27 +632,6 @@ namespace Nz::ShaderAst
return clone;
}
ExpressionPtr SanitizeVisitor::Clone(SelectOptionExpression& node)
{
MandatoryExpr(node.truePath);
MandatoryExpr(node.falsePath);
const Identifier* identifier = FindIdentifier(node.optionName);
if (!identifier)
throw AstError{ "unknown constant " + node.optionName };
if (identifier->type != Identifier::Type::Constant)
throw AstError{ "expected constant identifier" };
if (GetExpressionType(m_context->constantValues[identifier->index]) != ExpressionType{ PrimitiveType::Boolean })
throw AstError{ "constant is not a boolean" };
if (std::get<bool>(m_context->constantValues[identifier->index]))
return CloneExpression(node.truePath);
else
return CloneExpression(node.falsePath);
}
ExpressionPtr SanitizeVisitor::Clone(SwizzleExpression& node)
{
if (node.componentCount > 4)

28
src/Nazara/Shader/ShaderLangLexer.cpp
View File

@ -36,23 +36,23 @@ namespace Nz::ShaderLang
std::vector<Token> Tokenize(const std::string_view& str)
{
// Can't use std::from_chars for double, thanks to libc++ and libstdc++ developers for being lazy
// Can't use std::from_chars for double, thanks to libc++ and libstdc++ developers for being lazy, so we have to force C locale
ForceCLocale forceCLocale;
std::unordered_map<std::string, TokenType> reservedKeywords = {
{ "const", TokenType::Const },
{ "discard", TokenType::Discard },
{ "else", TokenType::Else },
{ "external", TokenType::External },
{ "false", TokenType::BoolFalse },
{ "fn", TokenType::FunctionDeclaration },
{ "if", TokenType::If },
{ "let", TokenType::Let },
{ "option", TokenType::Option },
{ "return", TokenType::Return },
{ "select_opt", TokenType::SelectOpt },
{ "struct", TokenType::Struct },
{ "true", TokenType::BoolTrue }
{ "const", TokenType::Const },
{ "const_select", TokenType::ConstSelect },
{ "discard", TokenType::Discard },
{ "else", TokenType::Else },
{ "external", TokenType::External },
{ "false", TokenType::BoolFalse },
{ "fn", TokenType::FunctionDeclaration },
{ "if", TokenType::If },
{ "let", TokenType::Let },
{ "option", TokenType::Option },
{ "return", TokenType::Return },
{ "struct", TokenType::Struct },
{ "true", TokenType::BoolTrue }
};
std::size_t currentPos = 0;

46
src/Nazara/Shader/ShaderLangParser.cpp
View File

@ -986,6 +986,26 @@ namespace Nz::ShaderLang
}
}
ShaderAst::ExpressionPtr Parser::ParseConstSelectExpression()
{
Expect(Advance(), TokenType::ConstSelect);
Expect(Advance(), TokenType::OpenParenthesis);
ShaderAst::ExpressionPtr cond = ParseExpression();
Expect(Advance(), TokenType::Comma);
ShaderAst::ExpressionPtr trueExpr = ParseExpression();
Expect(Advance(), TokenType::Comma);
ShaderAst::ExpressionPtr falseExpr = ParseExpression();
Expect(Advance(), TokenType::ClosingParenthesis);
return ShaderBuilder::ConditionalExpression(std::move(cond), std::move(trueExpr), std::move(falseExpr));
}
ShaderAst::ExpressionPtr Parser::ParseExpression()
{
return ParseBinOpRhs(0, ParsePrimaryExpression());
@ -1053,6 +1073,9 @@ namespace Nz::ShaderLang
Consume();
return ShaderBuilder::Constant(true);
case TokenType::ConstSelect:
return ParseConstSelectExpression();
case TokenType::FloatingPointValue:
return ParseFloatingPointExpression();
@ -1097,34 +1120,11 @@ namespace Nz::ShaderLang
case TokenType::OpenParenthesis:
return ParseParenthesisExpression();
case TokenType::SelectOpt:
return ParseSelectOptExpression();
default:
throw UnexpectedToken{};
}
}
ShaderAst::ExpressionPtr Parser::ParseSelectOptExpression()
{
Expect(Advance(), TokenType::SelectOpt);
Expect(Advance(), TokenType::OpenParenthesis);
std::string optionName = ParseIdentifierAsName();
Expect(Advance(), TokenType::Comma);
ShaderAst::ExpressionPtr trueExpr = ParseExpression();
Expect(Advance(), TokenType::Comma);
ShaderAst::ExpressionPtr falseExpr = ParseExpression();
Expect(Advance(), TokenType::ClosingParenthesis);
return ShaderBuilder::SelectOption(std::move(optionName), std::move(trueExpr), std::move(falseExpr));
}
ShaderAst::AttributeType Parser::ParseIdentifierAsAttributeType()
{
const Token& identifierToken = Expect(Advance(), TokenType::Identifier);