From f93a4287cf833134020e5b35c4b800c2edff1b94 Mon Sep 17 00:00:00 2001 From: Ninni Pipping Date: Thu, 11 May 2023 12:32:23 +0200 Subject: Enable shadow warnings and fix raised errors (cherry picked from commit 71ee65dc5701a0675ae6b1879a694a28c7206a63) --- servers/rendering/shader_compiler.cpp | 36 +++++------ servers/rendering/shader_language.cpp | 114 +++++++++++++++++----------------- servers/rendering/shader_language.h | 48 +++++++------- 3 files changed, 99 insertions(+), 99 deletions(-) (limited to 'servers') diff --git a/servers/rendering/shader_compiler.cpp b/servers/rendering/shader_compiler.cpp index 8737d3b217..1f889572df 100644 --- a/servers/rendering/shader_compiler.cpp +++ b/servers/rendering/shader_compiler.cpp @@ -441,7 +441,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene String code; switch (p_node->type) { - case SL::Node::TYPE_SHADER: { + case SL::Node::NODE_TYPE_SHADER: { SL::ShaderNode *pnode = (SL::ShaderNode *)p_node; for (int i = 0; i < pnode->render_modes.size(); i++) { @@ -786,11 +786,11 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene //code+=dump_node_code(pnode->body,p_level); } break; - case SL::Node::TYPE_STRUCT: { + case SL::Node::NODE_TYPE_STRUCT: { } break; - case SL::Node::TYPE_FUNCTION: { + case SL::Node::NODE_TYPE_FUNCTION: { } break; - case SL::Node::TYPE_BLOCK: { + case SL::Node::NODE_TYPE_BLOCK: { SL::BlockNode *bnode = (SL::BlockNode *)p_node; //variables @@ -801,7 +801,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene for (int i = 0; i < bnode->statements.size(); i++) { String scode = _dump_node_code(bnode->statements[i], p_level, r_gen_code, p_actions, p_default_actions, p_assigning); - if (bnode->statements[i]->type == SL::Node::TYPE_CONTROL_FLOW || bnode->single_statement) { + if (bnode->statements[i]->type == SL::Node::NODE_TYPE_CONTROL_FLOW || bnode->single_statement) { code += scode; //use directly if (bnode->use_comma_between_statements && i + 1 < bnode->statements.size()) { code += ","; @@ -815,7 +815,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene } } break; - case SL::Node::TYPE_VARIABLE_DECLARATION: { + case SL::Node::NODE_TYPE_VARIABLE_DECLARATION: { SL::VariableDeclarationNode *vdnode = (SL::VariableDeclarationNode *)p_node; String declaration; @@ -873,7 +873,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene code += declaration; } break; - case SL::Node::TYPE_VARIABLE: { + case SL::Node::NODE_TYPE_VARIABLE: { SL::VariableNode *vnode = (SL::VariableNode *)p_node; bool use_fragment_varying = false; @@ -966,7 +966,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene } } break; - case SL::Node::TYPE_ARRAY_CONSTRUCT: { + case SL::Node::NODE_TYPE_ARRAY_CONSTRUCT: { SL::ArrayConstructNode *acnode = (SL::ArrayConstructNode *)p_node; int sz = acnode->initializer.size(); if (acnode->datatype == SL::TYPE_STRUCT) { @@ -986,7 +986,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene } code += ")"; } break; - case SL::Node::TYPE_ARRAY: { + case SL::Node::NODE_TYPE_ARRAY: { SL::ArrayNode *anode = (SL::ArrayNode *)p_node; bool use_fragment_varying = false; @@ -1077,7 +1077,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene } } break; - case SL::Node::TYPE_CONSTANT: { + case SL::Node::NODE_TYPE_CONSTANT: { SL::ConstantNode *cnode = (SL::ConstantNode *)p_node; if (cnode->array_size == 0) { @@ -1104,7 +1104,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene } } break; - case SL::Node::TYPE_OPERATOR: { + case SL::Node::NODE_TYPE_OPERATOR: { SL::OperatorNode *onode = (SL::OperatorNode *)p_node; switch (onode->op) { @@ -1135,7 +1135,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene case SL::OP_CALL: case SL::OP_STRUCT: case SL::OP_CONSTRUCT: { - ERR_FAIL_COND_V(onode->arguments[0]->type != SL::Node::TYPE_VARIABLE, String()); + ERR_FAIL_COND_V(onode->arguments[0]->type != SL::Node::NODE_TYPE_VARIABLE, String()); const SL::VariableNode *vnode = static_cast(onode->arguments[0]); const SL::FunctionNode *func = nullptr; const bool is_internal_func = internal_functions.has(vnode->name); @@ -1205,12 +1205,12 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene bool done = false; do { switch (node->type) { - case SL::Node::TYPE_VARIABLE: { + case SL::Node::NODE_TYPE_VARIABLE: { name = static_cast(node)->name; done = true; found = true; } break; - case SL::Node::TYPE_MEMBER: { + case SL::Node::NODE_TYPE_MEMBER: { node = static_cast(node)->owner; } break; default: { @@ -1232,12 +1232,12 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene bool correct_texture_uniform = false; switch (onode->arguments[i]->type) { - case SL::Node::TYPE_VARIABLE: { + case SL::Node::NODE_TYPE_VARIABLE: { const SL::VariableNode *varnode = static_cast(onode->arguments[i]); texture_uniform = varnode->name; correct_texture_uniform = true; } break; - case SL::Node::TYPE_ARRAY: { + case SL::Node::NODE_TYPE_ARRAY: { const SL::ArrayNode *anode = static_cast(onode->arguments[i]); texture_uniform = anode->name; correct_texture_uniform = true; @@ -1366,7 +1366,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene } } break; - case SL::Node::TYPE_CONTROL_FLOW: { + case SL::Node::NODE_TYPE_CONTROL_FLOW: { SL::ControlFlowNode *cfnode = (SL::ControlFlowNode *)p_node; if (cfnode->flow_op == SL::FLOW_OP_IF) { code += _mktab(p_level) + "if (" + _dump_node_code(cfnode->expressions[0], p_level, r_gen_code, p_actions, p_default_actions, p_assigning) + ")\n"; @@ -1418,7 +1418,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene } } break; - case SL::Node::TYPE_MEMBER: { + case SL::Node::NODE_TYPE_MEMBER: { SL::MemberNode *mnode = (SL::MemberNode *)p_node; code = _dump_node_code(mnode->owner, p_level, r_gen_code, p_actions, p_default_actions, p_assigning) + "." + mnode->name; if (mnode->index_expression != nullptr) { diff --git a/servers/rendering/shader_language.cpp b/servers/rendering/shader_language.cpp index 084fb64a53..0e880e5cf1 100644 --- a/servers/rendering/shader_language.cpp +++ b/servers/rendering/shader_language.cpp @@ -3063,7 +3063,7 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const FunctionI Vector args2; Vector args3; - ERR_FAIL_COND_V(p_func->arguments[0]->type != Node::TYPE_VARIABLE, false); + ERR_FAIL_COND_V(p_func->arguments[0]->type != Node::NODE_TYPE_VARIABLE, false); StringName name = static_cast(p_func->arguments[0])->name.operator String(); @@ -3117,14 +3117,14 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const FunctionI failed_builtin = true; bool fail = false; for (int i = 0; i < argcount; i++) { - if (p_func->arguments[i + 1]->type == Node::TYPE_ARRAY) { + if (p_func->arguments[i + 1]->type == Node::NODE_TYPE_ARRAY) { const ArrayNode *anode = static_cast(p_func->arguments[i + 1]); if (anode->call_expression == nullptr && !anode->is_indexed()) { fail = true; break; } } - if (get_scalar_type(args[i]) == args[i] && p_func->arguments[i + 1]->type == Node::TYPE_CONSTANT && convert_constant(static_cast(p_func->arguments[i + 1]), builtin_func_defs[idx].args[i])) { + if (get_scalar_type(args[i]) == args[i] && p_func->arguments[i + 1]->type == Node::NODE_TYPE_CONSTANT && convert_constant(static_cast(p_func->arguments[i + 1]), builtin_func_defs[idx].args[i])) { //all good, but needs implicit conversion later } else if (args[i] != builtin_func_defs[idx].args[i]) { fail = true; @@ -3160,7 +3160,7 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const FunctionI int max = builtin_func_const_args[constarg_idx].max; bool error = false; - if (p_func->arguments[arg]->type == Node::TYPE_VARIABLE) { + if (p_func->arguments[arg]->type == Node::NODE_TYPE_VARIABLE) { const VariableNode *vn = static_cast(p_func->arguments[arg]); bool is_const = false; @@ -3172,7 +3172,7 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const FunctionI error = true; } } else { - if (p_func->arguments[arg]->type == Node::TYPE_CONSTANT) { + if (p_func->arguments[arg]->type == Node::NODE_TYPE_CONSTANT) { const ConstantNode *cn = static_cast(p_func->arguments[arg]); if (cn->get_datatype() == TYPE_INT && cn->values.size() == 1) { @@ -3207,17 +3207,17 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const FunctionI break; } if (arg_idx < argcount) { - if (p_func->arguments[arg_idx + 1]->type != Node::TYPE_VARIABLE && p_func->arguments[arg_idx + 1]->type != Node::TYPE_MEMBER && p_func->arguments[arg_idx + 1]->type != Node::TYPE_ARRAY) { + if (p_func->arguments[arg_idx + 1]->type != Node::NODE_TYPE_VARIABLE && p_func->arguments[arg_idx + 1]->type != Node::NODE_TYPE_MEMBER && p_func->arguments[arg_idx + 1]->type != Node::NODE_TYPE_ARRAY) { _set_error(vformat(RTR("Argument %d of function '%s' is not a variable, array, or member."), arg_idx + 1, String(name))); return false; } - if (p_func->arguments[arg_idx + 1]->type == Node::TYPE_ARRAY) { + if (p_func->arguments[arg_idx + 1]->type == Node::NODE_TYPE_ARRAY) { ArrayNode *mn = static_cast(p_func->arguments[arg_idx + 1]); if (mn->is_const) { fail = true; } - } else if (p_func->arguments[arg_idx + 1]->type == Node::TYPE_MEMBER) { + } else if (p_func->arguments[arg_idx + 1]->type == Node::NODE_TYPE_MEMBER) { MemberNode *mn = static_cast(p_func->arguments[arg_idx + 1]); if (mn->basetype_const) { fail = true; @@ -3250,18 +3250,18 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const FunctionI } StringName var_name; - if (p_func->arguments[arg_idx + 1]->type == Node::TYPE_ARRAY) { + if (p_func->arguments[arg_idx + 1]->type == Node::NODE_TYPE_ARRAY) { var_name = static_cast(p_func->arguments[arg_idx + 1])->name; - } else if (p_func->arguments[arg_idx + 1]->type == Node::TYPE_MEMBER) { + } else if (p_func->arguments[arg_idx + 1]->type == Node::NODE_TYPE_MEMBER) { Node *n = static_cast(p_func->arguments[arg_idx + 1])->owner; - while (n->type == Node::TYPE_MEMBER) { + while (n->type == Node::NODE_TYPE_MEMBER) { n = static_cast(n)->owner; } - if (n->type != Node::TYPE_VARIABLE && n->type != Node::TYPE_ARRAY) { + if (n->type != Node::NODE_TYPE_VARIABLE && n->type != Node::NODE_TYPE_ARRAY) { _set_error(vformat(RTR("Argument %d of function '%s' is not a variable, array, or member."), arg_idx + 1, String(name))); return false; } - if (n->type == Node::TYPE_VARIABLE) { + if (n->type == Node::NODE_TYPE_VARIABLE) { var_name = static_cast(n)->name; } else { // TYPE_ARRAY var_name = static_cast(n)->name; @@ -3298,7 +3298,7 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const FunctionI } //implicitly convert values if possible for (int i = 0; i < argcount; i++) { - if (get_scalar_type(args[i]) != args[i] || args[i] == builtin_func_defs[idx].args[i] || p_func->arguments[i + 1]->type != Node::TYPE_CONSTANT) { + if (get_scalar_type(args[i]) != args[i] || args[i] == builtin_func_defs[idx].args[i] || p_func->arguments[i + 1]->type != Node::NODE_TYPE_CONSTANT) { //can't do implicit conversion here continue; } @@ -3422,7 +3422,7 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const FunctionI bool fail = false; for (int j = 0; j < args.size(); j++) { - if (get_scalar_type(args[j]) == args[j] && p_func->arguments[j + 1]->type == Node::TYPE_CONSTANT && args3[j] == 0 && convert_constant(static_cast(p_func->arguments[j + 1]), pfunc->arguments[j].type)) { + if (get_scalar_type(args[j]) == args[j] && p_func->arguments[j + 1]->type == Node::NODE_TYPE_CONSTANT && args3[j] == 0 && convert_constant(static_cast(p_func->arguments[j + 1]), pfunc->arguments[j].type)) { //all good, but it needs implicit conversion later } else if (args[j] != pfunc->arguments[j].type || (args[j] == TYPE_STRUCT && args2[j] != pfunc->arguments[j].type_str) || args3[j] != pfunc->arguments[j].array_size) { String func_arg_name; @@ -3457,7 +3457,7 @@ bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const FunctionI if (!fail) { //implicitly convert values if possible for (int k = 0; k < args.size(); k++) { - if (get_scalar_type(args[k]) != args[k] || args[k] == pfunc->arguments[k].type || p_func->arguments[k + 1]->type != Node::TYPE_CONSTANT) { + if (get_scalar_type(args[k]) != args[k] || args[k] == pfunc->arguments[k].type || p_func->arguments[k + 1]->type != Node::NODE_TYPE_CONSTANT) { //can't do implicit conversion here continue; } @@ -3565,7 +3565,7 @@ bool ShaderLanguage::_parse_function_arguments(BlockNode *p_block, const Functio return false; } - if (is_const_decl && arg->type == Node::TYPE_VARIABLE) { + if (is_const_decl && arg->type == Node::NODE_TYPE_VARIABLE) { const VariableNode *var = static_cast(arg); if (!var->is_const) { _set_error(RTR("Expected constant expression.")); @@ -4531,7 +4531,7 @@ bool ShaderLanguage::_validate_varying_assign(ShaderNode::Varying &p_varying, St bool ShaderLanguage::_check_node_constness(const Node *p_node) const { switch (p_node->type) { - case Node::TYPE_OPERATOR: { + case Node::NODE_TYPE_OPERATOR: { const OperatorNode *op_node = static_cast(p_node); for (int i = int(op_node->op == OP_CALL); i < op_node->arguments.size(); i++) { if (!_check_node_constness(op_node->arguments[i])) { @@ -4539,15 +4539,15 @@ bool ShaderLanguage::_check_node_constness(const Node *p_node) const { } } } break; - case Node::TYPE_CONSTANT: + case Node::NODE_TYPE_CONSTANT: break; - case Node::TYPE_VARIABLE: { + case Node::NODE_TYPE_VARIABLE: { const VariableNode *var_node = static_cast(p_node); if (!var_node->is_const) { return false; } } break; - case Node::TYPE_ARRAY: { + case Node::NODE_TYPE_ARRAY: { const ArrayNode *arr_node = static_cast(p_node); if (!arr_node->is_const) { return false; @@ -4560,7 +4560,7 @@ bool ShaderLanguage::_check_node_constness(const Node *p_node) const { } bool ShaderLanguage::_validate_assign(Node *p_node, const FunctionInfo &p_function_info, String *r_message) { - if (p_node->type == Node::TYPE_OPERATOR) { + if (p_node->type == Node::NODE_TYPE_OPERATOR) { OperatorNode *op = static_cast(p_node); if (op->op == OP_INDEX) { @@ -4577,7 +4577,7 @@ bool ShaderLanguage::_validate_assign(Node *p_node, const FunctionInfo &p_functi return false; } - } else if (p_node->type == Node::TYPE_MEMBER) { + } else if (p_node->type == Node::NODE_TYPE_MEMBER) { MemberNode *member = static_cast(p_node); if (member->has_swizzling_duplicates) { @@ -4589,7 +4589,7 @@ bool ShaderLanguage::_validate_assign(Node *p_node, const FunctionInfo &p_functi return _validate_assign(member->owner, p_function_info, r_message); - } else if (p_node->type == Node::TYPE_VARIABLE) { + } else if (p_node->type == Node::NODE_TYPE_VARIABLE) { VariableNode *var = static_cast(p_node); if (shader->uniforms.has(var->name)) { @@ -4609,7 +4609,7 @@ bool ShaderLanguage::_validate_assign(Node *p_node, const FunctionInfo &p_functi if (!(p_function_info.built_ins.has(var->name) && p_function_info.built_ins[var->name].constant)) { return true; } - } else if (p_node->type == Node::TYPE_ARRAY) { + } else if (p_node->type == Node::NODE_TYPE_ARRAY) { ArrayNode *arr = static_cast(p_node); if (shader->constants.has(arr->name) || arr->is_const) { @@ -4727,7 +4727,7 @@ Error ShaderLanguage::_parse_array_size(BlockNode *p_block, const FunctionInfo & _set_tkpos(pos); Node *n = _parse_and_reduce_expression(p_block, p_function_info); if (n) { - if (n->type == Node::TYPE_VARIABLE) { + if (n->type == Node::NODE_TYPE_VARIABLE) { VariableNode *vn = static_cast(n); if (vn) { ConstantNode::Value v; @@ -4750,7 +4750,7 @@ Error ShaderLanguage::_parse_array_size(BlockNode *p_block, const FunctionInfo & } } } - } else if (n->type == Node::TYPE_OPERATOR) { + } else if (n->type == Node::NODE_TYPE_OPERATOR) { _set_error(vformat(RTR("Array size expressions are not supported."))); return ERR_PARSE_ERROR; } @@ -5296,10 +5296,10 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons ArgumentQualifier arg_qual = call_function->arguments[i].qualifier; bool is_out_arg = arg_qual != ArgumentQualifier::ARGUMENT_QUALIFIER_IN; - if (n->type == Node::TYPE_VARIABLE || n->type == Node::TYPE_ARRAY) { + if (n->type == Node::NODE_TYPE_VARIABLE || n->type == Node::NODE_TYPE_ARRAY) { StringName varname; - if (n->type == Node::TYPE_VARIABLE) { + if (n->type == Node::NODE_TYPE_VARIABLE) { VariableNode *vn = static_cast(n); varname = vn->name; } else { // TYPE_ARRAY @@ -5347,23 +5347,23 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons if (is_const_arg || is_out_arg) { StringName varname; - if (n->type == Node::TYPE_CONSTANT || n->type == Node::TYPE_OPERATOR || n->type == Node::TYPE_ARRAY_CONSTRUCT) { + if (n->type == Node::NODE_TYPE_CONSTANT || n->type == Node::NODE_TYPE_OPERATOR || n->type == Node::NODE_TYPE_ARRAY_CONSTRUCT) { if (!is_const_arg) { error = true; } - } else if (n->type == Node::TYPE_ARRAY) { + } else if (n->type == Node::NODE_TYPE_ARRAY) { ArrayNode *an = static_cast(n); if (!is_const_arg && (an->call_expression != nullptr || an->is_const)) { error = true; } varname = an->name; - } else if (n->type == Node::TYPE_VARIABLE) { + } else if (n->type == Node::NODE_TYPE_VARIABLE) { VariableNode *vn = static_cast(n); if (vn->is_const && !is_const_arg) { error = true; } varname = vn->name; - } else if (n->type == Node::TYPE_MEMBER) { + } else if (n->type == Node::NODE_TYPE_MEMBER) { MemberNode *mn = static_cast(n); if (mn->basetype_const && is_out_arg) { error = true; @@ -5389,7 +5389,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons } if (is_sampler_type(call_function->arguments[i].type)) { //let's see where our argument comes from - ERR_CONTINUE(n->type != Node::TYPE_VARIABLE); //bug? this should always be a variable + ERR_CONTINUE(n->type != Node::NODE_TYPE_VARIABLE); //bug? this should always be a variable VariableNode *vn = static_cast(n); StringName varname = vn->name; if (shader->uniforms.has(varname)) { @@ -5599,7 +5599,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons return nullptr; } - if (index_expression->type == Node::TYPE_CONSTANT) { + if (index_expression->type == Node::NODE_TYPE_CONSTANT) { ConstantNode *cnode = static_cast(index_expression); if (cnode) { if (!cnode->values.is_empty()) { @@ -6064,7 +6064,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons return nullptr; } - if (index_expression->type == Node::TYPE_CONSTANT) { + if (index_expression->type == Node::NODE_TYPE_CONSTANT) { ConstantNode *cnode = static_cast(index_expression); if (cnode) { if (!cnode->values.is_empty()) { @@ -6118,7 +6118,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons String member_struct_name; if (expr->get_array_size() > 0) { - if (index->type == Node::TYPE_CONSTANT) { + if (index->type == Node::NODE_TYPE_CONSTANT) { uint32_t index_constant = static_cast(index)->values[0].uint; if (index_constant >= (uint32_t)expr->get_array_size()) { _set_error(vformat(RTR("Index [%d] out of range [%d..%d]."), index_constant, 0, expr->get_array_size() - 1)); @@ -6136,7 +6136,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons case TYPE_IVEC2: case TYPE_UVEC2: case TYPE_MAT2: - if (index->type == Node::TYPE_CONSTANT) { + if (index->type == Node::NODE_TYPE_CONSTANT) { uint32_t index_constant = static_cast(index)->values[0].uint; if (index_constant >= 2) { _set_error(vformat(RTR("Index [%d] out of range [%d..%d]."), index_constant, 0, 1)); @@ -6170,7 +6170,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons case TYPE_IVEC3: case TYPE_UVEC3: case TYPE_MAT3: - if (index->type == Node::TYPE_CONSTANT) { + if (index->type == Node::NODE_TYPE_CONSTANT) { uint32_t index_constant = static_cast(index)->values[0].uint; if (index_constant >= 3) { _set_error(vformat(RTR("Index [%d] out of range [%d..%d]."), index_constant, 0, 2)); @@ -6203,7 +6203,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons case TYPE_IVEC4: case TYPE_UVEC4: case TYPE_MAT4: - if (index->type == Node::TYPE_CONSTANT) { + if (index->type == Node::NODE_TYPE_CONSTANT) { uint32_t index_constant = static_cast(index)->values[0].uint; if (index_constant >= 4) { _set_error(vformat(RTR("Index [%d] out of range [%d..%d]."), index_constant, 0, 3)); @@ -6702,7 +6702,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons } ShaderLanguage::Node *ShaderLanguage::_reduce_expression(BlockNode *p_block, ShaderLanguage::Node *p_node) { - if (p_node->type != Node::TYPE_OPERATOR) { + if (p_node->type != Node::NODE_TYPE_OPERATOR) { return p_node; } @@ -6710,7 +6710,7 @@ ShaderLanguage::Node *ShaderLanguage::_reduce_expression(BlockNode *p_block, Sha OperatorNode *op = static_cast(p_node); if (op->op == OP_CONSTRUCT) { - ERR_FAIL_COND_V(op->arguments[0]->type != Node::TYPE_VARIABLE, p_node); + ERR_FAIL_COND_V(op->arguments[0]->type != Node::NODE_TYPE_VARIABLE, p_node); DataType type = op->get_datatype(); DataType base = get_scalar_type(type); @@ -6720,7 +6720,7 @@ ShaderLanguage::Node *ShaderLanguage::_reduce_expression(BlockNode *p_block, Sha for (int i = 1; i < op->arguments.size(); i++) { op->arguments.write[i] = _reduce_expression(p_block, op->arguments[i]); - if (op->arguments[i]->type == Node::TYPE_CONSTANT) { + if (op->arguments[i]->type == Node::NODE_TYPE_CONSTANT) { ConstantNode *cn = static_cast(op->arguments[i]); if (get_scalar_type(cn->datatype) == base) { @@ -6772,7 +6772,7 @@ ShaderLanguage::Node *ShaderLanguage::_reduce_expression(BlockNode *p_block, Sha return cn; } else if (op->op == OP_NEGATE) { op->arguments.write[0] = _reduce_expression(p_block, op->arguments[0]); - if (op->arguments[0]->type == Node::TYPE_CONSTANT) { + if (op->arguments[0]->type == Node::NODE_TYPE_CONSTANT) { ConstantNode *cn = static_cast(op->arguments[0]); DataType base = get_scalar_type(cn->datatype); @@ -7179,7 +7179,7 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const FunctionInfo &p_fun return ERR_PARSE_ERROR; } - if (is_const && n->type == Node::TYPE_OPERATOR && static_cast(n)->op == OP_CALL) { + if (is_const && n->type == Node::NODE_TYPE_OPERATOR && static_cast(n)->op == OP_CALL) { _set_error(RTR("Expected a constant expression.")); return ERR_PARSE_ERROR; } @@ -7235,7 +7235,7 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const FunctionInfo &p_fun if (!n) { return ERR_PARSE_ERROR; } - if (is_const && n->type == Node::TYPE_OPERATOR && static_cast(n)->op == OP_CALL) { + if (is_const && n->type == Node::NODE_TYPE_OPERATOR && static_cast(n)->op == OP_CALL) { OperatorNode *op = static_cast(n); for (int i = 1; i < op->arguments.size(); i++) { if (!_check_node_constness(op->arguments[i])) { @@ -7245,7 +7245,7 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const FunctionInfo &p_fun } } - if (n->type == Node::TYPE_CONSTANT) { + if (n->type == Node::NODE_TYPE_CONSTANT) { ConstantNode *const_node = static_cast(n); if (const_node && const_node->values.size() == 1) { var.value = const_node->values[0]; @@ -7412,7 +7412,7 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const FunctionInfo &p_fun ControlFlowNode *flow = static_cast(switch_block->statements[i]); if (flow) { if (flow->flow_op == FLOW_OP_CASE) { - if (flow->expressions[0]->type == Node::TYPE_CONSTANT) { + if (flow->expressions[0]->type == Node::NODE_TYPE_CONSTANT) { ConstantNode *cn = static_cast(flow->expressions[0]); if (!cn || cn->values.is_empty()) { return ERR_PARSE_ERROR; @@ -7422,7 +7422,7 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const FunctionInfo &p_fun return ERR_PARSE_ERROR; } constants.insert(cn->values[0].sint); - } else if (flow->expressions[0]->type == Node::TYPE_VARIABLE) { + } else if (flow->expressions[0]->type == Node::NODE_TYPE_VARIABLE) { VariableNode *vn = static_cast(flow->expressions[0]); if (!vn) { return ERR_PARSE_ERROR; @@ -7852,9 +7852,9 @@ Error ShaderLanguage::_parse_block(BlockNode *p_block, const FunctionInfo &p_fun if (!expr) { return ERR_PARSE_ERROR; } - is_condition = expr->type == Node::TYPE_OPERATOR && expr->get_datatype() == TYPE_BOOL; + is_condition = expr->type == Node::NODE_TYPE_OPERATOR && expr->get_datatype() == TYPE_BOOL; - if (expr->type == Node::TYPE_OPERATOR) { + if (expr->type == Node::NODE_TYPE_OPERATOR) { OperatorNode *op = static_cast(expr); if (op->op == OP_EMPTY) { is_var_init = true; @@ -8916,7 +8916,7 @@ Error ShaderLanguage::_parse_shader(const HashMap &p_f if (!expr) { return ERR_PARSE_ERROR; } - if (expr->type != Node::TYPE_CONSTANT) { + if (expr->type != Node::NODE_TYPE_CONSTANT) { _set_error(RTR("Expected constant expression after '='.")); return ERR_PARSE_ERROR; } @@ -9276,7 +9276,7 @@ Error ShaderLanguage::_parse_shader(const HashMap &p_f return ERR_PARSE_ERROR; } - if (n->type == Node::TYPE_OPERATOR && static_cast(n)->op == OP_CALL) { + if (n->type == Node::NODE_TYPE_OPERATOR && static_cast(n)->op == OP_CALL) { _set_error(RTR("Expected constant expression.")); return ERR_PARSE_ERROR; } @@ -9343,7 +9343,7 @@ Error ShaderLanguage::_parse_shader(const HashMap &p_f keyword_completion_context = CF_GLOBAL_SPACE; } #endif // DEBUG_ENABLED - if (expr->type == Node::TYPE_OPERATOR && static_cast(expr)->op == OP_CALL) { + if (expr->type == Node::NODE_TYPE_OPERATOR && static_cast(expr)->op == OP_CALL) { OperatorNode *op = static_cast(expr); for (int i = 1; i < op->arguments.size(); i++) { if (!_check_node_constness(op->arguments[i])) { @@ -9756,7 +9756,7 @@ Error ShaderLanguage::_find_last_flow_op_in_op(ControlFlowNode *p_flow, FlowOper bool found = false; for (int i = p_flow->blocks.size() - 1; i >= 0; i--) { - if (p_flow->blocks[i]->type == Node::TYPE_BLOCK) { + if (p_flow->blocks[i]->type == Node::NODE_TYPE_BLOCK) { BlockNode *last_block = static_cast(p_flow->blocks[i]); if (_find_last_flow_op_in_block(last_block, p_op) == OK) { found = true; @@ -9774,7 +9774,7 @@ Error ShaderLanguage::_find_last_flow_op_in_block(BlockNode *p_block, FlowOperat bool found = false; for (int i = p_block->statements.size() - 1; i >= 0; i--) { - if (p_block->statements[i]->type == Node::TYPE_CONTROL_FLOW) { + if (p_block->statements[i]->type == Node::NODE_TYPE_CONTROL_FLOW) { ControlFlowNode *flow = static_cast(p_block->statements[i]); if (flow->flow_op == p_op) { found = true; @@ -9785,7 +9785,7 @@ Error ShaderLanguage::_find_last_flow_op_in_block(BlockNode *p_block, FlowOperat break; } } - } else if (p_block->statements[i]->type == Node::TYPE_BLOCK) { + } else if (p_block->statements[i]->type == Node::NODE_TYPE_BLOCK) { BlockNode *block = static_cast(p_block->statements[i]); if (_find_last_flow_op_in_block(block, p_op) == OK) { found = true; diff --git a/servers/rendering/shader_language.h b/servers/rendering/shader_language.h index 220160e5fd..0ddd27f028 100644 --- a/servers/rendering/shader_language.h +++ b/servers/rendering/shader_language.h @@ -357,18 +357,18 @@ public: Node *next = nullptr; enum Type { - TYPE_SHADER, - TYPE_FUNCTION, - TYPE_BLOCK, - TYPE_VARIABLE, - TYPE_VARIABLE_DECLARATION, - TYPE_CONSTANT, - TYPE_OPERATOR, - TYPE_CONTROL_FLOW, - TYPE_MEMBER, - TYPE_ARRAY, - TYPE_ARRAY_CONSTRUCT, - TYPE_STRUCT, + NODE_TYPE_SHADER, + NODE_TYPE_FUNCTION, + NODE_TYPE_BLOCK, + NODE_TYPE_VARIABLE, + NODE_TYPE_VARIABLE_DECLARATION, + NODE_TYPE_CONSTANT, + NODE_TYPE_OPERATOR, + NODE_TYPE_CONTROL_FLOW, + NODE_TYPE_MEMBER, + NODE_TYPE_ARRAY, + NODE_TYPE_ARRAY_CONSTRUCT, + NODE_TYPE_STRUCT, }; Type type; @@ -407,7 +407,7 @@ public: virtual bool is_indexed() const override { return op == OP_INDEX; } OperatorNode() : - Node(TYPE_OPERATOR) {} + Node(NODE_TYPE_OPERATOR) {} }; struct VariableNode : public Node { @@ -421,7 +421,7 @@ public: virtual String get_datatype_name() const override { return String(struct_name); } VariableNode() : - Node(TYPE_VARIABLE) {} + Node(NODE_TYPE_VARIABLE) {} }; struct VariableDeclarationNode : public Node { @@ -442,7 +442,7 @@ public: virtual DataType get_datatype() const override { return datatype; } VariableDeclarationNode() : - Node(TYPE_VARIABLE_DECLARATION) {} + Node(NODE_TYPE_VARIABLE_DECLARATION) {} }; struct ArrayNode : public Node { @@ -462,7 +462,7 @@ public: virtual bool is_indexed() const override { return index_expression != nullptr; } ArrayNode() : - Node(TYPE_ARRAY) {} + Node(NODE_TYPE_ARRAY) {} }; struct ArrayConstructNode : public Node { @@ -475,7 +475,7 @@ public: virtual int get_array_size() const override { return initializer.size(); } ArrayConstructNode() : - Node(TYPE_ARRAY_CONSTRUCT) {} + Node(NODE_TYPE_ARRAY_CONSTRUCT) {} }; struct ConstantNode : public Node { @@ -498,7 +498,7 @@ public: virtual int get_array_size() const override { return array_size; } ConstantNode() : - Node(TYPE_CONSTANT) {} + Node(NODE_TYPE_CONSTANT) {} }; struct FunctionNode; @@ -536,7 +536,7 @@ public: bool use_comma_between_statements = false; BlockNode() : - Node(TYPE_BLOCK) {} + Node(NODE_TYPE_BLOCK) {} }; struct ControlFlowNode : public Node { @@ -545,7 +545,7 @@ public: Vector blocks; ControlFlowNode() : - Node(TYPE_CONTROL_FLOW) {} + Node(NODE_TYPE_CONTROL_FLOW) {} }; struct MemberNode : public Node { @@ -569,13 +569,13 @@ public: virtual bool is_indexed() const override { return index_expression != nullptr || call_expression != nullptr; } MemberNode() : - Node(TYPE_MEMBER) {} + Node(NODE_TYPE_MEMBER) {} }; struct StructNode : public Node { List members; StructNode() : - Node(TYPE_STRUCT) {} + Node(NODE_TYPE_STRUCT) {} }; struct FunctionNode : public Node { @@ -611,7 +611,7 @@ public: virtual int get_array_size() const override { return return_array_size; } FunctionNode() : - Node(TYPE_FUNCTION) {} + Node(NODE_TYPE_FUNCTION) {} }; struct ShaderNode : public Node { @@ -718,7 +718,7 @@ public: Vector vstructs; ShaderNode() : - Node(TYPE_SHADER) {} + Node(NODE_TYPE_SHADER) {} }; struct UniformOrderComparator { -- cgit v1.2.3