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

Shader: Replace select_opt by const_select

Browse Source
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
Download Patch File Download Diff File Expand all files Collapse all files

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);