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

Renderer: Rename enums

Browse Source 
ExpressionType => BasicType
ShaderAst::Type => ShaderExpressionType
This commit is contained in:
Jérôme Leclercq
2020-07-16 18:34:58 +02:00
parent c7a8091e68
commit 1d2fb88198
26 changed files with 210 additions and 184 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/Nazara/OpenGLRenderer/Wrapper/Context.cpp
View File

@@ -278,6 +278,8 @@ namespace Nz::GL
glGetIntegerv(GL_VIEWPORT, res.data());
m_state.viewport = { res[0], res[1], res[2], res[3] };
EnableVerticalSync(false);
return true;
}

7
src/Nazara/OpenGLRenderer/Wrapper/Win32/WGLContext.cpp
View File

@@ -67,6 +67,13 @@ namespace Nz::GL
void WGLContext::EnableVerticalSync(bool enabled)
{
if (wglSwapIntervalEXT)
{
if (!SetCurrentContext(this))
return;
wglSwapIntervalEXT(enabled);
}
}
void WGLContext::SwapBuffers()

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

@@ -163,7 +163,7 @@ namespace Nz
m_environment = std::move(environment);
}
void GlslWriter::Append(ShaderAst::Type type)
void GlslWriter::Append(ShaderExpressionType type)
{
std::visit([&](auto&& arg)
{
@@ -181,32 +181,32 @@ namespace Nz
}
}
void GlslWriter::Append(ShaderNodes::ExpressionType type)
void GlslWriter::Append(ShaderNodes::BasicType type)
{
switch (type)
{
case ShaderNodes::ExpressionType::Boolean:
case ShaderNodes::BasicType::Boolean:
Append("bool");
break;
case ShaderNodes::ExpressionType::Float1:
case ShaderNodes::BasicType::Float1:
Append("float");
break;
case ShaderNodes::ExpressionType::Float2:
case ShaderNodes::BasicType::Float2:
Append("vec2");
break;
case ShaderNodes::ExpressionType::Float3:
case ShaderNodes::BasicType::Float3:
Append("vec3");
break;
case ShaderNodes::ExpressionType::Float4:
case ShaderNodes::BasicType::Float4:
Append("vec4");
break;
case ShaderNodes::ExpressionType::Mat4x4:
case ShaderNodes::BasicType::Mat4x4:
Append("mat4");
break;
case ShaderNodes::ExpressionType::Sampler2D:
case ShaderNodes::BasicType::Sampler2D:
Append("sampler2D");
break;
case ShaderNodes::ExpressionType::Void:
case ShaderNodes::BasicType::Void:
Append("void");
break;
}
@@ -395,23 +395,23 @@ namespace Nz
{
switch (node.exprType)
{
case ShaderNodes::ExpressionType::Boolean:
case ShaderNodes::BasicType::Boolean:
Append((node.values.bool1) ? "true" : "false");
break;
case ShaderNodes::ExpressionType::Float1:
case ShaderNodes::BasicType::Float1:
Append(std::to_string(node.values.vec1));
break;
case ShaderNodes::ExpressionType::Float2:
case ShaderNodes::BasicType::Float2:
Append("vec2(" + std::to_string(node.values.vec2.x) + ", " + std::to_string(node.values.vec2.y) + ")");
break;
case ShaderNodes::ExpressionType::Float3:
case ShaderNodes::BasicType::Float3:
Append("vec3(" + std::to_string(node.values.vec3.x) + ", " + std::to_string(node.values.vec3.y) + ", " + std::to_string(node.values.vec3.z) + ")");
break;
case ShaderNodes::ExpressionType::Float4:
case ShaderNodes::BasicType::Float4:
Append("vec4(" + std::to_string(node.values.vec4.x) + ", " + std::to_string(node.values.vec4.y) + ", " + std::to_string(node.values.vec4.z) + ", " + std::to_string(node.values.vec4.w) + ")");
break;

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

@@ -7,7 +7,7 @@
namespace Nz
{
void ShaderAst::AddFunction(std::string name, ShaderNodes::StatementPtr statement, std::vector<FunctionParameter> parameters, ShaderNodes::ExpressionType returnType)
void ShaderAst::AddFunction(std::string name, ShaderNodes::StatementPtr statement, std::vector<FunctionParameter> parameters, ShaderNodes::BasicType returnType)
{
auto& functionEntry = m_functions.emplace_back();
functionEntry.name = std::move(name);
@@ -16,7 +16,7 @@ namespace Nz
functionEntry.statement = std::move(statement);
}
void ShaderAst::AddInput(std::string name, Type type, std::optional<std::size_t> locationIndex)
void ShaderAst::AddInput(std::string name, ShaderExpressionType type, std::optional<std::size_t> locationIndex)
{
auto& inputEntry = m_inputs.emplace_back();
inputEntry.name = std::move(name);
@@ -24,7 +24,7 @@ namespace Nz
inputEntry.type = std::move(type);
}
void ShaderAst::AddOutput(std::string name, Type type, std::optional<std::size_t> locationIndex)
void ShaderAst::AddOutput(std::string name, ShaderExpressionType type, std::optional<std::size_t> locationIndex)
{
auto& outputEntry = m_outputs.emplace_back();
outputEntry.name = std::move(name);
@@ -39,7 +39,7 @@ namespace Nz
structEntry.members = std::move(members);
}
void ShaderAst::AddUniform(std::string name, Type type, std::optional<std::size_t> bindingIndex, std::optional<ShaderNodes::MemoryLayout> memoryLayout)
void ShaderAst::AddUniform(std::string name, ShaderExpressionType type, std::optional<std::size_t> bindingIndex, std::optional<ShaderNodes::MemoryLayout> memoryLayout)
{
auto& uniformEntry = m_uniforms.emplace_back();
uniformEntry.bindingIndex = std::move(bindingIndex);

32
src/Nazara/Renderer/ShaderNodes.cpp
View File

@@ -47,7 +47,7 @@ namespace Nz::ShaderNodes
return ExpressionCategory::LValue;
}
ExpressionType Identifier::GetExpressionType() const
BasicType Identifier::GetExpressionType() const
{
assert(var);
return var->type;
@@ -59,7 +59,7 @@ namespace Nz::ShaderNodes
}
ExpressionType AssignOp::GetExpressionType() const
BasicType AssignOp::GetExpressionType() const
{
return left->GetExpressionType();
}
@@ -70,9 +70,9 @@ namespace Nz::ShaderNodes
}
ExpressionType BinaryOp::GetExpressionType() const
BasicType BinaryOp::GetExpressionType() const
{
ShaderNodes::ExpressionType exprType = ShaderNodes::ExpressionType::Void;
ShaderNodes::BasicType exprType = ShaderNodes::BasicType::Void;
switch (op)
{
@@ -84,15 +84,15 @@ namespace Nz::ShaderNodes
case ShaderNodes::BinaryType::Divide:
case ShaderNodes::BinaryType::Multiply:
//FIXME
exprType = static_cast<ExpressionType>(std::max(UnderlyingCast(left->GetExpressionType()), UnderlyingCast(right->GetExpressionType())));
exprType = static_cast<BasicType>(std::max(UnderlyingCast(left->GetExpressionType()), UnderlyingCast(right->GetExpressionType())));
break;
case ShaderNodes::BinaryType::Equality:
exprType = ExpressionType::Boolean;
exprType = BasicType::Boolean;
break;
}
NazaraAssert(exprType != ShaderNodes::ExpressionType::Void, "Unhandled builtin");
NazaraAssert(exprType != ShaderNodes::BasicType::Void, "Unhandled builtin");
return exprType;
}
@@ -109,7 +109,7 @@ namespace Nz::ShaderNodes
}
ExpressionType Constant::GetExpressionType() const
BasicType Constant::GetExpressionType() const
{
return exprType;
}
@@ -119,7 +119,7 @@ namespace Nz::ShaderNodes
visitor.Visit(*this);
}
ExpressionType Cast::GetExpressionType() const
BasicType Cast::GetExpressionType() const
{
return exprType;
}
@@ -135,9 +135,9 @@ namespace Nz::ShaderNodes
return ExpressionCategory::LValue;
}
ExpressionType SwizzleOp::GetExpressionType() const
BasicType SwizzleOp::GetExpressionType() const
{
return static_cast<ExpressionType>(UnderlyingCast(GetComponentType(expression->GetExpressionType())) + componentCount - 1);
return static_cast<BasicType>(UnderlyingCast(GetComponentType(expression->GetExpressionType())) + componentCount - 1);
}
void SwizzleOp::Visit(ShaderVisitor& visitor)
@@ -146,9 +146,9 @@ namespace Nz::ShaderNodes
}
ExpressionType Sample2D::GetExpressionType() const
BasicType Sample2D::GetExpressionType() const
{
return ExpressionType::Float4;
return BasicType::Float4;
}
void Sample2D::Visit(ShaderVisitor& visitor)
@@ -157,7 +157,7 @@ namespace Nz::ShaderNodes
}
ExpressionType IntrinsicCall::GetExpressionType() const
BasicType IntrinsicCall::GetExpressionType() const
{
switch (intrinsic)
{
@@ -165,11 +165,11 @@ namespace Nz::ShaderNodes
return parameters.front()->GetExpressionType();
case IntrinsicType::DotProduct:
return ExpressionType::Float1;
return BasicType::Float1;
}
NazaraAssert(false, "Unhandled builtin");
return ExpressionType::Void;
return BasicType::Void;
}
void IntrinsicCall::Visit(ShaderVisitor& visitor)

