From dc5b3c9dbac393dcf2e6e7860ecc7e42d4c81e2d Mon Sep 17 00:00:00 2001 From: Bogdan Nagirniak Date: Mon, 4 Sep 2023 19:08:08 +0300 Subject: [PATCH 01/12] Initial changes to use NodeItem::Type --- .../nodes/shader/materialx/nodes/node_item.cc | 362 +++++++++++------- .../nodes/shader/materialx/nodes/node_item.h | 16 +- .../shader/materialx/nodes/node_parser.cc | 9 +- .../shader/materialx/nodes/tex_checker.cc | 2 +- .../nodes/shader/materialx/nodes/tex_noise.cc | 2 +- 5 files changed, 232 insertions(+), 159 deletions(-) diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.cc b/source/blender/nodes/shader/materialx/nodes/node_item.cc index f3cf3779058c..4a36994f68b3 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.cc +++ b/source/blender/nodes/shader/materialx/nodes/node_item.cc @@ -12,6 +12,49 @@ namespace blender::nodes::materialx { NodeItem::NodeItem(MaterialX::GraphElement *graph) : graph_(graph) {} +NodeItem::Type NodeItem::type(const std::string &mx_type) +{ + if (mx_type == "float") { + return Type::Float; + } + if (mx_type == "vector2") { + return Type::Vector2; + } + if (mx_type == "vector3") { + return Type::Vector3; + } + if (mx_type == "vector4") { + return Type::Vector4; + } + if (mx_type == "color3") { + return Type::Color3; + } + if (mx_type == "color4") { + return Type::Color4; + } + return Type::Other; +} + +std::string NodeItem::type(Type mx_type) +{ + switch (mx_type) { + case Type::Float: + return "float"; + case Type::Vector2: + return "vector2"; + case Type::Vector3: + return "vector3"; + case Type::Vector4: + return "vector4"; + case Type::Color3: + return "color3"; + case Type::Color4: + return "color4"; + default: + return ""; + } +} + NodeItem NodeItem::empty() const { return NodeItem(graph_); @@ -135,31 +178,28 @@ bool NodeItem::operator==(const NodeItem &other) const return false; } - std::string mx_type; + Type mx_type; auto val1 = value; auto val2 = other.value; if (!adjust_types(val1, val2, mx_type)) { return false; } - if (mx_type == "float") { - return val1->asA() == val2->asA(); + switch (mx_type) { + case Type::Vector2: + return val1->asA() == val2->asA(); + case Type::Vector3: + return val1->asA() == val2->asA(); + case Type::Vector4: + return val1->asA() == val2->asA(); + case Type::Float: + return val1->asA() == val2->asA(); + case Type::Color3: + return val1->asA() == val2->asA(); + case Type::Color4: + return val1->asA() == val2->asA(); + default: + break; } - if (mx_type == "color3") { - return val1->asA() == val2->asA(); - } - if (mx_type == "color4") { - return val1->asA() == val2->asA(); - } - if (mx_type == "vector2") { - return val1->asA() == val2->asA(); - } - if (mx_type == "vector3") { - return val1->asA() == val2->asA(); - } - if (mx_type == "vector4") { - return val1->asA() == val2->asA(); - } - return false; } @@ -197,33 +237,40 @@ NodeItem NodeItem::dotproduct(const NodeItem &other) const { NodeItem d = arithmetic(other, "dotproduct", [](float a, float b) { return a * b; }); if (d.value) { - std::string mx_type = d.type(); + Type mx_type = d.type(); float f = 0.0f; - if (mx_type == "float") { - f = value->asA(); - } - else if (mx_type == "color3") { - auto v = value->asA(); - f = v[0] + v[1] + v[2]; - } - else if (mx_type == "color4") { - auto v = value->asA(); - f = v[0] + v[1] + v[2] + v[3]; - } - else if (mx_type == "vector2") { - auto v = value->asA(); - f = v[0] + v[1]; - } - else if (mx_type == "vector3") { - auto v = value->asA(); - f = v[0] + v[1] + v[2]; - } - else if (mx_type == "vector4") { - auto v = value->asA(); - f = v[0] + v[1] + v[2] + v[3]; - } - else { - BLI_assert_unreachable(); + switch (mx_type) { + case Type::Float: { + f = value->asA(); + break; + } + case Type::Vector2: { + auto v = value->asA(); + f = v[0] + v[1]; + break; + } + case Type::Vector3: { + auto v = value->asA(); + f = v[0] + v[1] + v[2]; + break; + } + case Type::Vector4: { + auto v = value->asA(); + f = v[0] + v[1] + v[2] + v[3]; + break; + } + case Type::Color3: { + auto v = value->asA(); + f = v[0] + v[1] + v[2]; + break; + } + case Type::Color4: { + auto v = value->asA(); + f = v[0] + v[1] + v[2] + v[3]; + break; + } + default: + BLI_assert_unreachable(); } d.value = MaterialX::Value::createValue(f); } @@ -246,13 +293,13 @@ NodeItem NodeItem::if_else(const std::string &condition, } NodeItem res = empty(); - if (type() != "float" || other.type() != "float") { + if (type() != Type::Float || other.type() != Type::Float) { return res; } auto val1 = if_val; auto val2 = else_val; - std::string mx_type; + Type mx_type; if (!adjust_types(val1, val2, mx_type)) { return res; } @@ -279,7 +326,7 @@ NodeItem NodeItem::if_else(const std::string &condition, res = func(value->asA(), other.value->asA()) ? val1 : val2; } else { - res.node = graph_->addNode(mx_category, MaterialX::EMPTY_STRING, mx_type); + res.node = graph_->addNode(mx_category, MaterialX::EMPTY_STRING, type(mx_type)); res.set_input("value1", *this); res.set_input("value2", other); res.set_input("in1", val1); @@ -376,37 +423,43 @@ NodeItem NodeItem::exp() const NodeItem NodeItem::to_color3() const { - std::string mx_type = type(); + Type mx_type = type(); NodeItem res = empty(); if (value) { MaterialX::Color3 c; - if (mx_type == "float") { - float v = value->asA(); - c = {v, v, v}; - } - else if (mx_type == "color3") { - auto v = value->asA(); - c = {v[0], v[1], v[2]}; - } - else if (mx_type == "color4") { - auto v = value->asA(); - c = {v[0], v[1], v[2]}; - } - else if (mx_type == "vector3") { - auto v = value->asA(); - c = {v[0], v[1], v[2]}; - } - else if (mx_type == "vector4") { - auto v = value->asA(); - c = {v[0], v[1], v[2]}; - } - else { - return res; + switch (mx_type) { + case Type::Float: { + float v = value->asA(); + c = {v, v, v}; + break; + } + case Type::Color3: { + auto v = value->asA(); + c = {v[0], v[1], v[2]}; + break; + } + case Type::Color4: { + auto v = value->asA(); + c = {v[0], v[1], v[2]}; + break; + } + case Type::Vector3: { + auto v = value->asA(); + c = {v[0], v[1], v[2]}; + break; + } + case Type::Vector4: { + auto v = value->asA(); + c = {v[0], v[1], v[2]}; + break; + } + default: + return res; } res.value = MaterialX::Value::createValue(c); } else if (node) { - if (mx_type != "color3") { + if (mx_type !=Type::Color3) { return res; } res.node = node; @@ -416,13 +469,18 @@ NodeItem NodeItem::to_color3() const bool NodeItem::is_numeric() const { - std::string t = type(); - return ELEM(t, "float", "color3", "color4", "vector2", "vector3", "vector4"); + return type() >= Type::Float; } -std::string NodeItem::type() const +NodeItem::Type NodeItem::type() const { - return value ? value->getTypeString() : node->getType(); + if (value) { + return type(value->getTypeString()); + } + if (node) { + return type(node->getType()); + } + return Type::Empty; } NodeItem NodeItem::arithmetic(const std::string &mx_category, @@ -483,7 +541,7 @@ NodeItem NodeItem::arithmetic(const NodeItem &other, return res; } - std::string mx_type; + Type mx_type; if (value && other.value) { auto val1 = value; auto val2 = other.value; @@ -491,43 +549,50 @@ NodeItem NodeItem::arithmetic(const NodeItem &other, return res; } - if (mx_type == "float") { - float v1 = val1->asA(); - float v2 = val2->asA(); - res.value = MaterialX::Value::createValue(func(v1, v2)); - } - else if (mx_type == "color3") { - auto v1 = val1->asA(); - auto v2 = val2->asA(); - res.value = MaterialX::Value::createValue( - {func(v1[0], v2[0]), func(v1[1], v2[1]), func(v1[2], v2[2])}); - } - else if (mx_type == "color4") { - auto v1 = val1->asA(); - auto v2 = val2->asA(); - res.value = MaterialX::Value::createValue( - {func(v1[0], v2[0]), func(v1[1], v2[1]), func(v1[2], v2[2]), func(v1[3], v2[3])}); - } - else if (mx_type == "vector2") { - auto v1 = val1->asA(); - auto v2 = val2->asA(); - res.value = MaterialX::Value::createValue( - {func(v1[0], v2[0]), func(v1[1], v2[1])}); - } - else if (mx_type == "vector3") { - auto v1 = val1->asA(); - auto v2 = val2->asA(); - res.value = MaterialX::Value::createValue( - {func(v1[0], v2[0]), func(v1[1], v2[1]), func(v1[2], v2[2])}); - } - else if (mx_type == "vector4") { - auto v1 = val1->asA(); - auto v2 = val2->asA(); - res.value = MaterialX::Value::createValue( - {func(v1[0], v2[0]), func(v1[1], v2[1]), func(v1[2], v2[2]), func(v1[3], v2[3])}); - } - else { - BLI_assert_unreachable(); + switch (mx_type) { + case Type::Float: { + float v1 = val1->asA(); + float v2 = val2->asA(); + res.value = MaterialX::Value::createValue(func(v1, v2)); + break; + } + case Type::Color3: { + auto v1 = val1->asA(); + auto v2 = val2->asA(); + res.value = MaterialX::Value::createValue( + {func(v1[0], v2[0]), func(v1[1], v2[1]), func(v1[2], v2[2])}); + break; + } + case Type::Color4: { + auto v1 = val1->asA(); + auto v2 = val2->asA(); + res.value = MaterialX::Value::createValue( + {func(v1[0], v2[0]), func(v1[1], v2[1]), func(v1[2], v2[2]), func(v1[3], v2[3])}); + break; + } + case Type::Vector2: { + auto v1 = val1->asA(); + auto v2 = val2->asA(); + res.value = MaterialX::Value::createValue( + {func(v1[0], v2[0]), func(v1[1], v2[1])}); + break; + } + case Type::Vector3: { + auto v1 = val1->asA(); + auto v2 = val2->asA(); + res.value = MaterialX::Value::createValue( + {func(v1[0], v2[0]), func(v1[1], v2[1]), func(v1[2], v2[2])}); + break; + } + case Type::Vector4: { + auto v1 = val1->asA(); + auto v2 = val2->asA(); + res.value = MaterialX::Value::createValue( + {func(v1[0], v2[0]), func(v1[1], v2[1]), func(v1[2], v2[2]), func(v1[3], v2[3])}); + break; + } + default: + BLI_assert_unreachable(); } } else { @@ -537,50 +602,51 @@ NodeItem NodeItem::arithmetic(const NodeItem &other, return res; } - res.node = graph_->addNode(mx_category, MaterialX::EMPTY_STRING, mx_type); + res.node = graph_->addNode(mx_category, MaterialX::EMPTY_STRING, type(mx_type)); res.set_input("in1", val1); res.set_input("in2", val2); } return res; } -MaterialX::ValuePtr NodeItem::float_to_type(float v, std::string mx_type) +MaterialX::ValuePtr NodeItem::float_to_type(float v, Type mx_type) { - if (mx_type == "float") { - return MaterialX::Value::createValue(v); + MaterialX::ValuePtr res; + switch (mx_type) { + case Type::Float: + res = MaterialX::Value::createValue(v); + break; + case Type::Vector2: + res = MaterialX::Value::createValue({v, v}); + break; + case Type::Vector3: + res = MaterialX::Value::createValue({v, v, v}); + break; + case Type::Vector4: + res = MaterialX::Value::createValue({v, v, v, v}); + break; + case Type::Color3: + res = MaterialX::Value::createValue({v, v, v}); + break; + case Type::Color4: + res = MaterialX::Value::createValue({v, v, v, v}); + break; + default: + BLI_assert_unreachable(); } - if (mx_type == "color3") { - return MaterialX::Value::createValue({v, v, v}); - } - if (mx_type == "color4") { - return MaterialX::Value::createValue({v, v, v, 1.0f}); - } - if (mx_type == "vector2") { - return MaterialX::Value::createValue({v, v}); - } - if (mx_type == "vector3") { - return MaterialX::Value::createValue({v, v, v}); - } - if (mx_type == "vector4") { - return MaterialX::Value::createValue({v, v, v, 1.0f}); - } - - BLI_assert_unreachable(); - return nullptr; + return res; } -bool NodeItem::adjust_types(MaterialX::ValuePtr &val1, - MaterialX::ValuePtr &val2, - std::string &mx_type) +bool NodeItem::adjust_types(MaterialX::ValuePtr &val1, MaterialX::ValuePtr &val2, Type &mx_type) { - std::string t1 = val1->getTypeString(); - std::string t2 = val2->getTypeString(); + Type t1 = type(val1->getTypeString()); + Type t2 = type(val2->getTypeString()); if (t1 != t2) { - if (t1 == "float") { + if (t1 == Type::Float) { val1 = float_to_type(val1->asA(), t2); mx_type = t2; } - else if (t2 == "float") { + else if (t2 == Type::Float) { val2 = float_to_type(val2->asA(), t1); mx_type = t1; } @@ -594,16 +660,16 @@ bool NodeItem::adjust_types(MaterialX::ValuePtr &val1, return true; } -bool NodeItem::adjust_types(NodeItem &val1, NodeItem &val2, std::string &mx_type) +bool NodeItem::adjust_types(NodeItem &val1, NodeItem &val2, Type &mx_type) { - std::string t1 = val1.type(); - std::string t2 = val2.type(); + Type t1 = val1.type(); + Type t2 = val2.type(); if (t1 != t2) { - if (val1.value && t1 == "float") { + if (val1.value && t1 == Type::Float) { val1.value = float_to_type(val1.value->asA(), t2); mx_type = t2; } - else if (val2.value && t2 == "float") { + else if (val2.value && t2 == Type::Float) { val2.value = float_to_type(val2.value->asA(), t1); mx_type = t1; } diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.h b/source/blender/nodes/shader/materialx/nodes/node_item.h index 2f746cda36b7..3bf3d84d2f61 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.h +++ b/source/blender/nodes/shader/materialx/nodes/node_item.h @@ -9,6 +9,9 @@ namespace blender::nodes::materialx { class NodeItem { + public: + enum class Type { Empty = 0, Other, Float, Vector2, Vector3, Vector4, Color3, Color4 }; + public: MaterialX::ValuePtr value; MaterialX::NodePtr node; @@ -20,6 +23,9 @@ class NodeItem { NodeItem(MaterialX::GraphElement *graph); ~NodeItem() = default; + static Type type(const std::string &mx_type); + static std::string type(Type mx_type); + NodeItem empty() const; template NodeItem val(const T &data) const; @@ -75,19 +81,17 @@ class NodeItem { NodeItem to_color3() const; bool is_numeric() const; - std::string type() const; + Type type() const; private: NodeItem arithmetic(const std::string &mx_category, std::function func) const; NodeItem arithmetic(const NodeItem &other, const std::string &mx_category, std::function func) const; - static MaterialX::ValuePtr float_to_type(float v, std::string mx_type); + static MaterialX::ValuePtr float_to_type(float v, Type mx_type); /* Functions for adjusting values to make equal types */ - static bool adjust_types(MaterialX::ValuePtr &val1, - MaterialX::ValuePtr &val2, - std::string &mx_type); - static bool adjust_types(NodeItem &val1, NodeItem &val2, std::string &mx_type); + static bool adjust_types(MaterialX::ValuePtr &val1, MaterialX::ValuePtr &val2, Type &mx_type); + static bool adjust_types(NodeItem &val1, NodeItem &val2, Type &mx_type); }; template NodeItem NodeItem::val(const T &data) const diff --git a/source/blender/nodes/shader/materialx/nodes/node_parser.cc b/source/blender/nodes/shader/materialx/nodes/node_parser.cc index 0b7c6e82ad60..01a93fc31e60 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_parser.cc +++ b/source/blender/nodes/shader/materialx/nodes/node_parser.cc @@ -74,17 +74,20 @@ NodeItem NodeParser::get_input_default(const bNodeSocket &socket) case SOCK_FLOAT: { float v = socket.default_value_typed()->value; res.value = MaterialX::Value::createValue(v); - } break; + break; + } case SOCK_VECTOR: { const float *v = socket.default_value_typed()->value; res.value = MaterialX::Value::createValue( MaterialX::Vector3(v[0], v[1], v[2])); - } break; + break; + } case SOCK_RGBA: { const float *v = socket.default_value_typed()->value; res.value = MaterialX::Value::createValue( MaterialX::Color4(v[0], v[1], v[2], v[3])); - } break; + break; + } default: { CLOG_WARN(LOG_MATERIALX_SHADER, "Unsupported socket type: %d", socket.type); } diff --git a/source/blender/nodes/shader/materialx/nodes/tex_checker.cc b/source/blender/nodes/shader/materialx/nodes/tex_checker.cc index 63266bd5081a..78736f3fbda9 100644 --- a/source/blender/nodes/shader/materialx/nodes/tex_checker.cc +++ b/source/blender/nodes/shader/materialx/nodes/tex_checker.cc @@ -12,7 +12,7 @@ NodeItem TexCheckerNodeParser::compute() NodeItem color1 = get_input_value("Color1"); NodeItem color2 = get_input_value("Color2"); - if (scale.value && scale.type() == "float") { + if (scale.value && scale.type() == NodeItem::Type::Float) { float v = scale.value->asA(); scale = value(MaterialX::Vector2(v, v)); } diff --git a/source/blender/nodes/shader/materialx/nodes/tex_noise.cc b/source/blender/nodes/shader/materialx/nodes/tex_noise.cc index d3a016c63208..e9154bba74bd 100644 --- a/source/blender/nodes/shader/materialx/nodes/tex_noise.cc +++ b/source/blender/nodes/shader/materialx/nodes/tex_noise.cc @@ -12,7 +12,7 @@ NodeItem TexNoiseNodeParser::compute() NodeItem detail = get_input_value("Detail"); NodeItem lacunarity = get_input_value("Lacunarity"); - if (detail.value && detail.type() == "float") { + if (detail.value && detail.type() == NodeItem::Type::Float) { detail = value(int(detail.value->asA())); } -- 2.30.2 From 537fe23b81da4afa04b44f0087a63b22a47d6be7 Mon Sep 17 00:00:00 2001 From: Bogdan Nagirniak Date: Mon, 4 Sep 2023 20:24:03 +0300 Subject: [PATCH 02/12] Added more types. Simplified tex_checker.cc. Fixed review comment about subsurface in bsdf_principled.cc --- .../shader/materialx/nodes/bsdf_principled.cc | 22 +++++++------------ .../nodes/shader/materialx/nodes/node_item.cc | 10 +++++++++ .../nodes/shader/materialx/nodes/node_item.h | 2 +- .../shader/materialx/nodes/tex_checker.cc | 15 +++++-------- 4 files changed, 25 insertions(+), 24 deletions(-) diff --git a/source/blender/nodes/shader/materialx/nodes/bsdf_principled.cc b/source/blender/nodes/shader/materialx/nodes/bsdf_principled.cc index 43a046cc9292..05e780d74f5f 100644 --- a/source/blender/nodes/shader/materialx/nodes/bsdf_principled.cc +++ b/source/blender/nodes/shader/materialx/nodes/bsdf_principled.cc @@ -15,12 +15,8 @@ NodeItem BSDFPrincipledNodeParser::compute() NodeItem base_color = get_input_value("Base Color"); NodeItem subsurface = get_input_value("Subsurface"); - NodeItem subsurface_radius = empty(); - NodeItem subsurface_color = empty(); - if (subsurface != zero) { - subsurface_radius = get_input_value("Subsurface Radius"); - subsurface_color = get_input_value("Subsurface Color"); - } + NodeItem subsurface_radius = get_input_value("Subsurface Radius"); + NodeItem subsurface_color = get_input_value("Subsurface Color"); NodeItem metallic = get_input_value("Metallic"); NodeItem specular = get_input_value("Specular"); @@ -102,13 +98,11 @@ NodeItem BSDFPrincipledNodeParser::compute() res.set_input("transmission_extra_roughness", transmission_roughness); } - if (subsurface != zero) { - res.set_input("subsurface", subsurface); - res.set_input("subsurface_color", subsurface_color); - res.set_input("subsurface_radius", subsurface_radius); - if (anisotropic) { - res.set_input("subsurface_anisotropy", anisotropic); - } + res.set_input("subsurface", subsurface); + res.set_input("subsurface_color", subsurface_color); + res.set_input("subsurface_radius", subsurface_radius); + if (anisotropic) { + res.set_input("subsurface_anisotropy", anisotropic); } if (sheen != zero) { @@ -131,7 +125,7 @@ NodeItem BSDFPrincipledNodeParser::compute() if (emission != zero) { res.set_input("emission", emission_strength); - res.set_input("emission_color", emission); + res.set_input("emission_color", emission.to_color3()); } return res; diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.cc b/source/blender/nodes/shader/materialx/nodes/node_item.cc index 4a36994f68b3..9c401d5351fb 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.cc +++ b/source/blender/nodes/shader/materialx/nodes/node_item.cc @@ -14,6 +14,12 @@ NodeItem::NodeItem(MaterialX::GraphElement *graph) : graph_(graph) {} NodeItem::Type NodeItem::type(const std::string &mx_type) { + if (mx_type == "string") { + return Type::String; + } + if (mx_type == "integer") { + return Type::Integer; + } if (mx_type == "float") { return Type::Float; } @@ -38,6 +44,10 @@ NodeItem::Type NodeItem::type(const std::string &mx_type) std::string NodeItem::type(Type mx_type) { switch (mx_type) { + case Type::String: + return "string"; + case Type::Integer: + return "integer"; case Type::Float: return "float"; case Type::Vector2: diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.h b/source/blender/nodes/shader/materialx/nodes/node_item.h index 3bf3d84d2f61..3ca004ce861d 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.h +++ b/source/blender/nodes/shader/materialx/nodes/node_item.h @@ -10,7 +10,7 @@ namespace blender::nodes::materialx { class NodeItem { public: - enum class Type { Empty = 0, Other, Float, Vector2, Vector3, Vector4, Color3, Color4 }; + enum class Type { Empty = 0, Other, String, Integer, Float, Vector2, Vector3, Vector4, Color3, Color4 }; public: MaterialX::ValuePtr value; diff --git a/source/blender/nodes/shader/materialx/nodes/tex_checker.cc b/source/blender/nodes/shader/materialx/nodes/tex_checker.cc index 78736f3fbda9..b6e131071984 100644 --- a/source/blender/nodes/shader/materialx/nodes/tex_checker.cc +++ b/source/blender/nodes/shader/materialx/nodes/tex_checker.cc @@ -8,21 +8,18 @@ namespace blender::nodes::materialx { NodeItem TexCheckerNodeParser::compute() { - NodeItem scale = get_input_value("Scale"); + NodeItem vector = get_input_link("Vector"); NodeItem color1 = get_input_value("Color1"); NodeItem color2 = get_input_value("Color2"); + NodeItem scale = get_input_value("Scale"); - if (scale.value && scale.type() == NodeItem::Type::Float) { - float v = scale.value->asA(); - scale = value(MaterialX::Vector2(v, v)); + if (!vector) { + vector = create_node("texcoord", "vector2"); } - - NodeItem texcoord = create_node("texcoord", "vector2"); - NodeItem place2d = create_node("place2d", "vector2"); - place2d.set_input("texcoord", texcoord * scale); + vector = vector * scale; NodeItem separate = create_node("separate2", "multioutput"); - separate.set_input("in", place2d); + separate.set_input("in", vector); separate.add_output("outx", "float"); separate.add_output("outy", "float"); -- 2.30.2 From 87237c88e367bd470bd52fff302e500a4509ddee Mon Sep 17 00:00:00 2001 From: Bogdan Nagirniak Date: Mon, 4 Sep 2023 23:11:21 +0300 Subject: [PATCH 03/12] Implemented NodeItem::convert() --- .../nodes/shader/materialx/nodes/node_item.cc | 183 ++++++++++++++++++ .../nodes/shader/materialx/nodes/node_item.h | 5 + 2 files changed, 188 insertions(+) diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.cc b/source/blender/nodes/shader/materialx/nodes/node_item.cc index 9c401d5351fb..fa830b66394c 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.cc +++ b/source/blender/nodes/shader/materialx/nodes/node_item.cc @@ -431,6 +431,179 @@ NodeItem NodeItem::exp() const return arithmetic("exp", [](float a) { return std::expf(a); }); } +NodeItem NodeItem::convert(Type to_type) const +{ + Type t = type(); + if (t == to_type) { + return *this; + } + if (!is_arithmetic(t) || !is_arithmetic(to_type)) { + return empty(); + } + + switch (t) { + case Type::Vector2: + switch (to_type) { + case Type::Vector4: + return convert(Type::Vector3).convert(Type::Vector4); + case Type::Color3: + return convert(Type::Vector3).convert(Type::Color3); + case Type::Color4: + return convert(Type::Vector3).convert(Type::Color3).convert(Type::Color4); + default: + break; + } + break; + case Type::Vector3: + switch (to_type) { + case Type::Color4: + return convert(Type::Color3).convert(Type::Color4); + default: + break; + } + break; + case Type::Vector4: + switch (to_type) { + case Type::Vector2: + return convert(Type::Vector3).convert(Type::Vector2); + case Type::Color3: + return convert(Type::Vector3).convert(Type::Color3); + default: + break; + } + break; + case Type::Color3: + switch (to_type) { + case Type::Vector2: + return convert(Type::Vector3).convert(Type::Vector2); + case Type::Vector4: + return convert(Type::Vector3).convert(Type::Vector4); + default: + break; + } + break; + case Type::Color4: + switch (to_type) { + case Type::Vector2: + return convert(Type::Vector4).convert(Type::Vector3).convert(Type::Vector2); + case Type::Vector3: + return convert(Type::Vector4).convert(Type::Vector3); + default: + break; + } + break; + default: + break; + } + + NodeItem res = empty(); + if (value) { + switch (t) { + case Type::Float: { + float v = value->asA(); + switch (to_type) { + case Type::Vector2: + res.value = MaterialX::Value::createValue({v, v}); + break; + case Type::Vector3: + res.value = MaterialX::Value::createValue({v, v, v}); + break; + case Type::Vector4: + res.value = MaterialX::Value::createValue({v, v, v, 1.0f}); + break; + case Type::Color3: + res.value = MaterialX::Value::createValue({v, v, v}); + break; + case Type::Color4: + res.value = MaterialX::Value::createValue({v, v, v, 1.0f}); + break; + default: + BLI_assert_unreachable(); + } + break; + } + case Type::Vector2: { + auto v = value->asA(); + switch (to_type) { + case Type::Vector3: + res.value = MaterialX::Value::createValue({v[0], v[1], 0.0f}); + break; + default: + BLI_assert_unreachable(); + } + break; + } + case Type::Vector3: { + auto v = value->asA(); + switch (to_type) { + case Type::Vector2: + res.value = MaterialX::Value::createValue({v[0], v[1]}); + break; + case Type::Vector4: + res.value = + MaterialX::Value::createValue({v[0], v[1], v[2], 0.0f}); + break; + case Type::Color3: + res.value = MaterialX::Value::createValue({v[0], v[1], v[2]}); + break; + default: + BLI_assert_unreachable(); + } + break; + } + case Type::Vector4: { + auto v = value->asA(); + switch (to_type) { + case Type::Vector3: + res.value = MaterialX::Value::createValue({v[0], v[1], v[2]}); + break; + case Type::Color4: + res.value = MaterialX::Value::createValue({v[0], v[1], v[2], v[3]}); + break; + default: + BLI_assert_unreachable(); + } + break; + } + case Type::Color3: { + auto v = value->asA(); + switch (to_type) { + case Type::Vector3: + res.value = MaterialX::Value::createValue({v[0], v[1], v[2]}); + break; + case Type::Color4: + res.value = MaterialX::Value::createValue({v[0], v[1], v[2], 1.0f}); + break; + default: + BLI_assert_unreachable(); + } + break; + } + case Type::Color4: { + auto v = value->asA(); + switch (to_type) { + case Type::Vector4: + res.value = MaterialX::Value::createValue({v[0], v[1], v[2], v[3]}); + break; + case Type::Color3: + res.value = MaterialX::Value::createValue({v[0], v[1], v[2]}); + break; + default: + BLI_assert_unreachable(); + } + break; + } + default: + BLI_assert_unreachable(); + } + } + else { + res.node = graph_->addNode("convert", MaterialX::EMPTY_STRING, type(to_type)); + res.set_input("in", *this); + } + return res; +} + NodeItem NodeItem::to_color3() const { Type mx_type = type(); @@ -493,6 +666,16 @@ NodeItem::Type NodeItem::type() const return Type::Empty; } +bool NodeItem::is_arithmetic(Type t) +{ + return t >= Type::Float; +} + +bool NodeItem::is_arithmetic() const +{ + return is_arithmetic(type()); +} + NodeItem NodeItem::arithmetic(const std::string &mx_category, std::function func) const { diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.h b/source/blender/nodes/shader/materialx/nodes/node_item.h index 3ca004ce861d..0753ec5f9bf7 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.h +++ b/source/blender/nodes/shader/materialx/nodes/node_item.h @@ -79,11 +79,16 @@ class NodeItem { NodeItem sign() const; NodeItem exp() const; + NodeItem convert(Type to_type) const; NodeItem to_color3() const; bool is_numeric() const; Type type() const; private: + static bool is_arithmetic(Type t); + + bool is_arithmetic() const; + NodeItem arithmetic(const std::string &mx_category, std::function func) const; NodeItem arithmetic(const NodeItem &other, const std::string &mx_category, -- 2.30.2 From 266f05721baa09e3ab8ce49cd4084559f787ffe5 Mon Sep 17 00:00:00 2001 From: Bogdan Nagirniak Date: Mon, 4 Sep 2023 23:24:13 +0300 Subject: [PATCH 04/12] Improved arithmetic() --- .../nodes/shader/materialx/nodes/node_item.cc | 79 ++++++++++--------- .../nodes/shader/materialx/nodes/node_item.h | 1 - 2 files changed, 40 insertions(+), 40 deletions(-) diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.cc b/source/blender/nodes/shader/materialx/nodes/node_item.cc index fa830b66394c..c8ebc4f591bc 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.cc +++ b/source/blender/nodes/shader/materialx/nodes/node_item.cc @@ -650,11 +650,6 @@ NodeItem NodeItem::to_color3() const return res; } -bool NodeItem::is_numeric() const -{ - return type() >= Type::Float; -} - NodeItem::Type NodeItem::type() const { if (value) { @@ -679,43 +674,49 @@ bool NodeItem::is_arithmetic() const NodeItem NodeItem::arithmetic(const std::string &mx_category, std::function func) const { - if (!is_numeric()) { - return empty(); + NodeItem res = empty(); + Type t = type(); + if (!is_arithmetic(t)) { + return res; } - std::string t = value ? value->getTypeString() : node->getType(); - NodeItem res(graph_); if (value) { - if (t == "float") { - float v = value->asA(); - res.value = MaterialX::Value::createValue(func(v)); - } - else if (t == "color3") { - auto v = value->asA(); - res.value = MaterialX::Value::createValue( - {func(v[0]), func(v[1]), func(v[2])}); - } - else if (t == "color4") { - auto v = value->asA(); - res.value = MaterialX::Value::createValue( - {func(v[0]), func(v[1]), func(v[2]), func(v[3])}); - } - else if (t == "vector2") { - auto v = value->asA(); - res.value = MaterialX::Value::createValue({func(v[0]), func(v[1])}); - } - else if (t == "vector3") { - auto v = value->asA(); - res.value = MaterialX::Value::createValue( - {func(v[0]), func(v[1]), func(v[2])}); - } - else if (t == "vector4") { - auto v = value->asA(); - res.value = MaterialX::Value::createValue( - {func(v[0]), func(v[1]), func(v[2]), func(v[3])}); - } - else { - BLI_assert_unreachable(); + switch (t) { + case Type::Float: { + float v = value->asA(); + res.value = MaterialX::Value::createValue(func(v)); + break; + } + case Type::Color3: { + auto v = value->asA(); + res.value = MaterialX::Value::createValue( + {func(v[0]), func(v[1]), func(v[2])}); + break; + } + case Type::Color4: { + auto v = value->asA(); + res.value = MaterialX::Value::createValue( + {func(v[0]), func(v[1]), func(v[2]), func(v[3])}); + break; + } + case Type::Vector2: { + auto v = value->asA(); + res.value = MaterialX::Value::createValue({func(v[0]), func(v[1])}); + } + case Type::Vector3: { + auto v = value->asA(); + res.value = MaterialX::Value::createValue( + {func(v[0]), func(v[1]), func(v[2])}); + break; + } + case Type::Vector4: { + auto v = value->asA(); + res.value = MaterialX::Value::createValue( + {func(v[0]), func(v[1]), func(v[2]), func(v[3])}); + break; + } + default: + BLI_assert_unreachable(); } } else { diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.h b/source/blender/nodes/shader/materialx/nodes/node_item.h index 0753ec5f9bf7..128291c0ae80 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.h +++ b/source/blender/nodes/shader/materialx/nodes/node_item.h @@ -81,7 +81,6 @@ class NodeItem { NodeItem convert(Type to_type) const; NodeItem to_color3() const; - bool is_numeric() const; Type type() const; private: -- 2.30.2 From f8dab23f885969e82e1a2c157e26a2e4a91333fd Mon Sep 17 00:00:00 2001 From: Bogdan Nagirniak Date: Tue, 5 Sep 2023 00:37:56 +0300 Subject: [PATCH 05/12] Switched to use IfType enum. Removed unused code, Simplified some functions. --- .../shader/materialx/nodes/bsdf_principled.cc | 12 +- .../nodes/shader/materialx/nodes/math.cc | 6 +- .../nodes/shader/materialx/nodes/node_item.cc | 174 +++++++----------- .../nodes/shader/materialx/nodes/node_item.h | 8 +- .../shader/materialx/nodes/tex_checker.cc | 6 +- 5 files changed, 80 insertions(+), 126 deletions(-) diff --git a/source/blender/nodes/shader/materialx/nodes/bsdf_principled.cc b/source/blender/nodes/shader/materialx/nodes/bsdf_principled.cc index 05e780d74f5f..a8829ddf92fb 100644 --- a/source/blender/nodes/shader/materialx/nodes/bsdf_principled.cc +++ b/source/blender/nodes/shader/materialx/nodes/bsdf_principled.cc @@ -66,7 +66,7 @@ NodeItem BSDFPrincipledNodeParser::compute() /* Creating standard_surface */ NodeItem res = create_node("standard_surface", "surfaceshader"); res.set_input("base", 1.0, "float"); - res.set_input("base_color", base_color.to_color3()); + res.set_input("base_color", base_color, NodeItem::Type::Color3); res.set_input("diffuse_roughness", roughness); if (normal) { res.set_input("normal", normal); @@ -81,7 +81,7 @@ NodeItem BSDFPrincipledNodeParser::compute() if (specular != zero) { res.set_input("specular", specular); - res.set_input("specular_color", base_color.to_color3()); + res.set_input("specular_color", base_color, NodeItem::Type::Color3); res.set_input("specular_roughness", roughness); res.set_input("specular_IOR", ior); if (anisotropic) { @@ -94,7 +94,7 @@ NodeItem BSDFPrincipledNodeParser::compute() if (transmission != zero) { res.set_input("transmission", transmission); - res.set_input("transmission_color", base_color.to_color3()); + res.set_input("transmission_color", base_color, NodeItem::Type::Color3); res.set_input("transmission_extra_roughness", transmission_roughness); } @@ -107,13 +107,13 @@ NodeItem BSDFPrincipledNodeParser::compute() if (sheen != zero) { res.set_input("sheen", sheen); - res.set_input("sheen_color", base_color.to_color3()); + res.set_input("sheen_color", base_color, NodeItem::Type::Color3); res.set_input("sheen_roughness", roughness); } if (clearcoat != zero) { res.set_input("coat", clearcoat); - res.set_input("coat_color", base_color.to_color3()); + res.set_input("coat_color", base_color, NodeItem::Type::Color3); res.set_input("coat_roughness", clearcoat_roughness); res.set_input("coat_IOR", ior); if (anisotropic) { @@ -125,7 +125,7 @@ NodeItem BSDFPrincipledNodeParser::compute() if (emission != zero) { res.set_input("emission", emission_strength); - res.set_input("emission_color", emission.to_color3()); + res.set_input("emission_color", emission, NodeItem::Type::Color3); } return res; diff --git a/source/blender/nodes/shader/materialx/nodes/math.cc b/source/blender/nodes/shader/materialx/nodes/math.cc index cbd5d6fd023e..d5fb91183e5a 100644 --- a/source/blender/nodes/shader/materialx/nodes/math.cc +++ b/source/blender/nodes/shader/materialx/nodes/math.cc @@ -109,10 +109,10 @@ NodeItem MathNodeParser::compute() res = x.max(y); break; case NODE_MATH_LESS_THAN: - res = x.if_else("<", y, value(1.0f), value(0.0f)); + res = x.if_else(NodeItem::IfType::Less, y, value(1.0f), value(0.0f)); break; case NODE_MATH_GREATER_THAN: - res = x.if_else(">", y, value(1.0f), value(0.0f)); + res = x.if_else(NodeItem::IfType::Greater, y, value(1.0f), value(0.0f)); break; case NODE_MATH_MODULO: res = x % y; @@ -138,7 +138,7 @@ NodeItem MathNodeParser::compute() CLOG_WARN(LOG_MATERIALX_SHADER, "Unimplemented math operation %d", op); break; case NODE_MATH_COMPARE: - res = z.if_else("<", (x - y).abs(), value(1.0f), value(0.0f)); + res = z.if_else(NodeItem::IfType::Less, (x - y).abs(), value(1.0f), value(0.0f)); break; case NODE_MATH_MULTIPLY_ADD: res = x * y + z; diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.cc b/source/blender/nodes/shader/materialx/nodes/node_item.cc index c8ebc4f591bc..8e311397d758 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.cc +++ b/source/blender/nodes/shader/materialx/nodes/node_item.cc @@ -75,56 +75,54 @@ void NodeItem::set_input(const std::string &name, const std::string &output_name) { if (item.value) { - set_input(name, item.value); + Type t = item.type(); + std::string mx_type = type(t); + switch (t) { + case Type::String: + set_input(name, item.value->asA(), mx_type); + break; + case Type::Integer: + set_input(name, item.value->asA(), mx_type); + break; + case Type::Float: + set_input(name, item.value->asA(), mx_type); + break; + case Type::Vector2: + set_input(name, item.value->asA(), mx_type); + break; + case Type::Vector3: + set_input(name, item.value->asA(), mx_type); + break; + case Type::Vector4: + set_input(name, item.value->asA(), mx_type); + break; + case Type::Color3: + set_input(name, item.value->asA(), mx_type); + break; + case Type::Color4: + set_input(name, item.value->asA(), mx_type); + break; + default: + BLI_assert_unreachable(); + } } else if (item.node) { - set_input(name, item.node, output_name); + node->setConnectedNode(name, item.node); + if (output_name != "") { + node->setConnectedOutput(name, item.node->getOutput(output_name)); + } } else { CLOG_WARN(LOG_MATERIALX_SHADER, "Empty item to input: %s", name.c_str()); } } -void NodeItem::set_input(const std::string &name, const MaterialX::ValuePtr value) -{ - std::string mx_type = value->getTypeString(); - if (mx_type == "float") { - set_input(name, value->asA(), mx_type); - } - else if (mx_type == "integer") { - set_input(name, value->asA(), mx_type); - } - else if (mx_type == "vector2") { - set_input(name, value->asA(), mx_type); - } - else if (mx_type == "vector3") { - set_input(name, value->asA(), mx_type); - } - else if (mx_type == "vector4") { - set_input(name, value->asA(), mx_type); - } - else if (mx_type == "color3") { - set_input(name, value->asA(), mx_type); - } - else if (mx_type == "color4") { - set_input(name, value->asA(), mx_type); - } - else if (mx_type == "string") { - set_input(name, value->asA(), mx_type); - } - else { - BLI_assert_unreachable(); - } -} - void NodeItem::set_input(const std::string &name, - const MaterialX::NodePtr node, + const NodeItem &item, + Type to_type, const std::string &output_name) { - this->node->setConnectedNode(name, node); - if (output_name != "") { - this->node->setConnectedOutput("in1", node->getOutput(output_name)); - } + set_input(name, item.convert(to_type), output_name); } void NodeItem::add_output(const std::string &name, const std::string &mx_type) @@ -287,19 +285,20 @@ NodeItem NodeItem::dotproduct(const NodeItem &other) const return d; } -NodeItem NodeItem::if_else(const std::string &condition, +NodeItem NodeItem::if_else(IfType condition, const NodeItem &other, const NodeItem &if_val, const NodeItem &else_val) const { - if (condition == "<") { - return other.if_else(">", *this, else_val, if_val); - } - if (condition == "<=") { - return other.if_else(">=", *this, else_val, if_val); - } - if (condition == "!=") { - return if_else("==", other, else_val, if_val); + switch (condition) { + case IfType::Less: + return other.if_else(IfType::Greater, *this, else_val, if_val); + case IfType::LessEq: + return other.if_else(IfType::GreaterEq, *this, else_val, if_val); + case IfType::NotEq: + return if_else(IfType::Eq, other, else_val, if_val); + default: + break; } NodeItem res = empty(); @@ -316,20 +315,21 @@ NodeItem NodeItem::if_else(const std::string &condition, std::function func = nullptr; std::string mx_category; - if (condition == ">") { - mx_category = "ifgreater"; - func = [](float a, float b) { return a > b; }; - } - else if (condition == ">=") { - mx_category = "ifgreatereq"; - func = [](float a, float b) { return a >= b; }; - } - else if (condition == "==") { - mx_category = "ifequal"; - func = [](float a, float b) { return a == b; }; - } - else { - BLI_assert_unreachable(); + switch (condition) { + case IfType::Greater: + mx_category = "ifgreater"; + func = [](float a, float b) { return a > b; }; + break; + case IfType::GreaterEq: + mx_category = "ifgreatereq"; + func = [](float a, float b) { return a >= b; }; + break; + case IfType::Eq: + mx_category = "ifequal"; + func = [](float a, float b) { return a == b; }; + break; + default: + BLI_assert_unreachable(); } if (value && other.value) { @@ -604,52 +604,6 @@ NodeItem NodeItem::convert(Type to_type) const return res; } -NodeItem NodeItem::to_color3() const -{ - Type mx_type = type(); - NodeItem res = empty(); - if (value) { - MaterialX::Color3 c; - switch (mx_type) { - case Type::Float: { - float v = value->asA(); - c = {v, v, v}; - break; - } - case Type::Color3: { - auto v = value->asA(); - c = {v[0], v[1], v[2]}; - break; - } - case Type::Color4: { - auto v = value->asA(); - c = {v[0], v[1], v[2]}; - break; - } - case Type::Vector3: { - auto v = value->asA(); - c = {v[0], v[1], v[2]}; - break; - } - case Type::Vector4: { - auto v = value->asA(); - c = {v[0], v[1], v[2]}; - break; - } - default: - return res; - } - res.value = MaterialX::Value::createValue(c); - } - else if (node) { - if (mx_type !=Type::Color3) { - return res; - } - res.node = node; - } - return res; -} - NodeItem::Type NodeItem::type() const { if (value) { @@ -720,7 +674,7 @@ NodeItem NodeItem::arithmetic(const std::string &mx_category, } } else { - res.node = graph_->addNode(mx_category, MaterialX::EMPTY_STRING, t); + res.node = graph_->addNode(mx_category, MaterialX::EMPTY_STRING, type(t)); res.set_input("in", *this); } return res; @@ -731,7 +685,7 @@ NodeItem NodeItem::arithmetic(const NodeItem &other, std::function func) const { NodeItem res = empty(); - if (!is_numeric() || !other.is_numeric()) { + if (!is_arithmetic() || !other.is_arithmetic()) { return res; } diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.h b/source/blender/nodes/shader/materialx/nodes/node_item.h index 128291c0ae80..a025c1f5cff9 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.h +++ b/source/blender/nodes/shader/materialx/nodes/node_item.h @@ -11,6 +11,7 @@ namespace blender::nodes::materialx { class NodeItem { public: enum class Type { Empty = 0, Other, String, Integer, Float, Vector2, Vector3, Vector4, Color3, Color4 }; + enum class IfType { Less = 0, LessEq, Eq, GreaterEq, Greater, NotEq }; public: MaterialX::ValuePtr value; @@ -34,9 +35,9 @@ class NodeItem { void set_input(const std::string &name, const NodeItem &item, const std::string &output_name = ""); - void set_input(const std::string &name, const MaterialX::ValuePtr value); void set_input(const std::string &name, - const MaterialX::NodePtr node, + const NodeItem &item, + Type to_type, const std::string &output_name = ""); void add_output(const std::string &name, const std::string &mx_type); @@ -57,7 +58,7 @@ class NodeItem { NodeItem min(const NodeItem &other) const; NodeItem max(const NodeItem &other) const; NodeItem dotproduct(const NodeItem &other) const; - NodeItem if_else(const std::string &condition, + NodeItem if_else(IfType condition, const NodeItem &other, const NodeItem &if_val, const NodeItem &else_val) const; @@ -80,7 +81,6 @@ class NodeItem { NodeItem exp() const; NodeItem convert(Type to_type) const; - NodeItem to_color3() const; Type type() const; private: diff --git a/source/blender/nodes/shader/materialx/nodes/tex_checker.cc b/source/blender/nodes/shader/materialx/nodes/tex_checker.cc index b6e131071984..c86e59084041 100644 --- a/source/blender/nodes/shader/materialx/nodes/tex_checker.cc +++ b/source/blender/nodes/shader/materialx/nodes/tex_checker.cc @@ -32,11 +32,11 @@ NodeItem TexCheckerNodeParser::compute() modulo_y.set_input("in2", value(2.0f)); NodeItem ifequal = - (modulo_x.floor() + modulo_y.floor()).if_else("==", value(1.0f), value(0.0f), value(1.0f)); + (modulo_x.floor() + modulo_y.floor()).if_else(NodeItem::IfType::Eq, value(1.0f), value(0.0f), value(1.0f)); NodeItem res = create_node("mix", "color3"); - res.set_input("bg", color1.to_color3()); - res.set_input("fg", color2.to_color3()); + res.set_input("bg", color1, NodeItem::Type::Color3); + res.set_input("fg", color2, NodeItem::Type::Color3); res.set_input("mix", ifequal); return res; } -- 2.30.2 From 4bd93247d8c0d75d10688cc4a1bd5b8220086253 Mon Sep 17 00:00:00 2001 From: Bogdan Nagirniak Date: Tue, 5 Sep 2023 00:57:34 +0300 Subject: [PATCH 06/12] Renamings --- .../nodes/shader/materialx/nodes/node_item.cc | 33 ++++++++++--------- .../nodes/shader/materialx/nodes/node_item.h | 22 ++++++------- .../shader/materialx/nodes/tex_checker.cc | 4 +-- 3 files changed, 30 insertions(+), 29 deletions(-) diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.cc b/source/blender/nodes/shader/materialx/nodes/node_item.cc index 8e311397d758..87c3c0287b97 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.cc +++ b/source/blender/nodes/shader/materialx/nodes/node_item.cc @@ -12,38 +12,38 @@ namespace blender::nodes::materialx { NodeItem::NodeItem(MaterialX::GraphElement *graph) : graph_(graph) {} -NodeItem::Type NodeItem::type(const std::string &mx_type) +NodeItem::Type NodeItem::type(const std::string &type_str) { - if (mx_type == "string") { + if (type_str == "string") { return Type::String; } - if (mx_type == "integer") { + if (type_str == "integer") { return Type::Integer; } - if (mx_type == "float") { + if (type_str == "float") { return Type::Float; } - if (mx_type == "vector2") { + if (type_str == "vector2") { return Type::Vector2; } - if (mx_type == "vector3") { + if (type_str == "vector3") { return Type::Vector3; } - if (mx_type == "vector4") { + if (type_str == "vector4") { return Type::Vector4; } - if (mx_type == "color3") { + if (type_str == "color3") { return Type::Color3; } - if (mx_type == "color4") { + if (type_str == "color4") { return Type::Color4; } return Type::Other; } -std::string NodeItem::type(Type mx_type) +std::string NodeItem::type(Type tp) { - switch (mx_type) { + switch (tp) { case Type::String: return "string"; case Type::Integer: @@ -61,8 +61,9 @@ std::string NodeItem::type(Type mx_type) case Type::Color4: return "color4"; default: - return ""; + break; } + return ""; } NodeItem NodeItem::empty() const @@ -119,15 +120,15 @@ void NodeItem::set_input(const std::string &name, void NodeItem::set_input(const std::string &name, const NodeItem &item, - Type to_type, + Type in_type, const std::string &output_name) { - set_input(name, item.convert(to_type), output_name); + set_input(name, item.convert(in_type), output_name); } -void NodeItem::add_output(const std::string &name, const std::string &mx_type) +void NodeItem::add_output(const std::string &name, Type out_type) { - node->addOutput(name, mx_type); + node->addOutput(name, type(out_type)); } NodeItem::operator bool() const diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.h b/source/blender/nodes/shader/materialx/nodes/node_item.h index a025c1f5cff9..cb784198b3c0 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.h +++ b/source/blender/nodes/shader/materialx/nodes/node_item.h @@ -24,22 +24,22 @@ class NodeItem { NodeItem(MaterialX::GraphElement *graph); ~NodeItem() = default; - static Type type(const std::string &mx_type); - static std::string type(Type mx_type); + static Type type(const std::string &type_str); + static std::string type(Type tp); NodeItem empty() const; template NodeItem val(const T &data) const; template - void set_input(const std::string &name, const T &value, const std::string &mx_type); - void set_input(const std::string &name, + void set_input(const std::string &in_name, const T &value, const std::string &in_type); + void set_input(const std::string &in_name, const NodeItem &item, - const std::string &output_name = ""); - void set_input(const std::string &name, + const std::string &out_name = ""); + void set_input(const std::string &in_name, const NodeItem &item, - Type to_type, - const std::string &output_name = ""); - void add_output(const std::string &name, const std::string &mx_type); + Type in_type, + const std::string &out_name = ""); + void add_output(const std::string &in_name, Type out_type); operator bool() const; NodeItem operator+(const NodeItem &other) const; @@ -106,9 +106,9 @@ template NodeItem NodeItem::val(const T &data) const } template -void NodeItem::set_input(const std::string &name, const T &value, const std::string &mx_type) +void NodeItem::set_input(const std::string &in_name, const T &value, const std::string &in_type) { - node->setInputValue(name, value, mx_type); + node->setInputValue(in_name, value, in_type); } } // namespace blender::nodes::materialx diff --git a/source/blender/nodes/shader/materialx/nodes/tex_checker.cc b/source/blender/nodes/shader/materialx/nodes/tex_checker.cc index c86e59084041..330ed02a073a 100644 --- a/source/blender/nodes/shader/materialx/nodes/tex_checker.cc +++ b/source/blender/nodes/shader/materialx/nodes/tex_checker.cc @@ -20,8 +20,8 @@ NodeItem TexCheckerNodeParser::compute() NodeItem separate = create_node("separate2", "multioutput"); separate.set_input("in", vector); - separate.add_output("outx", "float"); - separate.add_output("outy", "float"); + separate.add_output("outx", NodeItem::Type::Float); + separate.add_output("outy", NodeItem::Type::Float); NodeItem modulo_x = create_node("modulo", "float"); modulo_x.set_input("in1", separate, "outx"); -- 2.30.2 From 0cdb6a7bd1c593a84e20c7f40d89e26acd728632 Mon Sep 17 00:00:00 2001 From: Bogdan Nagirniak Date: Tue, 5 Sep 2023 01:32:38 +0300 Subject: [PATCH 07/12] Simplified adjust functions --- .../nodes/shader/materialx/nodes/node_item.cc | 179 +++++------------- .../nodes/shader/materialx/nodes/node_item.h | 9 +- 2 files changed, 53 insertions(+), 135 deletions(-) diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.cc b/source/blender/nodes/shader/materialx/nodes/node_item.cc index 87c3c0287b97..b0b8a05c85bb 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.cc +++ b/source/blender/nodes/shader/materialx/nodes/node_item.cc @@ -187,29 +187,14 @@ bool NodeItem::operator==(const NodeItem &other) const return false; } - Type mx_type; - auto val1 = value; - auto val2 = other.value; - if (!adjust_types(val1, val2, mx_type)) { + + NodeItem item1 = *this; + NodeItem item2 = other; + Type tp = adjust_types(item1, item2); + if (tp == Type::Empty) { return false; } - switch (mx_type) { - case Type::Vector2: - return val1->asA() == val2->asA(); - case Type::Vector3: - return val1->asA() == val2->asA(); - case Type::Vector4: - return val1->asA() == val2->asA(); - case Type::Float: - return val1->asA() == val2->asA(); - case Type::Color3: - return val1->asA() == val2->asA(); - case Type::Color4: - return val1->asA() == val2->asA(); - default: - break; - } - return false; + return item1.value->getValueString() == item2.value->getValueString(); } bool NodeItem::operator!=(const NodeItem &other) const @@ -307,10 +292,10 @@ NodeItem NodeItem::if_else(IfType condition, return res; } - auto val1 = if_val; - auto val2 = else_val; - Type mx_type; - if (!adjust_types(val1, val2, mx_type)) { + auto item1 = if_val; + auto item2 = else_val; + Type tp = adjust_types(item1, item2); + if (tp == Type::Empty) { return res; } @@ -334,14 +319,14 @@ NodeItem NodeItem::if_else(IfType condition, } if (value && other.value) { - res = func(value->asA(), other.value->asA()) ? val1 : val2; + res = func(value->asA(), other.value->asA()) ? item1 : item2; } else { - res.node = graph_->addNode(mx_category, MaterialX::EMPTY_STRING, type(mx_type)); + res.node = graph_->addNode(mx_category, MaterialX::EMPTY_STRING, type(tp)); res.set_input("value1", *this); res.set_input("value2", other); - res.set_input("in1", val1); - res.set_input("in2", val2); + res.set_input("in1", item1); + res.set_input("in2", item2); } return res; @@ -626,7 +611,7 @@ bool NodeItem::is_arithmetic() const return is_arithmetic(type()); } -NodeItem NodeItem::arithmetic(const std::string &mx_category, +NodeItem NodeItem::arithmetic(const std::string &category, std::function func) const { NodeItem res = empty(); @@ -675,67 +660,63 @@ NodeItem NodeItem::arithmetic(const std::string &mx_category, } } else { - res.node = graph_->addNode(mx_category, MaterialX::EMPTY_STRING, type(t)); + res.node = graph_->addNode(category, MaterialX::EMPTY_STRING, type(t)); res.set_input("in", *this); } return res; } NodeItem NodeItem::arithmetic(const NodeItem &other, - const std::string &mx_category, + const std::string &category, std::function func) const { NodeItem res = empty(); - if (!is_arithmetic() || !other.is_arithmetic()) { + NodeItem item1 = *this; + NodeItem item2 = other; + Type tp = adjust_types(item1, item2); + if (tp == Type::Empty) { return res; } - Type mx_type; if (value && other.value) { - auto val1 = value; - auto val2 = other.value; - if (!adjust_types(val1, val2, mx_type)) { - return res; - } - - switch (mx_type) { + switch (tp) { case Type::Float: { - float v1 = val1->asA(); - float v2 = val2->asA(); + float v1 = item1.value->asA(); + float v2 = item2.value->asA(); res.value = MaterialX::Value::createValue(func(v1, v2)); break; } case Type::Color3: { - auto v1 = val1->asA(); - auto v2 = val2->asA(); + auto v1 = item1.value->asA(); + auto v2 = item2.value->asA(); res.value = MaterialX::Value::createValue( {func(v1[0], v2[0]), func(v1[1], v2[1]), func(v1[2], v2[2])}); break; } case Type::Color4: { - auto v1 = val1->asA(); - auto v2 = val2->asA(); + auto v1 = item1.value->asA(); + auto v2 = item2.value->asA(); res.value = MaterialX::Value::createValue( {func(v1[0], v2[0]), func(v1[1], v2[1]), func(v1[2], v2[2]), func(v1[3], v2[3])}); break; } case Type::Vector2: { - auto v1 = val1->asA(); - auto v2 = val2->asA(); + auto v1 = item1.value->asA(); + auto v2 = item2.value->asA(); res.value = MaterialX::Value::createValue( {func(v1[0], v2[0]), func(v1[1], v2[1])}); break; } case Type::Vector3: { - auto v1 = val1->asA(); - auto v2 = val2->asA(); + auto v1 = item1.value->asA(); + auto v2 = item2.value->asA(); res.value = MaterialX::Value::createValue( {func(v1[0], v2[0]), func(v1[1], v2[1]), func(v1[2], v2[2])}); break; } case Type::Vector4: { - auto v1 = val1->asA(); - auto v2 = val2->asA(); + auto v1 = item1.value->asA(); + auto v2 = item2.value->asA(); res.value = MaterialX::Value::createValue( {func(v1[0], v2[0]), func(v1[1], v2[1]), func(v1[2], v2[2]), func(v1[3], v2[3])}); break; @@ -745,91 +726,31 @@ NodeItem NodeItem::arithmetic(const NodeItem &other, } } else { - auto val1 = *this; - auto val2 = other; - if (!adjust_types(val1, val2, mx_type)) { - return res; - } - - res.node = graph_->addNode(mx_category, MaterialX::EMPTY_STRING, type(mx_type)); - res.set_input("in1", val1); - res.set_input("in2", val2); + res.node = graph_->addNode(category, MaterialX::EMPTY_STRING, type(tp)); + res.set_input("in1", item1); + res.set_input("in2", item2); } return res; } -MaterialX::ValuePtr NodeItem::float_to_type(float v, Type mx_type) +NodeItem::Type NodeItem::adjust_types(NodeItem &item1, NodeItem &item2) { - MaterialX::ValuePtr res; - switch (mx_type) { - case Type::Float: - res = MaterialX::Value::createValue(v); - break; - case Type::Vector2: - res = MaterialX::Value::createValue({v, v}); - break; - case Type::Vector3: - res = MaterialX::Value::createValue({v, v, v}); - break; - case Type::Vector4: - res = MaterialX::Value::createValue({v, v, v, v}); - break; - case Type::Color3: - res = MaterialX::Value::createValue({v, v, v}); - break; - case Type::Color4: - res = MaterialX::Value::createValue({v, v, v, v}); - break; - default: - BLI_assert_unreachable(); + Type t1 = item1.type(); + Type t2 = item2.type(); + if (t1 == t2) { + return t1; } - return res; -} - -bool NodeItem::adjust_types(MaterialX::ValuePtr &val1, MaterialX::ValuePtr &val2, Type &mx_type) -{ - Type t1 = type(val1->getTypeString()); - Type t2 = type(val2->getTypeString()); - if (t1 != t2) { - if (t1 == Type::Float) { - val1 = float_to_type(val1->asA(), t2); - mx_type = t2; - } - else if (t2 == Type::Float) { - val2 = float_to_type(val2->asA(), t1); - mx_type = t1; - } - else { - return false; - } + if (!is_arithmetic(t1) || !is_arithmetic(t2)) { + return Type::Empty; + } + if (t1 < t2) { + item1 = item1.convert(t2); + return t2; } else { - mx_type = t1; + item2 = item2.convert(t1); + return t1; } - return true; -} - -bool NodeItem::adjust_types(NodeItem &val1, NodeItem &val2, Type &mx_type) -{ - Type t1 = val1.type(); - Type t2 = val2.type(); - if (t1 != t2) { - if (val1.value && t1 == Type::Float) { - val1.value = float_to_type(val1.value->asA(), t2); - mx_type = t2; - } - else if (val2.value && t2 == Type::Float) { - val2.value = float_to_type(val2.value->asA(), t1); - mx_type = t1; - } - else { - return false; - } - } - else { - mx_type = t1; - } - return true; } } // namespace blender::nodes::materialx diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.h b/source/blender/nodes/shader/materialx/nodes/node_item.h index cb784198b3c0..e53132f3e77f 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.h +++ b/source/blender/nodes/shader/materialx/nodes/node_item.h @@ -88,14 +88,11 @@ class NodeItem { bool is_arithmetic() const; - NodeItem arithmetic(const std::string &mx_category, std::function func) const; + NodeItem arithmetic(const std::string &category, std::function func) const; NodeItem arithmetic(const NodeItem &other, - const std::string &mx_category, + const std::string &category, std::function func) const; - static MaterialX::ValuePtr float_to_type(float v, Type mx_type); - /* Functions for adjusting values to make equal types */ - static bool adjust_types(MaterialX::ValuePtr &val1, MaterialX::ValuePtr &val2, Type &mx_type); - static bool adjust_types(NodeItem &val1, NodeItem &val2, Type &mx_type); + static Type adjust_types(NodeItem &item1, NodeItem &item2); }; template NodeItem NodeItem::val(const T &data) const -- 2.30.2 From 826df5ce9235e27a228e5c29ef4448d32c03e9c7 Mon Sep 17 00:00:00 2001 From: Bogdan Nagirniak Date: Tue, 5 Sep 2023 01:34:49 +0300 Subject: [PATCH 08/12] make format --- source/blender/nodes/shader/materialx/nodes/math.cc | 2 +- .../nodes/shader/materialx/nodes/node_item.cc | 11 +++++------ .../nodes/shader/materialx/nodes/node_item.h | 13 ++++++++++++- .../nodes/shader/materialx/nodes/node_parser.cc | 8 ++++++-- .../nodes/shader/materialx/nodes/output_material.cc | 3 ++- .../nodes/shader/materialx/nodes/tex_checker.cc | 4 ++-- 6 files changed, 28 insertions(+), 13 deletions(-) diff --git a/source/blender/nodes/shader/materialx/nodes/math.cc b/source/blender/nodes/shader/materialx/nodes/math.cc index d5fb91183e5a..db841f394b76 100644 --- a/source/blender/nodes/shader/materialx/nodes/math.cc +++ b/source/blender/nodes/shader/materialx/nodes/math.cc @@ -2,8 +2,8 @@ * * SPDX-License-Identifier: GPL-2.0-or-later */ -#include "node_parser.h" #include "../material.h" +#include "node_parser.h" namespace blender::nodes::materialx { diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.cc b/source/blender/nodes/shader/materialx/nodes/node_item.cc index b0b8a05c85bb..a9517345a5fe 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.cc +++ b/source/blender/nodes/shader/materialx/nodes/node_item.cc @@ -187,7 +187,6 @@ bool NodeItem::operator==(const NodeItem &other) const return false; } - NodeItem item1 = *this; NodeItem item2 = other; Type tp = adjust_types(item1, item2); @@ -526,8 +525,8 @@ NodeItem NodeItem::convert(Type to_type) const res.value = MaterialX::Value::createValue({v[0], v[1]}); break; case Type::Vector4: - res.value = - MaterialX::Value::createValue({v[0], v[1], v[2], 0.0f}); + res.value = MaterialX::Value::createValue( + {v[0], v[1], v[2], 0.0f}); break; case Type::Color3: res.value = MaterialX::Value::createValue({v[0], v[1], v[2]}); @@ -569,7 +568,8 @@ NodeItem NodeItem::convert(Type to_type) const auto v = value->asA(); switch (to_type) { case Type::Vector4: - res.value = MaterialX::Value::createValue({v[0], v[1], v[2], v[3]}); + res.value = MaterialX::Value::createValue( + {v[0], v[1], v[2], v[3]}); break; case Type::Color3: res.value = MaterialX::Value::createValue({v[0], v[1], v[2]}); @@ -611,8 +611,7 @@ bool NodeItem::is_arithmetic() const return is_arithmetic(type()); } -NodeItem NodeItem::arithmetic(const std::string &category, - std::function func) const +NodeItem NodeItem::arithmetic(const std::string &category, std::function func) const { NodeItem res = empty(); Type t = type(); diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.h b/source/blender/nodes/shader/materialx/nodes/node_item.h index e53132f3e77f..9481a270d2ab 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.h +++ b/source/blender/nodes/shader/materialx/nodes/node_item.h @@ -10,7 +10,18 @@ namespace blender::nodes::materialx { class NodeItem { public: - enum class Type { Empty = 0, Other, String, Integer, Float, Vector2, Vector3, Vector4, Color3, Color4 }; + enum class Type { + Empty = 0, + Other, + String, + Integer, + Float, + Vector2, + Vector3, + Vector4, + Color3, + Color4 + }; enum class IfType { Less = 0, LessEq, Eq, GreaterEq, Greater, NotEq }; public: diff --git a/source/blender/nodes/shader/materialx/nodes/node_parser.cc b/source/blender/nodes/shader/materialx/nodes/node_parser.cc index 01a93fc31e60..187590c7332f 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_parser.cc +++ b/source/blender/nodes/shader/materialx/nodes/node_parser.cc @@ -14,7 +14,11 @@ NodeParser::NodeParser(MaterialX::GraphElement *graph, const Material *material, const bNode *node, const bNodeSocket *socket_out) - : graph_(graph), depsgraph_(depsgraph), material_(material), node_(node), socket_out_(socket_out) + : graph_(graph), + depsgraph_(depsgraph), + material_(material), + node_(node), + socket_out_(socket_out) { } @@ -118,7 +122,7 @@ NodeItem NodeParser::get_input_link(const bNodeSocket &socket) /* Checking if node was already computed */ res.node = graph_->getNode(node_name(from_node, link->fromsock)); if (res.node) { - return res; + return res; } /* Computing from_node with required NodeParser object */ diff --git a/source/blender/nodes/shader/materialx/nodes/output_material.cc b/source/blender/nodes/shader/materialx/nodes/output_material.cc index 5b5d9d0b7c66..92fd81dbbe22 100644 --- a/source/blender/nodes/shader/materialx/nodes/output_material.cc +++ b/source/blender/nodes/shader/materialx/nodes/output_material.cc @@ -37,7 +37,8 @@ NodeItem OutputMaterialNodeParser::compute(const std::string &socket_name) NodeItem OutputMaterialNodeParser::compute_default() { NodeItem surface = create_node("standard_surface", "surfaceshader"); - surface.set_input("base_color", value(MaterialX::Color3(material_->r, material_->g, material_->b))); + surface.set_input("base_color", + value(MaterialX::Color3(material_->r, material_->g, material_->b))); surface.set_input("diffuse_roughness", value(material_->roughness)); if (material_->metallic > 0.0f) { surface.set_input("metalness", value(material_->metallic)); diff --git a/source/blender/nodes/shader/materialx/nodes/tex_checker.cc b/source/blender/nodes/shader/materialx/nodes/tex_checker.cc index 330ed02a073a..dff82fcfcc6b 100644 --- a/source/blender/nodes/shader/materialx/nodes/tex_checker.cc +++ b/source/blender/nodes/shader/materialx/nodes/tex_checker.cc @@ -31,8 +31,8 @@ NodeItem TexCheckerNodeParser::compute() modulo_y.set_input("in1", separate, "outy"); modulo_y.set_input("in2", value(2.0f)); - NodeItem ifequal = - (modulo_x.floor() + modulo_y.floor()).if_else(NodeItem::IfType::Eq, value(1.0f), value(0.0f), value(1.0f)); + NodeItem ifequal = (modulo_x.floor() + modulo_y.floor()) + .if_else(NodeItem::IfType::Eq, value(1.0f), value(0.0f), value(1.0f)); NodeItem res = create_node("mix", "color3"); res.set_input("bg", color1, NodeItem::Type::Color3); -- 2.30.2 From 53c4638b53c31ec180980cb53a377430a154a56e Mon Sep 17 00:00:00 2001 From: Bogdan Nagirniak Date: Tue, 5 Sep 2023 01:52:24 +0300 Subject: [PATCH 09/12] Rearranging functions order --- .../nodes/shader/materialx/nodes/node_item.cc | 404 +++++++++--------- .../nodes/shader/materialx/nodes/node_item.h | 51 +-- 2 files changed, 228 insertions(+), 227 deletions(-) diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.cc b/source/blender/nodes/shader/materialx/nodes/node_item.cc index a9517345a5fe..029997247a63 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.cc +++ b/source/blender/nodes/shader/materialx/nodes/node_item.cc @@ -12,125 +12,6 @@ namespace blender::nodes::materialx { NodeItem::NodeItem(MaterialX::GraphElement *graph) : graph_(graph) {} -NodeItem::Type NodeItem::type(const std::string &type_str) -{ - if (type_str == "string") { - return Type::String; - } - if (type_str == "integer") { - return Type::Integer; - } - if (type_str == "float") { - return Type::Float; - } - if (type_str == "vector2") { - return Type::Vector2; - } - if (type_str == "vector3") { - return Type::Vector3; - } - if (type_str == "vector4") { - return Type::Vector4; - } - if (type_str == "color3") { - return Type::Color3; - } - if (type_str == "color4") { - return Type::Color4; - } - return Type::Other; -} - -std::string NodeItem::type(Type tp) -{ - switch (tp) { - case Type::String: - return "string"; - case Type::Integer: - return "integer"; - case Type::Float: - return "float"; - case Type::Vector2: - return "vector2"; - case Type::Vector3: - return "vector3"; - case Type::Vector4: - return "vector4"; - case Type::Color3: - return "color3"; - case Type::Color4: - return "color4"; - default: - break; - } - return ""; -} - -NodeItem NodeItem::empty() const -{ - return NodeItem(graph_); -} - -void NodeItem::set_input(const std::string &name, - const NodeItem &item, - const std::string &output_name) -{ - if (item.value) { - Type t = item.type(); - std::string mx_type = type(t); - switch (t) { - case Type::String: - set_input(name, item.value->asA(), mx_type); - break; - case Type::Integer: - set_input(name, item.value->asA(), mx_type); - break; - case Type::Float: - set_input(name, item.value->asA(), mx_type); - break; - case Type::Vector2: - set_input(name, item.value->asA(), mx_type); - break; - case Type::Vector3: - set_input(name, item.value->asA(), mx_type); - break; - case Type::Vector4: - set_input(name, item.value->asA(), mx_type); - break; - case Type::Color3: - set_input(name, item.value->asA(), mx_type); - break; - case Type::Color4: - set_input(name, item.value->asA(), mx_type); - break; - default: - BLI_assert_unreachable(); - } - } - else if (item.node) { - node->setConnectedNode(name, item.node); - if (output_name != "") { - node->setConnectedOutput(name, item.node->getOutput(output_name)); - } - } - else { - CLOG_WARN(LOG_MATERIALX_SHADER, "Empty item to input: %s", name.c_str()); - } -} - -void NodeItem::set_input(const std::string &name, - const NodeItem &item, - Type in_type, - const std::string &output_name) -{ - set_input(name, item.convert(in_type), output_name); -} - -void NodeItem::add_output(const std::string &name, Type out_type) -{ - node->addOutput(name, type(out_type)); -} - NodeItem::operator bool() const { return value || node; @@ -270,67 +151,6 @@ NodeItem NodeItem::dotproduct(const NodeItem &other) const return d; } -NodeItem NodeItem::if_else(IfType condition, - const NodeItem &other, - const NodeItem &if_val, - const NodeItem &else_val) const -{ - switch (condition) { - case IfType::Less: - return other.if_else(IfType::Greater, *this, else_val, if_val); - case IfType::LessEq: - return other.if_else(IfType::GreaterEq, *this, else_val, if_val); - case IfType::NotEq: - return if_else(IfType::Eq, other, else_val, if_val); - default: - break; - } - - NodeItem res = empty(); - if (type() != Type::Float || other.type() != Type::Float) { - return res; - } - - auto item1 = if_val; - auto item2 = else_val; - Type tp = adjust_types(item1, item2); - if (tp == Type::Empty) { - return res; - } - - std::function func = nullptr; - std::string mx_category; - switch (condition) { - case IfType::Greater: - mx_category = "ifgreater"; - func = [](float a, float b) { return a > b; }; - break; - case IfType::GreaterEq: - mx_category = "ifgreatereq"; - func = [](float a, float b) { return a >= b; }; - break; - case IfType::Eq: - mx_category = "ifequal"; - func = [](float a, float b) { return a == b; }; - break; - default: - BLI_assert_unreachable(); - } - - if (value && other.value) { - res = func(value->asA(), other.value->asA()) ? item1 : item2; - } - else { - res.node = graph_->addNode(mx_category, MaterialX::EMPTY_STRING, type(tp)); - res.set_input("value1", *this); - res.set_input("value2", other); - res.set_input("in1", item1); - res.set_input("in2", item2); - } - - return res; -} - NodeItem NodeItem::blend(const NodeItem &a, const NodeItem &b) const { return (val(1.0f) - *this) * a + *this * b; @@ -590,6 +410,72 @@ NodeItem NodeItem::convert(Type to_type) const return res; } +NodeItem NodeItem::if_else(IfType condition, + const NodeItem &other, + const NodeItem &if_val, + const NodeItem &else_val) const +{ + switch (condition) { + case IfType::Less: + return other.if_else(IfType::Greater, *this, else_val, if_val); + case IfType::LessEq: + return other.if_else(IfType::GreaterEq, *this, else_val, if_val); + case IfType::NotEq: + return if_else(IfType::Eq, other, else_val, if_val); + default: + break; + } + + NodeItem res = empty(); + if (type() != Type::Float || other.type() != Type::Float) { + return res; + } + + auto item1 = if_val; + auto item2 = else_val; + Type tp = adjust_types(item1, item2); + if (tp == Type::Empty) { + return res; + } + + std::function func = nullptr; + std::string mx_category; + switch (condition) { + case IfType::Greater: + mx_category = "ifgreater"; + func = [](float a, float b) { return a > b; }; + break; + case IfType::GreaterEq: + mx_category = "ifgreatereq"; + func = [](float a, float b) { return a >= b; }; + break; + case IfType::Eq: + mx_category = "ifequal"; + func = [](float a, float b) { return a == b; }; + break; + default: + BLI_assert_unreachable(); + } + + if (value && other.value) { + res = func(value->asA(), other.value->asA()) ? item1 : item2; + } + else { + res.node = graph_->addNode(mx_category, MaterialX::EMPTY_STRING, type(tp)); + res.set_input("value1", *this); + res.set_input("value2", other); + res.set_input("in1", item1); + res.set_input("in2", item2); + } + + return res; +} + +NodeItem NodeItem::empty() const +{ + return NodeItem(graph_); +} + NodeItem::Type NodeItem::type() const { if (value) { @@ -601,9 +487,143 @@ NodeItem::Type NodeItem::type() const return Type::Empty; } -bool NodeItem::is_arithmetic(Type t) +void NodeItem::set_input(const std::string &name, + const NodeItem &item, + const std::string &output_name) { - return t >= Type::Float; + if (item.value) { + Type t = item.type(); + std::string mx_type = type(t); + switch (t) { + case Type::String: + set_input(name, item.value->asA(), mx_type); + break; + case Type::Integer: + set_input(name, item.value->asA(), mx_type); + break; + case Type::Float: + set_input(name, item.value->asA(), mx_type); + break; + case Type::Vector2: + set_input(name, item.value->asA(), mx_type); + break; + case Type::Vector3: + set_input(name, item.value->asA(), mx_type); + break; + case Type::Vector4: + set_input(name, item.value->asA(), mx_type); + break; + case Type::Color3: + set_input(name, item.value->asA(), mx_type); + break; + case Type::Color4: + set_input(name, item.value->asA(), mx_type); + break; + default: + BLI_assert_unreachable(); + } + } + else if (item.node) { + node->setConnectedNode(name, item.node); + if (output_name != "") { + node->setConnectedOutput(name, item.node->getOutput(output_name)); + } + } + else { + CLOG_WARN(LOG_MATERIALX_SHADER, "Empty item to input: %s", name.c_str()); + } +} + +void NodeItem::set_input(const std::string &name, + const NodeItem &item, + Type in_type, + const std::string &output_name) +{ + set_input(name, item.convert(in_type), output_name); +} + +void NodeItem::add_output(const std::string &name, Type out_type) +{ + node->addOutput(name, type(out_type)); +} + +NodeItem::Type NodeItem::type(const std::string &tp) +{ + if (tp == "string") { + return Type::String; + } + if (tp == "integer") { + return Type::Integer; + } + if (tp == "float") { + return Type::Float; + } + if (tp == "vector2") { + return Type::Vector2; + } + if (tp == "vector3") { + return Type::Vector3; + } + if (tp == "vector4") { + return Type::Vector4; + } + if (tp == "color3") { + return Type::Color3; + } + if (tp == "color4") { + return Type::Color4; + } + return Type::Other; +} + +std::string NodeItem::type(Type tp) +{ + switch (tp) { + case Type::String: + return "string"; + case Type::Integer: + return "integer"; + case Type::Float: + return "float"; + case Type::Vector2: + return "vector2"; + case Type::Vector3: + return "vector3"; + case Type::Vector4: + return "vector4"; + case Type::Color3: + return "color3"; + case Type::Color4: + return "color4"; + default: + break; + } + return ""; +} + +bool NodeItem::is_arithmetic(Type tp) +{ + return tp >= Type::Float; +} + +NodeItem::Type NodeItem::adjust_types(NodeItem &item1, NodeItem &item2) +{ + Type t1 = item1.type(); + Type t2 = item2.type(); + if (t1 == t2) { + return t1; + } + if (!is_arithmetic(t1) || !is_arithmetic(t2)) { + return Type::Empty; + } + if (t1 < t2) { + item1 = item1.convert(t2); + return t2; + } + else { + item2 = item2.convert(t1); + return t1; + } } bool NodeItem::is_arithmetic() const @@ -732,24 +752,4 @@ NodeItem NodeItem::arithmetic(const NodeItem &other, return res; } -NodeItem::Type NodeItem::adjust_types(NodeItem &item1, NodeItem &item2) -{ - Type t1 = item1.type(); - Type t2 = item2.type(); - if (t1 == t2) { - return t1; - } - if (!is_arithmetic(t1) || !is_arithmetic(t2)) { - return Type::Empty; - } - if (t1 < t2) { - item1 = item1.convert(t2); - return t2; - } - else { - item2 = item2.convert(t1); - return t1; - } -} - } // namespace blender::nodes::materialx diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.h b/source/blender/nodes/shader/materialx/nodes/node_item.h index 9481a270d2ab..06ef7ddee23d 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.h +++ b/source/blender/nodes/shader/materialx/nodes/node_item.h @@ -35,23 +35,7 @@ class NodeItem { NodeItem(MaterialX::GraphElement *graph); ~NodeItem() = default; - static Type type(const std::string &type_str); - static std::string type(Type tp); - - NodeItem empty() const; - template NodeItem val(const T &data) const; - - template - void set_input(const std::string &in_name, const T &value, const std::string &in_type); - void set_input(const std::string &in_name, - const NodeItem &item, - const std::string &out_name = ""); - void set_input(const std::string &in_name, - const NodeItem &item, - Type in_type, - const std::string &out_name = ""); - void add_output(const std::string &in_name, Type out_type); - + /* Operators */ operator bool() const; NodeItem operator+(const NodeItem &other) const; NodeItem operator-(const NodeItem &other) const; @@ -63,16 +47,13 @@ class NodeItem { bool operator==(const NodeItem &other) const; bool operator!=(const NodeItem &other) const; + /* Math functions */ NodeItem abs() const; NodeItem floor() const; NodeItem ceil() const; NodeItem min(const NodeItem &other) const; NodeItem max(const NodeItem &other) const; NodeItem dotproduct(const NodeItem &other) const; - NodeItem if_else(IfType condition, - const NodeItem &other, - const NodeItem &if_val, - const NodeItem &else_val) const; NodeItem blend(const NodeItem &a, const NodeItem &b) const; NodeItem clamp(const NodeItem &min_val, const NodeItem &max_val) const; NodeItem clamp(float min_val = 0.0f, float max_val = 1.0f) const; @@ -90,20 +71,40 @@ class NodeItem { NodeItem sqrt() const; NodeItem sign() const; NodeItem exp() const; - NodeItem convert(Type to_type) const; + NodeItem if_else(IfType condition, + const NodeItem &other, + const NodeItem &if_val, + const NodeItem &else_val) const; + + /* Useful functions */ + NodeItem empty() const; + template NodeItem val(const T &data) const; Type type() const; + /* Functions to set input and output */ + template + void set_input(const std::string &in_name, const T &value, const std::string &in_type); + void set_input(const std::string &in_name, + const NodeItem &item, + const std::string &out_name = ""); + void set_input(const std::string &in_name, + const NodeItem &item, + Type in_type, + const std::string &out_name = ""); + void add_output(const std::string &in_name, Type out_type); + private: - static bool is_arithmetic(Type t); + static Type type(const std::string &tp); + static std::string type(Type tp); + static bool is_arithmetic(Type tp); + static Type adjust_types(NodeItem &item1, NodeItem &item2); bool is_arithmetic() const; - NodeItem arithmetic(const std::string &category, std::function func) const; NodeItem arithmetic(const NodeItem &other, const std::string &category, std::function func) const; - static Type adjust_types(NodeItem &item1, NodeItem &item2); }; template NodeItem NodeItem::val(const T &data) const -- 2.30.2 From 8c8ee4d5c032395701788a69c1adcec2ed0115f7 Mon Sep 17 00:00:00 2001 From: Bogdan Nagirniak Date: Tue, 5 Sep 2023 09:46:27 +0300 Subject: [PATCH 10/12] Code improvements --- .../nodes/shader/materialx/nodes/node_item.cc | 30 +++++++++++-------- .../shader/materialx/nodes/tex_checker.cc | 2 +- .../nodes/shader/materialx/nodes/tex_noise.cc | 5 ++-- 3 files changed, 22 insertions(+), 15 deletions(-) diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.cc b/source/blender/nodes/shader/materialx/nodes/node_item.cc index 029997247a63..e66422536e0a 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.cc +++ b/source/blender/nodes/shader/materialx/nodes/node_item.cc @@ -238,15 +238,20 @@ NodeItem NodeItem::exp() const NodeItem NodeItem::convert(Type to_type) const { - Type t = type(); - if (t == to_type) { + Type tp = type(); + if (tp == to_type) { return *this; } - if (!is_arithmetic(t) || !is_arithmetic(to_type)) { + if (!is_arithmetic(tp) || !is_arithmetic(to_type)) { return empty(); } - switch (t) { + if (to_type == Type::Float) { + /* TODO: Convert to float, should be used */ + } + + /* Converting types which requires > 1 iteration */ + switch (tp) { case Type::Vector2: switch (to_type) { case Type::Vector4: @@ -301,9 +306,10 @@ NodeItem NodeItem::convert(Type to_type) const break; } + /* Converting 1 iteration types */ NodeItem res = empty(); if (value) { - switch (t) { + switch (tp) { case Type::Float: { float v = value->asA(); switch (to_type) { @@ -492,9 +498,9 @@ void NodeItem::set_input(const std::string &name, const std::string &output_name) { if (item.value) { - Type t = item.type(); - std::string mx_type = type(t); - switch (t) { + Type tp = item.type(); + std::string mx_type = type(tp); + switch (tp) { case Type::String: set_input(name, item.value->asA(), mx_type); break; @@ -634,13 +640,13 @@ bool NodeItem::is_arithmetic() const NodeItem NodeItem::arithmetic(const std::string &category, std::function func) const { NodeItem res = empty(); - Type t = type(); - if (!is_arithmetic(t)) { + Type tp = type(); + if (!is_arithmetic(tp)) { return res; } if (value) { - switch (t) { + switch (tp) { case Type::Float: { float v = value->asA(); res.value = MaterialX::Value::createValue(func(v)); @@ -679,7 +685,7 @@ NodeItem NodeItem::arithmetic(const std::string &category, std::functionaddNode(category, MaterialX::EMPTY_STRING, type(t)); + res.node = graph_->addNode(category, MaterialX::EMPTY_STRING, type(tp)); res.set_input("in", *this); } return res; diff --git a/source/blender/nodes/shader/materialx/nodes/tex_checker.cc b/source/blender/nodes/shader/materialx/nodes/tex_checker.cc index dff82fcfcc6b..98507da882ab 100644 --- a/source/blender/nodes/shader/materialx/nodes/tex_checker.cc +++ b/source/blender/nodes/shader/materialx/nodes/tex_checker.cc @@ -19,7 +19,7 @@ NodeItem TexCheckerNodeParser::compute() vector = vector * scale; NodeItem separate = create_node("separate2", "multioutput"); - separate.set_input("in", vector); + separate.set_input("in", vector, NodeItem::Type::Vector2); separate.add_output("outx", NodeItem::Type::Float); separate.add_output("outy", NodeItem::Type::Float); diff --git a/source/blender/nodes/shader/materialx/nodes/tex_noise.cc b/source/blender/nodes/shader/materialx/nodes/tex_noise.cc index e9154bba74bd..2136f8abd066 100644 --- a/source/blender/nodes/shader/materialx/nodes/tex_noise.cc +++ b/source/blender/nodes/shader/materialx/nodes/tex_noise.cc @@ -16,10 +16,11 @@ NodeItem TexNoiseNodeParser::compute() detail = value(int(detail.value->asA())); } - NodeItem texcoord = create_node("position", "vector3"); + NodeItem position = create_node("position", "vector3"); + position = position * scale; NodeItem res = create_node("fractal3d", "color3"); - res.set_input("position", texcoord * scale); + res.set_input("position", position, NodeItem::Type::Vector3); res.set_input("octaves", detail); res.set_input("lacunarity", lacunarity); return res; -- 2.30.2 From 8c13cb78c48b9fa2895fc3da96aec2dadd08f274 Mon Sep 17 00:00:00 2001 From: Bogdan Nagirniak Date: Tue, 5 Sep 2023 12:05:56 +0300 Subject: [PATCH 11/12] Renamed IfType -> CompareOp, added TODO --- .../nodes/shader/materialx/nodes/math.cc | 6 ++--- .../nodes/shader/materialx/nodes/node_item.cc | 26 ++++++++++--------- .../nodes/shader/materialx/nodes/node_item.h | 4 +-- .../shader/materialx/nodes/tex_checker.cc | 2 +- 4 files changed, 20 insertions(+), 18 deletions(-) diff --git a/source/blender/nodes/shader/materialx/nodes/math.cc b/source/blender/nodes/shader/materialx/nodes/math.cc index db841f394b76..598c80a2faee 100644 --- a/source/blender/nodes/shader/materialx/nodes/math.cc +++ b/source/blender/nodes/shader/materialx/nodes/math.cc @@ -109,10 +109,10 @@ NodeItem MathNodeParser::compute() res = x.max(y); break; case NODE_MATH_LESS_THAN: - res = x.if_else(NodeItem::IfType::Less, y, value(1.0f), value(0.0f)); + res = x.if_else(NodeItem::CompareOp::Less, y, value(1.0f), value(0.0f)); break; case NODE_MATH_GREATER_THAN: - res = x.if_else(NodeItem::IfType::Greater, y, value(1.0f), value(0.0f)); + res = x.if_else(NodeItem::CompareOp::Greater, y, value(1.0f), value(0.0f)); break; case NODE_MATH_MODULO: res = x % y; @@ -138,7 +138,7 @@ NodeItem MathNodeParser::compute() CLOG_WARN(LOG_MATERIALX_SHADER, "Unimplemented math operation %d", op); break; case NODE_MATH_COMPARE: - res = z.if_else(NodeItem::IfType::Less, (x - y).abs(), value(1.0f), value(0.0f)); + res = z.if_else(NodeItem::CompareOp::Less, (x - y).abs(), value(1.0f), value(0.0f)); break; case NODE_MATH_MULTIPLY_ADD: res = x * y + z; diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.cc b/source/blender/nodes/shader/materialx/nodes/node_item.cc index e66422536e0a..e5a9300df537 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.cc +++ b/source/blender/nodes/shader/materialx/nodes/node_item.cc @@ -416,18 +416,18 @@ NodeItem NodeItem::convert(Type to_type) const return res; } -NodeItem NodeItem::if_else(IfType condition, +NodeItem NodeItem::if_else(CompareOp op, const NodeItem &other, const NodeItem &if_val, const NodeItem &else_val) const { - switch (condition) { - case IfType::Less: - return other.if_else(IfType::Greater, *this, else_val, if_val); - case IfType::LessEq: - return other.if_else(IfType::GreaterEq, *this, else_val, if_val); - case IfType::NotEq: - return if_else(IfType::Eq, other, else_val, if_val); + switch (op) { + case CompareOp::Less: + return other.if_else(CompareOp::Greater, *this, else_val, if_val); + case CompareOp::LessEq: + return other.if_else(CompareOp::GreaterEq, *this, else_val, if_val); + case CompareOp::NotEq: + return if_else(CompareOp::Eq, other, else_val, if_val); default: break; } @@ -446,16 +446,16 @@ NodeItem NodeItem::if_else(IfType condition, std::function func = nullptr; std::string mx_category; - switch (condition) { - case IfType::Greater: + switch (op) { + case CompareOp::Greater: mx_category = "ifgreater"; func = [](float a, float b) { return a > b; }; break; - case IfType::GreaterEq: + case CompareOp::GreaterEq: mx_category = "ifgreatereq"; func = [](float a, float b) { return a >= b; }; break; - case IfType::Eq: + case CompareOp::Eq: mx_category = "ifequal"; func = [](float a, float b) { return a == b; }; break; @@ -685,6 +685,8 @@ NodeItem NodeItem::arithmetic(const std::string &category, std::functionaddNode(category, MaterialX::EMPTY_STRING, type(tp)); res.set_input("in", *this); } diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.h b/source/blender/nodes/shader/materialx/nodes/node_item.h index 06ef7ddee23d..2254d5b0cf38 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.h +++ b/source/blender/nodes/shader/materialx/nodes/node_item.h @@ -22,7 +22,7 @@ class NodeItem { Color3, Color4 }; - enum class IfType { Less = 0, LessEq, Eq, GreaterEq, Greater, NotEq }; + enum class CompareOp { Less = 0, LessEq, Eq, GreaterEq, Greater, NotEq }; public: MaterialX::ValuePtr value; @@ -72,7 +72,7 @@ class NodeItem { NodeItem sign() const; NodeItem exp() const; NodeItem convert(Type to_type) const; - NodeItem if_else(IfType condition, + NodeItem if_else(CompareOp op, const NodeItem &other, const NodeItem &if_val, const NodeItem &else_val) const; diff --git a/source/blender/nodes/shader/materialx/nodes/tex_checker.cc b/source/blender/nodes/shader/materialx/nodes/tex_checker.cc index 98507da882ab..8325bb0e06ef 100644 --- a/source/blender/nodes/shader/materialx/nodes/tex_checker.cc +++ b/source/blender/nodes/shader/materialx/nodes/tex_checker.cc @@ -32,7 +32,7 @@ NodeItem TexCheckerNodeParser::compute() modulo_y.set_input("in2", value(2.0f)); NodeItem ifequal = (modulo_x.floor() + modulo_y.floor()) - .if_else(NodeItem::IfType::Eq, value(1.0f), value(0.0f), value(1.0f)); + .if_else(NodeItem::CompareOp::Eq, value(1.0f), value(0.0f), value(1.0f)); NodeItem res = create_node("mix", "color3"); res.set_input("bg", color1, NodeItem::Type::Color3); -- 2.30.2 From 2895a03e8305d4e2903dbd7a448985b5b9e6fe7a Mon Sep 17 00:00:00 2001 From: Bogdan Nagirniak Date: Tue, 5 Sep 2023 12:38:18 +0300 Subject: [PATCH 12/12] Renamed Type tp to more convenient names. --- .../nodes/shader/materialx/nodes/node_item.cc | 68 +++++++++---------- .../nodes/shader/materialx/nodes/node_item.h | 8 +-- 2 files changed, 38 insertions(+), 38 deletions(-) diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.cc b/source/blender/nodes/shader/materialx/nodes/node_item.cc index e5a9300df537..5e6df0555fce 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.cc +++ b/source/blender/nodes/shader/materialx/nodes/node_item.cc @@ -70,8 +70,8 @@ bool NodeItem::operator==(const NodeItem &other) const NodeItem item1 = *this; NodeItem item2 = other; - Type tp = adjust_types(item1, item2); - if (tp == Type::Empty) { + Type to_type = adjust_types(item1, item2); + if (to_type == Type::Empty) { return false; } return item1.value->getValueString() == item2.value->getValueString(); @@ -238,11 +238,11 @@ NodeItem NodeItem::exp() const NodeItem NodeItem::convert(Type to_type) const { - Type tp = type(); - if (tp == to_type) { + Type from_type = type(); + if (from_type == to_type) { return *this; } - if (!is_arithmetic(tp) || !is_arithmetic(to_type)) { + if (!is_arithmetic(from_type) || !is_arithmetic(to_type)) { return empty(); } @@ -251,7 +251,7 @@ NodeItem NodeItem::convert(Type to_type) const } /* Converting types which requires > 1 iteration */ - switch (tp) { + switch (from_type) { case Type::Vector2: switch (to_type) { case Type::Vector4: @@ -309,7 +309,7 @@ NodeItem NodeItem::convert(Type to_type) const /* Converting 1 iteration types */ NodeItem res = empty(); if (value) { - switch (tp) { + switch (from_type) { case Type::Float: { float v = value->asA(); switch (to_type) { @@ -439,8 +439,8 @@ NodeItem NodeItem::if_else(CompareOp op, auto item1 = if_val; auto item2 = else_val; - Type tp = adjust_types(item1, item2); - if (tp == Type::Empty) { + Type to_type = adjust_types(item1, item2); + if (to_type == Type::Empty) { return res; } @@ -467,7 +467,7 @@ NodeItem NodeItem::if_else(CompareOp op, res = func(value->asA(), other.value->asA()) ? item1 : item2; } else { - res.node = graph_->addNode(mx_category, MaterialX::EMPTY_STRING, type(tp)); + res.node = graph_->addNode(mx_category, MaterialX::EMPTY_STRING, type(to_type)); res.set_input("value1", *this); res.set_input("value2", other); res.set_input("in1", item1); @@ -498,9 +498,9 @@ void NodeItem::set_input(const std::string &name, const std::string &output_name) { if (item.value) { - Type tp = item.type(); - std::string mx_type = type(tp); - switch (tp) { + Type item_type = item.type(); + std::string mx_type = type(item_type); + switch (item_type) { case Type::String: set_input(name, item.value->asA(), mx_type); break; @@ -553,38 +553,38 @@ void NodeItem::add_output(const std::string &name, Type out_type) node->addOutput(name, type(out_type)); } -NodeItem::Type NodeItem::type(const std::string &tp) +NodeItem::Type NodeItem::type(const std::string &type_str) { - if (tp == "string") { + if (type_str == "string") { return Type::String; } - if (tp == "integer") { + if (type_str == "integer") { return Type::Integer; } - if (tp == "float") { + if (type_str == "float") { return Type::Float; } - if (tp == "vector2") { + if (type_str == "vector2") { return Type::Vector2; } - if (tp == "vector3") { + if (type_str == "vector3") { return Type::Vector3; } - if (tp == "vector4") { + if (type_str == "vector4") { return Type::Vector4; } - if (tp == "color3") { + if (type_str == "color3") { return Type::Color3; } - if (tp == "color4") { + if (type_str == "color4") { return Type::Color4; } return Type::Other; } -std::string NodeItem::type(Type tp) +std::string NodeItem::type(Type type) { - switch (tp) { + switch (type) { case Type::String: return "string"; case Type::Integer: @@ -607,9 +607,9 @@ std::string NodeItem::type(Type tp) return ""; } -bool NodeItem::is_arithmetic(Type tp) +bool NodeItem::is_arithmetic(Type type) { - return tp >= Type::Float; + return type >= Type::Float; } NodeItem::Type NodeItem::adjust_types(NodeItem &item1, NodeItem &item2) @@ -640,13 +640,13 @@ bool NodeItem::is_arithmetic() const NodeItem NodeItem::arithmetic(const std::string &category, std::function func) const { NodeItem res = empty(); - Type tp = type(); - if (!is_arithmetic(tp)) { + Type type = this->type(); + if (!is_arithmetic(type)) { return res; } if (value) { - switch (tp) { + switch (type) { case Type::Float: { float v = value->asA(); res.value = MaterialX::Value::createValue(func(v)); @@ -687,7 +687,7 @@ NodeItem NodeItem::arithmetic(const std::string &category, std::functionaddNode(category, MaterialX::EMPTY_STRING, type(tp)); + res.node = graph_->addNode(category, MaterialX::EMPTY_STRING, this->type(type)); res.set_input("in", *this); } return res; @@ -700,13 +700,13 @@ NodeItem NodeItem::arithmetic(const NodeItem &other, NodeItem res = empty(); NodeItem item1 = *this; NodeItem item2 = other; - Type tp = adjust_types(item1, item2); - if (tp == Type::Empty) { + Type to_type = adjust_types(item1, item2); + if (to_type == Type::Empty) { return res; } if (value && other.value) { - switch (tp) { + switch (to_type) { case Type::Float: { float v1 = item1.value->asA(); float v2 = item2.value->asA(); @@ -753,7 +753,7 @@ NodeItem NodeItem::arithmetic(const NodeItem &other, } } else { - res.node = graph_->addNode(category, MaterialX::EMPTY_STRING, type(tp)); + res.node = graph_->addNode(category, MaterialX::EMPTY_STRING, type(to_type)); res.set_input("in1", item1); res.set_input("in2", item2); } diff --git a/source/blender/nodes/shader/materialx/nodes/node_item.h b/source/blender/nodes/shader/materialx/nodes/node_item.h index 2254d5b0cf38..466ce42b954d 100644 --- a/source/blender/nodes/shader/materialx/nodes/node_item.h +++ b/source/blender/nodes/shader/materialx/nodes/node_item.h @@ -12,7 +12,7 @@ class NodeItem { public: enum class Type { Empty = 0, - Other, + Other, /* For MaterialX types like: surfaceshader, bsdf, edf, ...*/ String, Integer, Float, @@ -95,9 +95,9 @@ class NodeItem { void add_output(const std::string &in_name, Type out_type); private: - static Type type(const std::string &tp); - static std::string type(Type tp); - static bool is_arithmetic(Type tp); + static Type type(const std::string &type_str); + static std::string type(Type type); + static bool is_arithmetic(Type type); static Type adjust_types(NodeItem &item1, NodeItem &item2); bool is_arithmetic() const; -- 2.30.2