26
src/Nazara/Renderer/ShaderSerializer.cpp
View File

@@ -170,23 +170,23 @@ namespace Nz
switch (node.exprType)
{
case ShaderNodes::ExpressionType::Boolean:
case ShaderNodes::BasicType::Boolean:
Value(node.values.bool1);
break;
case ShaderNodes::ExpressionType::Float1:
case ShaderNodes::BasicType::Float1:
Value(node.values.vec1);
break;
case ShaderNodes::ExpressionType::Float2:
case ShaderNodes::BasicType::Float2:
Value(node.values.vec2);
break;
case ShaderNodes::ExpressionType::Float3:
case ShaderNodes::BasicType::Float3:
Value(node.values.vec3);
break;
case ShaderNodes::ExpressionType::Float4:
case ShaderNodes::BasicType::Float4:
Value(node.values.vec4);
break;
}
@@ -249,12 +249,12 @@ namespace Nz
{
m_stream << s_magicNumber << s_currentVersion;
auto SerializeType = [&](const ShaderAst::Type& type)
auto SerializeType = [&](const ShaderExpressionType& type)
{
std::visit([&](auto&& arg)
{
using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, ShaderNodes::ExpressionType>)
if constexpr (std::is_same_v<T, ShaderNodes::BasicType>)
{
m_stream << UInt8(0);
m_stream << UInt32(arg);
@@ -448,7 +448,7 @@ namespace Nz
for (UInt32 i = 0; i < inputCount; ++i)
{
std::string inputName;
ShaderAst::Type inputType;
ShaderExpressionType inputType;
std::optional<std::size_t> location;
Value(inputName);
@@ -463,7 +463,7 @@ namespace Nz
for (UInt32 i = 0; i < outputCount; ++i)
{
std::string outputName;
ShaderAst::Type outputType;
ShaderExpressionType outputType;
std::optional<std::size_t> location;
Value(outputName);
@@ -478,7 +478,7 @@ namespace Nz
for (UInt32 i = 0; i < uniformCount; ++i)
{
std::string name;
ShaderAst::Type type;
ShaderExpressionType type;
std::optional<std::size_t> binding;
std::optional<ShaderNodes::MemoryLayout> memLayout;
@@ -495,7 +495,7 @@ namespace Nz
for (UInt32 i = 0; i < funcCount; ++i)
{
std::string name;
ShaderNodes::ExpressionType retType;
ShaderNodes::BasicType retType;
std::vector<ShaderAst::FunctionParameter> parameters;
Value(name);
@@ -560,7 +560,7 @@ namespace Nz
}
}
void ShaderUnserializer::Type(ShaderAst::Type& type)
void ShaderUnserializer::Type(ShaderExpressionType& type)
{
UInt8 typeIndex;
Value(typeIndex);
@@ -569,7 +569,7 @@ namespace Nz
{
case 0: //< Primitive
{
ShaderNodes::ExpressionType exprType;
ShaderNodes::BasicType exprType;
Enum(exprType);
type = exprType;

44
src/Nazara/Renderer/ShaderValidator.cpp
View File

@@ -21,7 +21,7 @@ namespace Nz
struct Local
{
std::string name;
ShaderNodes::ExpressionType type;
ShaderNodes::BasicType type;
};
const ShaderAst::Function* currentFunction;
@@ -77,7 +77,7 @@ namespace Nz
return TypeMustMatch(left->GetExpressionType(), right->GetExpressionType());
}
void ShaderValidator::TypeMustMatch(const ShaderAst::Type& left, const ShaderAst::Type& right)
void ShaderValidator::TypeMustMatch(const ShaderExpressionType& left, const ShaderExpressionType& right)
{
if (left != right)
throw AstError{ "Left expression type must match right expression type" };
@@ -101,8 +101,8 @@ namespace Nz
MandatoryNode(node.left);
MandatoryNode(node.right);
ShaderNodes::ExpressionType leftType = node.left->GetExpressionType();
ShaderNodes::ExpressionType rightType = node.right->GetExpressionType();
ShaderNodes::BasicType leftType = node.left->GetExpressionType();
ShaderNodes::BasicType rightType = node.right->GetExpressionType();
switch (node.op)
{
@@ -117,31 +117,31 @@ namespace Nz
{
switch (leftType)
{
case ShaderNodes::ExpressionType::Float1:
case ShaderNodes::BasicType::Float1:
{
if (ShaderNodes::Node::GetComponentType(rightType) != ShaderNodes::ExpressionType::Float1)
if (ShaderNodes::Node::GetComponentType(rightType) != ShaderNodes::BasicType::Float1)
throw AstError{ "Left expression type is not compatible with right expression type" };
break;
}
case ShaderNodes::ExpressionType::Float2:
case ShaderNodes::ExpressionType::Float3:
case ShaderNodes::ExpressionType::Float4:
case ShaderNodes::BasicType::Float2:
case ShaderNodes::BasicType::Float3:
case ShaderNodes::BasicType::Float4:
{
if (leftType != rightType && rightType != ShaderNodes::ExpressionType::Float1)
if (leftType != rightType && rightType != ShaderNodes::BasicType::Float1)
throw AstError{ "Left expression type is not compatible with right expression type" };
break;
}
case ShaderNodes::ExpressionType::Mat4x4:
case ShaderNodes::BasicType::Mat4x4:
{
switch (rightType)
{
case ShaderNodes::ExpressionType::Float1:
case ShaderNodes::ExpressionType::Float4:
case ShaderNodes::ExpressionType::Mat4x4:
case ShaderNodes::BasicType::Float1:
case ShaderNodes::BasicType::Float4:
case ShaderNodes::BasicType::Mat4x4:
break;
default:
@@ -318,7 +318,7 @@ namespace Nz
for (auto& param : node.parameters)
MandatoryNode(param);
ShaderNodes::ExpressionType type = node.parameters.front()->GetExpressionType();
ShaderNodes::BasicType type = node.parameters.front()->GetExpressionType();
for (std::size_t i = 1; i < node.parameters.size(); ++i)
{
if (type != node.parameters[i]->GetExpressionType())
@@ -333,7 +333,7 @@ namespace Nz
{
case ShaderNodes::IntrinsicType::CrossProduct:
{
if (node.parameters[0]->GetExpressionType() != ShaderNodes::ExpressionType::Float3)
if (node.parameters[0]->GetExpressionType() != ShaderNodes::BasicType::Float3)
throw AstError{ "CrossProduct only works with Float3 expressions" };
break;
@@ -349,10 +349,10 @@ namespace Nz
void ShaderValidator::Visit(const ShaderNodes::Sample2D& node)
{
if (MandatoryExpr(node.sampler)->GetExpressionType() != ShaderNodes::ExpressionType::Sampler2D)
if (MandatoryExpr(node.sampler)->GetExpressionType() != ShaderNodes::BasicType::Sampler2D)
throw AstError{ "Sampler must be a Sampler2D" };
if (MandatoryExpr(node.coordinates)->GetExpressionType() != ShaderNodes::ExpressionType::Float2)
if (MandatoryExpr(node.coordinates)->GetExpressionType() != ShaderNodes::BasicType::Float2)
throw AstError{ "Coordinates must be a Float2" };
Visit(node.sampler);
@@ -380,10 +380,10 @@ namespace Nz
switch (MandatoryExpr(node.expression)->GetExpressionType())
{
case ShaderNodes::ExpressionType::Float1:
case ShaderNodes::ExpressionType::Float2:
case ShaderNodes::ExpressionType::Float3:
case ShaderNodes::ExpressionType::Float4:
case ShaderNodes::BasicType::Float1:
case ShaderNodes::BasicType::Float2:
case ShaderNodes::BasicType::Float3:
case ShaderNodes::BasicType::Float4:
break;
default: