From a3b7f972d05227f0b59c3b44946578f824396373 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Mon, 5 Dec 2022 09:41:04 +0000 Subject: [PATCH 01/33] Some initial files for matrix nodes. --- source/blender/blenkernel/BKE_node.h | 4 + .../editors/space_node/node_templates.cc | 6 + .../blender/nodes/NOD_socket_declarations.hh | 54 +++++++++ source/blender/nodes/NOD_static_types.h | 4 + source/blender/nodes/function/CMakeLists.txt | 4 + .../function/nodes/node_fn_combine_matrix.cc | 110 +++++++++++++++++ .../function/nodes/node_fn_input_matrix.cc | 110 +++++++++++++++++ .../function/nodes/node_fn_matrix_math.cc | 110 +++++++++++++++++ .../function/nodes/node_fn_separate_matrix.cc | 110 +++++++++++++++++ .../nodes/intern/node_socket_declarations.cc | 112 ++++++++++++++++++ 10 files changed, 624 insertions(+) create mode 100644 source/blender/nodes/function/nodes/node_fn_combine_matrix.cc create mode 100644 source/blender/nodes/function/nodes/node_fn_input_matrix.cc create mode 100644 source/blender/nodes/function/nodes/node_fn_matrix_math.cc create mode 100644 source/blender/nodes/function/nodes/node_fn_separate_matrix.cc diff --git a/source/blender/blenkernel/BKE_node.h b/source/blender/blenkernel/BKE_node.h index 3680d8ac8cd..9173ccd1f63 100644 --- a/source/blender/blenkernel/BKE_node.h +++ b/source/blender/blenkernel/BKE_node.h @@ -1567,6 +1567,10 @@ struct TexResult; #define FN_NODE_INPUT_INT 1220 #define FN_NODE_SEPARATE_COLOR 1221 #define FN_NODE_COMBINE_COLOR 1222 +#define FN_NODE_INPUT_MATRIX 1223 +#define FN_NODE_SEPARATE_MATRIX 1224 +#define FN_NODE_COMBINE_MATRIX 1225 +#define FN_NODE_MATRIX_MATH 1226 /** \} */ diff --git a/source/blender/editors/space_node/node_templates.cc b/source/blender/editors/space_node/node_templates.cc index 18c6e49c8a2..e7fd1bb9829 100644 --- a/source/blender/editors/space_node/node_templates.cc +++ b/source/blender/editors/space_node/node_templates.cc @@ -382,6 +382,12 @@ static Vector ui_node_link_items(NodeLinkArg *arg, else if (dynamic_cast(&socket_decl)) { item.socket_type = SOCK_VECTOR; } + else if (dynamic_cast(&socket_decl)) { + item.socket_type = SOCK_MATRIX3x3; + } + else if (dynamic_cast(&socket_decl)) { + item.socket_type = SOCK_MATRIX4x4; + } else if (dynamic_cast(&socket_decl)) { item.socket_type = SOCK_RGBA; } diff --git a/source/blender/nodes/NOD_socket_declarations.hh b/source/blender/nodes/NOD_socket_declarations.hh index 503327ac4da..5c6f9c51ccf 100644 --- a/source/blender/nodes/NOD_socket_declarations.hh +++ b/source/blender/nodes/NOD_socket_declarations.hh @@ -7,6 +7,8 @@ #include "RNA_types.h" #include "BLI_color.hh" +#include "BLI_float3x3.hh" +#include "BLI_float4x4.hh" #include "BLI_math_vec_types.hh" namespace blender::nodes::decl { @@ -96,6 +98,58 @@ class VectorBuilder : public SocketDeclarationBuilder { VectorBuilder &compact(); }; +class Matrix3x3Builder; + +class Matrix3x3 : public SocketDeclaration { + private: + float3x3 default_value_ = float3x3::identity(); + float soft_min_value_ = -FLT_MAX; + float soft_max_value_ = FLT_MAX; + + friend Matrix3x3Builder; + + public: + using Builder = Matrix3x3Builder; + + bNodeSocket &build(bNodeTree &ntree, bNode &node) const override; + bool matches(const bNodeSocket &socket) const override; + bNodeSocket &update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket &socket) const override; + bool can_connect(const bNodeSocket &socket) const override; +}; + +class Matrix3x3Builder : public SocketDeclarationBuilder { + public: + Matrix3x3Builder &default_value(const float3x3 value); + Matrix3x3Builder &min(float min); + Matrix3x3Builder &max(float max); +}; + +class Matrix4x4Builder; + +class Matrix4x4 : public SocketDeclaration { + private: + float4x4 default_value_ = float4x4::identity(); + float soft_min_value_ = -FLT_MAX; + float soft_max_value_ = FLT_MAX; + + friend Matrix4x4Builder; + + public: + using Builder = Matrix4x4Builder; + + bNodeSocket &build(bNodeTree &ntree, bNode &node) const override; + bool matches(const bNodeSocket &socket) const override; + bNodeSocket &update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket &socket) const override; + bool can_connect(const bNodeSocket &socket) const override; +}; + +class Matrix4x4Builder : public SocketDeclarationBuilder { + public: + Matrix4x4Builder &default_value(const float4x4 value); + Matrix4x4Builder &min(float min); + Matrix4x4Builder &max(float max); +}; + class BoolBuilder; class Bool : public SocketDeclaration { diff --git a/source/blender/nodes/NOD_static_types.h b/source/blender/nodes/NOD_static_types.h index 03cab5a778a..d40670d704d 100644 --- a/source/blender/nodes/NOD_static_types.h +++ b/source/blender/nodes/NOD_static_types.h @@ -279,6 +279,10 @@ DefNode(FunctionNode, FN_NODE_SEPARATE_COLOR, def_fn_combsep_color, "SEPARATE_CO DefNode(FunctionNode, FN_NODE_SLICE_STRING, 0, "SLICE_STRING", SliceString, "Slice String", "") DefNode(FunctionNode, FN_NODE_STRING_LENGTH, 0, "STRING_LENGTH", StringLength, "String Length", "") DefNode(FunctionNode, FN_NODE_VALUE_TO_STRING, 0, "VALUE_TO_STRING", ValueToString, "Value to String", "") +DefNode(FunctionNode, FN_NODE_INPUT_MATRIX, 0, "INPUT_MATRIX", InputMatrix, "Matrix", "") +DefNode(FunctionNode, FN_NODE_SEPARATE_MATRIX, 0, "SEPARATE_MATRIX", SeparateMatrix, "Separate Matrix", "") +DefNode(FunctionNode, FN_NODE_COMBINE_MATRIX, 0, "COMBINE_MATRIX", CombineMatrix, "Combine Matrix", "") +DefNode(FunctionNode, FN_NODE_MATRIX_MATH, 0, "MATRIX_MATH", MatrixMath, "Matrix Math", "") DefNode(GeometryNode, GEO_NODE_ACCUMULATE_FIELD, def_geo_accumulate_field, "ACCUMULATE_FIELD", AccumulateField, "Accumulate Field", "Add the values of an evaluated field together and output the running total for each element") DefNode(GeometryNode, GEO_NODE_ATTRIBUTE_DOMAIN_SIZE, def_geo_attribute_domain_size, "ATTRIBUTE_DOMAIN_SIZE", AttributeDomainSize, "Domain Size", "Retrieve the number of elements in a geometry for each attribute domain") diff --git a/source/blender/nodes/function/CMakeLists.txt b/source/blender/nodes/function/CMakeLists.txt index c95201ddfd7..88c78518224 100644 --- a/source/blender/nodes/function/CMakeLists.txt +++ b/source/blender/nodes/function/CMakeLists.txt @@ -21,18 +21,22 @@ set(SRC nodes/node_fn_align_euler_to_vector.cc nodes/node_fn_boolean_math.cc nodes/node_fn_combine_color.cc + nodes/node_fn_combine_matrix.cc nodes/node_fn_compare.cc nodes/node_fn_float_to_int.cc nodes/node_fn_input_bool.cc nodes/node_fn_input_color.cc nodes/node_fn_input_int.cc + nodes/node_fn_input_matrix.cc nodes/node_fn_input_special_characters.cc nodes/node_fn_input_string.cc nodes/node_fn_input_vector.cc + nodes/node_fn_matrix_math.cc nodes/node_fn_random_value.cc nodes/node_fn_replace_string.cc nodes/node_fn_rotate_euler.cc nodes/node_fn_separate_color.cc + nodes/node_fn_separate_matrix.cc nodes/node_fn_slice_string.cc nodes/node_fn_string_length.cc nodes/node_fn_value_to_string.cc diff --git a/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc b/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc new file mode 100644 index 00000000000..318c8997f9a --- /dev/null +++ b/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc @@ -0,0 +1,110 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "node_function_util.hh" + +#include "UI_interface.h" +#include "UI_resources.h" + +namespace blender::nodes::node_fn_combine_color_cc { + +NODE_STORAGE_FUNCS(NodeCombSepColor) + +static void node_declare(NodeDeclarationBuilder &b) +{ + b.is_function_node(); + b.add_input(N_("Red")).default_value(0.0f).min(0.0f).max(1.0f).subtype(PROP_FACTOR); + b.add_input(N_("Green")) + .default_value(0.0f) + .min(0.0f) + .max(1.0f) + .subtype(PROP_FACTOR); + b.add_input(N_("Blue")) + .default_value(0.0f) + .min(0.0f) + .max(1.0f) + .subtype(PROP_FACTOR); + b.add_input(N_("Alpha")) + .default_value(1.0f) + .min(0.0f) + .max(1.0f) + .subtype(PROP_FACTOR); + b.add_output(N_("Color")); +}; + +static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) +{ + uiItemR(layout, ptr, "mode", 0, "", ICON_NONE); +} + +static void node_update(bNodeTree * /*tree*/, bNode *node) +{ + const NodeCombSepColor &storage = node_storage(*node); + node_combsep_color_label(&node->inputs, (NodeCombSepColorMode)storage.mode); +} + +static void node_init(bNodeTree * /*tree*/, bNode *node) +{ + NodeCombSepColor *data = MEM_cnew(__func__); + data->mode = NODE_COMBSEP_COLOR_RGB; + node->storage = data; +} + +static const fn::MultiFunction *get_multi_function(const bNode &bnode) +{ + const NodeCombSepColor &storage = node_storage(bnode); + + static fn::CustomMF_SI_SI_SI_SI_SO rgba_fn{ + "RGB", [](float r, float g, float b, float a) { return ColorGeometry4f(r, g, b, a); }}; + static fn::CustomMF_SI_SI_SI_SI_SO hsva_fn{ + "HSV", [](float h, float s, float v, float a) { + ColorGeometry4f r_color; + hsv_to_rgb(h, s, v, &r_color.r, &r_color.g, &r_color.b); + r_color.a = a; + return r_color; + }}; + static fn::CustomMF_SI_SI_SI_SI_SO hsla_fn{ + "HSL", [](float h, float s, float l, float a) { + ColorGeometry4f color; + hsl_to_rgb(h, s, l, &color.r, &color.g, &color.b); + color.a = a; + return color; + }}; + + switch (storage.mode) { + case NODE_COMBSEP_COLOR_RGB: + return &rgba_fn; + case NODE_COMBSEP_COLOR_HSV: + return &hsva_fn; + case NODE_COMBSEP_COLOR_HSL: + return &hsla_fn; + } + + BLI_assert_unreachable(); + return nullptr; +} + +static void node_build_multi_function(NodeMultiFunctionBuilder &builder) +{ + const fn::MultiFunction *fn = get_multi_function(builder.node()); + builder.set_matching_fn(fn); +} + +} // namespace blender::nodes::node_fn_combine_color_cc + +void register_node_type_fn_combine_color(void) +{ + namespace file_ns = blender::nodes::node_fn_combine_color_cc; + + static bNodeType ntype; + + fn_node_type_base(&ntype, FN_NODE_COMBINE_COLOR, "Combine Color", NODE_CLASS_CONVERTER); + ntype.declare = file_ns::node_declare; + ntype.updatefunc = file_ns::node_update; + ntype.initfunc = file_ns::node_init; + node_type_storage( + &ntype, "NodeCombSepColor", node_free_standard_storage, node_copy_standard_storage); + ntype.build_multi_function = file_ns::node_build_multi_function; + ntype.draw_buttons = file_ns::node_layout; + + nodeRegisterType(&ntype); +} diff --git a/source/blender/nodes/function/nodes/node_fn_input_matrix.cc b/source/blender/nodes/function/nodes/node_fn_input_matrix.cc new file mode 100644 index 00000000000..318c8997f9a --- /dev/null +++ b/source/blender/nodes/function/nodes/node_fn_input_matrix.cc @@ -0,0 +1,110 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "node_function_util.hh" + +#include "UI_interface.h" +#include "UI_resources.h" + +namespace blender::nodes::node_fn_combine_color_cc { + +NODE_STORAGE_FUNCS(NodeCombSepColor) + +static void node_declare(NodeDeclarationBuilder &b) +{ + b.is_function_node(); + b.add_input(N_("Red")).default_value(0.0f).min(0.0f).max(1.0f).subtype(PROP_FACTOR); + b.add_input(N_("Green")) + .default_value(0.0f) + .min(0.0f) + .max(1.0f) + .subtype(PROP_FACTOR); + b.add_input(N_("Blue")) + .default_value(0.0f) + .min(0.0f) + .max(1.0f) + .subtype(PROP_FACTOR); + b.add_input(N_("Alpha")) + .default_value(1.0f) + .min(0.0f) + .max(1.0f) + .subtype(PROP_FACTOR); + b.add_output(N_("Color")); +}; + +static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) +{ + uiItemR(layout, ptr, "mode", 0, "", ICON_NONE); +} + +static void node_update(bNodeTree * /*tree*/, bNode *node) +{ + const NodeCombSepColor &storage = node_storage(*node); + node_combsep_color_label(&node->inputs, (NodeCombSepColorMode)storage.mode); +} + +static void node_init(bNodeTree * /*tree*/, bNode *node) +{ + NodeCombSepColor *data = MEM_cnew(__func__); + data->mode = NODE_COMBSEP_COLOR_RGB; + node->storage = data; +} + +static const fn::MultiFunction *get_multi_function(const bNode &bnode) +{ + const NodeCombSepColor &storage = node_storage(bnode); + + static fn::CustomMF_SI_SI_SI_SI_SO rgba_fn{ + "RGB", [](float r, float g, float b, float a) { return ColorGeometry4f(r, g, b, a); }}; + static fn::CustomMF_SI_SI_SI_SI_SO hsva_fn{ + "HSV", [](float h, float s, float v, float a) { + ColorGeometry4f r_color; + hsv_to_rgb(h, s, v, &r_color.r, &r_color.g, &r_color.b); + r_color.a = a; + return r_color; + }}; + static fn::CustomMF_SI_SI_SI_SI_SO hsla_fn{ + "HSL", [](float h, float s, float l, float a) { + ColorGeometry4f color; + hsl_to_rgb(h, s, l, &color.r, &color.g, &color.b); + color.a = a; + return color; + }}; + + switch (storage.mode) { + case NODE_COMBSEP_COLOR_RGB: + return &rgba_fn; + case NODE_COMBSEP_COLOR_HSV: + return &hsva_fn; + case NODE_COMBSEP_COLOR_HSL: + return &hsla_fn; + } + + BLI_assert_unreachable(); + return nullptr; +} + +static void node_build_multi_function(NodeMultiFunctionBuilder &builder) +{ + const fn::MultiFunction *fn = get_multi_function(builder.node()); + builder.set_matching_fn(fn); +} + +} // namespace blender::nodes::node_fn_combine_color_cc + +void register_node_type_fn_combine_color(void) +{ + namespace file_ns = blender::nodes::node_fn_combine_color_cc; + + static bNodeType ntype; + + fn_node_type_base(&ntype, FN_NODE_COMBINE_COLOR, "Combine Color", NODE_CLASS_CONVERTER); + ntype.declare = file_ns::node_declare; + ntype.updatefunc = file_ns::node_update; + ntype.initfunc = file_ns::node_init; + node_type_storage( + &ntype, "NodeCombSepColor", node_free_standard_storage, node_copy_standard_storage); + ntype.build_multi_function = file_ns::node_build_multi_function; + ntype.draw_buttons = file_ns::node_layout; + + nodeRegisterType(&ntype); +} diff --git a/source/blender/nodes/function/nodes/node_fn_matrix_math.cc b/source/blender/nodes/function/nodes/node_fn_matrix_math.cc new file mode 100644 index 00000000000..318c8997f9a --- /dev/null +++ b/source/blender/nodes/function/nodes/node_fn_matrix_math.cc @@ -0,0 +1,110 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "node_function_util.hh" + +#include "UI_interface.h" +#include "UI_resources.h" + +namespace blender::nodes::node_fn_combine_color_cc { + +NODE_STORAGE_FUNCS(NodeCombSepColor) + +static void node_declare(NodeDeclarationBuilder &b) +{ + b.is_function_node(); + b.add_input(N_("Red")).default_value(0.0f).min(0.0f).max(1.0f).subtype(PROP_FACTOR); + b.add_input(N_("Green")) + .default_value(0.0f) + .min(0.0f) + .max(1.0f) + .subtype(PROP_FACTOR); + b.add_input(N_("Blue")) + .default_value(0.0f) + .min(0.0f) + .max(1.0f) + .subtype(PROP_FACTOR); + b.add_input(N_("Alpha")) + .default_value(1.0f) + .min(0.0f) + .max(1.0f) + .subtype(PROP_FACTOR); + b.add_output(N_("Color")); +}; + +static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) +{ + uiItemR(layout, ptr, "mode", 0, "", ICON_NONE); +} + +static void node_update(bNodeTree * /*tree*/, bNode *node) +{ + const NodeCombSepColor &storage = node_storage(*node); + node_combsep_color_label(&node->inputs, (NodeCombSepColorMode)storage.mode); +} + +static void node_init(bNodeTree * /*tree*/, bNode *node) +{ + NodeCombSepColor *data = MEM_cnew(__func__); + data->mode = NODE_COMBSEP_COLOR_RGB; + node->storage = data; +} + +static const fn::MultiFunction *get_multi_function(const bNode &bnode) +{ + const NodeCombSepColor &storage = node_storage(bnode); + + static fn::CustomMF_SI_SI_SI_SI_SO rgba_fn{ + "RGB", [](float r, float g, float b, float a) { return ColorGeometry4f(r, g, b, a); }}; + static fn::CustomMF_SI_SI_SI_SI_SO hsva_fn{ + "HSV", [](float h, float s, float v, float a) { + ColorGeometry4f r_color; + hsv_to_rgb(h, s, v, &r_color.r, &r_color.g, &r_color.b); + r_color.a = a; + return r_color; + }}; + static fn::CustomMF_SI_SI_SI_SI_SO hsla_fn{ + "HSL", [](float h, float s, float l, float a) { + ColorGeometry4f color; + hsl_to_rgb(h, s, l, &color.r, &color.g, &color.b); + color.a = a; + return color; + }}; + + switch (storage.mode) { + case NODE_COMBSEP_COLOR_RGB: + return &rgba_fn; + case NODE_COMBSEP_COLOR_HSV: + return &hsva_fn; + case NODE_COMBSEP_COLOR_HSL: + return &hsla_fn; + } + + BLI_assert_unreachable(); + return nullptr; +} + +static void node_build_multi_function(NodeMultiFunctionBuilder &builder) +{ + const fn::MultiFunction *fn = get_multi_function(builder.node()); + builder.set_matching_fn(fn); +} + +} // namespace blender::nodes::node_fn_combine_color_cc + +void register_node_type_fn_combine_color(void) +{ + namespace file_ns = blender::nodes::node_fn_combine_color_cc; + + static bNodeType ntype; + + fn_node_type_base(&ntype, FN_NODE_COMBINE_COLOR, "Combine Color", NODE_CLASS_CONVERTER); + ntype.declare = file_ns::node_declare; + ntype.updatefunc = file_ns::node_update; + ntype.initfunc = file_ns::node_init; + node_type_storage( + &ntype, "NodeCombSepColor", node_free_standard_storage, node_copy_standard_storage); + ntype.build_multi_function = file_ns::node_build_multi_function; + ntype.draw_buttons = file_ns::node_layout; + + nodeRegisterType(&ntype); +} diff --git a/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc b/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc new file mode 100644 index 00000000000..318c8997f9a --- /dev/null +++ b/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc @@ -0,0 +1,110 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "node_function_util.hh" + +#include "UI_interface.h" +#include "UI_resources.h" + +namespace blender::nodes::node_fn_combine_color_cc { + +NODE_STORAGE_FUNCS(NodeCombSepColor) + +static void node_declare(NodeDeclarationBuilder &b) +{ + b.is_function_node(); + b.add_input(N_("Red")).default_value(0.0f).min(0.0f).max(1.0f).subtype(PROP_FACTOR); + b.add_input(N_("Green")) + .default_value(0.0f) + .min(0.0f) + .max(1.0f) + .subtype(PROP_FACTOR); + b.add_input(N_("Blue")) + .default_value(0.0f) + .min(0.0f) + .max(1.0f) + .subtype(PROP_FACTOR); + b.add_input(N_("Alpha")) + .default_value(1.0f) + .min(0.0f) + .max(1.0f) + .subtype(PROP_FACTOR); + b.add_output(N_("Color")); +}; + +static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) +{ + uiItemR(layout, ptr, "mode", 0, "", ICON_NONE); +} + +static void node_update(bNodeTree * /*tree*/, bNode *node) +{ + const NodeCombSepColor &storage = node_storage(*node); + node_combsep_color_label(&node->inputs, (NodeCombSepColorMode)storage.mode); +} + +static void node_init(bNodeTree * /*tree*/, bNode *node) +{ + NodeCombSepColor *data = MEM_cnew(__func__); + data->mode = NODE_COMBSEP_COLOR_RGB; + node->storage = data; +} + +static const fn::MultiFunction *get_multi_function(const bNode &bnode) +{ + const NodeCombSepColor &storage = node_storage(bnode); + + static fn::CustomMF_SI_SI_SI_SI_SO rgba_fn{ + "RGB", [](float r, float g, float b, float a) { return ColorGeometry4f(r, g, b, a); }}; + static fn::CustomMF_SI_SI_SI_SI_SO hsva_fn{ + "HSV", [](float h, float s, float v, float a) { + ColorGeometry4f r_color; + hsv_to_rgb(h, s, v, &r_color.r, &r_color.g, &r_color.b); + r_color.a = a; + return r_color; + }}; + static fn::CustomMF_SI_SI_SI_SI_SO hsla_fn{ + "HSL", [](float h, float s, float l, float a) { + ColorGeometry4f color; + hsl_to_rgb(h, s, l, &color.r, &color.g, &color.b); + color.a = a; + return color; + }}; + + switch (storage.mode) { + case NODE_COMBSEP_COLOR_RGB: + return &rgba_fn; + case NODE_COMBSEP_COLOR_HSV: + return &hsva_fn; + case NODE_COMBSEP_COLOR_HSL: + return &hsla_fn; + } + + BLI_assert_unreachable(); + return nullptr; +} + +static void node_build_multi_function(NodeMultiFunctionBuilder &builder) +{ + const fn::MultiFunction *fn = get_multi_function(builder.node()); + builder.set_matching_fn(fn); +} + +} // namespace blender::nodes::node_fn_combine_color_cc + +void register_node_type_fn_combine_color(void) +{ + namespace file_ns = blender::nodes::node_fn_combine_color_cc; + + static bNodeType ntype; + + fn_node_type_base(&ntype, FN_NODE_COMBINE_COLOR, "Combine Color", NODE_CLASS_CONVERTER); + ntype.declare = file_ns::node_declare; + ntype.updatefunc = file_ns::node_update; + ntype.initfunc = file_ns::node_init; + node_type_storage( + &ntype, "NodeCombSepColor", node_free_standard_storage, node_copy_standard_storage); + ntype.build_multi_function = file_ns::node_build_multi_function; + ntype.draw_buttons = file_ns::node_layout; + + nodeRegisterType(&ntype); +} diff --git a/source/blender/nodes/intern/node_socket_declarations.cc b/source/blender/nodes/intern/node_socket_declarations.cc index a7d281bcf52..487ffd39fca 100644 --- a/source/blender/nodes/intern/node_socket_declarations.cc +++ b/source/blender/nodes/intern/node_socket_declarations.cc @@ -248,6 +248,118 @@ bNodeSocket &Vector::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket /** \} */ +/* -------------------------------------------------------------------- */ +/** \name #Matrix3x3 + * \{ */ + +bNodeSocket &Matrix3x3::build(bNodeTree &ntree, bNode &node) const +{ + bNodeSocket &socket = *nodeAddStaticSocket( + &ntree, &node, in_out_, SOCK_MATRIX3x3, PROP_MATRIX, identifier_.c_str(), name_.c_str()); + this->set_common_flags(socket); + bNodeSocketValueMatrix3x3 &value = *(bNodeSocketValueMatrix3x3 *)socket.default_value; + copy_m3_m3(value.value, default_value_.ptr()); + value.min = soft_min_value_; + value.max = soft_max_value_; + return socket; +} + +bool Matrix3x3::matches(const bNodeSocket &socket) const +{ + if (!this->matches_common_data(socket)) { + return false; + } + if (socket.type != SOCK_MATRIX3x3) { + return false; + } + if (socket.typeinfo->subtype != PROP_MATRIX) { + return false; + } + return true; +} + +bool Matrix3x3::can_connect(const bNodeSocket &socket) const +{ + if (!sockets_can_connect(*this, socket)) { + return false; + } + return basic_types_can_connect(*this, socket); +} + +bNodeSocket &Matrix3x3::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket &socket) const +{ + if (socket.type != SOCK_MATRIX3x3) { + BLI_assert(socket.in_out == in_out_); + return this->build(ntree, node); + } + if (socket.typeinfo->subtype != PROP_MATRIX) { + modify_subtype_except_for_storage(socket, PROP_MATRIX); + } + this->set_common_flags(socket); + bNodeSocketValueMatrix3x3 &value = *(bNodeSocketValueMatrix3x3 *)socket.default_value; + value.subtype = PROP_MATRIX; + STRNCPY(socket.name, name_.c_str()); + return socket; +} + +/** \} */ + +/* -------------------------------------------------------------------- */ +/** \name #Matrix4x4 + * \{ */ + +bNodeSocket &Matrix4x4::build(bNodeTree &ntree, bNode &node) const +{ + bNodeSocket &socket = *nodeAddStaticSocket( + &ntree, &node, in_out_, SOCK_MATRIX4x4, PROP_MATRIX, identifier_.c_str(), name_.c_str()); + this->set_common_flags(socket); + bNodeSocketValueMatrix4x4 &value = *(bNodeSocketValueMatrix4x4 *)socket.default_value; + copy_m4_m4(value.value, default_value_.ptr()); + value.min = soft_min_value_; + value.max = soft_max_value_; + return socket; +} + +bool Matrix4x4::matches(const bNodeSocket &socket) const +{ + if (!this->matches_common_data(socket)) { + return false; + } + if (socket.type != SOCK_MATRIX4x4) { + return false; + } + if (socket.typeinfo->subtype != PROP_MATRIX) { + return false; + } + return true; +} + +bool Matrix4x4::can_connect(const bNodeSocket &socket) const +{ + if (!sockets_can_connect(*this, socket)) { + return false; + } + return basic_types_can_connect(*this, socket); +} + +bNodeSocket &Matrix4x4::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket &socket) const +{ + if (socket.type != SOCK_MATRIX4x4) { + BLI_assert(socket.in_out == in_out_); + return this->build(ntree, node); + } + if (socket.typeinfo->subtype != PROP_MATRIX) { + modify_subtype_except_for_storage(socket, PROP_MATRIX); + } + this->set_common_flags(socket); + bNodeSocketValueMatrix4x4 &value = *(bNodeSocketValueMatrix4x4 *)socket.default_value; + value.subtype = PROP_MATRIX; + STRNCPY(socket.name, name_.c_str()); + return socket; +} + +/** \} */ + /* -------------------------------------------------------------------- */ /** \name #Bool * \{ */ -- 2.30.2 From 87004bd122ddddb829a082222477454204da03b5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Mon, 5 Dec 2022 18:11:17 +0000 Subject: [PATCH 02/33] Blenkernel socket identifiers. --- source/blender/blenkernel/intern/node.cc | 20 ++++++ source/blender/makesdna/DNA_node_types.h | 2 + source/blender/makesrna/intern/rna_nodetree.c | 67 +++++++++++++++++++ .../nodes/intern/node_socket_declarations.cc | 64 ++---------------- 4 files changed, 95 insertions(+), 58 deletions(-) diff --git a/source/blender/blenkernel/intern/node.cc b/source/blender/blenkernel/intern/node.cc index 8bff3a8f997..333ebddb444 100644 --- a/source/blender/blenkernel/intern/node.cc +++ b/source/blender/blenkernel/intern/node.cc @@ -311,6 +311,8 @@ static void library_foreach_node_socket(LibraryForeachIDData *data, bNodeSocket case SOCK_CUSTOM: case SOCK_SHADER: case SOCK_GEOMETRY: + case SOCK_MATRIX3x3: + case SOCK_MATRIX4x4: break; } } @@ -450,6 +452,12 @@ static void write_node_socket_default_value(BlendWriter *writer, bNodeSocket *so case SOCK_MATERIAL: BLO_write_struct(writer, bNodeSocketValueMaterial, sock->default_value); break; + case SOCK_MATRIX3x3: + BLO_write_struct(writer, bNodeSocketValueMatrix3x3, sock->default_value); + break; + case SOCK_MATRIX4x4: + BLO_write_struct(writer, bNodeSocketValueMatrix4x4, sock->default_value); + break; case SOCK_CUSTOM: /* Custom node sockets where default_value is defined uses custom properties for storage. */ break; @@ -873,6 +881,8 @@ static void lib_link_node_socket(BlendLibReader *reader, Library *lib, bNodeSock case SOCK_CUSTOM: case SOCK_SHADER: case SOCK_GEOMETRY: + case SOCK_MATRIX3x3: + case SOCK_MATRIX4x4: break; } } @@ -968,6 +978,8 @@ static void expand_node_socket(BlendExpander *expander, bNodeSocket *sock) case SOCK_CUSTOM: case SOCK_SHADER: case SOCK_GEOMETRY: + case SOCK_MATRIX3x3: + case SOCK_MATRIX4x4: break; } } @@ -1583,6 +1595,8 @@ static void socket_id_user_increment(bNodeSocket *sock) case SOCK_CUSTOM: case SOCK_SHADER: case SOCK_GEOMETRY: + case SOCK_MATRIX3x3: + case SOCK_MATRIX4x4: break; } } @@ -1642,6 +1656,8 @@ static bool socket_id_user_decrement(bNodeSocket *sock) case SOCK_CUSTOM: case SOCK_SHADER: case SOCK_GEOMETRY: + case SOCK_MATRIX3x3: + case SOCK_MATRIX4x4: break; } return false; @@ -1786,6 +1802,10 @@ const char *nodeStaticSocketType(int type, int subtype) return "NodeSocketTexture"; case SOCK_MATERIAL: return "NodeSocketMaterial"; + case SOCK_MATRIX3x3: + return "NodeSocketMatrix3x3"; + case SOCK_MATRIX4x4: + return "NodeSocketMatrix4x4"; } return nullptr; } diff --git a/source/blender/makesdna/DNA_node_types.h b/source/blender/makesdna/DNA_node_types.h index e87adacbc9a..49c62cbbf9d 100644 --- a/source/blender/makesdna/DNA_node_types.h +++ b/source/blender/makesdna/DNA_node_types.h @@ -232,6 +232,8 @@ typedef enum eNodeSocketDatatype { SOCK_COLLECTION = 11, SOCK_TEXTURE = 12, SOCK_MATERIAL = 13, + SOCK_MATRIX3x3 = 14, + SOCK_MATRIX4x4 = 15, } eNodeSocketDatatype; /** Socket shape. */ diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c index 4a0094831b9..3c864081d4c 100644 --- a/source/blender/makesrna/intern/rna_nodetree.c +++ b/source/blender/makesrna/intern/rna_nodetree.c @@ -11484,6 +11484,73 @@ static void rna_def_node_socket_vector(BlenderRNA *brna, RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); } +static void rna_def_node_socket_matrix3x3(BlenderRNA *brna, + const char *identifier, + const char *interface_idname) +{ + StructRNA *srna; + PropertyRNA *prop; + const float *value_default; + + /* choose sensible common default based on subtype */ + switch (subtype) { + case PROP_DIRECTION: { + static const float default_direction[3] = {0.0f, 0.0f, 1.0f}; + value_default = default_direction; + break; + } + default: { + static const float default_vector[3] = {0.0f, 0.0f, 0.0f}; + value_default = default_vector; + break; + } + } + + srna = RNA_def_struct(brna, identifier, "NodeSocketStandard"); + RNA_def_struct_ui_text(srna, "Vector Node Socket", "3D vector socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); + + RNA_def_struct_sdna_from(srna, "bNodeSocketValueVector", "default_value"); + + prop = RNA_def_property(srna, "default_value", PROP_FLOAT, subtype); + RNA_def_property_float_sdna(prop, NULL, "value"); + RNA_def_property_float_array_default(prop, value_default); + RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketStandard_vector_range"); + RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update"); + RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE); + + RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); + + /* socket interface */ + srna = RNA_def_struct(brna, interface_idname, "NodeSocketInterfaceStandard"); + RNA_def_struct_ui_text(srna, "Vector Node Socket Interface", "3D vector socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); + + RNA_def_struct_sdna_from(srna, "bNodeSocketValueVector", "default_value"); + + prop = RNA_def_property(srna, "default_value", PROP_FLOAT, subtype); + RNA_def_property_float_sdna(prop, NULL, "value"); + RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); + RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketStandard_vector_range"); + RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketInterface_update"); + + prop = RNA_def_property(srna, "min_value", PROP_FLOAT, PROP_NONE); + RNA_def_property_float_sdna(prop, NULL, "min"); + RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); + RNA_def_property_ui_text(prop, "Minimum Value", "Minimum value"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketInterface_update"); + + prop = RNA_def_property(srna, "max_value", PROP_FLOAT, PROP_NONE); + RNA_def_property_float_sdna(prop, NULL, "max"); + RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); + RNA_def_property_ui_text(prop, "Maximum Value", "Maximum value"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketInterface_update"); + + RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); +} + static void rna_def_node_socket_color(BlenderRNA *brna, const char *identifier, const char *interface_idname) diff --git a/source/blender/nodes/intern/node_socket_declarations.cc b/source/blender/nodes/intern/node_socket_declarations.cc index 487ffd39fca..33aaec43101 100644 --- a/source/blender/nodes/intern/node_socket_declarations.cc +++ b/source/blender/nodes/intern/node_socket_declarations.cc @@ -254,13 +254,9 @@ bNodeSocket &Vector::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket bNodeSocket &Matrix3x3::build(bNodeTree &ntree, bNode &node) const { - bNodeSocket &socket = *nodeAddStaticSocket( - &ntree, &node, in_out_, SOCK_MATRIX3x3, PROP_MATRIX, identifier_.c_str(), name_.c_str()); + bNodeSocket &socket = *nodeAddSocket( + &ntree, &node, in_out_, "NodeSocketMatrix3x3", identifier_.c_str(), name_.c_str()); this->set_common_flags(socket); - bNodeSocketValueMatrix3x3 &value = *(bNodeSocketValueMatrix3x3 *)socket.default_value; - copy_m3_m3(value.value, default_value_.ptr()); - value.min = soft_min_value_; - value.max = soft_max_value_; return socket; } @@ -272,34 +268,12 @@ bool Matrix3x3::matches(const bNodeSocket &socket) const if (socket.type != SOCK_MATRIX3x3) { return false; } - if (socket.typeinfo->subtype != PROP_MATRIX) { - return false; - } return true; } bool Matrix3x3::can_connect(const bNodeSocket &socket) const { - if (!sockets_can_connect(*this, socket)) { - return false; - } - return basic_types_can_connect(*this, socket); -} - -bNodeSocket &Matrix3x3::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket &socket) const -{ - if (socket.type != SOCK_MATRIX3x3) { - BLI_assert(socket.in_out == in_out_); - return this->build(ntree, node); - } - if (socket.typeinfo->subtype != PROP_MATRIX) { - modify_subtype_except_for_storage(socket, PROP_MATRIX); - } - this->set_common_flags(socket); - bNodeSocketValueMatrix3x3 &value = *(bNodeSocketValueMatrix3x3 *)socket.default_value; - value.subtype = PROP_MATRIX; - STRNCPY(socket.name, name_.c_str()); - return socket; + return sockets_can_connect(*this, socket) && socket.type == SOCK_MATRIX3x3; } /** \} */ @@ -310,13 +284,9 @@ bNodeSocket &Matrix3x3::update_or_build(bNodeTree &ntree, bNode &node, bNodeSock bNodeSocket &Matrix4x4::build(bNodeTree &ntree, bNode &node) const { - bNodeSocket &socket = *nodeAddStaticSocket( - &ntree, &node, in_out_, SOCK_MATRIX4x4, PROP_MATRIX, identifier_.c_str(), name_.c_str()); + bNodeSocket &socket = *nodeAddSocket( + &ntree, &node, in_out_, "NodeSocketMatrix4x4", identifier_.c_str(), name_.c_str()); this->set_common_flags(socket); - bNodeSocketValueMatrix4x4 &value = *(bNodeSocketValueMatrix4x4 *)socket.default_value; - copy_m4_m4(value.value, default_value_.ptr()); - value.min = soft_min_value_; - value.max = soft_max_value_; return socket; } @@ -328,34 +298,12 @@ bool Matrix4x4::matches(const bNodeSocket &socket) const if (socket.type != SOCK_MATRIX4x4) { return false; } - if (socket.typeinfo->subtype != PROP_MATRIX) { - return false; - } return true; } bool Matrix4x4::can_connect(const bNodeSocket &socket) const { - if (!sockets_can_connect(*this, socket)) { - return false; - } - return basic_types_can_connect(*this, socket); -} - -bNodeSocket &Matrix4x4::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket &socket) const -{ - if (socket.type != SOCK_MATRIX4x4) { - BLI_assert(socket.in_out == in_out_); - return this->build(ntree, node); - } - if (socket.typeinfo->subtype != PROP_MATRIX) { - modify_subtype_except_for_storage(socket, PROP_MATRIX); - } - this->set_common_flags(socket); - bNodeSocketValueMatrix4x4 &value = *(bNodeSocketValueMatrix4x4 *)socket.default_value; - value.subtype = PROP_MATRIX; - STRNCPY(socket.name, name_.c_str()); - return socket; + return sockets_can_connect(*this, socket) && socket.type == SOCK_MATRIX4x4; } /** \} */ -- 2.30.2 From 9a55a9bdd5812597bb9a1aced37f440ebb74dd70 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Tue, 6 Dec 2022 09:21:14 +0000 Subject: [PATCH 03/33] Plumbing for the SOCK_MATRIX types. --- source/blender/blenkernel/intern/node.cc | 8 ++ .../blenkernel/intern/node_tree_update.cc | 2 +- source/blender/editors/space_node/drawnode.cc | 34 ++++++ .../editors/space_node/node_relationships.cc | 12 +- .../editors/space_node/node_templates.cc | 2 + source/blender/makesrna/intern/rna_nodetree.c | 4 + source/blender/modifiers/intern/MOD_nodes.cc | 52 ++++++++- .../nodes/geometry/node_geometry_tree.cc | 4 +- .../nodes/geometry/node_geometry_util.cc | 4 + source/blender/nodes/intern/node_socket.cc | 108 ++++++++++++++++++ .../nodes/intern/node_socket_declarations.cc | 40 ++++++- 11 files changed, 261 insertions(+), 9 deletions(-) diff --git a/source/blender/blenkernel/intern/node.cc b/source/blender/blenkernel/intern/node.cc index 333ebddb444..52e3a41ee20 100644 --- a/source/blender/blenkernel/intern/node.cc +++ b/source/blender/blenkernel/intern/node.cc @@ -1883,6 +1883,10 @@ const char *nodeStaticSocketInterfaceType(int type, int subtype) return "NodeSocketInterfaceTexture"; case SOCK_MATERIAL: return "NodeSocketInterfaceMaterial"; + case SOCK_MATRIX3x3: + return "NodeSocketInterfaceMatrix3x3"; + case SOCK_MATRIX4x4: + return "NodeSocketInterfaceMatrix4x4"; } return nullptr; } @@ -1916,6 +1920,10 @@ const char *nodeStaticSocketLabel(int type, int /*subtype*/) return "Texture"; case SOCK_MATERIAL: return "Material"; + case SOCK_MATRIX3x3: + return "Matrix3x3"; + case SOCK_MATRIX4x4: + return "Matrix4x4"; } return nullptr; } diff --git a/source/blender/blenkernel/intern/node_tree_update.cc b/source/blender/blenkernel/intern/node_tree_update.cc index bb063dadb06..d6c025cd5e9 100644 --- a/source/blender/blenkernel/intern/node_tree_update.cc +++ b/source/blender/blenkernel/intern/node_tree_update.cc @@ -72,7 +72,7 @@ namespace node_field_inferencing { static bool is_field_socket_type(eNodeSocketDatatype type) { - return ELEM(type, SOCK_FLOAT, SOCK_INT, SOCK_BOOLEAN, SOCK_VECTOR, SOCK_RGBA); + return ELEM(type, SOCK_FLOAT, SOCK_INT, SOCK_BOOLEAN, SOCK_VECTOR, SOCK_RGBA, SOCK_MATRIX3x3, SOCK_MATRIX4x4); } static bool is_field_socket_type(const bNodeSocket &socket) diff --git a/source/blender/editors/space_node/drawnode.cc b/source/blender/editors/space_node/drawnode.cc index 708efc0c7a6..d51580ee4aa 100644 --- a/source/blender/editors/space_node/drawnode.cc +++ b/source/blender/editors/space_node/drawnode.cc @@ -1200,6 +1200,8 @@ static const float std_node_socket_colors[][4] = { {0.96, 0.96, 0.96, 1.0}, /* SOCK_COLLECTION */ {0.62, 0.31, 0.64, 1.0}, /* SOCK_TEXTURE */ {0.92, 0.46, 0.51, 1.0}, /* SOCK_MATERIAL */ + {0.01, 0.61, 0.66, 1.0}, /* SOCK_MATRIX3x3 */ + {0.01, 0.36, 0.62, 1.0}, /* SOCK_MATRIX4x4 */ }; /* common color callbacks for standard types */ @@ -1320,6 +1322,24 @@ static void std_node_socket_draw( } } break; + case SOCK_MATRIX3x3: + if (sock->flag & SOCK_COMPACT) { + uiTemplateComponentMenu(layout, ptr, "default_value", text); + } + else { + uiLayout *column = uiLayoutColumn(layout, true); + uiItemR(column, ptr, "default_value", DEFAULT_FLAGS, text, ICON_NONE); + } + break; + case SOCK_MATRIX4x4: + if (sock->flag & SOCK_COMPACT) { + uiTemplateComponentMenu(layout, ptr, "default_value", text); + } + else { + uiLayout *column = uiLayoutColumn(layout, true); + uiItemR(column, ptr, "default_value", DEFAULT_FLAGS, text, ICON_NONE); + } + break; case SOCK_RGBA: { if (text[0] == '\0') { uiItemR(layout, ptr, "default_value", DEFAULT_FLAGS, "", 0); @@ -1450,6 +1470,20 @@ static void std_node_socket_interface_draw(bContext * /*C*/, uiLayout *layout, P uiItemR(sub, ptr, "max_value", DEFAULT_FLAGS, IFACE_("Max"), ICON_NONE); break; } + case SOCK_MATRIX3x3: { + uiItemR(col, ptr, "default_value", DEFAULT_FLAGS, IFACE_("Default"), ICON_NONE); + uiLayout *sub = uiLayoutColumn(col, true); + uiItemR(sub, ptr, "min_value", DEFAULT_FLAGS, IFACE_("Min"), ICON_NONE); + uiItemR(sub, ptr, "max_value", DEFAULT_FLAGS, IFACE_("Max"), ICON_NONE); + break; + } + case SOCK_MATRIX4x4: { + uiItemR(col, ptr, "default_value", DEFAULT_FLAGS, IFACE_("Default"), ICON_NONE); + uiLayout *sub = uiLayoutColumn(col, true); + uiItemR(sub, ptr, "min_value", DEFAULT_FLAGS, IFACE_("Min"), ICON_NONE); + uiItemR(sub, ptr, "max_value", DEFAULT_FLAGS, IFACE_("Max"), ICON_NONE); + break; + } case SOCK_BOOLEAN: case SOCK_RGBA: case SOCK_STRING: diff --git a/source/blender/editors/space_node/node_relationships.cc b/source/blender/editors/space_node/node_relationships.cc index 93761388f43..045c5402703 100644 --- a/source/blender/editors/space_node/node_relationships.cc +++ b/source/blender/editors/space_node/node_relationships.cc @@ -451,6 +451,10 @@ static eCustomDataType socket_type_to_custom_data_type(const eNodeSocketDatatype return CD_PROP_INT32; case SOCK_VECTOR: return CD_PROP_FLOAT3; + case SOCK_MATRIX3x3: + return CD_PROP_FLOAT3x3; + case SOCK_MATRIX4x4: + return CD_PROP_FLOAT4x4; case SOCK_BOOLEAN: return CD_PROP_BOOL; case SOCK_RGBA: @@ -2070,8 +2074,12 @@ static int get_main_socket_priority(const bNodeSocket *socket) return 3; case SOCK_VECTOR: return 4; - case SOCK_RGBA: + case SOCK_MATRIX3x3: return 5; + case SOCK_MATRIX4x4: + return 6; + case SOCK_RGBA: + return 7; case SOCK_STRING: case SOCK_SHADER: case SOCK_OBJECT: @@ -2080,7 +2088,7 @@ static int get_main_socket_priority(const bNodeSocket *socket) case SOCK_COLLECTION: case SOCK_TEXTURE: case SOCK_MATERIAL: - return 6; + return 8; } return -1; } diff --git a/source/blender/editors/space_node/node_templates.cc b/source/blender/editors/space_node/node_templates.cc index e7fd1bb9829..580d1133523 100644 --- a/source/blender/editors/space_node/node_templates.cc +++ b/source/blender/editors/space_node/node_templates.cc @@ -868,6 +868,8 @@ static void ui_node_draw_input( else { switch (input.type) { case SOCK_VECTOR: + case SOCK_MATRIX3x3: + case SOCK_MATRIX4x4: uiItemS(sub); sub = uiLayoutColumn(sub, true); ATTR_FALLTHROUGH; diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c index 3c864081d4c..5bd102cacf3 100644 --- a/source/blender/makesrna/intern/rna_nodetree.c +++ b/source/blender/makesrna/intern/rna_nodetree.c @@ -62,6 +62,8 @@ static const EnumPropertyItem node_socket_data_type_items[] = { {SOCK_INT, "INT", 0, "Integer", ""}, {SOCK_BOOLEAN, "BOOLEAN", 0, "Boolean", ""}, {SOCK_VECTOR, "VECTOR", 0, "Vector", ""}, + {SOCK_MATRIX3x3, "MATRIX3x3", 0, "3x3 Matrix", ""}, + {SOCK_MATRIX4x4, "MATRIX4x4", 0, "4x4 Matrix", ""}, {SOCK_STRING, "STRING", 0, "String", ""}, {SOCK_RGBA, "RGBA", 0, "Color", ""}, {SOCK_OBJECT, "OBJECT", 0, "Object", ""}, @@ -89,6 +91,8 @@ static const EnumPropertyItem node_socket_type_items[] = { {SOCK_INT, "INT", 0, "Integer", ""}, {SOCK_BOOLEAN, "BOOLEAN", 0, "Boolean", ""}, {SOCK_VECTOR, "VECTOR", 0, "Vector", ""}, + {SOCK_MATRIX3x3, "MATRIX3x3", 0, "3x3 Matrix", ""}, + {SOCK_MATRIX4x4, "MATRIX4x4", 0, "4x4 Matrix", ""}, {SOCK_STRING, "STRING", 0, "String", ""}, {SOCK_RGBA, "RGBA", 0, "RGBA", ""}, {SOCK_SHADER, "SHADER", 0, "Shader", ""}, diff --git a/source/blender/modifiers/intern/MOD_nodes.cc b/source/blender/modifiers/intern/MOD_nodes.cc index a8e5e2ab0a2..7ccd861a5dc 100644 --- a/source/blender/modifiers/intern/MOD_nodes.cc +++ b/source/blender/modifiers/intern/MOD_nodes.cc @@ -12,6 +12,8 @@ #include "MEM_guardedalloc.h" #include "BLI_array.hh" +#include "BLI_float3x3.hh" +#include "BLI_float4x4.hh" #include "BLI_listbase.h" #include "BLI_math_vec_types.hh" #include "BLI_multi_value_map.hh" @@ -100,6 +102,8 @@ using blender::ColorGeometry4f; using blender::CPPType; using blender::destruct_ptr; using blender::float3; +using blender::float3x3; +using blender::float4x4; using blender::FunctionRef; using blender::GMutablePointer; using blender::GMutableSpan; @@ -417,7 +421,7 @@ static const std::string attribute_name_suffix = "_attribute_name"; */ static bool socket_type_has_attribute_toggle(const bNodeSocket &socket) { - return ELEM(socket.type, SOCK_FLOAT, SOCK_VECTOR, SOCK_BOOLEAN, SOCK_RGBA, SOCK_INT); + return ELEM(socket.type, SOCK_FLOAT, SOCK_VECTOR, SOCK_BOOLEAN, SOCK_RGBA, SOCK_INT, SOCK_MATRIX3x3, SOCK_MATRIX4x4); } /** @@ -475,6 +479,36 @@ id_property_create_from_socket(const bNodeSocket &socket) } return property; } + case SOCK_MATRIX3x3: { + const bNodeSocketValueMatrix3x3 *value = static_cast( + socket.default_value); + auto property = bke::idprop::create(socket.identifier, Span(value->value, 9)); + IDPropertyUIDataFloat *ui_data = (IDPropertyUIDataFloat *)IDP_ui_data_ensure(property.get()); + ui_data->base.rna_subtype = PROP_MATRIX; + ui_data->min = ui_data->soft_min = double(value->min); + ui_data->max = ui_data->soft_max = double(value->max); + ui_data->default_array = (double *)MEM_mallocN(sizeof(double[9]), "mod_prop_default"); + ui_data->default_array_len = 9; + for (const int i : IndexRange(9)) { + ui_data->default_array[i] = double(value->value[i]); + } + return property; + } + case SOCK_MATRIX4x4: { + const bNodeSocketValueMatrix4x4 *value = static_cast( + socket.default_value); + auto property = bke::idprop::create(socket.identifier, Span(value->value, 16)); + IDPropertyUIDataFloat *ui_data = (IDPropertyUIDataFloat *)IDP_ui_data_ensure(property.get()); + ui_data->base.rna_subtype = PROP_MATRIX; + ui_data->min = ui_data->soft_min = double(value->min); + ui_data->max = ui_data->soft_max = double(value->max); + ui_data->default_array = (double *)MEM_mallocN(sizeof(double[16]), "mod_prop_default"); + ui_data->default_array_len = 16; + for (const int i : IndexRange(16)) { + ui_data->default_array[i] = double(value->value[i]); + } + return property; + } case SOCK_RGBA: { const bNodeSocketValueRGBA *value = static_cast( socket.default_value); @@ -551,6 +585,10 @@ static bool id_property_type_matches_socket(const bNodeSocket &socket, const IDP return property.type == IDP_INT; case SOCK_VECTOR: return property.type == IDP_ARRAY && property.subtype == IDP_FLOAT && property.len == 3; + case SOCK_MATRIX3x3: + return property.type == IDP_ARRAY && property.subtype == IDP_FLOAT && property.len == 9; + case SOCK_MATRIX4x4: + return property.type == IDP_ARRAY && property.subtype == IDP_FLOAT && property.len == 16; case SOCK_RGBA: return property.type == IDP_ARRAY && property.subtype == IDP_FLOAT && property.len == 4; case SOCK_BOOLEAN: @@ -595,6 +633,18 @@ static void init_socket_cpp_value_from_property(const IDProperty &property, new (r_value) ValueOrField(value); break; } + case SOCK_MATRIX3x3: { + float3x3 value; + copy_m3_m3(value.ptr(), (const float (*)[3])IDP_Array(&property)); + new (r_value) ValueOrField(value); + break; + } + case SOCK_MATRIX4x4: { + float4x4 value; + copy_m4_m4(value.ptr(), (const float(*)[4])IDP_Array(&property)); + new (r_value) ValueOrField(value); + break; + } case SOCK_RGBA: { blender::ColorGeometry4f value; copy_v4_v4((float *)value, (const float *)IDP_Array(&property)); diff --git a/source/blender/nodes/geometry/node_geometry_tree.cc b/source/blender/nodes/geometry/node_geometry_tree.cc index 1339024b776..ddbbbaca1b8 100644 --- a/source/blender/nodes/geometry/node_geometry_tree.cc +++ b/source/blender/nodes/geometry/node_geometry_tree.cc @@ -100,7 +100,9 @@ static bool geometry_node_tree_socket_type_valid(bNodeTreeType * /*treetype*/, SOCK_COLLECTION, SOCK_TEXTURE, SOCK_IMAGE, - SOCK_MATERIAL); + SOCK_MATERIAL, + SOCK_MATRIX3x3, + SOCK_MATRIX4x4); } void register_node_tree_type_geo() diff --git a/source/blender/nodes/geometry/node_geometry_util.cc b/source/blender/nodes/geometry/node_geometry_util.cc index 8b962d39b3c..a48477542d7 100644 --- a/source/blender/nodes/geometry/node_geometry_util.cc +++ b/source/blender/nodes/geometry/node_geometry_util.cc @@ -21,6 +21,10 @@ std::optional node_data_type_to_custom_data_type(const eNodeSoc return CD_PROP_FLOAT; case SOCK_VECTOR: return CD_PROP_FLOAT3; + case SOCK_MATRIX3x3: + return CD_PROP_MATRIX3; + case SOCK_MATRIX4x4: + return CD_PROP_MATRIX4; case SOCK_RGBA: return CD_PROP_COLOR; case SOCK_BOOLEAN: diff --git a/source/blender/nodes/intern/node_socket.cc b/source/blender/nodes/intern/node_socket.cc index 02611bb675f..dddc81f4441 100644 --- a/source/blender/nodes/intern/node_socket.cc +++ b/source/blender/nodes/intern/node_socket.cc @@ -10,6 +10,8 @@ #include "DNA_node_types.h" #include "BLI_color.hh" +#include "BLI_float3x3.hh" +#include "BLI_float4x4.hh" #include "BLI_listbase.h" #include "BLI_math_vec_types.hh" #include "BLI_string.h" @@ -77,6 +79,24 @@ struct bNodeSocket *node_add_socket_from_template(struct bNodeTree *ntree, dval->max = stemp->max; break; } + case SOCK_MATRIX3x3: { + bNodeSocketValueMatrix3x3 *dval = (bNodeSocketValueMatrix3x3 *)sock->default_value; + dval->value[0] = stemp->val1; + dval->value[1] = stemp->val2; + dval->value[2] = stemp->val3; + dval->min = stemp->min; + dval->max = stemp->max; + break; + } + case SOCK_MATRIX4x4: { + bNodeSocketValueMatrix4x4 *dval = (bNodeSocketValueMatrix4x4 *)sock->default_value; + dval->value[0] = stemp->val1; + dval->value[1] = stemp->val2; + dval->value[2] = stemp->val3; + dval->min = stemp->min; + dval->max = stemp->max; + break; + } case SOCK_RGBA: { bNodeSocketValueRGBA *dval = (bNodeSocketValueRGBA *)sock->default_value; dval->value[0] = stemp->val1; @@ -330,6 +350,34 @@ void node_socket_init_default_value(bNodeSocket *sock) sock->default_value = dval; break; } + case SOCK_MATRIX3x3: { + static float default_value[][3] = { + {1.0f, 0.0f, 0.0f}, {0.0f, 1.0f, 0.0f}, {0.0f, 0.0f, 1.0f}}; + bNodeSocketValueMatrix3x3 *dval = MEM_cnew( + "node socket value matrix 3x3"); + dval->subtype = subtype; + copy_m3_m3(dval->value, default_value); + dval->min = -FLT_MAX; + dval->max = FLT_MAX; + + sock->default_value = dval; + break; + } + case SOCK_MATRIX4x4: { + static float default_value[][4] = {{1.0f, 0.0f, 0.0f, 0.0f}, + {0.0f, 1.0f, 0.0f, 0.0f}, + {0.0f, 0.0f, 1.0f, 0.0f}, + {0.0f, 0.0f, 0.0f, 1.0f}}; + bNodeSocketValueMatrix4x4 *dval = MEM_cnew( + "node socket value vector"); + dval->subtype = subtype; + copy_m4_m4(dval->value, default_value); + dval->min = -FLT_MAX; + dval->max = FLT_MAX; + + sock->default_value = dval; + break; + } case SOCK_RGBA: { static float default_value[] = {0.0f, 0.0f, 0.0f, 1.0f}; bNodeSocketValueRGBA *dval = MEM_cnew("node socket value color"); @@ -430,6 +478,18 @@ void node_socket_copy_default_value(bNodeSocket *to, const bNodeSocket *from) *toval = *fromval; break; } + case SOCK_MATRIX3x3: { + bNodeSocketValueMatrix3x3 *toval = (bNodeSocketValueMatrix3x3 *)to->default_value; + bNodeSocketValueMatrix3x3 *fromval = (bNodeSocketValueMatrix3x3 *)from->default_value; + *toval = *fromval; + break; + } + case SOCK_MATRIX4x4: { + bNodeSocketValueMatrix4x4 *toval = (bNodeSocketValueMatrix4x4 *)to->default_value; + bNodeSocketValueMatrix4x4 *fromval = (bNodeSocketValueMatrix4x4 *)from->default_value; + *toval = *fromval; + break; + } case SOCK_RGBA: { bNodeSocketValueRGBA *toval = (bNodeSocketValueRGBA *)to->default_value; bNodeSocketValueRGBA *fromval = (bNodeSocketValueRGBA *)from->default_value; @@ -590,6 +650,22 @@ static void standard_node_socket_interface_verify_socket(bNodeTree * /*ntree*/, toval->max = fromval->max; break; } + case SOCK_MATRIX3x3: { + bNodeSocketValueMatrix3x3 *toval = (bNodeSocketValueMatrix3x3 *)sock->default_value; + const bNodeSocketValueMatrix3x3 *fromval = (const bNodeSocketValueMatrix3x3 *) + interface_socket->default_value; + toval->min = fromval->min; + toval->max = fromval->max; + break; + } + case SOCK_MATRIX4x4: { + bNodeSocketValueMatrix4x4 *toval = (bNodeSocketValueMatrix4x4 *)sock->default_value; + const bNodeSocketValueMatrix4x4 *fromval = (const bNodeSocketValueMatrix4x4 *) + interface_socket->default_value; + toval->min = fromval->min; + toval->max = fromval->max; + break; + } } } @@ -744,6 +820,38 @@ static bNodeSocketType *make_socket_type_vector(PropertySubType subtype) return socktype; } +static bNodeSocketType *make_socket_type_matrix3() +{ + bNodeSocketType *socktype = make_standard_socket_type(SOCK_MATRIX3x3, PROP_MATRIX); + socktype->base_cpp_type = &blender::CPPType::get(); + socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) { + *(blender::float3x3 *)r_value = ((bNodeSocketValueMatrix3x3 *)socket.default_value)->value; + }; + socktype->geometry_nodes_cpp_type = &blender::CPPType::get>(); + socktype->get_geometry_nodes_cpp_value = [](const bNodeSocket &socket, void *r_value) { + blender::float3x3 value; + socket.typeinfo->get_base_cpp_value(socket, &value); + new (r_value) ValueOrField(value); + }; + return socktype; +} + +static bNodeSocketType *make_socket_type_matrix4() +{ + bNodeSocketType *socktype = make_standard_socket_type(SOCK_MATRIX4x4, PROP_MATRIX); + socktype->base_cpp_type = &blender::CPPType::get(); + socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) { + *(blender::float4x4 *)r_value = ((bNodeSocketValueMatrix4x4 *)socket.default_value)->value; + }; + socktype->geometry_nodes_cpp_type = &blender::CPPType::get>(); + socktype->get_geometry_nodes_cpp_value = [](const bNodeSocket &socket, void *r_value) { + blender::float4x4 value; + socket.typeinfo->get_base_cpp_value(socket, &value); + new (r_value) ValueOrField(value); + }; + return socktype; +} + static bNodeSocketType *make_socket_type_rgba() { bNodeSocketType *socktype = make_standard_socket_type(SOCK_RGBA, PROP_NONE); diff --git a/source/blender/nodes/intern/node_socket_declarations.cc b/source/blender/nodes/intern/node_socket_declarations.cc index 33aaec43101..f6263571824 100644 --- a/source/blender/nodes/intern/node_socket_declarations.cc +++ b/source/blender/nodes/intern/node_socket_declarations.cc @@ -254,9 +254,13 @@ bNodeSocket &Vector::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket bNodeSocket &Matrix3x3::build(bNodeTree &ntree, bNode &node) const { - bNodeSocket &socket = *nodeAddSocket( - &ntree, &node, in_out_, "NodeSocketMatrix3x3", identifier_.c_str(), name_.c_str()); + bNodeSocket &socket = *nodeAddStaticSocket( + &ntree, &node, in_out_, SOCK_MATRIX3x3, PROP_MATRIX, identifier_.c_str(), name_.c_str()); this->set_common_flags(socket); + bNodeSocketValueMatrix3x3 &value = *(bNodeSocketValueMatrix3x3 *)socket.default_value; + copy_m3_m3(value.value, default_value_.ptr()); + value.min = soft_min_value_; + value.max = soft_max_value_; return socket; } @@ -276,6 +280,18 @@ bool Matrix3x3::can_connect(const bNodeSocket &socket) const return sockets_can_connect(*this, socket) && socket.type == SOCK_MATRIX3x3; } +bNodeSocket &Matrix3x3::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket &socket) const +{ + if (socket.type != SOCK_MATRIX3x3) { + BLI_assert(socket.in_out == in_out_); + return this->build(ntree, node); + } + this->set_common_flags(socket); + bNodeSocketValueMatrix3x3 &value = *(bNodeSocketValueMatrix3x3 *)socket.default_value; + STRNCPY(socket.name, name_.c_str()); + return socket; +} + /** \} */ /* -------------------------------------------------------------------- */ @@ -284,9 +300,13 @@ bool Matrix3x3::can_connect(const bNodeSocket &socket) const bNodeSocket &Matrix4x4::build(bNodeTree &ntree, bNode &node) const { - bNodeSocket &socket = *nodeAddSocket( - &ntree, &node, in_out_, "NodeSocketMatrix4x4", identifier_.c_str(), name_.c_str()); + bNodeSocket &socket = *nodeAddStaticSocket( + &ntree, &node, in_out_, SOCK_MATRIX4x4, PROP_MATRIX, identifier_.c_str(), name_.c_str()); this->set_common_flags(socket); + bNodeSocketValueMatrix4x4 &value = *(bNodeSocketValueMatrix4x4 *)socket.default_value; + copy_m4_m4(value.value, default_value_.ptr()); + value.min = soft_min_value_; + value.max = soft_max_value_; return socket; } @@ -306,6 +326,18 @@ bool Matrix4x4::can_connect(const bNodeSocket &socket) const return sockets_can_connect(*this, socket) && socket.type == SOCK_MATRIX4x4; } +bNodeSocket &Matrix4x4::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket &socket) const +{ + if (socket.type != SOCK_MATRIX4x4) { + BLI_assert(socket.in_out == in_out_); + return this->build(ntree, node); + } + this->set_common_flags(socket); + bNodeSocketValueMatrix4x4 &value = *(bNodeSocketValueMatrix4x4 *)socket.default_value; + STRNCPY(socket.name, name_.c_str()); + return socket; +} + /** \} */ /* -------------------------------------------------------------------- */ -- 2.30.2 From 8bfd84a3c927dd436729a94a2c0a9022137831c2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Thu, 8 Dec 2022 22:12:20 +0000 Subject: [PATCH 04/33] Finished majority of boilerplate code for matrix socket types. --- source/blender/blenkernel/intern/node.cc | 53 +++-- .../blenkernel/intern/node_tree_update.cc | 2 +- source/blender/editors/space_node/drawnode.cc | 29 +-- .../editors/space_node/node_relationships.cc | 17 +- .../editors/space_node/node_templates.cc | 9 +- source/blender/makesdna/DNA_node_types.h | 20 +- source/blender/makesrna/intern/rna_nodetree.c | 217 +++++++++++++++--- source/blender/modifiers/intern/MOD_nodes.cc | 24 +- .../nodes/geometry/node_geometry_tree.cc | 4 +- .../nodes/geometry/node_geometry_util.cc | 4 +- source/blender/nodes/intern/node_socket.cc | 106 +++++++-- .../nodes/intern/node_socket_declarations.cc | 16 +- 12 files changed, 370 insertions(+), 131 deletions(-) diff --git a/source/blender/blenkernel/intern/node.cc b/source/blender/blenkernel/intern/node.cc index 52e3a41ee20..218485aeb58 100644 --- a/source/blender/blenkernel/intern/node.cc +++ b/source/blender/blenkernel/intern/node.cc @@ -311,8 +311,9 @@ static void library_foreach_node_socket(LibraryForeachIDData *data, bNodeSocket case SOCK_CUSTOM: case SOCK_SHADER: case SOCK_GEOMETRY: - case SOCK_MATRIX3x3: - case SOCK_MATRIX4x4: + case SOCK_MATRIX_2X2: + case SOCK_MATRIX_3X3: + case SOCK_MATRIX_4X4: break; } } @@ -452,10 +453,13 @@ static void write_node_socket_default_value(BlendWriter *writer, bNodeSocket *so case SOCK_MATERIAL: BLO_write_struct(writer, bNodeSocketValueMaterial, sock->default_value); break; - case SOCK_MATRIX3x3: + case SOCK_MATRIX_2X2: + BLO_write_struct(writer, bNodeSocketValueMatrix2x2, sock->default_value); + break; + case SOCK_MATRIX_3X3: BLO_write_struct(writer, bNodeSocketValueMatrix3x3, sock->default_value); break; - case SOCK_MATRIX4x4: + case SOCK_MATRIX_4X4: BLO_write_struct(writer, bNodeSocketValueMatrix4x4, sock->default_value); break; case SOCK_CUSTOM: @@ -881,8 +885,8 @@ static void lib_link_node_socket(BlendLibReader *reader, Library *lib, bNodeSock case SOCK_CUSTOM: case SOCK_SHADER: case SOCK_GEOMETRY: - case SOCK_MATRIX3x3: - case SOCK_MATRIX4x4: + case SOCK_MATRIX_3X3: + case SOCK_MATRIX_4X4: break; } } @@ -978,8 +982,9 @@ static void expand_node_socket(BlendExpander *expander, bNodeSocket *sock) case SOCK_CUSTOM: case SOCK_SHADER: case SOCK_GEOMETRY: - case SOCK_MATRIX3x3: - case SOCK_MATRIX4x4: + case SOCK_MATRIX_2X2: + case SOCK_MATRIX_3X3: + case SOCK_MATRIX_4X4: break; } } @@ -1595,8 +1600,9 @@ static void socket_id_user_increment(bNodeSocket *sock) case SOCK_CUSTOM: case SOCK_SHADER: case SOCK_GEOMETRY: - case SOCK_MATRIX3x3: - case SOCK_MATRIX4x4: + case SOCK_MATRIX_2X2: + case SOCK_MATRIX_3X3: + case SOCK_MATRIX_4X4: break; } } @@ -1656,8 +1662,9 @@ static bool socket_id_user_decrement(bNodeSocket *sock) case SOCK_CUSTOM: case SOCK_SHADER: case SOCK_GEOMETRY: - case SOCK_MATRIX3x3: - case SOCK_MATRIX4x4: + case SOCK_MATRIX_2X2: + case SOCK_MATRIX_3X3: + case SOCK_MATRIX_4X4: break; } return false; @@ -1802,9 +1809,11 @@ const char *nodeStaticSocketType(int type, int subtype) return "NodeSocketTexture"; case SOCK_MATERIAL: return "NodeSocketMaterial"; - case SOCK_MATRIX3x3: + case SOCK_MATRIX_2X2: + return "NodeSocketMatrix2x2"; + case SOCK_MATRIX_3X3: return "NodeSocketMatrix3x3"; - case SOCK_MATRIX4x4: + case SOCK_MATRIX_4X4: return "NodeSocketMatrix4x4"; } return nullptr; @@ -1883,9 +1892,11 @@ const char *nodeStaticSocketInterfaceType(int type, int subtype) return "NodeSocketInterfaceTexture"; case SOCK_MATERIAL: return "NodeSocketInterfaceMaterial"; - case SOCK_MATRIX3x3: + case SOCK_MATRIX_2X2: + return "NodeSocketInterfaceMatrix2x2"; + case SOCK_MATRIX_3X3: return "NodeSocketInterfaceMatrix3x3"; - case SOCK_MATRIX4x4: + case SOCK_MATRIX_4X4: return "NodeSocketInterfaceMatrix4x4"; } return nullptr; @@ -1920,10 +1931,12 @@ const char *nodeStaticSocketLabel(int type, int /*subtype*/) return "Texture"; case SOCK_MATERIAL: return "Material"; - case SOCK_MATRIX3x3: - return "Matrix3x3"; - case SOCK_MATRIX4x4: - return "Matrix4x4"; + case SOCK_MATRIX_2X2: + return "2x2 Matrix"; + case SOCK_MATRIX_3X3: + return "3x3 Matrix"; + case SOCK_MATRIX_4X4: + return "4x4 Matrix"; } return nullptr; } diff --git a/source/blender/blenkernel/intern/node_tree_update.cc b/source/blender/blenkernel/intern/node_tree_update.cc index d6c025cd5e9..b32c6f8963f 100644 --- a/source/blender/blenkernel/intern/node_tree_update.cc +++ b/source/blender/blenkernel/intern/node_tree_update.cc @@ -72,7 +72,7 @@ namespace node_field_inferencing { static bool is_field_socket_type(eNodeSocketDatatype type) { - return ELEM(type, SOCK_FLOAT, SOCK_INT, SOCK_BOOLEAN, SOCK_VECTOR, SOCK_RGBA, SOCK_MATRIX3x3, SOCK_MATRIX4x4); + return ELEM(type, SOCK_FLOAT, SOCK_INT, SOCK_BOOLEAN, SOCK_VECTOR, SOCK_RGBA, SOCK_MATRIX_2X2, SOCK_MATRIX_3X3, SOCK_MATRIX_4X4); } static bool is_field_socket_type(const bNodeSocket &socket) diff --git a/source/blender/editors/space_node/drawnode.cc b/source/blender/editors/space_node/drawnode.cc index d51580ee4aa..23c9e8276f8 100644 --- a/source/blender/editors/space_node/drawnode.cc +++ b/source/blender/editors/space_node/drawnode.cc @@ -1200,8 +1200,9 @@ static const float std_node_socket_colors[][4] = { {0.96, 0.96, 0.96, 1.0}, /* SOCK_COLLECTION */ {0.62, 0.31, 0.64, 1.0}, /* SOCK_TEXTURE */ {0.92, 0.46, 0.51, 1.0}, /* SOCK_MATERIAL */ - {0.01, 0.61, 0.66, 1.0}, /* SOCK_MATRIX3x3 */ - {0.01, 0.36, 0.62, 1.0}, /* SOCK_MATRIX4x4 */ + {0.01, 0.61, 0.66, 1.0}, /* SOCK_MATRIX_2X2 */ + {0.01, 0.61, 0.66, 1.0}, /* SOCK_MATRIX_3X3 */ + {0.01, 0.61, 0.66, 1.0}, /* SOCK_MATRIX_4X4 */ }; /* common color callbacks for standard types */ @@ -1322,16 +1323,9 @@ static void std_node_socket_draw( } } break; - case SOCK_MATRIX3x3: - if (sock->flag & SOCK_COMPACT) { - uiTemplateComponentMenu(layout, ptr, "default_value", text); - } - else { - uiLayout *column = uiLayoutColumn(layout, true); - uiItemR(column, ptr, "default_value", DEFAULT_FLAGS, text, ICON_NONE); - } - break; - case SOCK_MATRIX4x4: + case SOCK_MATRIX_2X2: + case SOCK_MATRIX_3X3: + case SOCK_MATRIX_4X4: if (sock->flag & SOCK_COMPACT) { uiTemplateComponentMenu(layout, ptr, "default_value", text); } @@ -1470,14 +1464,9 @@ static void std_node_socket_interface_draw(bContext * /*C*/, uiLayout *layout, P uiItemR(sub, ptr, "max_value", DEFAULT_FLAGS, IFACE_("Max"), ICON_NONE); break; } - case SOCK_MATRIX3x3: { - uiItemR(col, ptr, "default_value", DEFAULT_FLAGS, IFACE_("Default"), ICON_NONE); - uiLayout *sub = uiLayoutColumn(col, true); - uiItemR(sub, ptr, "min_value", DEFAULT_FLAGS, IFACE_("Min"), ICON_NONE); - uiItemR(sub, ptr, "max_value", DEFAULT_FLAGS, IFACE_("Max"), ICON_NONE); - break; - } - case SOCK_MATRIX4x4: { + case SOCK_MATRIX_2X2: + case SOCK_MATRIX_3X3: + case SOCK_MATRIX_4X4: { uiItemR(col, ptr, "default_value", DEFAULT_FLAGS, IFACE_("Default"), ICON_NONE); uiLayout *sub = uiLayoutColumn(col, true); uiItemR(sub, ptr, "min_value", DEFAULT_FLAGS, IFACE_("Min"), ICON_NONE); diff --git a/source/blender/editors/space_node/node_relationships.cc b/source/blender/editors/space_node/node_relationships.cc index 045c5402703..b4e942aea82 100644 --- a/source/blender/editors/space_node/node_relationships.cc +++ b/source/blender/editors/space_node/node_relationships.cc @@ -451,9 +451,11 @@ static eCustomDataType socket_type_to_custom_data_type(const eNodeSocketDatatype return CD_PROP_INT32; case SOCK_VECTOR: return CD_PROP_FLOAT3; - case SOCK_MATRIX3x3: + case SOCK_MATRIX_2X2: + return CD_PROP_FLOAT2x2; + case SOCK_MATRIX_3X3: return CD_PROP_FLOAT3x3; - case SOCK_MATRIX4x4: + case SOCK_MATRIX_4X4: return CD_PROP_FLOAT4x4; case SOCK_BOOLEAN: return CD_PROP_BOOL; @@ -2074,12 +2076,8 @@ static int get_main_socket_priority(const bNodeSocket *socket) return 3; case SOCK_VECTOR: return 4; - case SOCK_MATRIX3x3: - return 5; - case SOCK_MATRIX4x4: - return 6; case SOCK_RGBA: - return 7; + return 5; case SOCK_STRING: case SOCK_SHADER: case SOCK_OBJECT: @@ -2088,7 +2086,10 @@ static int get_main_socket_priority(const bNodeSocket *socket) case SOCK_COLLECTION: case SOCK_TEXTURE: case SOCK_MATERIAL: - return 8; + case SOCK_MATRIX_2X2: + case SOCK_MATRIX_3X3: + case SOCK_MATRIX_4X4: + return 6; } return -1; } diff --git a/source/blender/editors/space_node/node_templates.cc b/source/blender/editors/space_node/node_templates.cc index 580d1133523..ec9c067161d 100644 --- a/source/blender/editors/space_node/node_templates.cc +++ b/source/blender/editors/space_node/node_templates.cc @@ -383,10 +383,10 @@ static Vector ui_node_link_items(NodeLinkArg *arg, item.socket_type = SOCK_VECTOR; } else if (dynamic_cast(&socket_decl)) { - item.socket_type = SOCK_MATRIX3x3; + item.socket_type = SOCK_MATRIX_3X3; } else if (dynamic_cast(&socket_decl)) { - item.socket_type = SOCK_MATRIX4x4; + item.socket_type = SOCK_MATRIX_4X4; } else if (dynamic_cast(&socket_decl)) { item.socket_type = SOCK_RGBA; @@ -868,8 +868,9 @@ static void ui_node_draw_input( else { switch (input.type) { case SOCK_VECTOR: - case SOCK_MATRIX3x3: - case SOCK_MATRIX4x4: + case SOCK_MATRIX_2X2: + case SOCK_MATRIX_3X3: + case SOCK_MATRIX_4X4: uiItemS(sub); sub = uiLayoutColumn(sub, true); ATTR_FALLTHROUGH; diff --git a/source/blender/makesdna/DNA_node_types.h b/source/blender/makesdna/DNA_node_types.h index 49c62cbbf9d..522d031658e 100644 --- a/source/blender/makesdna/DNA_node_types.h +++ b/source/blender/makesdna/DNA_node_types.h @@ -232,8 +232,9 @@ typedef enum eNodeSocketDatatype { SOCK_COLLECTION = 11, SOCK_TEXTURE = 12, SOCK_MATERIAL = 13, - SOCK_MATRIX3x3 = 14, - SOCK_MATRIX4x4 = 15, + SOCK_MATRIX_2X2 = 14, + SOCK_MATRIX_3X3 = 15, + SOCK_MATRIX_4X4 = 16, } eNodeSocketDatatype; /** Socket shape. */ @@ -676,6 +677,21 @@ typedef struct bNodeSocketValueVector { float min, max; } bNodeSocketValueVector; +typedef struct bNodeSocketValueMatrix2x2 { + float value[2][2]; + float min, max; +} bNodeSocketValueMatrix2x2; + +typedef struct bNodeSocketValueMatrix3x3 { + float value[3][3]; + float min, max; +} bNodeSocketValueMatrix3x3; + +typedef struct bNodeSocketValueMatrix4x4 { + float value[4][4]; + float min, max; +} bNodeSocketValueMatrix4x4; + typedef struct bNodeSocketValueRGBA { float value[4]; } bNodeSocketValueRGBA; diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c index 5bd102cacf3..cabe05affd2 100644 --- a/source/blender/makesrna/intern/rna_nodetree.c +++ b/source/blender/makesrna/intern/rna_nodetree.c @@ -62,8 +62,9 @@ static const EnumPropertyItem node_socket_data_type_items[] = { {SOCK_INT, "INT", 0, "Integer", ""}, {SOCK_BOOLEAN, "BOOLEAN", 0, "Boolean", ""}, {SOCK_VECTOR, "VECTOR", 0, "Vector", ""}, - {SOCK_MATRIX3x3, "MATRIX3x3", 0, "3x3 Matrix", ""}, - {SOCK_MATRIX4x4, "MATRIX4x4", 0, "4x4 Matrix", ""}, + {SOCK_MATRIX_2X2, "MATRIX2x2", 0, "2x2 Matrix", ""}, + {SOCK_MATRIX_3X3, "MATRIX3x3", 0, "3x3 Matrix", ""}, + {SOCK_MATRIX_4X4, "MATRIX4x4", 0, "4x4 Matrix", ""}, {SOCK_STRING, "STRING", 0, "String", ""}, {SOCK_RGBA, "RGBA", 0, "Color", ""}, {SOCK_OBJECT, "OBJECT", 0, "Object", ""}, @@ -91,8 +92,9 @@ static const EnumPropertyItem node_socket_type_items[] = { {SOCK_INT, "INT", 0, "Integer", ""}, {SOCK_BOOLEAN, "BOOLEAN", 0, "Boolean", ""}, {SOCK_VECTOR, "VECTOR", 0, "Vector", ""}, - {SOCK_MATRIX3x3, "MATRIX3x3", 0, "3x3 Matrix", ""}, - {SOCK_MATRIX4x4, "MATRIX4x4", 0, "4x4 Matrix", ""}, + {SOCK_MATRIX_2X2, "MATRIX2x2", 0, "2x2 Matrix", ""}, + {SOCK_MATRIX_3X3, "MATRIX3x3", 0, "3x3 Matrix", ""}, + {SOCK_MATRIX_4X4, "MATRIX4x4", 0, "4x4 Matrix", ""}, {SOCK_STRING, "STRING", 0, "String", ""}, {SOCK_RGBA, "RGBA", 0, "RGBA", ""}, {SOCK_SHADER, "SHADER", 0, "Shader", ""}, @@ -3219,6 +3221,54 @@ static void rna_NodeSocketStandard_vector_range( *softmax = dval->max; } +static void rna_NodeSocketStandard_matrix3x3_range( + PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax) +{ + bNodeSocket *sock = ptr->data; + bNodeSocketValueMatrix3x3 *dval = sock->default_value; + + if (dval->max < dval->min) { + dval->max = dval->min; + } + + *min = -FLT_MAX; + *max = FLT_MAX; + *softmin = dval->min; + *softmax = dval->max; +} + +static void rna_NodeSocketStandard_matrix4x4_range( + PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax) +{ + bNodeSocket *sock = ptr->data; + bNodeSocketValueMatrix4x4 *dval = sock->default_value; + + if (dval->max < dval->min) { + dval->max = dval->min; + } + + *min = -FLT_MAX; + *max = FLT_MAX; + *softmin = dval->min; + *softmax = dval->max; +} + +static void rna_NodeSocketStandard_matrix2x2_range( + PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax) +{ + bNodeSocket *sock = ptr->data; + bNodeSocketValueMatrix2x2 *dval = sock->default_value; + + if (dval->max < dval->min) { + dval->max = dval->min; + } + + *min = -FLT_MAX; + *max = FLT_MAX; + *softmin = dval->min; + *softmax = dval->max; +} + /* using a context update function here, to avoid searching the node if possible */ static void rna_NodeSocketStandard_value_update(struct bContext *C, PointerRNA *ptr) { @@ -11488,38 +11538,24 @@ static void rna_def_node_socket_vector(BlenderRNA *brna, RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); } -static void rna_def_node_socket_matrix3x3(BlenderRNA *brna, +static void rna_def_node_socket_matrix2x2(BlenderRNA *brna, const char *identifier, const char *interface_idname) { StructRNA *srna; PropertyRNA *prop; - const float *value_default; - - /* choose sensible common default based on subtype */ - switch (subtype) { - case PROP_DIRECTION: { - static const float default_direction[3] = {0.0f, 0.0f, 1.0f}; - value_default = default_direction; - break; - } - default: { - static const float default_vector[3] = {0.0f, 0.0f, 0.0f}; - value_default = default_vector; - break; - } - } + const float value_default[] = {1.0f, 0.0f, 0.0f, 1.0f}; srna = RNA_def_struct(brna, identifier, "NodeSocketStandard"); - RNA_def_struct_ui_text(srna, "Vector Node Socket", "3D vector socket of a node"); + RNA_def_struct_ui_text(srna, "Matrix 2x2 Node Socket", "2x2 matrix socket of a node"); RNA_def_struct_sdna(srna, "bNodeSocket"); - RNA_def_struct_sdna_from(srna, "bNodeSocketValueVector", "default_value"); + RNA_def_struct_sdna_from(srna, "bNodeSocketValueMatrix2x2", "default_value"); - prop = RNA_def_property(srna, "default_value", PROP_FLOAT, subtype); + prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_MATRIX); RNA_def_property_float_sdna(prop, NULL, "value"); RNA_def_property_float_array_default(prop, value_default); - RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketStandard_vector_range"); + RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketStandard_matrix2x2_range"); RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update"); RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE); @@ -11528,15 +11564,136 @@ static void rna_def_node_socket_matrix3x3(BlenderRNA *brna, /* socket interface */ srna = RNA_def_struct(brna, interface_idname, "NodeSocketInterfaceStandard"); - RNA_def_struct_ui_text(srna, "Vector Node Socket Interface", "3D vector socket of a node"); + RNA_def_struct_ui_text(srna, "Matrix 2x2 Node Socket Interface", "2x2 matrix socket of a node"); RNA_def_struct_sdna(srna, "bNodeSocket"); - RNA_def_struct_sdna_from(srna, "bNodeSocketValueVector", "default_value"); + RNA_def_struct_sdna_from(srna, "bNodeSocketValueMatrix2x2", "default_value"); - prop = RNA_def_property(srna, "default_value", PROP_FLOAT, subtype); + prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_MATRIX); RNA_def_property_float_sdna(prop, NULL, "value"); RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketStandard_vector_range"); + RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketStandard_matrix2x2_range"); + RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketInterface_update"); + + prop = RNA_def_property(srna, "min_value", PROP_FLOAT, PROP_NONE); + RNA_def_property_float_sdna(prop, NULL, "min"); + RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); + RNA_def_property_ui_text(prop, "Minimum Value", "Minimum value"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketInterface_update"); + + prop = RNA_def_property(srna, "max_value", PROP_FLOAT, PROP_NONE); + RNA_def_property_float_sdna(prop, NULL, "max"); + RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); + RNA_def_property_ui_text(prop, "Maximum Value", "Maximum value"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketInterface_update"); + + RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); +} + +static void rna_def_node_socket_matrix3x3(BlenderRNA *brna, + const char *identifier, + const char *interface_idname) +{ + StructRNA *srna; + PropertyRNA *prop; + const float value_default[] = {1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f}; + + srna = RNA_def_struct(brna, identifier, "NodeSocketStandard"); + RNA_def_struct_ui_text(srna, "Matrix 3x3 Node Socket", "3x3 matrix socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); + + RNA_def_struct_sdna_from(srna, "bNodeSocketValueMatrix3x3", "default_value"); + + prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_MATRIX); + RNA_def_property_float_sdna(prop, NULL, "value"); + RNA_def_property_float_array_default(prop, value_default); + RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketStandard_matrix3x3_range"); + RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update"); + RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE); + + RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); + + /* socket interface */ + srna = RNA_def_struct(brna, interface_idname, "NodeSocketInterfaceStandard"); + RNA_def_struct_ui_text(srna, "Matrix 3x3 Node Socket Interface", "3x3 matrix socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); + + RNA_def_struct_sdna_from(srna, "bNodeSocketValueMatrix3x3", "default_value"); + + prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_MATRIX); + RNA_def_property_float_sdna(prop, NULL, "value"); + RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); + RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketStandard_matrix3x3_range"); + RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketInterface_update"); + + prop = RNA_def_property(srna, "min_value", PROP_FLOAT, PROP_NONE); + RNA_def_property_float_sdna(prop, NULL, "min"); + RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); + RNA_def_property_ui_text(prop, "Minimum Value", "Minimum value"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketInterface_update"); + + prop = RNA_def_property(srna, "max_value", PROP_FLOAT, PROP_NONE); + RNA_def_property_float_sdna(prop, NULL, "max"); + RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); + RNA_def_property_ui_text(prop, "Maximum Value", "Maximum value"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketInterface_update"); + + RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); +} + +static void rna_def_node_socket_matrix4x4(BlenderRNA *brna, + const char *identifier, + const char *interface_idname) +{ + StructRNA *srna; + PropertyRNA *prop; + const float value_default[] = {1.0f, + 0.0f, + 0.0f, + 0.0f, + 0.0f, + 1.0f, + 0.0f, + 0.0f, + 0.0f, + 0.0f, + 1.0f, + 0.0f, + 0.0f, + 0.0f, + 0.0f, + 1.0f}; + + srna = RNA_def_struct(brna, identifier, "NodeSocketStandard"); + RNA_def_struct_ui_text(srna, "Matrix 4x4 Node Socket", "4x4 matrix socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); + + RNA_def_struct_sdna_from(srna, "bNodeSocketValueMatrix4x4", "default_value"); + + prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_MATRIX); + RNA_def_property_float_sdna(prop, NULL, "value"); + RNA_def_property_float_array_default(prop, value_default); + RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketStandard_matrix4x4_range"); + RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update"); + RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE); + + RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); + + /* socket interface */ + srna = RNA_def_struct(brna, interface_idname, "NodeSocketInterfaceStandard"); + RNA_def_struct_ui_text(srna, "Matrix 4x4 Node Socket Interface", "4x4 matrix socket of a node"); + RNA_def_struct_sdna(srna, "bNodeSocket"); + + RNA_def_struct_sdna_from(srna, "bNodeSocketValueMatrix4x4", "default_value"); + + prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_MATRIX); + RNA_def_property_float_sdna(prop, NULL, "value"); + RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); + RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketStandard_matrix4x4_range"); RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketInterface_update"); @@ -11996,6 +12153,10 @@ static void rna_def_node_socket_standard_types(BlenderRNA *brna) rna_def_node_socket_vector( brna, "NodeSocketVectorXYZ", "NodeSocketInterfaceVectorXYZ", PROP_XYZ); + rna_def_node_socket_matrix2x2(brna, "NodeSocketMatrix2x2", "NodeSocketInterfaceMatrix2x2"); + rna_def_node_socket_matrix3x3(brna, "NodeSocketMatrix3x3", "NodeSocketInterfaceMatrix3x3"); + rna_def_node_socket_matrix4x4(brna, "NodeSocketMatrix4x4", "NodeSocketInterfaceMatrix4x4"); + rna_def_node_socket_color(brna, "NodeSocketColor", "NodeSocketInterfaceColor"); rna_def_node_socket_string(brna, "NodeSocketString", "NodeSocketInterfaceString"); diff --git a/source/blender/modifiers/intern/MOD_nodes.cc b/source/blender/modifiers/intern/MOD_nodes.cc index 7ccd861a5dc..b2e2dfc6e3c 100644 --- a/source/blender/modifiers/intern/MOD_nodes.cc +++ b/source/blender/modifiers/intern/MOD_nodes.cc @@ -421,7 +421,7 @@ static const std::string attribute_name_suffix = "_attribute_name"; */ static bool socket_type_has_attribute_toggle(const bNodeSocket &socket) { - return ELEM(socket.type, SOCK_FLOAT, SOCK_VECTOR, SOCK_BOOLEAN, SOCK_RGBA, SOCK_INT, SOCK_MATRIX3x3, SOCK_MATRIX4x4); + return ELEM(socket.type, SOCK_FLOAT, SOCK_VECTOR, SOCK_BOOLEAN, SOCK_RGBA, SOCK_INT, SOCK_MATRIX_3X3, SOCK_MATRIX_4X4); } /** @@ -479,10 +479,11 @@ id_property_create_from_socket(const bNodeSocket &socket) } return property; } - case SOCK_MATRIX3x3: { + case SOCK_MATRIX_3X3: { const bNodeSocketValueMatrix3x3 *value = static_cast( socket.default_value); - auto property = bke::idprop::create(socket.identifier, Span(value->value, 9)); + const Span default_value_span((float *)value->value, 9); + auto property = bke::idprop::create(socket.identifier, default_value_span); IDPropertyUIDataFloat *ui_data = (IDPropertyUIDataFloat *)IDP_ui_data_ensure(property.get()); ui_data->base.rna_subtype = PROP_MATRIX; ui_data->min = ui_data->soft_min = double(value->min); @@ -490,14 +491,15 @@ id_property_create_from_socket(const bNodeSocket &socket) ui_data->default_array = (double *)MEM_mallocN(sizeof(double[9]), "mod_prop_default"); ui_data->default_array_len = 9; for (const int i : IndexRange(9)) { - ui_data->default_array[i] = double(value->value[i]); + ui_data->default_array[i] = double(default_value_span[i]); } return property; } - case SOCK_MATRIX4x4: { + case SOCK_MATRIX_4X4: { const bNodeSocketValueMatrix4x4 *value = static_cast( socket.default_value); - auto property = bke::idprop::create(socket.identifier, Span(value->value, 16)); + const Span default_value_span((float *)value->value, 16); + auto property = bke::idprop::create(socket.identifier, default_value_span); IDPropertyUIDataFloat *ui_data = (IDPropertyUIDataFloat *)IDP_ui_data_ensure(property.get()); ui_data->base.rna_subtype = PROP_MATRIX; ui_data->min = ui_data->soft_min = double(value->min); @@ -505,7 +507,7 @@ id_property_create_from_socket(const bNodeSocket &socket) ui_data->default_array = (double *)MEM_mallocN(sizeof(double[16]), "mod_prop_default"); ui_data->default_array_len = 16; for (const int i : IndexRange(16)) { - ui_data->default_array[i] = double(value->value[i]); + ui_data->default_array[i] = double(default_value_span[i]); } return property; } @@ -585,9 +587,9 @@ static bool id_property_type_matches_socket(const bNodeSocket &socket, const IDP return property.type == IDP_INT; case SOCK_VECTOR: return property.type == IDP_ARRAY && property.subtype == IDP_FLOAT && property.len == 3; - case SOCK_MATRIX3x3: + case SOCK_MATRIX_3X3: return property.type == IDP_ARRAY && property.subtype == IDP_FLOAT && property.len == 9; - case SOCK_MATRIX4x4: + case SOCK_MATRIX_4X4: return property.type == IDP_ARRAY && property.subtype == IDP_FLOAT && property.len == 16; case SOCK_RGBA: return property.type == IDP_ARRAY && property.subtype == IDP_FLOAT && property.len == 4; @@ -633,13 +635,13 @@ static void init_socket_cpp_value_from_property(const IDProperty &property, new (r_value) ValueOrField(value); break; } - case SOCK_MATRIX3x3: { + case SOCK_MATRIX_3X3: { float3x3 value; copy_m3_m3(value.ptr(), (const float (*)[3])IDP_Array(&property)); new (r_value) ValueOrField(value); break; } - case SOCK_MATRIX4x4: { + case SOCK_MATRIX_4X4: { float4x4 value; copy_m4_m4(value.ptr(), (const float(*)[4])IDP_Array(&property)); new (r_value) ValueOrField(value); diff --git a/source/blender/nodes/geometry/node_geometry_tree.cc b/source/blender/nodes/geometry/node_geometry_tree.cc index ddbbbaca1b8..8e13a67735b 100644 --- a/source/blender/nodes/geometry/node_geometry_tree.cc +++ b/source/blender/nodes/geometry/node_geometry_tree.cc @@ -101,8 +101,8 @@ static bool geometry_node_tree_socket_type_valid(bNodeTreeType * /*treetype*/, SOCK_TEXTURE, SOCK_IMAGE, SOCK_MATERIAL, - SOCK_MATRIX3x3, - SOCK_MATRIX4x4); + SOCK_MATRIX_3X3, + SOCK_MATRIX_4X4); } void register_node_tree_type_geo() diff --git a/source/blender/nodes/geometry/node_geometry_util.cc b/source/blender/nodes/geometry/node_geometry_util.cc index a48477542d7..d3058349a12 100644 --- a/source/blender/nodes/geometry/node_geometry_util.cc +++ b/source/blender/nodes/geometry/node_geometry_util.cc @@ -21,9 +21,9 @@ std::optional node_data_type_to_custom_data_type(const eNodeSoc return CD_PROP_FLOAT; case SOCK_VECTOR: return CD_PROP_FLOAT3; - case SOCK_MATRIX3x3: + case SOCK_MATRIX_3X3: return CD_PROP_MATRIX3; - case SOCK_MATRIX4x4: + case SOCK_MATRIX_4X4: return CD_PROP_MATRIX4; case SOCK_RGBA: return CD_PROP_COLOR; diff --git a/source/blender/nodes/intern/node_socket.cc b/source/blender/nodes/intern/node_socket.cc index dddc81f4441..59527c70f49 100644 --- a/source/blender/nodes/intern/node_socket.cc +++ b/source/blender/nodes/intern/node_socket.cc @@ -79,20 +79,49 @@ struct bNodeSocket *node_add_socket_from_template(struct bNodeTree *ntree, dval->max = stemp->max; break; } - case SOCK_MATRIX3x3: { - bNodeSocketValueMatrix3x3 *dval = (bNodeSocketValueMatrix3x3 *)sock->default_value; - dval->value[0] = stemp->val1; - dval->value[1] = stemp->val2; - dval->value[2] = stemp->val3; + case SOCK_MATRIX_2X2: { + bNodeSocketValueMatrix2x2 *dval = (bNodeSocketValueMatrix2x2 *)sock->default_value; + dval->value[0][0] = stemp->val1; + dval->value[0][1] = 0.0f; + dval->value[1][0] = 0.0f; + dval->value[1][1] = stemp->val1; dval->min = stemp->min; dval->max = stemp->max; break; } - case SOCK_MATRIX4x4: { + case SOCK_MATRIX_3X3: { + bNodeSocketValueMatrix3x3 *dval = (bNodeSocketValueMatrix3x3 *)sock->default_value; + dval->value[0][0] = stemp->val1; + dval->value[0][1] = 0.0f; + dval->value[0][2] = 0.0f; + dval->value[1][0] = 0.0f; + dval->value[1][1] = stemp->val1; + dval->value[1][2] = 0.0f; + dval->value[2][0] = 0.0f; + dval->value[2][1] = 0.0f; + dval->value[2][2] = stemp->val1; + dval->min = stemp->min; + dval->max = stemp->max; + break; + } + case SOCK_MATRIX_4X4: { bNodeSocketValueMatrix4x4 *dval = (bNodeSocketValueMatrix4x4 *)sock->default_value; - dval->value[0] = stemp->val1; - dval->value[1] = stemp->val2; - dval->value[2] = stemp->val3; + dval->value[0][0] = stemp->val1; + dval->value[0][1] = 0.0f; + dval->value[0][2] = 0.0f; + dval->value[0][3] = 0.0f; + dval->value[1][0] = 0.0f; + dval->value[1][1] = stemp->val1; + dval->value[1][2] = 0.0f; + dval->value[1][3] = 0.0f; + dval->value[2][0] = 0.0f; + dval->value[2][1] = 0.0f; + dval->value[2][2] = stemp->val1; + dval->value[2][3] = 0.0f; + dval->value[3][0] = 0.0f; + dval->value[3][1] = 0.0f; + dval->value[3][2] = 0.0f; + dval->value[3][3] = stemp->val1; dval->min = stemp->min; dval->max = stemp->max; break; @@ -350,12 +379,22 @@ void node_socket_init_default_value(bNodeSocket *sock) sock->default_value = dval; break; } - case SOCK_MATRIX3x3: { + case SOCK_MATRIX_2X2: { + static float default_value[][2] = {{1.0f, 0.0f}, {0.0f, 1.0f}}; + bNodeSocketValueMatrix2x2 *dval = MEM_cnew( + "node socket value matrix 2x2"); + copy_m2_m2(dval->value, default_value); + dval->min = -FLT_MAX; + dval->max = FLT_MAX; + + sock->default_value = dval; + break; + } + case SOCK_MATRIX_3X3: { static float default_value[][3] = { {1.0f, 0.0f, 0.0f}, {0.0f, 1.0f, 0.0f}, {0.0f, 0.0f, 1.0f}}; bNodeSocketValueMatrix3x3 *dval = MEM_cnew( "node socket value matrix 3x3"); - dval->subtype = subtype; copy_m3_m3(dval->value, default_value); dval->min = -FLT_MAX; dval->max = FLT_MAX; @@ -363,14 +402,13 @@ void node_socket_init_default_value(bNodeSocket *sock) sock->default_value = dval; break; } - case SOCK_MATRIX4x4: { + case SOCK_MATRIX_4X4: { static float default_value[][4] = {{1.0f, 0.0f, 0.0f, 0.0f}, {0.0f, 1.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 1.0f, 0.0f}, {0.0f, 0.0f, 0.0f, 1.0f}}; bNodeSocketValueMatrix4x4 *dval = MEM_cnew( "node socket value vector"); - dval->subtype = subtype; copy_m4_m4(dval->value, default_value); dval->min = -FLT_MAX; dval->max = FLT_MAX; @@ -478,13 +516,19 @@ void node_socket_copy_default_value(bNodeSocket *to, const bNodeSocket *from) *toval = *fromval; break; } - case SOCK_MATRIX3x3: { + case SOCK_MATRIX_2X2: { + bNodeSocketValueMatrix2x2 *toval = (bNodeSocketValueMatrix2x2 *)to->default_value; + bNodeSocketValueMatrix2x2 *fromval = (bNodeSocketValueMatrix2x2 *)from->default_value; + *toval = *fromval; + break; + } + case SOCK_MATRIX_3X3: { bNodeSocketValueMatrix3x3 *toval = (bNodeSocketValueMatrix3x3 *)to->default_value; bNodeSocketValueMatrix3x3 *fromval = (bNodeSocketValueMatrix3x3 *)from->default_value; *toval = *fromval; break; } - case SOCK_MATRIX4x4: { + case SOCK_MATRIX_4X4: { bNodeSocketValueMatrix4x4 *toval = (bNodeSocketValueMatrix4x4 *)to->default_value; bNodeSocketValueMatrix4x4 *fromval = (bNodeSocketValueMatrix4x4 *)from->default_value; *toval = *fromval; @@ -650,18 +694,26 @@ static void standard_node_socket_interface_verify_socket(bNodeTree * /*ntree*/, toval->max = fromval->max; break; } - case SOCK_MATRIX3x3: { - bNodeSocketValueMatrix3x3 *toval = (bNodeSocketValueMatrix3x3 *)sock->default_value; - const bNodeSocketValueMatrix3x3 *fromval = (const bNodeSocketValueMatrix3x3 *) - interface_socket->default_value; + case SOCK_MATRIX_2X2: { + bNodeSocketValueMatrix2x2 *toval = (bNodeSocketValueMatrix2x2 *)sock->default_value; + const bNodeSocketValueMatrix2x2 *fromval = (const bNodeSocketValueMatrix2x2 *) + interface_socket->default_value; toval->min = fromval->min; toval->max = fromval->max; break; } - case SOCK_MATRIX4x4: { + case SOCK_MATRIX_3X3: { + bNodeSocketValueMatrix3x3 *toval = (bNodeSocketValueMatrix3x3 *)sock->default_value; + const bNodeSocketValueMatrix3x3 *fromval = (const bNodeSocketValueMatrix3x3 *) + interface_socket->default_value; + toval->min = fromval->min; + toval->max = fromval->max; + break; + } + case SOCK_MATRIX_4X4: { bNodeSocketValueMatrix4x4 *toval = (bNodeSocketValueMatrix4x4 *)sock->default_value; const bNodeSocketValueMatrix4x4 *fromval = (const bNodeSocketValueMatrix4x4 *) - interface_socket->default_value; + interface_socket->default_value; toval->min = fromval->min; toval->max = fromval->max; break; @@ -820,9 +872,9 @@ static bNodeSocketType *make_socket_type_vector(PropertySubType subtype) return socktype; } -static bNodeSocketType *make_socket_type_matrix3() +static bNodeSocketType *make_socket_type_matrix3x3() { - bNodeSocketType *socktype = make_standard_socket_type(SOCK_MATRIX3x3, PROP_MATRIX); + bNodeSocketType *socktype = make_standard_socket_type(SOCK_MATRIX_3X3, PROP_MATRIX); socktype->base_cpp_type = &blender::CPPType::get(); socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) { *(blender::float3x3 *)r_value = ((bNodeSocketValueMatrix3x3 *)socket.default_value)->value; @@ -836,9 +888,9 @@ static bNodeSocketType *make_socket_type_matrix3() return socktype; } -static bNodeSocketType *make_socket_type_matrix4() +static bNodeSocketType *make_socket_type_matrix4x4() { - bNodeSocketType *socktype = make_standard_socket_type(SOCK_MATRIX4x4, PROP_MATRIX); + bNodeSocketType *socktype = make_standard_socket_type(SOCK_MATRIX_4X4, PROP_MATRIX); socktype->base_cpp_type = &blender::CPPType::get(); socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) { *(blender::float4x4 *)r_value = ((bNodeSocketValueMatrix4x4 *)socket.default_value)->value; @@ -986,6 +1038,10 @@ void register_standard_node_socket_types() nodeRegisterSocketType(make_socket_type_vector(PROP_EULER)); nodeRegisterSocketType(make_socket_type_vector(PROP_XYZ)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_MATRIX_2X2, PROP_MATRIX)); + nodeRegisterSocketType(make_socket_type_matrix3x3()); + nodeRegisterSocketType(make_socket_type_matrix4x4()); + nodeRegisterSocketType(make_socket_type_rgba()); nodeRegisterSocketType(make_socket_type_string()); diff --git a/source/blender/nodes/intern/node_socket_declarations.cc b/source/blender/nodes/intern/node_socket_declarations.cc index f6263571824..aa23ac367f5 100644 --- a/source/blender/nodes/intern/node_socket_declarations.cc +++ b/source/blender/nodes/intern/node_socket_declarations.cc @@ -255,7 +255,7 @@ bNodeSocket &Vector::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket bNodeSocket &Matrix3x3::build(bNodeTree &ntree, bNode &node) const { bNodeSocket &socket = *nodeAddStaticSocket( - &ntree, &node, in_out_, SOCK_MATRIX3x3, PROP_MATRIX, identifier_.c_str(), name_.c_str()); + &ntree, &node, in_out_, SOCK_MATRIX_3X3, PROP_MATRIX, identifier_.c_str(), name_.c_str()); this->set_common_flags(socket); bNodeSocketValueMatrix3x3 &value = *(bNodeSocketValueMatrix3x3 *)socket.default_value; copy_m3_m3(value.value, default_value_.ptr()); @@ -269,7 +269,7 @@ bool Matrix3x3::matches(const bNodeSocket &socket) const if (!this->matches_common_data(socket)) { return false; } - if (socket.type != SOCK_MATRIX3x3) { + if (socket.type != SOCK_MATRIX_3X3) { return false; } return true; @@ -277,12 +277,12 @@ bool Matrix3x3::matches(const bNodeSocket &socket) const bool Matrix3x3::can_connect(const bNodeSocket &socket) const { - return sockets_can_connect(*this, socket) && socket.type == SOCK_MATRIX3x3; + return sockets_can_connect(*this, socket) && socket.type == SOCK_MATRIX_3X3; } bNodeSocket &Matrix3x3::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket &socket) const { - if (socket.type != SOCK_MATRIX3x3) { + if (socket.type != SOCK_MATRIX_3X3) { BLI_assert(socket.in_out == in_out_); return this->build(ntree, node); } @@ -301,7 +301,7 @@ bNodeSocket &Matrix3x3::update_or_build(bNodeTree &ntree, bNode &node, bNodeSock bNodeSocket &Matrix4x4::build(bNodeTree &ntree, bNode &node) const { bNodeSocket &socket = *nodeAddStaticSocket( - &ntree, &node, in_out_, SOCK_MATRIX4x4, PROP_MATRIX, identifier_.c_str(), name_.c_str()); + &ntree, &node, in_out_, SOCK_MATRIX_4X4, PROP_MATRIX, identifier_.c_str(), name_.c_str()); this->set_common_flags(socket); bNodeSocketValueMatrix4x4 &value = *(bNodeSocketValueMatrix4x4 *)socket.default_value; copy_m4_m4(value.value, default_value_.ptr()); @@ -315,7 +315,7 @@ bool Matrix4x4::matches(const bNodeSocket &socket) const if (!this->matches_common_data(socket)) { return false; } - if (socket.type != SOCK_MATRIX4x4) { + if (socket.type != SOCK_MATRIX_4X4) { return false; } return true; @@ -323,12 +323,12 @@ bool Matrix4x4::matches(const bNodeSocket &socket) const bool Matrix4x4::can_connect(const bNodeSocket &socket) const { - return sockets_can_connect(*this, socket) && socket.type == SOCK_MATRIX4x4; + return sockets_can_connect(*this, socket) && socket.type == SOCK_MATRIX_4X4; } bNodeSocket &Matrix4x4::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket &socket) const { - if (socket.type != SOCK_MATRIX4x4) { + if (socket.type != SOCK_MATRIX_4X4) { BLI_assert(socket.in_out == in_out_); return this->build(ntree, node); } -- 2.30.2 From 726ad272aa08b2eb497f05c5cfc3a5b68a22d1fd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Sat, 10 Dec 2022 00:00:55 +0000 Subject: [PATCH 05/33] Implementation of the input, combine and separate nodes for matrix_4x4. --- source/blender/blenkernel/BKE_node.h | 8 +- source/blender/makesdna/DNA_node_types.h | 28 ++ source/blender/makesrna/intern/rna_nodetree.c | 110 +++++++ source/blender/nodes/NOD_static_types.h | 8 +- .../nodes/function/node_function_register.cc | 4 + .../nodes/function/node_function_register.hh | 4 + .../function/nodes/node_fn_combine_matrix.cc | 200 ++++++++---- .../function/nodes/node_fn_input_matrix.cc | 144 ++++----- .../function/nodes/node_fn_matrix_math.cc | 12 +- .../function/nodes/node_fn_separate_matrix.cc | 291 ++++++++++++++---- 10 files changed, 603 insertions(+), 206 deletions(-) diff --git a/source/blender/blenkernel/BKE_node.h b/source/blender/blenkernel/BKE_node.h index 9173ccd1f63..86be7f21844 100644 --- a/source/blender/blenkernel/BKE_node.h +++ b/source/blender/blenkernel/BKE_node.h @@ -1567,10 +1567,10 @@ struct TexResult; #define FN_NODE_INPUT_INT 1220 #define FN_NODE_SEPARATE_COLOR 1221 #define FN_NODE_COMBINE_COLOR 1222 -#define FN_NODE_INPUT_MATRIX 1223 -#define FN_NODE_SEPARATE_MATRIX 1224 -#define FN_NODE_COMBINE_MATRIX 1225 -#define FN_NODE_MATRIX_MATH 1226 +#define FN_NODE_INPUT_MATRIX_4X4 1223 +#define FN_NODE_SEPARATE_MATRIX_4X4 1224 +#define FN_NODE_COMBINE_MATRIX_4X4 1225 +#define FN_NODE_MATRIX_4X4_MATH 1226 /** \} */ diff --git a/source/blender/makesdna/DNA_node_types.h b/source/blender/makesdna/DNA_node_types.h index 522d031658e..bbc38874394 100644 --- a/source/blender/makesdna/DNA_node_types.h +++ b/source/blender/makesdna/DNA_node_types.h @@ -1599,6 +1599,14 @@ typedef struct NodeShaderMix { char _pad[3]; } NodeShaderMix; +typedef struct NodeInputMatrix { + float vec0[3]; + float vec1[3]; + float vec2[3]; + float vec3[3]; + float elements[4][4]; +} NodeInputMatrix; + /* script node mode */ #define NODE_SCRIPT_INTERNAL 0 #define NODE_SCRIPT_EXTERNAL 1 @@ -1873,6 +1881,20 @@ typedef enum NodeVectorMathOperation { NODE_VECTOR_MATH_MULTIPLY_ADD = 26, } NodeVectorMathOperation; +typedef enum NodeMatrixMathOperation { + NODE_MATRIX_MATH_ADD = 0, + NODE_MATRIX_MATH_SUBTRACT = 1, + NODE_MATRIX_MATH_SCALAR_MULTIPLY = 2, + NODE_MATRIX_MATH_MULTIPLY = 3, + NODE_MATRIX_MATH_TRANSPOSE = 4, + NODE_MATRIX_MATH_INVERSE = 5, + NODE_MATRIX_MATH_DETERMINANT = 6, + NODE_MATRIX_MATH_TRACE = 7, + NODE_MATRIX_MATH_IS_SYMMETRIC = 8, + NODE_MATRIX_MATH_IS_ANTI_SYMMETRIC = 9, + NODE_MATRIX_MATH_IS_ORTHOGONAL = 10, +} NodeMatrixMathOperation; + typedef enum NodeBooleanMathOperation { NODE_BOOLEAN_MATH_AND = 0, NODE_BOOLEAN_MATH_OR = 1, @@ -2367,3 +2389,9 @@ typedef enum NodeCombSepColorMode { NODE_COMBSEP_COLOR_HSV = 1, NODE_COMBSEP_COLOR_HSL = 2, } NodeCombSepColorMode; + +typedef enum NodeCombSepMatrixMode { + NODE_COMBSEP_MATRIX_COLUMNS = 0, + NODE_COMBSEP_MATRIX_ROWS = 1, + NODE_COMBSEP_MATRIX_ELEMENTS = 2, +} NodeCombSepMatrixMode; diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c index cabe05affd2..d5f59efbab8 100644 --- a/source/blender/makesrna/intern/rna_nodetree.c +++ b/source/blender/makesrna/intern/rna_nodetree.c @@ -294,6 +294,24 @@ const EnumPropertyItem rna_enum_node_vec_math_items[] = { {0, NULL, 0, NULL, NULL}, }; +const EnumPropertyItem rna_enum_node_matrix_math_items[] = { + {NODE_MATRIX_MATH_ADD, "ADD", 0, "Add", ""}, + {NODE_MATRIX_MATH_SUBTRACT, "SUBTRACT", 0, "Subtract", ""}, + {NODE_MATRIX_MATH_SCALAR_MULTIPLY, "SCALAR_MULTIPLY", 0, "Scalar Multiply", ""}, + {NODE_MATRIX_MATH_MULTIPLY, "MULTIPLY", 0, "Multiply", ""}, + RNA_ENUM_ITEM_SEPR, + {NODE_MATRIX_MATH_TRANSPOSE, "TRANSPOSE", 0, "Transpose", ""}, + {NODE_MATRIX_MATH_INVERSE, "INVERSE", 0, "Inverse", ""}, + RNA_ENUM_ITEM_SEPR, + {NODE_MATRIX_MATH_DETERMINANT, "DETERMINANT", 0, "Determinant", ""}, + {NODE_MATRIX_MATH_TRACE, "TRACE", 0, "Trace", ""}, + RNA_ENUM_ITEM_SEPR, + {NODE_MATRIX_MATH_IS_SYMMETRIC, "IS_SYMMETRIC", 0, "Is Symmetric", ""}, + {NODE_MATRIX_MATH_IS_ANTI_SYMMETRIC, "IS_ANTI_SYMMETRIC", 0, "Is Anti-Symmetric", ""}, + {NODE_MATRIX_MATH_IS_ORTHOGONAL, "IS_ORTHOGONAL", 0, "Is Orthogonal", ""}, + {0, NULL, 0, NULL, NULL}, +}; + const EnumPropertyItem rna_enum_node_boolean_math_items[] = { {NODE_BOOLEAN_MATH_AND, "AND", 0, "And", "True when both inputs are true"}, {NODE_BOOLEAN_MATH_OR, "OR", 0, "Or", "True when at least one input is true"}, @@ -505,6 +523,13 @@ static const EnumPropertyItem rna_node_combsep_color_items[] = { {0, NULL, 0, NULL, NULL}, }; +static const EnumPropertyItem rna_node_combsep_matrix_items[] = { + {NODE_COMBSEP_MATRIX_COLUMNS, "COLUMNS", ICON_NONE, "Columns", "Use vectors as matrix columns"}, + {NODE_COMBSEP_MATRIX_ROWS, "ROWS", ICON_NONE, "Rows", "Use vectors as matrix rows"}, + {NODE_COMBSEP_MATRIX_ELEMENTS, "ELEMENTS", ICON_NONE, "Elements", "Use individual matrix elements"}, + {0, NULL, 0, NULL, NULL}, +}; + #ifndef RNA_RUNTIME static const EnumPropertyItem node_sampler_type_items[] = { {0, "NEAREST", 0, "Nearest", ""}, @@ -5179,6 +5204,91 @@ static void def_fn_combsep_color(StructRNA *srna) RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } +static void def_fn_input_matrix_4x4(StructRNA *srna) +{ + static const float default_vec0[] = {1.0f, 0.0f, 0.0f}; + static const float default_vec1[] = {0.0f, 1.0f, 0.0f}; + static const float default_vec2[] = {0.0f, 0.0f, 1.0f}; + static const float default_elements[] = { + 1.0f, + 0.0f, + 0.0f, + 0.0f, + 0.0f, + 1.0f, + 0.0f, + 0.0f, + 0.0f, + 0.0f, + 1.0f, + 0.0f, + 0.0f, + 0.0f, + 0.0f, + 1.0f, + }; + PropertyRNA *prop; + + prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); + RNA_def_property_enum_sdna(prop, NULL, "custom1"); + RNA_def_property_enum_items(prop, rna_node_combsep_matrix_items); + RNA_def_property_ui_text(prop, "Mode", "Mode of matrix composition"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); + RNA_def_struct_sdna_from(srna, "NodeInputInt", "storage"); + + RNA_def_struct_sdna_from(srna, "NodeInputMatrix", "storage"); + + prop = RNA_def_property(srna, "vec0", PROP_FLOAT, PROP_NONE); + RNA_def_property_float_sdna(prop, NULL, "vec0"); + RNA_def_property_array(prop, 3); + RNA_def_property_float_array_default(prop, default_vec0); + RNA_def_property_ui_text(prop, "Vector 0", "Row or column vector"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); + + prop = RNA_def_property(srna, "vec1", PROP_FLOAT, PROP_NONE); + RNA_def_property_float_sdna(prop, NULL, "vec1"); + RNA_def_property_array(prop, 3); + RNA_def_property_float_array_default(prop, default_vec0); + RNA_def_property_ui_text(prop, "Vector 1", "Row or column vector"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); + + prop = RNA_def_property(srna, "vec2", PROP_FLOAT, PROP_NONE); + RNA_def_property_float_sdna(prop, NULL, "vec2"); + RNA_def_property_array(prop, 3); + RNA_def_property_float_array_default(prop, default_vec0); + RNA_def_property_ui_text(prop, "Vector 2", "Row or column vector"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); + + prop = RNA_def_property(srna, "elements", PROP_FLOAT, PROP_MATRIX); + RNA_def_property_float_sdna(prop, NULL, "elements"); + RNA_def_property_array(prop, 16); + RNA_def_property_float_array_default(prop, default_elements); + RNA_def_property_ui_text(prop, "Integer", "Input value used for unconnected socket"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); +} + +static void def_fn_combsep_matrix(StructRNA *srna) +{ + PropertyRNA *prop; + + prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); + RNA_def_property_enum_sdna(prop, NULL, "custom1"); + RNA_def_property_enum_items(prop, rna_node_combsep_matrix_items); + RNA_def_property_ui_text(prop, "Mode", "Mode of matrix composition"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); +} + +static void def_fn_matrix_4x4_math(StructRNA *srna) +{ + PropertyRNA *prop; + + prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE); + RNA_def_property_enum_sdna(prop, NULL, "custom1"); + RNA_def_property_enum_items(prop, rna_enum_node_matrix_math_items); + RNA_def_property_ui_text(prop, "Operation", ""); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNode_socket_update"); +} + /* -- Shader Nodes ---------------------------------------------------------- */ static void def_sh_output(StructRNA *srna) diff --git a/source/blender/nodes/NOD_static_types.h b/source/blender/nodes/NOD_static_types.h index d40670d704d..90ea65171bd 100644 --- a/source/blender/nodes/NOD_static_types.h +++ b/source/blender/nodes/NOD_static_types.h @@ -279,10 +279,10 @@ DefNode(FunctionNode, FN_NODE_SEPARATE_COLOR, def_fn_combsep_color, "SEPARATE_CO DefNode(FunctionNode, FN_NODE_SLICE_STRING, 0, "SLICE_STRING", SliceString, "Slice String", "") DefNode(FunctionNode, FN_NODE_STRING_LENGTH, 0, "STRING_LENGTH", StringLength, "String Length", "") DefNode(FunctionNode, FN_NODE_VALUE_TO_STRING, 0, "VALUE_TO_STRING", ValueToString, "Value to String", "") -DefNode(FunctionNode, FN_NODE_INPUT_MATRIX, 0, "INPUT_MATRIX", InputMatrix, "Matrix", "") -DefNode(FunctionNode, FN_NODE_SEPARATE_MATRIX, 0, "SEPARATE_MATRIX", SeparateMatrix, "Separate Matrix", "") -DefNode(FunctionNode, FN_NODE_COMBINE_MATRIX, 0, "COMBINE_MATRIX", CombineMatrix, "Combine Matrix", "") -DefNode(FunctionNode, FN_NODE_MATRIX_MATH, 0, "MATRIX_MATH", MatrixMath, "Matrix Math", "") +DefNode(FunctionNode, FN_NODE_INPUT_MATRIX_4X4, def_fn_input_matrix_4x4, "INPUT_MATRIX_4X4", InputMatrix, "4x4 Matrix", "") +DefNode(FunctionNode, FN_NODE_SEPARATE_MATRIX_4X4, def_fn_combsep_matrix, "SEPARATE_MATRIX_4X4", SeparateMatrix, "Separate 4x4 Matrix", "") +DefNode(FunctionNode, FN_NODE_COMBINE_MATRIX_4X4, def_fn_combsep_matrix, "COMBINE_MATRIX_4X4", CombineMatrix, "Combine 4x4 Matrix", "") +DefNode(FunctionNode, FN_NODE_MATRIX_4X4_MATH, def_fn_matrix_4x4_math, "MATRIX_4X4_MATH", MatrixMath, "4x4 Matrix Math", "") DefNode(GeometryNode, GEO_NODE_ACCUMULATE_FIELD, def_geo_accumulate_field, "ACCUMULATE_FIELD", AccumulateField, "Accumulate Field", "Add the values of an evaluated field together and output the running total for each element") DefNode(GeometryNode, GEO_NODE_ATTRIBUTE_DOMAIN_SIZE, def_geo_attribute_domain_size, "ATTRIBUTE_DOMAIN_SIZE", AttributeDomainSize, "Domain Size", "Retrieve the number of elements in a geometry for each attribute domain") diff --git a/source/blender/nodes/function/node_function_register.cc b/source/blender/nodes/function/node_function_register.cc index 8c5ce489832..9d0de0c6807 100644 --- a/source/blender/nodes/function/node_function_register.cc +++ b/source/blender/nodes/function/node_function_register.cc @@ -9,18 +9,22 @@ void register_function_nodes() register_node_type_fn_align_euler_to_vector(); register_node_type_fn_boolean_math(); register_node_type_fn_combine_color(); + register_node_type_fn_combine_matrix_4x4(); register_node_type_fn_compare(); register_node_type_fn_float_to_int(); register_node_type_fn_input_bool(); register_node_type_fn_input_color(); register_node_type_fn_input_int(); + register_node_type_fn_input_matrix_4x4(); register_node_type_fn_input_special_characters(); register_node_type_fn_input_string(); register_node_type_fn_input_vector(); + register_node_type_fn_matrix_4x4_math(); register_node_type_fn_random_value(); register_node_type_fn_replace_string(); register_node_type_fn_rotate_euler(); register_node_type_fn_separate_color(); + register_node_type_fn_separate_matrix_4x4(); register_node_type_fn_slice_string(); register_node_type_fn_string_length(); register_node_type_fn_value_to_string(); diff --git a/source/blender/nodes/function/node_function_register.hh b/source/blender/nodes/function/node_function_register.hh index 7f3e7c1cd8c..4104dd983c1 100644 --- a/source/blender/nodes/function/node_function_register.hh +++ b/source/blender/nodes/function/node_function_register.hh @@ -5,18 +5,22 @@ void register_node_type_fn_align_euler_to_vector(); void register_node_type_fn_boolean_math(); void register_node_type_fn_combine_color(); +void register_node_type_fn_combine_matrix_4x4(); void register_node_type_fn_compare(); void register_node_type_fn_float_to_int(); void register_node_type_fn_input_bool(); void register_node_type_fn_input_color(); void register_node_type_fn_input_int(); +void register_node_type_fn_input_matrix_4x4(); void register_node_type_fn_input_special_characters(); void register_node_type_fn_input_string(); void register_node_type_fn_input_vector(); +void register_node_type_fn_matrix_4x4_math(); void register_node_type_fn_random_value(); void register_node_type_fn_replace_string(); void register_node_type_fn_rotate_euler(); void register_node_type_fn_separate_color(); +void register_node_type_fn_separate_matrix_4x4(); void register_node_type_fn_slice_string(); void register_node_type_fn_string_length(); void register_node_type_fn_value_to_string(); diff --git a/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc b/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc index 318c8997f9a..9f0e50b7668 100644 --- a/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc @@ -5,30 +5,32 @@ #include "UI_interface.h" #include "UI_resources.h" -namespace blender::nodes::node_fn_combine_color_cc { - -NODE_STORAGE_FUNCS(NodeCombSepColor) +namespace blender::nodes::node_fn_combine_matrix4x4_cc { static void node_declare(NodeDeclarationBuilder &b) { b.is_function_node(); - b.add_input(N_("Red")).default_value(0.0f).min(0.0f).max(1.0f).subtype(PROP_FACTOR); - b.add_input(N_("Green")) - .default_value(0.0f) - .min(0.0f) - .max(1.0f) - .subtype(PROP_FACTOR); - b.add_input(N_("Blue")) - .default_value(0.0f) - .min(0.0f) - .max(1.0f) - .subtype(PROP_FACTOR); - b.add_input(N_("Alpha")) - .default_value(1.0f) - .min(0.0f) - .max(1.0f) - .subtype(PROP_FACTOR); - b.add_output(N_("Color")); + b.add_input(N_("Vec0")).default_value({1.0f, 0.0f, 0.0f}); + b.add_input(N_("Vec1")).default_value({0.0f, 1.0f, 0.0f}); + b.add_input(N_("Vec2")).default_value({0.0f, 0.0f, 1.0f}); + b.add_input(N_("Vec3")).default_value({0.0f, 0.0f, 0.0f}); + b.add_input(N_("Row 0 Col 0")).default_value(1.0f); + b.add_input(N_("Row 1 Col 0")).default_value(0.0f); + b.add_input(N_("Row 2 Col 0")).default_value(0.0f); + b.add_input(N_("Row 3 Col 0")).default_value(0.0f); + b.add_input(N_("Row 0 Col 1")).default_value(0.0f); + b.add_input(N_("Row 1 Col 1")).default_value(1.0f); + b.add_input(N_("Row 2 Col 1")).default_value(0.0f); + b.add_input(N_("Row 3 Col 1")).default_value(0.0f); + b.add_input(N_("Row 0 Col 2")).default_value(0.0f); + b.add_input(N_("Row 1 Col 2")).default_value(0.0f); + b.add_input(N_("Row 2 Col 2")).default_value(1.0f); + b.add_input(N_("Row 3 Col 2")).default_value(0.0f); + b.add_input(N_("Row 0 Col 3")).default_value(0.0f); + b.add_input(N_("Row 1 Col 3")).default_value(0.0f); + b.add_input(N_("Row 2 Col 3")).default_value(0.0f); + b.add_input(N_("Row 3 Col 3")).default_value(1.0f); + b.add_output(N_("Matrix")); }; static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) @@ -36,47 +38,137 @@ static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) uiItemR(layout, ptr, "mode", 0, "", ICON_NONE); } -static void node_update(bNodeTree * /*tree*/, bNode *node) +static void node_update(bNodeTree *tree, bNode *node) { - const NodeCombSepColor &storage = node_storage(*node); - node_combsep_color_label(&node->inputs, (NodeCombSepColorMode)storage.mode); + const NodeCombSepMatrixMode mode = (NodeCombSepMatrixMode)node->custom1; + + const IndexRange vector_sockets(0, 4); + const IndexRange scalar_sockets(4, 16); + const bool show_vector_sockets = ELEM( + mode, NODE_COMBSEP_MATRIX_COLUMNS, NODE_COMBSEP_MATRIX_ROWS); + const bool show_scalar_sockets = ELEM(mode, NODE_COMBSEP_MATRIX_ELEMENTS); + + for (const int i : vector_sockets) { + nodeSetSocketAvailability(tree, &node->input_socket(i), show_vector_sockets); + } + for (const int i : scalar_sockets) { + nodeSetSocketAvailability(tree, &node->input_socket(i), show_scalar_sockets); + } + + switch (mode) { + case NODE_COMBSEP_MATRIX_COLUMNS: + node_sock_label(&node->input_socket(vector_sockets[0]), "Column 0"); + node_sock_label(&node->input_socket(vector_sockets[1]), "Column 1"); + node_sock_label(&node->input_socket(vector_sockets[2]), "Column 2"); + node_sock_label(&node->input_socket(vector_sockets[3]), "Column 3"); + break; + case NODE_COMBSEP_MATRIX_ROWS: + node_sock_label(&node->input_socket(vector_sockets[0]), "Row 0"); + node_sock_label(&node->input_socket(vector_sockets[1]), "Row 1"); + node_sock_label(&node->input_socket(vector_sockets[2]), "Row 2"); + node_sock_label(&node->input_socket(vector_sockets[3]), "Row 3"); + break; + case NODE_COMBSEP_MATRIX_ELEMENTS: + break; + } } static void node_init(bNodeTree * /*tree*/, bNode *node) { - NodeCombSepColor *data = MEM_cnew(__func__); - data->mode = NODE_COMBSEP_COLOR_RGB; - node->storage = data; + node->custom1 = NODE_COMBSEP_MATRIX_COLUMNS; } static const fn::MultiFunction *get_multi_function(const bNode &bnode) { - const NodeCombSepColor &storage = node_storage(bnode); + const NodeCombSepMatrixMode mode = (NodeCombSepMatrixMode)bnode.custom1; - static fn::CustomMF_SI_SI_SI_SI_SO rgba_fn{ - "RGB", [](float r, float g, float b, float a) { return ColorGeometry4f(r, g, b, a); }}; - static fn::CustomMF_SI_SI_SI_SI_SO hsva_fn{ - "HSV", [](float h, float s, float v, float a) { - ColorGeometry4f r_color; - hsv_to_rgb(h, s, v, &r_color.r, &r_color.g, &r_color.b); - r_color.a = a; - return r_color; - }}; - static fn::CustomMF_SI_SI_SI_SI_SO hsla_fn{ - "HSL", [](float h, float s, float l, float a) { - ColorGeometry4f color; - hsl_to_rgb(h, s, l, &color.r, &color.g, &color.b); - color.a = a; - return color; + static fn::CustomMF_SI_SI_SI_SI_SO + columns_to_matrix_fn{ + "columns_to_matrix", + [](const float3 &c0, const float3 &c1, const float3 &c2, const float3 &c3) { + float4x4 m; + copy_v3_v3(m[0], c0); + m[0][3] = 0.0f; + copy_v3_v3(m[1], c1); + m[1][3] = 0.0f; + copy_v3_v3(m[2], c2); + m[2][3] = 0.0f; + copy_v3_v3(m[3], c3); + m[3][3] = 1.0f; + return m; + }}; + static fn::CustomMF_SI_SI_SI_SI_SO rows_to_matrix_fn{ + "rows_to_matrix", + [](const float3 &r0, const float3 &r1, const float3 &r2, const float3 &r3) { + float4x4 m; + m[0][0] = r0[0]; + m[0][1] = r1[0]; + m[0][2] = r2[0]; + m[0][3] = 0.0f; + m[1][0] = r0[1]; + m[1][1] = r1[1]; + m[1][2] = r2[1]; + m[1][3] = 0.0f; + m[2][0] = r0[2]; + m[2][1] = r1[2]; + m[2][2] = r2[2]; + m[2][3] = 0.0f; + m[3][0] = r0[3]; + m[3][1] = r1[3]; + m[3][2] = r2[3]; + m[3][3] = 1.0f; + return m; }}; + using Element = fn::MFParamTag; + using Matrix = fn::MFParamTag; + static fn::CustomMF + elements_to_matrix_fn{ + "elements_to_matrix", + [](float m00, + float m01, + float m02, + float m03, + float m10, + float m11, + float m12, + float m13, + float m20, + float m21, + float m22, + float m23, + float m30, + float m31, + float m32, + float m33, + float4x4 &result) { + const float elements[] = { + m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33}; + result = float4x4(elements); + }}; - switch (storage.mode) { - case NODE_COMBSEP_COLOR_RGB: - return &rgba_fn; - case NODE_COMBSEP_COLOR_HSV: - return &hsva_fn; - case NODE_COMBSEP_COLOR_HSL: - return &hsla_fn; + switch (mode) { + case NODE_COMBSEP_MATRIX_COLUMNS: + return &columns_to_matrix_fn; + case NODE_COMBSEP_MATRIX_ROWS: + return &rows_to_matrix_fn; + case NODE_COMBSEP_MATRIX_ELEMENTS: + return &elements_to_matrix_fn; } BLI_assert_unreachable(); @@ -89,20 +181,18 @@ static void node_build_multi_function(NodeMultiFunctionBuilder &builder) builder.set_matching_fn(fn); } -} // namespace blender::nodes::node_fn_combine_color_cc +} // namespace blender::nodes::node_fn_combine_matrix4x4_cc -void register_node_type_fn_combine_color(void) +void register_node_type_fn_combine_matrix_4x4(void) { - namespace file_ns = blender::nodes::node_fn_combine_color_cc; + namespace file_ns = blender::nodes::node_fn_combine_matrix4x4_cc; static bNodeType ntype; - fn_node_type_base(&ntype, FN_NODE_COMBINE_COLOR, "Combine Color", NODE_CLASS_CONVERTER); + fn_node_type_base(&ntype, FN_NODE_COMBINE_MATRIX_4X4, "Combine 4x4 Matrix", NODE_CLASS_CONVERTER); ntype.declare = file_ns::node_declare; ntype.updatefunc = file_ns::node_update; ntype.initfunc = file_ns::node_init; - node_type_storage( - &ntype, "NodeCombSepColor", node_free_standard_storage, node_copy_standard_storage); ntype.build_multi_function = file_ns::node_build_multi_function; ntype.draw_buttons = file_ns::node_layout; diff --git a/source/blender/nodes/function/nodes/node_fn_input_matrix.cc b/source/blender/nodes/function/nodes/node_fn_input_matrix.cc index 318c8997f9a..aa596aaeb92 100644 --- a/source/blender/nodes/function/nodes/node_fn_input_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_input_matrix.cc @@ -5,104 +5,106 @@ #include "UI_interface.h" #include "UI_resources.h" -namespace blender::nodes::node_fn_combine_color_cc { +namespace blender::nodes::node_fn_input_matrix4x4_cc { -NODE_STORAGE_FUNCS(NodeCombSepColor) +NODE_STORAGE_FUNCS(NodeInputMatrix); static void node_declare(NodeDeclarationBuilder &b) { - b.is_function_node(); - b.add_input(N_("Red")).default_value(0.0f).min(0.0f).max(1.0f).subtype(PROP_FACTOR); - b.add_input(N_("Green")) - .default_value(0.0f) - .min(0.0f) - .max(1.0f) - .subtype(PROP_FACTOR); - b.add_input(N_("Blue")) - .default_value(0.0f) - .min(0.0f) - .max(1.0f) - .subtype(PROP_FACTOR); - b.add_input(N_("Alpha")) - .default_value(1.0f) - .min(0.0f) - .max(1.0f) - .subtype(PROP_FACTOR); - b.add_output(N_("Color")); + b.add_output(N_("Matrix")); }; static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) { - uiItemR(layout, ptr, "mode", 0, "", ICON_NONE); -} + const bNode *node = (const bNode *)ptr->data; + const NodeCombSepMatrixMode mode = (NodeCombSepMatrixMode)node->custom1; -static void node_update(bNodeTree * /*tree*/, bNode *node) -{ - const NodeCombSepColor &storage = node_storage(*node); - node_combsep_color_label(&node->inputs, (NodeCombSepColorMode)storage.mode); + uiItemR(layout, ptr, "mode", 0, "", ICON_NONE); + + switch (mode) { + case NODE_COMBSEP_MATRIX_COLUMNS: + uiItemR(layout, ptr, "vec0", 0, "Column 0", ICON_NONE); + uiItemR(layout, ptr, "vec1", 0, "Column 1", ICON_NONE); + uiItemR(layout, ptr, "vec2", 0, "Column 2", ICON_NONE); + uiItemR(layout, ptr, "vec3", 0, "Column 3", ICON_NONE); + break; + case NODE_COMBSEP_MATRIX_ROWS: + uiItemR(layout, ptr, "vec0", 0, "Row 0", ICON_NONE); + uiItemR(layout, ptr, "vec1", 0, "Row 1", ICON_NONE); + uiItemR(layout, ptr, "vec2", 0, "Row 2", ICON_NONE); + uiItemR(layout, ptr, "vec3", 0, "Row 3", ICON_NONE); + break; + case NODE_COMBSEP_MATRIX_ELEMENTS: + uiItemR(layout, ptr, "elements", 0, "", ICON_NONE); + break; + } } static void node_init(bNodeTree * /*tree*/, bNode *node) { - NodeCombSepColor *data = MEM_cnew(__func__); - data->mode = NODE_COMBSEP_COLOR_RGB; + node->custom1 = NODE_COMBSEP_MATRIX_COLUMNS; + + NodeInputMatrix *data = MEM_new(__func__); + copy_v3_v3(data->vec0, float3(1.0f, 0.0f, 0.0f)); + copy_v3_v3(data->vec1, float3(0.0f, 1.0f, 0.0f)); + copy_v3_v3(data->vec2, float3(0.0f, 0.0f, 1.0f)); + copy_v3_v3(data->vec3, float3(0.0f, 0.0f, 0.0f)); + unit_m4(data->elements); node->storage = data; } -static const fn::MultiFunction *get_multi_function(const bNode &bnode) -{ - const NodeCombSepColor &storage = node_storage(bnode); - - static fn::CustomMF_SI_SI_SI_SI_SO rgba_fn{ - "RGB", [](float r, float g, float b, float a) { return ColorGeometry4f(r, g, b, a); }}; - static fn::CustomMF_SI_SI_SI_SI_SO hsva_fn{ - "HSV", [](float h, float s, float v, float a) { - ColorGeometry4f r_color; - hsv_to_rgb(h, s, v, &r_color.r, &r_color.g, &r_color.b); - r_color.a = a; - return r_color; - }}; - static fn::CustomMF_SI_SI_SI_SI_SO hsla_fn{ - "HSL", [](float h, float s, float l, float a) { - ColorGeometry4f color; - hsl_to_rgb(h, s, l, &color.r, &color.g, &color.b); - color.a = a; - return color; - }}; - - switch (storage.mode) { - case NODE_COMBSEP_COLOR_RGB: - return &rgba_fn; - case NODE_COMBSEP_COLOR_HSV: - return &hsva_fn; - case NODE_COMBSEP_COLOR_HSL: - return &hsla_fn; - } - - BLI_assert_unreachable(); - return nullptr; -} - static void node_build_multi_function(NodeMultiFunctionBuilder &builder) { - const fn::MultiFunction *fn = get_multi_function(builder.node()); - builder.set_matching_fn(fn); + const NodeInputMatrix &storage = node_storage(builder.node()); + const NodeCombSepMatrixMode mode = (NodeCombSepMatrixMode)builder.node().custom1; + float4x4 matrix; + switch (mode) { + case NODE_COMBSEP_MATRIX_COLUMNS: + copy_v3_v3(matrix[0], storage.vec0); + matrix[0][3] = 0.0f; + copy_v3_v3(matrix[1], storage.vec1); + matrix[1][3] = 0.0f; + copy_v3_v3(matrix[2], storage.vec2); + matrix[2][3] = 0.0f; + copy_v3_v3(matrix[3], storage.vec3); + matrix[3][3] = 1.0f; + break; + case NODE_COMBSEP_MATRIX_ROWS: + matrix[0][0] = storage.vec0[0]; + matrix[0][1] = storage.vec1[0]; + matrix[0][2] = storage.vec2[0]; + matrix[0][3] = 0.0f; + matrix[1][0] = storage.vec0[1]; + matrix[1][1] = storage.vec1[1]; + matrix[1][2] = storage.vec2[1]; + matrix[1][3] = 0.0f; + matrix[2][0] = storage.vec0[2]; + matrix[2][1] = storage.vec1[2]; + matrix[2][2] = storage.vec2[2]; + matrix[2][3] = 0.0f; + matrix[3][0] = storage.vec0[3]; + matrix[3][1] = storage.vec1[3]; + matrix[3][2] = storage.vec2[3]; + matrix[3][3] = 1.0f; + break; + case NODE_COMBSEP_MATRIX_ELEMENTS: + matrix = float4x4(storage.elements); + break; + } + builder.construct_and_set_matching_fn>(matrix); } -} // namespace blender::nodes::node_fn_combine_color_cc +} // namespace blender::nodes::node_fn_input_matrix4x4_cc -void register_node_type_fn_combine_color(void) +void register_node_type_fn_input_matrix_4x4(void) { - namespace file_ns = blender::nodes::node_fn_combine_color_cc; + namespace file_ns = blender::nodes::node_fn_input_matrix4x4_cc; static bNodeType ntype; - fn_node_type_base(&ntype, FN_NODE_COMBINE_COLOR, "Combine Color", NODE_CLASS_CONVERTER); + fn_node_type_base(&ntype, FN_NODE_INPUT_MATRIX_4X4, "4x4 Matrix", NODE_CLASS_INPUT); ntype.declare = file_ns::node_declare; - ntype.updatefunc = file_ns::node_update; ntype.initfunc = file_ns::node_init; - node_type_storage( - &ntype, "NodeCombSepColor", node_free_standard_storage, node_copy_standard_storage); ntype.build_multi_function = file_ns::node_build_multi_function; ntype.draw_buttons = file_ns::node_layout; diff --git a/source/blender/nodes/function/nodes/node_fn_matrix_math.cc b/source/blender/nodes/function/nodes/node_fn_matrix_math.cc index 318c8997f9a..633d7126840 100644 --- a/source/blender/nodes/function/nodes/node_fn_matrix_math.cc +++ b/source/blender/nodes/function/nodes/node_fn_matrix_math.cc @@ -5,7 +5,7 @@ #include "UI_interface.h" #include "UI_resources.h" -namespace blender::nodes::node_fn_combine_color_cc { +namespace blender::nodes::node_fn_matrix4x4_math_cc { NODE_STORAGE_FUNCS(NodeCombSepColor) @@ -89,20 +89,18 @@ static void node_build_multi_function(NodeMultiFunctionBuilder &builder) builder.set_matching_fn(fn); } -} // namespace blender::nodes::node_fn_combine_color_cc +} // namespace blender::nodes::node_fn_matrix4x4_math_cc -void register_node_type_fn_combine_color(void) +void register_node_type_fn_matrix_4x4_math(void) { - namespace file_ns = blender::nodes::node_fn_combine_color_cc; + namespace file_ns = blender::nodes::node_fn_matrix4x4_math_cc; static bNodeType ntype; - fn_node_type_base(&ntype, FN_NODE_COMBINE_COLOR, "Combine Color", NODE_CLASS_CONVERTER); + fn_node_type_base(&ntype, FN_NODE_MATRIX_4X4_MATH, "4x4 Matrix Math", NODE_CLASS_CONVERTER); ntype.declare = file_ns::node_declare; ntype.updatefunc = file_ns::node_update; ntype.initfunc = file_ns::node_init; - node_type_storage( - &ntype, "NodeCombSepColor", node_free_standard_storage, node_copy_standard_storage); ntype.build_multi_function = file_ns::node_build_multi_function; ntype.draw_buttons = file_ns::node_layout; diff --git a/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc b/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc index 318c8997f9a..d95f2b8360e 100644 --- a/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc @@ -5,30 +5,32 @@ #include "UI_interface.h" #include "UI_resources.h" -namespace blender::nodes::node_fn_combine_color_cc { - -NODE_STORAGE_FUNCS(NodeCombSepColor) +namespace blender::nodes::node_fn_separate_matrix4x4_cc { static void node_declare(NodeDeclarationBuilder &b) { b.is_function_node(); - b.add_input(N_("Red")).default_value(0.0f).min(0.0f).max(1.0f).subtype(PROP_FACTOR); - b.add_input(N_("Green")) - .default_value(0.0f) - .min(0.0f) - .max(1.0f) - .subtype(PROP_FACTOR); - b.add_input(N_("Blue")) - .default_value(0.0f) - .min(0.0f) - .max(1.0f) - .subtype(PROP_FACTOR); - b.add_input(N_("Alpha")) - .default_value(1.0f) - .min(0.0f) - .max(1.0f) - .subtype(PROP_FACTOR); - b.add_output(N_("Color")); + b.add_input(N_("Matrix")).default_value(float4x4::identity()); + b.add_output(N_("Vec0")); + b.add_output(N_("Vec1")); + b.add_output(N_("Vec2")); + b.add_output(N_("Vec3")); + b.add_output(N_("Row 0 Col 0")); + b.add_output(N_("Row 1 Col 0")); + b.add_output(N_("Row 2 Col 0")); + b.add_output(N_("Row 3 Col 0")); + b.add_output(N_("Row 0 Col 1")); + b.add_output(N_("Row 1 Col 1")); + b.add_output(N_("Row 2 Col 1")); + b.add_output(N_("Row 3 Col 1")); + b.add_output(N_("Row 0 Col 2")); + b.add_output(N_("Row 1 Col 2")); + b.add_output(N_("Row 2 Col 2")); + b.add_output(N_("Row 3 Col 2")); + b.add_output(N_("Row 0 Col 3")); + b.add_output(N_("Row 1 Col 3")); + b.add_output(N_("Row 2 Col 3")); + b.add_output(N_("Row 3 Col 3")); }; static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) @@ -36,73 +38,232 @@ static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) uiItemR(layout, ptr, "mode", 0, "", ICON_NONE); } -static void node_update(bNodeTree * /*tree*/, bNode *node) +static void node_update(bNodeTree *tree, bNode *node) { - const NodeCombSepColor &storage = node_storage(*node); - node_combsep_color_label(&node->inputs, (NodeCombSepColorMode)storage.mode); + const NodeCombSepMatrixMode mode = (NodeCombSepMatrixMode)node->custom1; + + const IndexRange vector_sockets(0, 4); + const IndexRange scalar_sockets(4, 16); + const bool show_vector_sockets = ELEM( + mode, NODE_COMBSEP_MATRIX_COLUMNS, NODE_COMBSEP_MATRIX_ROWS); + const bool show_scalar_sockets = ELEM(mode, NODE_COMBSEP_MATRIX_ELEMENTS); + + for (const int i : vector_sockets) { + nodeSetSocketAvailability(tree, &node->output_socket(i), show_vector_sockets); + } + for (const int i : scalar_sockets) { + nodeSetSocketAvailability(tree, &node->output_socket(i), show_scalar_sockets); + } + + switch (mode) { + case NODE_COMBSEP_MATRIX_COLUMNS: + node_sock_label(&node->output_socket(vector_sockets[0]), "Column 0"); + node_sock_label(&node->output_socket(vector_sockets[1]), "Column 1"); + node_sock_label(&node->output_socket(vector_sockets[2]), "Column 2"); + node_sock_label(&node->output_socket(vector_sockets[3]), "Column 3"); + break; + case NODE_COMBSEP_MATRIX_ROWS: + node_sock_label(&node->output_socket(vector_sockets[0]), "Row 0"); + node_sock_label(&node->output_socket(vector_sockets[1]), "Row 1"); + node_sock_label(&node->output_socket(vector_sockets[2]), "Row 2"); + node_sock_label(&node->output_socket(vector_sockets[3]), "Row 3"); + break; + case NODE_COMBSEP_MATRIX_ELEMENTS: + break; + } } static void node_init(bNodeTree * /*tree*/, bNode *node) { - NodeCombSepColor *data = MEM_cnew(__func__); - data->mode = NODE_COMBSEP_COLOR_RGB; - node->storage = data; + node->custom1 = NODE_COMBSEP_MATRIX_COLUMNS; } -static const fn::MultiFunction *get_multi_function(const bNode &bnode) -{ - const NodeCombSepColor &storage = node_storage(bnode); - - static fn::CustomMF_SI_SI_SI_SI_SO rgba_fn{ - "RGB", [](float r, float g, float b, float a) { return ColorGeometry4f(r, g, b, a); }}; - static fn::CustomMF_SI_SI_SI_SI_SO hsva_fn{ - "HSV", [](float h, float s, float v, float a) { - ColorGeometry4f r_color; - hsv_to_rgb(h, s, v, &r_color.r, &r_color.g, &r_color.b); - r_color.a = a; - return r_color; - }}; - static fn::CustomMF_SI_SI_SI_SI_SO hsla_fn{ - "HSL", [](float h, float s, float l, float a) { - ColorGeometry4f color; - hsl_to_rgb(h, s, l, &color.r, &color.g, &color.b); - color.a = a; - return color; - }}; - - switch (storage.mode) { - case NODE_COMBSEP_COLOR_RGB: - return &rgba_fn; - case NODE_COMBSEP_COLOR_HSV: - return &hsva_fn; - case NODE_COMBSEP_COLOR_HSL: - return &hsla_fn; +class SeparateColumnsFunction : public fn::MultiFunction { + public: + SeparateColumnsFunction() + { + static fn::MFSignature signature = create_signature(); + this->set_signature(&signature); } - BLI_assert_unreachable(); - return nullptr; -} + static fn::MFSignature create_signature() + { + fn::MFSignatureBuilder signature{"Separate Matrix 4x4"}; + signature.single_input("Matrix"); + signature.single_output("Column0"); + signature.single_output("Column1"); + signature.single_output("Column2"); + signature.single_output("Column3"); + return signature.build(); + } + + void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override + { + const VArray &matrices = params.readonly_single_input(0, "Matrix"); + MutableSpan col0 = params.uninitialized_single_output(1, "Column0"); + MutableSpan col1 = params.uninitialized_single_output(2, "Column1"); + MutableSpan col2 = params.uninitialized_single_output(3, "Column2"); + MutableSpan col3 = params.uninitialized_single_output(4, "Column3"); + + for (int64_t i : mask) { + const float4x4 &mat = matrices[i]; + col0[i] = float3(mat[0]); + col1[i] = float3(mat[1]); + col2[i] = float3(mat[2]); + col3[i] = float3(mat[3]); + } + } +}; + +class SeparateRowsFunction : public fn::MultiFunction { + public: + SeparateRowsFunction() + { + static fn::MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static fn::MFSignature create_signature() + { + fn::MFSignatureBuilder signature{"Separate Matrix 4x4"}; + signature.single_input("Matrix"); + signature.single_output("Row0"); + signature.single_output("Row1"); + signature.single_output("Row2"); + signature.single_output("Row3"); + return signature.build(); + } + + void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override + { + const VArray &matrices = params.readonly_single_input(0, "Matrix"); + MutableSpan row0 = params.uninitialized_single_output(1, "Row0"); + MutableSpan row1 = params.uninitialized_single_output(2, "Row1"); + MutableSpan row2 = params.uninitialized_single_output(3, "Row2"); + MutableSpan row3 = params.uninitialized_single_output(4, "Row3"); + + for (int64_t i : mask) { + const float4x4 &mat = matrices[i]; + row0[i] = float3(mat[0][0], mat[1][0], mat[2][0]); + row1[i] = float3(mat[0][1], mat[1][1], mat[2][1]); + row2[i] = float3(mat[0][2], mat[1][2], mat[2][2]); + row3[i] = float3(mat[0][3], mat[1][3], mat[2][3]); + } + } +}; + +class SeparateElementsFunction : public fn::MultiFunction { + public: + SeparateElementsFunction() + { + static fn::MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static fn::MFSignature create_signature() + { + fn::MFSignatureBuilder signature{"Separate Matrix 4x4"}; + signature.single_input("Matrix"); + signature.single_output("Row0Column0"); + signature.single_output("Row0Column1"); + signature.single_output("Row0Column2"); + signature.single_output("Row0Column3"); + signature.single_output("Row1Column0"); + signature.single_output("Row1Column1"); + signature.single_output("Row1Column2"); + signature.single_output("Row1Column3"); + signature.single_output("Row2Column0"); + signature.single_output("Row2Column1"); + signature.single_output("Row2Column2"); + signature.single_output("Row2Column3"); + signature.single_output("Row3Column0"); + signature.single_output("Row3Column1"); + signature.single_output("Row3Column2"); + signature.single_output("Row3Column3"); + return signature.build(); + } + + void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override + { + const VArray &matrices = params.readonly_single_input(0, "Matrix"); + MutableSpan m00 = params.uninitialized_single_output(1, "Row0Column0"); + MutableSpan m10 = params.uninitialized_single_output(2, "Row0Column1"); + MutableSpan m20 = params.uninitialized_single_output(3, "Row0Column2"); + MutableSpan m30 = params.uninitialized_single_output(4, "Row0Column3"); + MutableSpan m01 = params.uninitialized_single_output(5, "Row1Column0"); + MutableSpan m11 = params.uninitialized_single_output(6, "Row1Column1"); + MutableSpan m21 = params.uninitialized_single_output(7, "Row1Column2"); + MutableSpan m31 = params.uninitialized_single_output(8, "Row1Column3"); + MutableSpan m02 = params.uninitialized_single_output(9, "Row2Column0"); + MutableSpan m12 = params.uninitialized_single_output(10, "Row2Column1"); + MutableSpan m22 = params.uninitialized_single_output(11, "Row2Column2"); + MutableSpan m32 = params.uninitialized_single_output(12, "Row2Column3"); + MutableSpan m03 = params.uninitialized_single_output(13, "Row3Column0"); + MutableSpan m13 = params.uninitialized_single_output(14, "Row3Column1"); + MutableSpan m23 = params.uninitialized_single_output(15, "Row3Column2"); + MutableSpan m33 = params.uninitialized_single_output(16, "Row3Column3"); + + for (int64_t i : mask) { + const float4x4 &mat = matrices[i]; + m00[i] = mat[0][0]; + m01[i] = mat[0][1]; + m02[i] = mat[0][2]; + m03[i] = mat[0][3]; + m10[i] = mat[1][0]; + m11[i] = mat[1][1]; + m12[i] = mat[1][2]; + m13[i] = mat[1][3]; + m20[i] = mat[2][0]; + m21[i] = mat[2][1]; + m22[i] = mat[2][2]; + m23[i] = mat[2][3]; + m30[i] = mat[3][0]; + m31[i] = mat[3][1]; + m32[i] = mat[3][2]; + m33[i] = mat[3][3]; + } + } +}; static void node_build_multi_function(NodeMultiFunctionBuilder &builder) { - const fn::MultiFunction *fn = get_multi_function(builder.node()); - builder.set_matching_fn(fn); + const NodeCombSepMatrixMode mode = (NodeCombSepMatrixMode)builder.node().custom1; + + switch (mode) { + case NODE_COMBSEP_MATRIX_COLUMNS: { + static SeparateColumnsFunction fn; + builder.set_matching_fn(fn); + break; + } + case NODE_COMBSEP_MATRIX_ROWS: { + static SeparateRowsFunction fn; + builder.set_matching_fn(fn); + break; + } + case NODE_COMBSEP_MATRIX_ELEMENTS: { + static SeparateElementsFunction fn; + builder.set_matching_fn(fn); + break; + } + default: { + BLI_assert_unreachable(); + break; + } + } } -} // namespace blender::nodes::node_fn_combine_color_cc +} // namespace blender::nodes::node_fn_separate_matrix4x4_cc -void register_node_type_fn_combine_color(void) +void register_node_type_fn_separate_matrix_4x4(void) { - namespace file_ns = blender::nodes::node_fn_combine_color_cc; + namespace file_ns = blender::nodes::node_fn_separate_matrix4x4_cc; static bNodeType ntype; - fn_node_type_base(&ntype, FN_NODE_COMBINE_COLOR, "Combine Color", NODE_CLASS_CONVERTER); + fn_node_type_base(&ntype, FN_NODE_SEPARATE_MATRIX_4X4, "Separate 4x4 Matrix", NODE_CLASS_CONVERTER); ntype.declare = file_ns::node_declare; ntype.updatefunc = file_ns::node_update; ntype.initfunc = file_ns::node_init; - node_type_storage( - &ntype, "NodeCombSepColor", node_free_standard_storage, node_copy_standard_storage); ntype.build_multi_function = file_ns::node_build_multi_function; ntype.draw_buttons = file_ns::node_layout; -- 2.30.2 From bfa19dacccc4a0e1c993ec5882e3a26a6d5172fa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Sat, 10 Dec 2022 12:45:44 +0000 Subject: [PATCH 06/33] Stub implementation of the matrix4x4 math node. --- source/blender/makesdna/DNA_node_types.h | 6 +- source/blender/makesrna/intern/rna_nodetree.c | 8 +- source/blender/nodes/NOD_static_types.h | 2 +- .../function/nodes/node_fn_matrix_math.cc | 130 +++++++++++------- 4 files changed, 85 insertions(+), 61 deletions(-) diff --git a/source/blender/makesdna/DNA_node_types.h b/source/blender/makesdna/DNA_node_types.h index bbc38874394..cd361096d50 100644 --- a/source/blender/makesdna/DNA_node_types.h +++ b/source/blender/makesdna/DNA_node_types.h @@ -1890,9 +1890,9 @@ typedef enum NodeMatrixMathOperation { NODE_MATRIX_MATH_INVERSE = 5, NODE_MATRIX_MATH_DETERMINANT = 6, NODE_MATRIX_MATH_TRACE = 7, - NODE_MATRIX_MATH_IS_SYMMETRIC = 8, - NODE_MATRIX_MATH_IS_ANTI_SYMMETRIC = 9, - NODE_MATRIX_MATH_IS_ORTHOGONAL = 10, + //NODE_MATRIX_MATH_IS_SYMMETRIC = 8, + //NODE_MATRIX_MATH_IS_ANTI_SYMMETRIC = 9, + //NODE_MATRIX_MATH_IS_ORTHOGONAL = 10, } NodeMatrixMathOperation; typedef enum NodeBooleanMathOperation { diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c index d5f59efbab8..60425a968a4 100644 --- a/source/blender/makesrna/intern/rna_nodetree.c +++ b/source/blender/makesrna/intern/rna_nodetree.c @@ -305,10 +305,10 @@ const EnumPropertyItem rna_enum_node_matrix_math_items[] = { RNA_ENUM_ITEM_SEPR, {NODE_MATRIX_MATH_DETERMINANT, "DETERMINANT", 0, "Determinant", ""}, {NODE_MATRIX_MATH_TRACE, "TRACE", 0, "Trace", ""}, - RNA_ENUM_ITEM_SEPR, - {NODE_MATRIX_MATH_IS_SYMMETRIC, "IS_SYMMETRIC", 0, "Is Symmetric", ""}, - {NODE_MATRIX_MATH_IS_ANTI_SYMMETRIC, "IS_ANTI_SYMMETRIC", 0, "Is Anti-Symmetric", ""}, - {NODE_MATRIX_MATH_IS_ORTHOGONAL, "IS_ORTHOGONAL", 0, "Is Orthogonal", ""}, + //RNA_ENUM_ITEM_SEPR, + //{NODE_MATRIX_MATH_IS_SYMMETRIC, "IS_SYMMETRIC", 0, "Is Symmetric", ""}, + //{NODE_MATRIX_MATH_IS_ANTI_SYMMETRIC, "IS_ANTI_SYMMETRIC", 0, "Is Anti-Symmetric", ""}, + //{NODE_MATRIX_MATH_IS_ORTHOGONAL, "IS_ORTHOGONAL", 0, "Is Orthogonal", ""}, {0, NULL, 0, NULL, NULL}, }; diff --git a/source/blender/nodes/NOD_static_types.h b/source/blender/nodes/NOD_static_types.h index 90ea65171bd..add10d2fa34 100644 --- a/source/blender/nodes/NOD_static_types.h +++ b/source/blender/nodes/NOD_static_types.h @@ -282,7 +282,7 @@ DefNode(FunctionNode, FN_NODE_VALUE_TO_STRING, 0, "VALUE_TO_STRING", ValueToStri DefNode(FunctionNode, FN_NODE_INPUT_MATRIX_4X4, def_fn_input_matrix_4x4, "INPUT_MATRIX_4X4", InputMatrix, "4x4 Matrix", "") DefNode(FunctionNode, FN_NODE_SEPARATE_MATRIX_4X4, def_fn_combsep_matrix, "SEPARATE_MATRIX_4X4", SeparateMatrix, "Separate 4x4 Matrix", "") DefNode(FunctionNode, FN_NODE_COMBINE_MATRIX_4X4, def_fn_combsep_matrix, "COMBINE_MATRIX_4X4", CombineMatrix, "Combine 4x4 Matrix", "") -DefNode(FunctionNode, FN_NODE_MATRIX_4X4_MATH, def_fn_matrix_4x4_math, "MATRIX_4X4_MATH", MatrixMath, "4x4 Matrix Math", "") +DefNode(FunctionNode, FN_NODE_MATRIX_4X4_MATH, def_fn_matrix_4x4_math, "MATRIX_4X4_MATH", Matrix4x4Math, "4x4 Matrix Math", "") DefNode(GeometryNode, GEO_NODE_ACCUMULATE_FIELD, def_geo_accumulate_field, "ACCUMULATE_FIELD", AccumulateField, "Accumulate Field", "Add the values of an evaluated field together and output the running total for each element") DefNode(GeometryNode, GEO_NODE_ATTRIBUTE_DOMAIN_SIZE, def_geo_attribute_domain_size, "ATTRIBUTE_DOMAIN_SIZE", AttributeDomainSize, "Domain Size", "Retrieve the number of elements in a geometry for each attribute domain") diff --git a/source/blender/nodes/function/nodes/node_fn_matrix_math.cc b/source/blender/nodes/function/nodes/node_fn_matrix_math.cc index 633d7126840..3c7131feee4 100644 --- a/source/blender/nodes/function/nodes/node_fn_matrix_math.cc +++ b/source/blender/nodes/function/nodes/node_fn_matrix_math.cc @@ -2,90 +2,114 @@ #include "node_function_util.hh" +#include "NOD_socket_search_link.hh" + #include "UI_interface.h" #include "UI_resources.h" -namespace blender::nodes::node_fn_matrix4x4_math_cc { +namespace blender::math { -NODE_STORAGE_FUNCS(NodeCombSepColor) +/* XXX These are placeholder functions based on BLI math until SIMD versions are available */ + +inline float4x4 [[nodiscard]] add(const float4x4 &a, const float4x4 &b) +{ + float4x4 r; + add_m4_m4m4(r.ptr(), a.ptr(), b.ptr()); + return r; +} + +inline float4x4 [[nodiscard]] subtract(const float4x4 &a, const float4x4 &b) +{ + float4x4 r; + sub_m4_m4m4(r.ptr(), a.ptr(), b.ptr()); + return r; +} + +} + +namespace blender::nodes::node_fn_matrix4x4_math_cc { static void node_declare(NodeDeclarationBuilder &b) { b.is_function_node(); - b.add_input(N_("Red")).default_value(0.0f).min(0.0f).max(1.0f).subtype(PROP_FACTOR); - b.add_input(N_("Green")) - .default_value(0.0f) - .min(0.0f) - .max(1.0f) - .subtype(PROP_FACTOR); - b.add_input(N_("Blue")) - .default_value(0.0f) - .min(0.0f) - .max(1.0f) - .subtype(PROP_FACTOR); - b.add_input(N_("Alpha")) - .default_value(1.0f) - .min(0.0f) - .max(1.0f) - .subtype(PROP_FACTOR); - b.add_output(N_("Color")); + b.add_input(N_("Matrix")); + b.add_input(N_("Matrix"), "Matrix_001"); + b.add_input(N_("Scale")).default_value(1.0f); + b.add_output(N_("Matrix")); + b.add_output(N_("Value")); }; static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) { - uiItemR(layout, ptr, "mode", 0, "", ICON_NONE); + uiItemR(layout, ptr, "operation", UI_ITEM_R_SPLIT_EMPTY_NAME, "", ICON_NONE); } -static void node_update(bNodeTree * /*tree*/, bNode *node) +static void node_update(bNodeTree *tree, bNode *node) { - const NodeCombSepColor &storage = node_storage(*node); - node_combsep_color_label(&node->inputs, (NodeCombSepColorMode)storage.mode); + const NodeMatrixMathOperation op = (NodeMatrixMathOperation)node->custom1; + + bNodeSocket *inMatrixA = &node->input_socket(0); + bNodeSocket *inMatrixB = &node->input_socket(1); + bNodeSocket *inScale = &node->input_socket(2); + bNodeSocket *outMatrix = &node->output_socket(3); + bNodeSocket *outValue = &node->output_socket(4); + + nodeSetSocketAvailability(tree, inMatrixA, true); + nodeSetSocketAvailability( + tree, + inMatrixB, + ELEM(op, NODE_MATRIX_MATH_ADD, NODE_MATRIX_MATH_SUBTRACT, NODE_MATRIX_MATH_MULTIPLY)); + nodeSetSocketAvailability(tree, inScale, ELEM(op, NODE_MATRIX_MATH_SCALAR_MULTIPLY)); + + nodeSetSocketAvailability(tree, + outMatrix, + ELEM(op, + NODE_MATRIX_MATH_ADD, + NODE_MATRIX_MATH_SUBTRACT, + NODE_MATRIX_MATH_SCALAR_MULTIPLY, + NODE_MATRIX_MATH_MULTIPLY, + NODE_MATRIX_MATH_TRANSPOSE, + NODE_MATRIX_MATH_INVERSE)); + nodeSetSocketAvailability( + tree, outValue, ELEM(op, NODE_MATRIX_MATH_DETERMINANT, NODE_MATRIX_MATH_TRACE)); + + /* Labels */ + node_sock_label_clear(inMatrixA); + node_sock_label_clear(inMatrixB); + node_sock_label_clear(inScale); + switch (op) { + } } static void node_init(bNodeTree * /*tree*/, bNode *node) { - NodeCombSepColor *data = MEM_cnew(__func__); - data->mode = NODE_COMBSEP_COLOR_RGB; - node->storage = data; + node->custom1 = NODE_MATRIX_MATH_ADD; } -static const fn::MultiFunction *get_multi_function(const bNode &bnode) +static const fn::MultiFunction *get_multi_function(NodeMatrixMathOperation op) { - const NodeCombSepColor &storage = node_storage(bnode); + static auto exec_preset_fast = fn::CustomMF_presets::AllSpanOrSingle(); + static auto exec_preset_slow = fn::CustomMF_presets::Materialized(); - static fn::CustomMF_SI_SI_SI_SI_SO rgba_fn{ - "RGB", [](float r, float g, float b, float a) { return ColorGeometry4f(r, g, b, a); }}; - static fn::CustomMF_SI_SI_SI_SI_SO hsva_fn{ - "HSV", [](float h, float s, float v, float a) { - ColorGeometry4f r_color; - hsv_to_rgb(h, s, v, &r_color.r, &r_color.g, &r_color.b); - r_color.a = a; - return r_color; - }}; - static fn::CustomMF_SI_SI_SI_SI_SO hsla_fn{ - "HSL", [](float h, float s, float l, float a) { - ColorGeometry4f color; - hsl_to_rgb(h, s, l, &color.r, &color.g, &color.b); - color.a = a; - return color; - }}; + const fn::MultiFunction *multi_fn = nullptr; - switch (storage.mode) { - case NODE_COMBSEP_COLOR_RGB: - return &rgba_fn; - case NODE_COMBSEP_COLOR_HSV: - return &hsva_fn; - case NODE_COMBSEP_COLOR_HSL: - return &hsla_fn; + switch (op) { + case NODE_MATRIX_MATH_ADD: { + static fn::CustomMF_SI_SI_SO fn{ + "add", + [](const float4x4 &a, const float4x4 &b, float4x4 &r) { r = math::add(a, b); }, + exec_preset_fast}; + return &fn; + } } - BLI_assert_unreachable(); return nullptr; } static void node_build_multi_function(NodeMultiFunctionBuilder &builder) { - const fn::MultiFunction *fn = get_multi_function(builder.node()); + const NodeMatrixMathOperation op = (NodeMatrixMathOperation)builder.node().custom1; + const fn::MultiFunction *fn = get_multi_function(op); builder.set_matching_fn(fn); } -- 2.30.2 From 8394e73a2f8203119c4eda26fbae79a3a381666a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Sat, 10 Dec 2022 14:22:19 +0000 Subject: [PATCH 07/33] Register CppType for float3x3. --- source/blender/blenlib/intern/cpp_types.cc | 3 +++ 1 file changed, 3 insertions(+) diff --git a/source/blender/blenlib/intern/cpp_types.cc b/source/blender/blenlib/intern/cpp_types.cc index eb8f03d942f..eb6043185d1 100644 --- a/source/blender/blenlib/intern/cpp_types.cc +++ b/source/blender/blenlib/intern/cpp_types.cc @@ -3,6 +3,7 @@ #include "BLI_color.hh" #include "BLI_cpp_type_make.hh" #include "BLI_cpp_types_make.hh" +#include "BLI_float3x3.hh" #include "BLI_float4x4.hh" #include "BLI_math_vec_types.hh" @@ -47,6 +48,7 @@ BLI_CPP_TYPE_MAKE(bool, CPPTypeFlags::BasicType) BLI_CPP_TYPE_MAKE(float, CPPTypeFlags::BasicType) BLI_CPP_TYPE_MAKE(blender::float2, CPPTypeFlags::BasicType) BLI_CPP_TYPE_MAKE(blender::float3, CPPTypeFlags::BasicType) +BLI_CPP_TYPE_MAKE(blender::float3x3, CPPTypeFlags::BasicType) BLI_CPP_TYPE_MAKE(blender::float4x4, CPPTypeFlags::BasicType) BLI_CPP_TYPE_MAKE(int8_t, CPPTypeFlags::BasicType) @@ -75,6 +77,7 @@ void register_cpp_types() BLI_CPP_TYPE_REGISTER(float); BLI_CPP_TYPE_REGISTER(blender::float2); BLI_CPP_TYPE_REGISTER(blender::float3); + BLI_CPP_TYPE_REGISTER(blender::float3x3); BLI_CPP_TYPE_REGISTER(blender::float4x4); BLI_CPP_TYPE_REGISTER(int8_t); -- 2.30.2 From 6156c1f8e1843ba43560c823f06efb0ddee43c08 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Sat, 10 Dec 2022 15:06:08 +0000 Subject: [PATCH 08/33] Hash function for the float3x3 type. --- source/blender/blenlib/BLI_float3x3.hh | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/source/blender/blenlib/BLI_float3x3.hh b/source/blender/blenlib/BLI_float3x3.hh index 178973c155d..af352349900 100644 --- a/source/blender/blenlib/BLI_float3x3.hh +++ b/source/blender/blenlib/BLI_float3x3.hh @@ -206,6 +206,16 @@ struct float3x3 { return scale; } + uint64_t hash() const + { + uint64_t h = 435109; + for (int i = 0; i < 9; i++) { + float value = (static_cast(values[0]))[i]; + h = h * 33 + *reinterpret_cast(&value); + } + return h; + } + friend bool operator==(const float3x3 &a, const float3x3 &b) { return equals_m3m3(a.values, b.values); -- 2.30.2 From f773604aae4dbe87e9661defcb1cbba2cf896bd6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Sat, 10 Dec 2022 15:06:30 +0000 Subject: [PATCH 09/33] Declare field CppTypes for float3x3 and float4x4. --- source/blender/functions/intern/cpp_types.cc | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/source/blender/functions/intern/cpp_types.cc b/source/blender/functions/intern/cpp_types.cc index 098e7030de4..8691761d9c1 100644 --- a/source/blender/functions/intern/cpp_types.cc +++ b/source/blender/functions/intern/cpp_types.cc @@ -3,6 +3,7 @@ #include "BLI_color.hh" #include "BLI_cpp_type_make.hh" #include "BLI_cpp_types_make.hh" +#include "BLI_float3x3.hh" #include "BLI_float4x4.hh" #include "BLI_math_vec_types.hh" @@ -12,6 +13,8 @@ FN_FIELD_CPP_TYPE_MAKE(float); FN_FIELD_CPP_TYPE_MAKE(blender::float2); FN_FIELD_CPP_TYPE_MAKE(blender::float3); +FN_FIELD_CPP_TYPE_MAKE(blender::float3x3); +FN_FIELD_CPP_TYPE_MAKE(blender::float4x4); FN_FIELD_CPP_TYPE_MAKE(blender::ColorGeometry4f); FN_FIELD_CPP_TYPE_MAKE(blender::ColorGeometry4b); FN_FIELD_CPP_TYPE_MAKE(bool); @@ -26,6 +29,8 @@ void FN_register_cpp_types() FN_FIELD_CPP_TYPE_REGISTER(float); FN_FIELD_CPP_TYPE_REGISTER(blender::float2); FN_FIELD_CPP_TYPE_REGISTER(blender::float3); + FN_FIELD_CPP_TYPE_REGISTER(blender::float3x3); + FN_FIELD_CPP_TYPE_REGISTER(blender::float4x4); FN_FIELD_CPP_TYPE_REGISTER(blender::ColorGeometry4f); FN_FIELD_CPP_TYPE_REGISTER(blender::ColorGeometry4b); FN_FIELD_CPP_TYPE_REGISTER(bool); -- 2.30.2 From 9cd8342506acf76f10979b3c5e28b5ec66455d72 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Sat, 10 Dec 2022 15:07:11 +0000 Subject: [PATCH 10/33] Fixed callback signature for matrix multifunctions. --- source/blender/nodes/function/nodes/node_fn_combine_matrix.cc | 4 ++-- source/blender/nodes/function/nodes/node_fn_matrix_math.cc | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc b/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc index 9f0e50b7668..1675d1e013c 100644 --- a/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc @@ -156,10 +156,10 @@ static const fn::MultiFunction *get_multi_function(const bNode &bnode) float m31, float m32, float m33, - float4x4 &result) { + float4x4 *result) { const float elements[] = { m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33}; - result = float4x4(elements); + *result = float4x4(elements); }}; switch (mode) { diff --git a/source/blender/nodes/function/nodes/node_fn_matrix_math.cc b/source/blender/nodes/function/nodes/node_fn_matrix_math.cc index 3c7131feee4..dea79587f56 100644 --- a/source/blender/nodes/function/nodes/node_fn_matrix_math.cc +++ b/source/blender/nodes/function/nodes/node_fn_matrix_math.cc @@ -97,7 +97,7 @@ static const fn::MultiFunction *get_multi_function(NodeMatrixMathOperation op) case NODE_MATRIX_MATH_ADD: { static fn::CustomMF_SI_SI_SO fn{ "add", - [](const float4x4 &a, const float4x4 &b, float4x4 &r) { r = math::add(a, b); }, + [](const float4x4 &a, const float4x4 &b) -> float4x4 { return math::add(a, b); }, exec_preset_fast}; return &fn; } -- 2.30.2 From eac7726df3222c482af7c063388c67260998a34e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Sat, 10 Dec 2022 15:27:59 +0000 Subject: [PATCH 11/33] Added missing implementation of socket declaration builders. --- .../blender/nodes/NOD_socket_declarations.hh | 52 ++++++++++++++++++- 1 file changed, 50 insertions(+), 2 deletions(-) diff --git a/source/blender/nodes/NOD_socket_declarations.hh b/source/blender/nodes/NOD_socket_declarations.hh index 5c6f9c51ccf..4e34085780e 100644 --- a/source/blender/nodes/NOD_socket_declarations.hh +++ b/source/blender/nodes/NOD_socket_declarations.hh @@ -119,7 +119,7 @@ class Matrix3x3 : public SocketDeclaration { class Matrix3x3Builder : public SocketDeclarationBuilder { public: - Matrix3x3Builder &default_value(const float3x3 value); + Matrix3x3Builder &default_value(const float3x3 &value); Matrix3x3Builder &min(float min); Matrix3x3Builder &max(float max); }; @@ -145,7 +145,7 @@ class Matrix4x4 : public SocketDeclaration { class Matrix4x4Builder : public SocketDeclarationBuilder { public: - Matrix4x4Builder &default_value(const float4x4 value); + Matrix4x4Builder &default_value(const float4x4 &value); Matrix4x4Builder &min(float min); Matrix4x4Builder &max(float max); }; @@ -373,6 +373,54 @@ inline VectorBuilder &VectorBuilder::compact() /** \} */ +/* -------------------------------------------------------------------- */ +/** \name #Matrix3x3Builder Inline Methods + * \{ */ + +inline Matrix3x3Builder &Matrix3x3Builder::default_value(const float3x3 &value) +{ + decl_->default_value_ = value; + return *this; +} + +inline Matrix3x3Builder &Matrix3x3Builder::min(const float min) +{ + decl_->soft_min_value_ = min; + return *this; +} + +inline Matrix3x3Builder &Matrix3x3Builder::max(const float max) +{ + decl_->soft_max_value_ = max; + return *this; +} + +/** \} */ + +/* -------------------------------------------------------------------- */ +/** \name #Matrix4x4Builder Inline Methods + * \{ */ + +inline Matrix4x4Builder &Matrix4x4Builder::default_value(const float4x4 &value) +{ + decl_->default_value_ = value; + return *this; +} + +inline Matrix4x4Builder &Matrix4x4Builder::min(const float min) +{ + decl_->soft_min_value_ = min; + return *this; +} + +inline Matrix4x4Builder &Matrix4x4Builder::max(const float max) +{ + decl_->soft_max_value_ = max; + return *this; +} + +/** \} */ + /* -------------------------------------------------------------------- */ /** \name #BoolBuilder Inline Methods * \{ */ -- 2.30.2 From 88cbc107f137e13e43f02308cf346ce184db752f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Sat, 10 Dec 2022 15:28:45 +0000 Subject: [PATCH 12/33] Include runtime C++ functions for bNode. --- source/blender/nodes/function/nodes/node_fn_combine_matrix.cc | 2 ++ source/blender/nodes/function/nodes/node_fn_input_matrix.cc | 2 ++ source/blender/nodes/function/nodes/node_fn_matrix_math.cc | 2 ++ source/blender/nodes/function/nodes/node_fn_separate_matrix.cc | 2 ++ 4 files changed, 8 insertions(+) diff --git a/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc b/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc index 1675d1e013c..5ebc0ac89b7 100644 --- a/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc @@ -2,6 +2,8 @@ #include "node_function_util.hh" +#include "BKE_node_runtime.hh" + #include "UI_interface.h" #include "UI_resources.h" diff --git a/source/blender/nodes/function/nodes/node_fn_input_matrix.cc b/source/blender/nodes/function/nodes/node_fn_input_matrix.cc index aa596aaeb92..32465e97d50 100644 --- a/source/blender/nodes/function/nodes/node_fn_input_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_input_matrix.cc @@ -2,6 +2,8 @@ #include "node_function_util.hh" +#include "BKE_node_runtime.hh" + #include "UI_interface.h" #include "UI_resources.h" diff --git a/source/blender/nodes/function/nodes/node_fn_matrix_math.cc b/source/blender/nodes/function/nodes/node_fn_matrix_math.cc index dea79587f56..9bdd580edbe 100644 --- a/source/blender/nodes/function/nodes/node_fn_matrix_math.cc +++ b/source/blender/nodes/function/nodes/node_fn_matrix_math.cc @@ -2,6 +2,8 @@ #include "node_function_util.hh" +#include "BKE_node_runtime.hh" + #include "NOD_socket_search_link.hh" #include "UI_interface.h" diff --git a/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc b/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc index d95f2b8360e..b1931fefb85 100644 --- a/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc @@ -2,6 +2,8 @@ #include "node_function_util.hh" +#include "BKE_node_runtime.hh" + #include "UI_interface.h" #include "UI_resources.h" -- 2.30.2 From 6b9e700ed15df3dfb78f3b985c999684ae6cdc45 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Sat, 10 Dec 2022 18:19:52 +0000 Subject: [PATCH 13/33] Custom data layer types for float matrix types. --- .../blenkernel/intern/attribute_access.cc | 4 + .../blender/blenkernel/intern/customdata.cc | 222 ++++++++++++++++++ .../editors/space_node/node_relationships.cc | 6 +- .../blender/makesdna/DNA_customdata_types.h | 15 +- .../nodes/geometry/node_geometry_util.cc | 4 +- 5 files changed, 242 insertions(+), 9 deletions(-) diff --git a/source/blender/blenkernel/intern/attribute_access.cc b/source/blender/blenkernel/intern/attribute_access.cc index e5c43a3f90e..459c76962de 100644 --- a/source/blender/blenkernel/intern/attribute_access.cc +++ b/source/blender/blenkernel/intern/attribute_access.cc @@ -81,6 +81,10 @@ static int attribute_data_type_complexity(const eCustomDataType data_type) return 6; case CD_PROP_COLOR: return 7; + case CD_PROP_FLOAT3X3: + return 8; + case CD_PROP_FLOAT4X4: + return 9; #if 0 /* These attribute types are not supported yet. */ case CD_PROP_STRING: return 6; diff --git a/source/blender/blenkernel/intern/customdata.cc b/source/blender/blenkernel/intern/customdata.cc index c8d7c4f2fdc..c170db2bd94 100644 --- a/source/blender/blenkernel/intern/customdata.cc +++ b/source/blender/blenkernel/intern/customdata.cc @@ -20,6 +20,8 @@ #include "BLI_bitmap.h" #include "BLI_color.hh" #include "BLI_endian_switch.h" +#include "BLI_float3x3.hh" +#include "BLI_float4x4.hh" #include "BLI_index_range.hh" #include "BLI_math.h" #include "BLI_math_color_blend.h" @@ -1637,6 +1639,165 @@ static void layerInterp_propbool(const void **sources, *(bool *)dest = result; } +/** \} */ + +/* -------------------------------------------------------------------- */ +/** \name Callbacks for ('float2x2', #CD_PROP_FLOAT2X2) + * \{ */ + +static void layerInterp_propfloat2x2(const void **sources, + const float *weights, + const float * /*sub_weights*/, + int count, + void *dest) +{ + float result[2][2] = {0.0f, 0.0f}; + for (int i = 0; i < count; i++) { + const float interp_weight = weights[i]; + const float (*src)[2] = static_cast(sources[i]); + madd_v4_v4fl((float *)result, (const float *)src, interp_weight); + } + copy_v4_v4((float *)dest, (float *)result); +} + +static void layerMultiply_propfloat2x2(void *data, const float fac) +{ + mul_v4_fl((float *)data, fac); +} + +static void layerAdd_propfloat2x2(void *data1, const void *data2) +{ + add_v4_v4((float *)data1, (const float *)data2); +} + +static bool layerValidate_propfloat2x2(void *data, const uint totitems, const bool do_fixes) +{ + float *values = static_cast(data); + bool has_errors = false; + for (int i = 0; i < totitems * 4; i++) { + if (!isfinite(values[i])) { + if (do_fixes) { + values[i] = 0.0f; + } + has_errors = true; + } + } + return has_errors; +} + +/** \} */ + +/* -------------------------------------------------------------------- */ +/** \name Callbacks for ('float3x3', #CD_PROP_FLOAT3X3) + * \{ */ + +static void layerInterp_propfloat3x3(const void **sources, + const float *weights, + const float * /*sub_weights*/, + int count, + void *dest) +{ + using blender::float3x3; + + float3x3 result = float3x3::zero(); + for (int i = 0; i < count; i++) { + const float interp_weight = weights[i]; + const float3x3 *src = static_cast(sources[i]); + madd_m3_m3m3fl(result.ptr(), result.ptr(), src->ptr(), interp_weight); + } + *static_cast(dest) = result.ptr(); +} + +static void layerMultiply_propfloat3x3(void *data, const float fac) +{ + using blender::float3x3; + + float3x3 *mat = static_cast(data); + mul_m3_fl(mat->ptr(), fac); +} + +static void layerAdd_propfloat3x3(void *data1, const void *data2) +{ + using blender::float3x3; + + float3x3 *mat1 = static_cast(data1); + const float3x3 *mat2 = static_cast(data2); + add_m3_m3m3(mat1->ptr(), mat1->ptr(), mat2->ptr()); +} + +static bool layerValidate_propfloat3x3(void *data, const uint totitems, const bool do_fixes) +{ + float *values = static_cast(data); + bool has_errors = false; + for (int i = 0; i < totitems * 9; i++) { + if (!isfinite(values[i])) { + if (do_fixes) { + values[i] = 0.0f; + } + has_errors = true; + } + } + return has_errors; +} + +/** \} */ + +/* -------------------------------------------------------------------- */ +/** \name Callbacks for ('float4x4', #CD_PROP_FLOAT4X4) + * \{ */ + +static void layerInterp_propfloat4x4(const void **sources, + const float *weights, + const float * /*sub_weights*/, + int count, + void *dest) +{ + using blender::float4x4; + + float4x4 result; + zero_m4(result.ptr()); + for (int i = 0; i < count; i++) { + const float interp_weight = weights[i]; + const float4x4 *src = static_cast(sources[i]); + madd_m4_m4m4fl(result.ptr(), result.ptr(), src->ptr(), interp_weight); + } + *static_cast(dest) = result.ptr(); +} + +static void layerMultiply_propfloat4x4(void *data, const float fac) +{ + using blender::float4x4; + + float4x4 *mat = static_cast(data); + mul_m4_fl(mat->ptr(), fac); +} + +static void layerAdd_propfloat4x4(void *data1, const void *data2) +{ + using blender::float4x4; + + float4x4 *mat1 = static_cast(data1); + const float4x4 *mat2 = static_cast(data2); + add_m4_m4m4(mat1->ptr(), mat1->ptr(), mat2->ptr()); +} + +static bool layerValidate_propfloat4x4(void *data, const uint totitems, const bool do_fixes) +{ + float *values = static_cast(data); + bool has_errors = false; + for (int i = 0; i < totitems * 16; i++) { + if (!isfinite(values[i])) { + if (do_fixes) { + values[i] = 0.0f; + } + has_errors = true; + } + } + return has_errors; +} + +/** \} */ + static const LayerTypeInfo LAYERTYPEINFO[CD_NUMTYPES] = { /* 0: CD_MVERT */ {sizeof(MVert), "MVert", 1, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}, @@ -2046,6 +2207,54 @@ static const LayerTypeInfo LAYERTYPEINFO[CD_NUMTYPES] = { nullptr}, /* 51: CD_HAIRLENGTH */ {sizeof(float), "float", 1, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}, + /* 52: CD_PROP_FLOAT2X2 */ + {sizeof(float[2][2]), + "float2x2", + 1, + N_("Float2x2"), + nullptr, + nullptr, + layerInterp_propfloat2x2, + nullptr, + nullptr, + nullptr, + layerValidate_propfloat2x2, + nullptr, + layerMultiply_propfloat2x2, + nullptr, + layerAdd_propfloat2x2}, + /* 53: CD_PROP_FLOAT3X3 */ + {sizeof(float[3][3]), + "float3x3", + 1, + N_("Float3x3"), + nullptr, + nullptr, + layerInterp_propfloat3x3, + nullptr, + nullptr, + nullptr, + layerValidate_propfloat3x3, + nullptr, + layerMultiply_propfloat3x3, + nullptr, + layerAdd_propfloat3x3}, + /* 54: CD_PROP_FLOAT4X4 */ + {sizeof(float[4][4]), + "float4x4", + 1, + N_("Float4x4"), + nullptr, + nullptr, + layerInterp_propfloat4x4, + nullptr, + nullptr, + nullptr, + layerValidate_propfloat4x4, + nullptr, + layerMultiply_propfloat4x4, + nullptr, + layerAdd_propfloat4x4}, }; static const char *LAYERTYPENAMES[CD_NUMTYPES] = { @@ -2103,6 +2312,9 @@ static const char *LAYERTYPENAMES[CD_NUMTYPES] = { "CDPropFloat2", "CDPropBoolean", "CDHairLength", + "CDPropFloat2x2", + "CDPropFloat3x3", + "CDPropFloat4x4", }; const CustomData_MeshMasks CD_MASK_BAREMESH = { @@ -5348,6 +5560,10 @@ const blender::CPPType *custom_data_type_to_cpp_type(const eCustomDataType type) return &CPPType::get(); case CD_PROP_FLOAT3: return &CPPType::get(); + case CD_PROP_FLOAT3X3: + return &CPPType::get(); + case CD_PROP_FLOAT4X4: + return &CPPType::get(); case CD_PROP_INT32: return &CPPType::get(); case CD_PROP_COLOR: @@ -5377,6 +5593,12 @@ eCustomDataType cpp_type_to_custom_data_type(const blender::CPPType &type) if (type.is()) { return CD_PROP_FLOAT3; } + if (type.is()) { + return CD_PROP_FLOAT3X3; + } + if (type.is()) { + return CD_PROP_FLOAT4X4; + } if (type.is()) { return CD_PROP_INT32; } diff --git a/source/blender/editors/space_node/node_relationships.cc b/source/blender/editors/space_node/node_relationships.cc index b4e942aea82..3d3312702a8 100644 --- a/source/blender/editors/space_node/node_relationships.cc +++ b/source/blender/editors/space_node/node_relationships.cc @@ -452,11 +452,11 @@ static eCustomDataType socket_type_to_custom_data_type(const eNodeSocketDatatype case SOCK_VECTOR: return CD_PROP_FLOAT3; case SOCK_MATRIX_2X2: - return CD_PROP_FLOAT2x2; + return CD_PROP_FLOAT2X2; case SOCK_MATRIX_3X3: - return CD_PROP_FLOAT3x3; + return CD_PROP_FLOAT3X3; case SOCK_MATRIX_4X4: - return CD_PROP_FLOAT4x4; + return CD_PROP_FLOAT4X4; case SOCK_BOOLEAN: return CD_PROP_BOOL; case SOCK_RGBA: diff --git a/source/blender/makesdna/DNA_customdata_types.h b/source/blender/makesdna/DNA_customdata_types.h index 0355ed3febe..d3dda943d5b 100644 --- a/source/blender/makesdna/DNA_customdata_types.h +++ b/source/blender/makesdna/DNA_customdata_types.h @@ -68,8 +68,7 @@ typedef struct CustomData { * MUST be >= CD_NUMTYPES, but we can't use a define here. * Correct size is ensured in CustomData_update_typemap assert(). */ - int typemap[52]; - char _pad[4]; + int typemap[55]; /** Number of layers, size of layers array. */ int totlayer, maxlayer; /** In editmode, total size of all data layers. */ @@ -155,7 +154,11 @@ typedef enum eCustomDataType { CD_HAIRLENGTH = 51, - CD_NUMTYPES = 52, + CD_PROP_FLOAT2X2 = 52, + CD_PROP_FLOAT3X3 = 53, + CD_PROP_FLOAT4X4 = 54, + + CD_NUMTYPES = 55, } eCustomDataType; /* Bits for eCustomDataMask */ @@ -209,6 +212,10 @@ typedef enum eCustomDataType { #define CD_MASK_HAIRLENGTH (1ULL << CD_HAIRLENGTH) +#define CD_MASK_FLOAT2X2 (1ULL << CD_PROP_FLOAT2X2) +#define CD_MASK_FLOAT3X3 (1ULL << CD_PROP_FLOAT3X3) +#define CD_MASK_FLOAT4X4 (1ULL << CD_PROP_FLOAT4X4) + /** Multi-resolution loop data. */ #define CD_MASK_MULTIRES_GRIDS (CD_MASK_MDISPS | CD_GRID_PAINT_MASK) @@ -219,7 +226,7 @@ typedef enum eCustomDataType { #define CD_MASK_PROP_ALL \ (CD_MASK_PROP_FLOAT | CD_MASK_PROP_FLOAT2 | CD_MASK_PROP_FLOAT3 | CD_MASK_PROP_INT32 | \ CD_MASK_PROP_COLOR | CD_MASK_PROP_STRING | CD_MASK_PROP_BYTE_COLOR | CD_MASK_PROP_BOOL | \ - CD_MASK_PROP_INT8) + CD_MASK_PROP_INT8 | CD_MASK_FLOAT2X2 | CD_MASK_FLOAT3X3 | CD_MASK_FLOAT4X4) /* All color attributes */ #define CD_MASK_COLOR_ALL (CD_MASK_PROP_COLOR | CD_MASK_PROP_BYTE_COLOR) diff --git a/source/blender/nodes/geometry/node_geometry_util.cc b/source/blender/nodes/geometry/node_geometry_util.cc index d3058349a12..7e52bdbe378 100644 --- a/source/blender/nodes/geometry/node_geometry_util.cc +++ b/source/blender/nodes/geometry/node_geometry_util.cc @@ -22,9 +22,9 @@ std::optional node_data_type_to_custom_data_type(const eNodeSoc case SOCK_VECTOR: return CD_PROP_FLOAT3; case SOCK_MATRIX_3X3: - return CD_PROP_MATRIX3; + return CD_PROP_FLOAT3X3; case SOCK_MATRIX_4X4: - return CD_PROP_MATRIX4; + return CD_PROP_FLOAT4X4; case SOCK_RGBA: return CD_PROP_COLOR; case SOCK_BOOLEAN: -- 2.30.2 From b5f6919a801f4e8a39cb287dc166a0cd2623701e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Sat, 10 Dec 2022 18:59:07 +0000 Subject: [PATCH 14/33] Node menu entries for matrix nodes. --- .../startup/bl_ui/node_add_menu_geometry.py | 15 +++++++++++++++ source/blender/nodes/NOD_static_types.h | 6 +++--- 2 files changed, 18 insertions(+), 3 deletions(-) diff --git a/release/scripts/startup/bl_ui/node_add_menu_geometry.py b/release/scripts/startup/bl_ui/node_add_menu_geometry.py index 83448f8e32a..c2c906eaf88 100644 --- a/release/scripts/startup/bl_ui/node_add_menu_geometry.py +++ b/release/scripts/startup/bl_ui/node_add_menu_geometry.py @@ -148,6 +148,7 @@ class NODE_MT_geometry_node_GEO_INPUT(Menu): node_add_menu.add_node_type(layout, "FunctionNodeInputString") node_add_menu.add_node_type(layout, "ShaderNodeValue") node_add_menu.add_node_type(layout, "FunctionNodeInputVector") + node_add_menu.add_node_type(layout, "FunctionNodeInputMatrix4x4") layout.separator() node_add_menu.add_node_type(layout, "GeometryNodeInputID") node_add_menu.add_node_type(layout, "GeometryNodeInputIndex") @@ -193,6 +194,18 @@ class NODE_MT_geometry_node_GEO_MATERIAL(Menu): node_add_menu.draw_assets_for_catalog(layout, self.bl_label) +class NODE_MT_category_GEO_MATRIX(Menu): + bl_idname = "NODE_MT_category_GEO_MATRIX" + bl_label = "Matrix" + + def draw(self, _context): + layout = self.layout + node_add_menu.add_node_type(layout, "FunctionNodeCombineMatrix4x4") + node_add_menu.add_node_type(layout, "FunctionNodeSeparateMatrix4x4") + node_add_menu.add_node_type(layout, "FunctionNodeMatrix4x4Math") + node_add_menu.draw_assets_for_catalog(layout, self.bl_label) + + class NODE_MT_geometry_node_GEO_MESH(Menu): bl_idname = "NODE_MT_geometry_node_GEO_MESH" bl_label = "Mesh" @@ -423,6 +436,7 @@ class NODE_MT_geometry_node_add_all(Menu): layout.menu("NODE_MT_geometry_node_GEO_INPUT") layout.menu("NODE_MT_geometry_node_GEO_INSTANCE") layout.menu("NODE_MT_geometry_node_GEO_MATERIAL") + layout.menu("NODE_MT_category_GEO_MATRIX") layout.menu("NODE_MT_geometry_node_GEO_MESH") layout.menu("NODE_MT_category_PRIMITIVES_MESH") layout.menu("NODE_MT_geometry_node_mesh_topology") @@ -450,6 +464,7 @@ classes = ( NODE_MT_geometry_node_GEO_INPUT, NODE_MT_geometry_node_GEO_INSTANCE, NODE_MT_geometry_node_GEO_MATERIAL, + NODE_MT_category_GEO_MATRIX, NODE_MT_geometry_node_GEO_MESH, NODE_MT_category_PRIMITIVES_MESH, NODE_MT_geometry_node_mesh_topology, diff --git a/source/blender/nodes/NOD_static_types.h b/source/blender/nodes/NOD_static_types.h index add10d2fa34..a012b7cc1af 100644 --- a/source/blender/nodes/NOD_static_types.h +++ b/source/blender/nodes/NOD_static_types.h @@ -279,9 +279,9 @@ DefNode(FunctionNode, FN_NODE_SEPARATE_COLOR, def_fn_combsep_color, "SEPARATE_CO DefNode(FunctionNode, FN_NODE_SLICE_STRING, 0, "SLICE_STRING", SliceString, "Slice String", "") DefNode(FunctionNode, FN_NODE_STRING_LENGTH, 0, "STRING_LENGTH", StringLength, "String Length", "") DefNode(FunctionNode, FN_NODE_VALUE_TO_STRING, 0, "VALUE_TO_STRING", ValueToString, "Value to String", "") -DefNode(FunctionNode, FN_NODE_INPUT_MATRIX_4X4, def_fn_input_matrix_4x4, "INPUT_MATRIX_4X4", InputMatrix, "4x4 Matrix", "") -DefNode(FunctionNode, FN_NODE_SEPARATE_MATRIX_4X4, def_fn_combsep_matrix, "SEPARATE_MATRIX_4X4", SeparateMatrix, "Separate 4x4 Matrix", "") -DefNode(FunctionNode, FN_NODE_COMBINE_MATRIX_4X4, def_fn_combsep_matrix, "COMBINE_MATRIX_4X4", CombineMatrix, "Combine 4x4 Matrix", "") +DefNode(FunctionNode, FN_NODE_INPUT_MATRIX_4X4, def_fn_input_matrix_4x4, "INPUT_MATRIX_4X4", InputMatrix4x4, "4x4 Matrix", "") +DefNode(FunctionNode, FN_NODE_SEPARATE_MATRIX_4X4, def_fn_combsep_matrix, "SEPARATE_MATRIX_4X4", SeparateMatrix4x4, "Separate 4x4 Matrix", "") +DefNode(FunctionNode, FN_NODE_COMBINE_MATRIX_4X4, def_fn_combsep_matrix, "COMBINE_MATRIX_4X4", CombineMatrix4x4, "Combine 4x4 Matrix", "") DefNode(FunctionNode, FN_NODE_MATRIX_4X4_MATH, def_fn_matrix_4x4_math, "MATRIX_4X4_MATH", Matrix4x4Math, "4x4 Matrix Math", "") DefNode(GeometryNode, GEO_NODE_ACCUMULATE_FIELD, def_geo_accumulate_field, "ACCUMULATE_FIELD", AccumulateField, "Accumulate Field", "Add the values of an evaluated field together and output the running total for each element") -- 2.30.2 From 147a3e635ec26d987d20ab535aaae7be4037c4f8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Sat, 10 Dec 2022 21:07:31 +0000 Subject: [PATCH 15/33] Fix vec3 input of the matrix input node. --- source/blender/makesrna/intern/rna_nodetree.c | 12 ++++++++++-- .../nodes/function/nodes/node_fn_input_matrix.cc | 12 ++++++------ 2 files changed, 16 insertions(+), 8 deletions(-) diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c index 60425a968a4..e91d53c3384 100644 --- a/source/blender/makesrna/intern/rna_nodetree.c +++ b/source/blender/makesrna/intern/rna_nodetree.c @@ -5209,6 +5209,7 @@ static void def_fn_input_matrix_4x4(StructRNA *srna) static const float default_vec0[] = {1.0f, 0.0f, 0.0f}; static const float default_vec1[] = {0.0f, 1.0f, 0.0f}; static const float default_vec2[] = {0.0f, 0.0f, 1.0f}; + static const float default_vec3[] = {0.0f, 0.0f, 0.0f}; static const float default_elements[] = { 1.0f, 0.0f, @@ -5248,17 +5249,24 @@ static void def_fn_input_matrix_4x4(StructRNA *srna) prop = RNA_def_property(srna, "vec1", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "vec1"); RNA_def_property_array(prop, 3); - RNA_def_property_float_array_default(prop, default_vec0); + RNA_def_property_float_array_default(prop, default_vec1); RNA_def_property_ui_text(prop, "Vector 1", "Row or column vector"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); prop = RNA_def_property(srna, "vec2", PROP_FLOAT, PROP_NONE); RNA_def_property_float_sdna(prop, NULL, "vec2"); RNA_def_property_array(prop, 3); - RNA_def_property_float_array_default(prop, default_vec0); + RNA_def_property_float_array_default(prop, default_vec2); RNA_def_property_ui_text(prop, "Vector 2", "Row or column vector"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); + prop = RNA_def_property(srna, "vec3", PROP_FLOAT, PROP_NONE); + RNA_def_property_float_sdna(prop, NULL, "vec3"); + RNA_def_property_array(prop, 3); + RNA_def_property_float_array_default(prop, default_vec3); + RNA_def_property_ui_text(prop, "Vector 3", "Row or column vector"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); + prop = RNA_def_property(srna, "elements", PROP_FLOAT, PROP_MATRIX); RNA_def_property_float_sdna(prop, NULL, "elements"); RNA_def_property_array(prop, 16); diff --git a/source/blender/nodes/function/nodes/node_fn_input_matrix.cc b/source/blender/nodes/function/nodes/node_fn_input_matrix.cc index 32465e97d50..6d128996678 100644 --- a/source/blender/nodes/function/nodes/node_fn_input_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_input_matrix.cc @@ -75,18 +75,18 @@ static void node_build_multi_function(NodeMultiFunctionBuilder &builder) matrix[0][0] = storage.vec0[0]; matrix[0][1] = storage.vec1[0]; matrix[0][2] = storage.vec2[0]; - matrix[0][3] = 0.0f; + matrix[0][3] = storage.vec3[0]; matrix[1][0] = storage.vec0[1]; matrix[1][1] = storage.vec1[1]; matrix[1][2] = storage.vec2[1]; - matrix[1][3] = 0.0f; + matrix[1][3] = storage.vec3[1]; matrix[2][0] = storage.vec0[2]; matrix[2][1] = storage.vec1[2]; matrix[2][2] = storage.vec2[2]; - matrix[2][3] = 0.0f; - matrix[3][0] = storage.vec0[3]; - matrix[3][1] = storage.vec1[3]; - matrix[3][2] = storage.vec2[3]; + matrix[2][3] = storage.vec3[2]; + matrix[3][0] = 0.0f; + matrix[3][1] = 0.0f; + matrix[3][2] = 0.0f; matrix[3][3] = 1.0f; break; case NODE_COMBSEP_MATRIX_ELEMENTS: -- 2.30.2 From eea512fbcc653117d1bda9f61abeeda43367582b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Sun, 11 Dec 2022 19:44:17 +0000 Subject: [PATCH 16/33] Matrix input mode for the instance-on-points node. --- source/blender/makesdna/DNA_node_types.h | 5 ++ source/blender/makesrna/intern/rna_nodetree.c | 16 +++++++ source/blender/nodes/NOD_static_types.h | 2 +- .../function/nodes/node_fn_combine_matrix.cc | 22 +++++---- .../function/nodes/node_fn_matrix_math.cc | 26 +++++----- .../function/nodes/node_fn_separate_matrix.cc | 16 +++---- .../nodes/node_geo_instance_on_points.cc | 48 +++++++++++++++++-- 7 files changed, 100 insertions(+), 35 deletions(-) diff --git a/source/blender/makesdna/DNA_node_types.h b/source/blender/makesdna/DNA_node_types.h index cd361096d50..c7a0f4c0896 100644 --- a/source/blender/makesdna/DNA_node_types.h +++ b/source/blender/makesdna/DNA_node_types.h @@ -2395,3 +2395,8 @@ typedef enum NodeCombSepMatrixMode { NODE_COMBSEP_MATRIX_ROWS = 1, NODE_COMBSEP_MATRIX_ELEMENTS = 2, } NodeCombSepMatrixMode; + +typedef enum GeometryNodeTransformInputMode { + GEO_NODE_TRANSFORM_INPUT_MATRIX = 0, + GEO_NODE_TRANSFORM_INPUT_LOCROTSCALE = 1, +} GeometryNodeTransformInputMode; diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c index e91d53c3384..49f2646d82a 100644 --- a/source/blender/makesrna/intern/rna_nodetree.c +++ b/source/blender/makesrna/intern/rna_nodetree.c @@ -562,6 +562,11 @@ static EnumPropertyItem rna_node_geometry_mesh_circle_fill_type_items[] = { {GEO_NODE_MESH_CIRCLE_FILL_TRIANGLE_FAN, "TRIANGLE_FAN", 0, "Triangles", ""}, {0, NULL, 0, NULL, NULL}, }; + +static const EnumPropertyItem rna_node_geometry_transform_input_mode_items[] = { + {GEO_NODE_TRANSFORM_INPUT_MATRIX, "LEFT", ICON_NONE, "Matrix", "Use instance transforms matrix"}, + {GEO_NODE_TRANSFORM_INPUT_LOCROTSCALE, "LOCROTSCALE", ICON_NONE, "LocRotScale", "Use instance location, rotation, and scale"}, + {0, NULL, 0, NULL, NULL}}; #endif #ifndef RNA_RUNTIME @@ -11013,6 +11018,17 @@ static void def_geo_field_at_index(StructRNA *srna) RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_GeometryNode_socket_update"); } +static void def_geo_instance_on_points(StructRNA *srna) +{ + PropertyRNA *prop; + + prop = RNA_def_property(srna, "transform_mode", PROP_ENUM, PROP_NONE); + RNA_def_property_enum_sdna(prop, NULL, "custom1"); + RNA_def_property_enum_items(prop, rna_node_geometry_transform_input_mode_items); + RNA_def_property_ui_text(prop, "Transform Mode", "Mode of defining transform for instances"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_GeometryNode_socket_update"); +} + static void def_geo_interpolate_domain(StructRNA *srna) { PropertyRNA *prop; diff --git a/source/blender/nodes/NOD_static_types.h b/source/blender/nodes/NOD_static_types.h index a012b7cc1af..17252dfc62c 100644 --- a/source/blender/nodes/NOD_static_types.h +++ b/source/blender/nodes/NOD_static_types.h @@ -352,7 +352,7 @@ DefNode(GeometryNode, GEO_NODE_INPUT_SPLINE_CYCLIC, 0, "INPUT_SPLINE_CYCLIC",Inp DefNode(GeometryNode, GEO_NODE_INPUT_SPLINE_LENGTH, 0, "SPLINE_LENGTH", SplineLength, "Spline Length", "Retrieve the total length of each spline, as a distance or as a number of points") DefNode(GeometryNode, GEO_NODE_INPUT_SPLINE_RESOLUTION, 0, "INPUT_SPLINE_RESOLUTION", InputSplineResolution, "Spline Resolution", "Retrieve the number of evaluated points that will be generated for every control point on curves") DefNode(GeometryNode, GEO_NODE_INPUT_TANGENT, 0, "INPUT_TANGENT", InputTangent, "Curve Tangent", "Retrieve the direction of curves at each control point") -DefNode(GeometryNode, GEO_NODE_INSTANCE_ON_POINTS, 0, "INSTANCE_ON_POINTS", InstanceOnPoints, "Instance on Points", "Generate a reference to geometry at each of the input points, without duplicating its underlying data") +DefNode(GeometryNode, GEO_NODE_INSTANCE_ON_POINTS, def_geo_instance_on_points, "INSTANCE_ON_POINTS", InstanceOnPoints, "Instance on Points", "Generate a reference to geometry at each of the input points, without duplicating its underlying data") DefNode(GeometryNode, GEO_NODE_INSTANCES_TO_POINTS, 0, "INSTANCES_TO_POINTS",InstancesToPoints, "Instances to Points","Generate points at the origins of instances.\nNote: Nested instances are not affected by this node") DefNode(GeometryNode, GEO_NODE_INTERPOLATE_DOMAIN, def_geo_interpolate_domain, "FIELD_ON_DOMAIN", FieldOnDomain, "Interpolate Domain", "Retrieve values from a field on a different domain besides the domain from the context") DefNode(GeometryNode, GEO_NODE_IS_VIEWPORT, 0, "IS_VIEWPORT", IsViewport, "Is Viewport", "Retrieve whether the nodes are being evaluated for the viewport rather than the final render") diff --git a/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc b/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc index 5ebc0ac89b7..32624761ed1 100644 --- a/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc @@ -51,24 +51,26 @@ static void node_update(bNodeTree *tree, bNode *node) const bool show_scalar_sockets = ELEM(mode, NODE_COMBSEP_MATRIX_ELEMENTS); for (const int i : vector_sockets) { - nodeSetSocketAvailability(tree, &node->input_socket(i), show_vector_sockets); + nodeSetSocketAvailability( + tree, (bNodeSocket *)BLI_findlink(&node->inputs, i), show_vector_sockets); } for (const int i : scalar_sockets) { - nodeSetSocketAvailability(tree, &node->input_socket(i), show_scalar_sockets); + nodeSetSocketAvailability( + tree, (bNodeSocket *)BLI_findlink(&node->inputs, i), show_scalar_sockets); } switch (mode) { case NODE_COMBSEP_MATRIX_COLUMNS: - node_sock_label(&node->input_socket(vector_sockets[0]), "Column 0"); - node_sock_label(&node->input_socket(vector_sockets[1]), "Column 1"); - node_sock_label(&node->input_socket(vector_sockets[2]), "Column 2"); - node_sock_label(&node->input_socket(vector_sockets[3]), "Column 3"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[0]), "Column 0"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[1]), "Column 1"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[2]), "Column 2"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[3]), "Column 3"); break; case NODE_COMBSEP_MATRIX_ROWS: - node_sock_label(&node->input_socket(vector_sockets[0]), "Row 0"); - node_sock_label(&node->input_socket(vector_sockets[1]), "Row 1"); - node_sock_label(&node->input_socket(vector_sockets[2]), "Row 2"); - node_sock_label(&node->input_socket(vector_sockets[3]), "Row 3"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[0]), "Row 0"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[1]), "Row 1"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[2]), "Row 2"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[3]), "Row 3"); break; case NODE_COMBSEP_MATRIX_ELEMENTS: break; diff --git a/source/blender/nodes/function/nodes/node_fn_matrix_math.cc b/source/blender/nodes/function/nodes/node_fn_matrix_math.cc index 9bdd580edbe..e52ef200490 100644 --- a/source/blender/nodes/function/nodes/node_fn_matrix_math.cc +++ b/source/blender/nodes/function/nodes/node_fn_matrix_math.cc @@ -50,21 +50,21 @@ static void node_update(bNodeTree *tree, bNode *node) { const NodeMatrixMathOperation op = (NodeMatrixMathOperation)node->custom1; - bNodeSocket *inMatrixA = &node->input_socket(0); - bNodeSocket *inMatrixB = &node->input_socket(1); - bNodeSocket *inScale = &node->input_socket(2); - bNodeSocket *outMatrix = &node->output_socket(3); - bNodeSocket *outValue = &node->output_socket(4); + bNodeSocket *in_matrix_a = (bNodeSocket *)BLI_findlink(&node->inputs, 0); + bNodeSocket *in_matrix_b = (bNodeSocket *)BLI_findlink(&node->inputs, 1); + bNodeSocket *in_scale = (bNodeSocket *)BLI_findlink(&node->inputs, 2); + bNodeSocket *out_matrix = (bNodeSocket *)BLI_findlink(&node->inputs, 3); + bNodeSocket *out_value = (bNodeSocket *)BLI_findlink(&node->inputs, 4); - nodeSetSocketAvailability(tree, inMatrixA, true); + nodeSetSocketAvailability(tree, in_matrix_a, true); nodeSetSocketAvailability( tree, - inMatrixB, + in_matrix_b, ELEM(op, NODE_MATRIX_MATH_ADD, NODE_MATRIX_MATH_SUBTRACT, NODE_MATRIX_MATH_MULTIPLY)); - nodeSetSocketAvailability(tree, inScale, ELEM(op, NODE_MATRIX_MATH_SCALAR_MULTIPLY)); + nodeSetSocketAvailability(tree, in_scale, ELEM(op, NODE_MATRIX_MATH_SCALAR_MULTIPLY)); nodeSetSocketAvailability(tree, - outMatrix, + out_matrix, ELEM(op, NODE_MATRIX_MATH_ADD, NODE_MATRIX_MATH_SUBTRACT, @@ -73,12 +73,12 @@ static void node_update(bNodeTree *tree, bNode *node) NODE_MATRIX_MATH_TRANSPOSE, NODE_MATRIX_MATH_INVERSE)); nodeSetSocketAvailability( - tree, outValue, ELEM(op, NODE_MATRIX_MATH_DETERMINANT, NODE_MATRIX_MATH_TRACE)); + tree, out_value, ELEM(op, NODE_MATRIX_MATH_DETERMINANT, NODE_MATRIX_MATH_TRACE)); /* Labels */ - node_sock_label_clear(inMatrixA); - node_sock_label_clear(inMatrixB); - node_sock_label_clear(inScale); + node_sock_label_clear(in_matrix_a); + node_sock_label_clear(in_matrix_b); + node_sock_label_clear(in_scale); switch (op) { } } diff --git a/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc b/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc index b1931fefb85..e074e739ce4 100644 --- a/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc @@ -59,16 +59,16 @@ static void node_update(bNodeTree *tree, bNode *node) switch (mode) { case NODE_COMBSEP_MATRIX_COLUMNS: - node_sock_label(&node->output_socket(vector_sockets[0]), "Column 0"); - node_sock_label(&node->output_socket(vector_sockets[1]), "Column 1"); - node_sock_label(&node->output_socket(vector_sockets[2]), "Column 2"); - node_sock_label(&node->output_socket(vector_sockets[3]), "Column 3"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[0]), "Column 0"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[1]), "Column 1"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[2]), "Column 2"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[3]), "Column 3"); break; case NODE_COMBSEP_MATRIX_ROWS: - node_sock_label(&node->output_socket(vector_sockets[0]), "Row 0"); - node_sock_label(&node->output_socket(vector_sockets[1]), "Row 1"); - node_sock_label(&node->output_socket(vector_sockets[2]), "Row 2"); - node_sock_label(&node->output_socket(vector_sockets[3]), "Row 3"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[0]), "Row 0"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[1]), "Row 1"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[2]), "Row 2"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[3]), "Row 3"); break; case NODE_COMBSEP_MATRIX_ELEMENTS: break; diff --git a/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc b/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc index 64546684186..90a308f219c 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc @@ -40,10 +40,33 @@ static void node_declare(NodeDeclarationBuilder &b) .subtype(PROP_XYZ) .supports_field() .description(N_("Scale of the instances")); + b.add_input(N_("Matrix")) + .default_value(float4x4::identity()) + .supports_field() + .description(N_("Transform matrix of the instances")); b.add_output(N_("Instances")); } +static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) +{ + uiItemR(layout, ptr, "transform_mode", 0, "", ICON_NONE); +} + +static void node_update(bNodeTree *tree, bNode *node) +{ + const GeometryNodeTransformInputMode transform_mode = (GeometryNodeTransformInputMode) + node->custom1; + + bNodeSocket *in_rotation = nodeFindSocket(node, SOCK_IN, "Rotation"); + bNodeSocket *in_scale = nodeFindSocket(node, SOCK_IN, "Scale"); + bNodeSocket *in_matrix = nodeFindSocket(node, SOCK_IN, "Matrix"); + + nodeSetSocketAvailability(tree, in_rotation, transform_mode == GEO_NODE_TRANSFORM_INPUT_LOCROTSCALE); + nodeSetSocketAvailability(tree, in_scale, transform_mode == GEO_NODE_TRANSFORM_INPUT_LOCROTSCALE); + nodeSetSocketAvailability(tree, in_matrix, transform_mode == GEO_NODE_TRANSFORM_INPUT_MATRIX); +} + static void add_instances_from_component( bke::Instances &dst_component, const GeometryComponent &src_component, @@ -53,11 +76,14 @@ static void add_instances_from_component( { const eAttrDomain domain = ATTR_DOMAIN_POINT; const int domain_num = src_component.attribute_domain_size(domain); + const GeometryNodeTransformInputMode transform_mode = + (GeometryNodeTransformInputMode)params.node().custom1; VArray pick_instance; VArray indices; VArray rotations; VArray scales; + VArray matrices; bke::GeometryFieldContext field_context{src_component, domain}; const Field selection_field = params.get_input>("Selection"); @@ -67,8 +93,15 @@ static void add_instances_from_component( * selected indices should be copied. */ evaluator.add(params.get_input>("Pick Instance"), &pick_instance); evaluator.add(params.get_input>("Instance Index"), &indices); - evaluator.add(params.get_input>("Rotation"), &rotations); - evaluator.add(params.get_input>("Scale"), &scales); + switch (transform_mode) { + case GEO_NODE_TRANSFORM_INPUT_MATRIX: + evaluator.add(params.get_input>("Matrix"), &matrices); + break; + case GEO_NODE_TRANSFORM_INPUT_LOCROTSCALE: + evaluator.add(params.get_input>("Rotation"), &rotations); + evaluator.add(params.get_input>("Scale"), &scales); + break; + } evaluator.evaluate(); const IndexMask selection = evaluator.get_evaluated_selection_as_mask(); @@ -114,7 +147,14 @@ static void add_instances_from_component( /* Compute base transform for every instances. */ float4x4 &dst_transform = dst_transforms[range_i]; - dst_transform = float4x4::from_loc_eul_scale(positions[i], rotations[i], scales[i]); + switch (transform_mode) { + case GEO_NODE_TRANSFORM_INPUT_MATRIX: + dst_transform = matrices[i]; + break; + case GEO_NODE_TRANSFORM_INPUT_LOCROTSCALE: + dst_transform = float4x4::from_loc_eul_scale(positions[i], rotations[i], scales[i]); + break; + } /* Reference that will be used by this new instance. */ int dst_handle = empty_reference_handle; @@ -236,6 +276,8 @@ void register_node_type_geo_instance_on_points() geo_node_type_base( &ntype, GEO_NODE_INSTANCE_ON_POINTS, "Instance on Points", NODE_CLASS_GEOMETRY); ntype.declare = file_ns::node_declare; + ntype.updatefunc = file_ns::node_update; + ntype.draw_buttons = file_ns::node_layout; ntype.geometry_node_execute = file_ns::node_geo_exec; nodeRegisterType(&ntype); } -- 2.30.2 From 9c01a58cebf188e26c3a08266c9216c20e30b6d3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Fri, 16 Dec 2022 14:48:19 +0000 Subject: [PATCH 17/33] Added nodes for both 3x3 and 4x4 matrix variants. --- .../startup/bl_ui/node_add_menu_geometry.py | 6 +- source/blender/blenkernel/BKE_node.h | 12 +- source/blender/makesdna/DNA_node_types.h | 14 +- source/blender/makesrna/intern/rna_nodetree.c | 87 +++---- source/blender/nodes/NOD_static_types.h | 12 +- source/blender/nodes/function/CMakeLists.txt | 12 +- .../nodes/function/node_function_register.cc | 4 + .../nodes/function/node_function_register.hh | 4 + .../nodes/node_fn_combine_matrix3x3.cc | 167 ++++++++++++ ...matrix.cc => node_fn_combine_matrix4x4.cc} | 12 +- .../function/nodes/node_fn_input_matrix.cc | 114 -------- .../function/nodes/node_fn_input_matrix3x3.cc | 52 ++++ .../function/nodes/node_fn_input_matrix4x4.cc | 52 ++++ .../function/nodes/node_fn_matrix3x3_math.cc | 134 ++++++++++ ...trix_math.cc => node_fn_matrix4x4_math.cc} | 2 - .../nodes/node_fn_separate_matrix3x3.cc | 246 ++++++++++++++++++ ...atrix.cc => node_fn_separate_matrix4x4.cc} | 6 +- 17 files changed, 747 insertions(+), 189 deletions(-) create mode 100644 source/blender/nodes/function/nodes/node_fn_combine_matrix3x3.cc rename source/blender/nodes/function/nodes/{node_fn_combine_matrix.cc => node_fn_combine_matrix4x4.cc} (98%) delete mode 100644 source/blender/nodes/function/nodes/node_fn_input_matrix.cc create mode 100644 source/blender/nodes/function/nodes/node_fn_input_matrix3x3.cc create mode 100644 source/blender/nodes/function/nodes/node_fn_input_matrix4x4.cc create mode 100644 source/blender/nodes/function/nodes/node_fn_matrix3x3_math.cc rename source/blender/nodes/function/nodes/{node_fn_matrix_math.cc => node_fn_matrix4x4_math.cc} (98%) create mode 100644 source/blender/nodes/function/nodes/node_fn_separate_matrix3x3.cc rename source/blender/nodes/function/nodes/{node_fn_separate_matrix.cc => node_fn_separate_matrix4x4.cc} (97%) diff --git a/release/scripts/startup/bl_ui/node_add_menu_geometry.py b/release/scripts/startup/bl_ui/node_add_menu_geometry.py index c2c906eaf88..d1f21f4901a 100644 --- a/release/scripts/startup/bl_ui/node_add_menu_geometry.py +++ b/release/scripts/startup/bl_ui/node_add_menu_geometry.py @@ -143,12 +143,13 @@ class NODE_MT_geometry_node_GEO_INPUT(Menu): node_add_menu.add_node_type(layout, "FunctionNodeInputInt") node_add_menu.add_node_type(layout, "GeometryNodeIsViewport") node_add_menu.add_node_type(layout, "GeometryNodeInputMaterial") + node_add_menu.add_node_type(layout, "FunctionNodeInputMatrix3x3") + node_add_menu.add_node_type(layout, "FunctionNodeInputMatrix4x4") node_add_menu.add_node_type(layout, "GeometryNodeObjectInfo") node_add_menu.add_node_type(layout, "GeometryNodeSelfObject") node_add_menu.add_node_type(layout, "FunctionNodeInputString") node_add_menu.add_node_type(layout, "ShaderNodeValue") node_add_menu.add_node_type(layout, "FunctionNodeInputVector") - node_add_menu.add_node_type(layout, "FunctionNodeInputMatrix4x4") layout.separator() node_add_menu.add_node_type(layout, "GeometryNodeInputID") node_add_menu.add_node_type(layout, "GeometryNodeInputIndex") @@ -200,8 +201,11 @@ class NODE_MT_category_GEO_MATRIX(Menu): def draw(self, _context): layout = self.layout + node_add_menu.add_node_type(layout, "FunctionNodeCombineMatrix3x3") node_add_menu.add_node_type(layout, "FunctionNodeCombineMatrix4x4") + node_add_menu.add_node_type(layout, "FunctionNodeSeparateMatrix3x3") node_add_menu.add_node_type(layout, "FunctionNodeSeparateMatrix4x4") + node_add_menu.add_node_type(layout, "FunctionNodeMatrix3x3Math") node_add_menu.add_node_type(layout, "FunctionNodeMatrix4x4Math") node_add_menu.draw_assets_for_catalog(layout, self.bl_label) diff --git a/source/blender/blenkernel/BKE_node.h b/source/blender/blenkernel/BKE_node.h index 86be7f21844..55eb06791f2 100644 --- a/source/blender/blenkernel/BKE_node.h +++ b/source/blender/blenkernel/BKE_node.h @@ -1567,10 +1567,14 @@ struct TexResult; #define FN_NODE_INPUT_INT 1220 #define FN_NODE_SEPARATE_COLOR 1221 #define FN_NODE_COMBINE_COLOR 1222 -#define FN_NODE_INPUT_MATRIX_4X4 1223 -#define FN_NODE_SEPARATE_MATRIX_4X4 1224 -#define FN_NODE_COMBINE_MATRIX_4X4 1225 -#define FN_NODE_MATRIX_4X4_MATH 1226 +#define FN_NODE_INPUT_MATRIX_3X3 1223 +#define FN_NODE_INPUT_MATRIX_4X4 1224 +#define FN_NODE_SEPARATE_MATRIX_3X3 1225 +#define FN_NODE_SEPARATE_MATRIX_4X4 1226 +#define FN_NODE_COMBINE_MATRIX_3X3 1227 +#define FN_NODE_COMBINE_MATRIX_4X4 1228 +#define FN_NODE_MATRIX_3X3_MATH 1229 +#define FN_NODE_MATRIX_4X4_MATH 1230 /** \} */ diff --git a/source/blender/makesdna/DNA_node_types.h b/source/blender/makesdna/DNA_node_types.h index c7a0f4c0896..2fa4ff9cc33 100644 --- a/source/blender/makesdna/DNA_node_types.h +++ b/source/blender/makesdna/DNA_node_types.h @@ -1599,13 +1599,13 @@ typedef struct NodeShaderMix { char _pad[3]; } NodeShaderMix; -typedef struct NodeInputMatrix { - float vec0[3]; - float vec1[3]; - float vec2[3]; - float vec3[3]; - float elements[4][4]; -} NodeInputMatrix; +typedef struct NodeInputMatrix3x3 { + float matrix[3][3]; +} NodeInputMatrix3x3; + +typedef struct NodeInputMatrix4x4 { + float matrix[4][4]; +} NodeInputMatrix4x4; /* script node mode */ #define NODE_SCRIPT_INTERNAL 0 diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c index 49f2646d82a..536f9b2bae1 100644 --- a/source/blender/makesrna/intern/rna_nodetree.c +++ b/source/blender/makesrna/intern/rna_nodetree.c @@ -5209,12 +5209,33 @@ static void def_fn_combsep_color(StructRNA *srna) RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } +static void def_fn_input_matrix_3x3(StructRNA *srna) +{ + static const float default_elements[] = { + 1.0f, + 0.0f, + 0.0f, + 0.0f, + 1.0f, + 0.0f, + 0.0f, + 0.0f, + 1.0f, + }; + PropertyRNA *prop; + + RNA_def_struct_sdna_from(srna, "NodeInputMatrix3x3", "storage"); + + prop = RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX); + RNA_def_property_float_sdna(prop, NULL, "matrix"); + RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_3x3); + RNA_def_property_float_array_default(prop, default_elements); + RNA_def_property_ui_text(prop, "Matrix", "Input value used for unconnected socket"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); +} + static void def_fn_input_matrix_4x4(StructRNA *srna) { - static const float default_vec0[] = {1.0f, 0.0f, 0.0f}; - static const float default_vec1[] = {0.0f, 1.0f, 0.0f}; - static const float default_vec2[] = {0.0f, 0.0f, 1.0f}; - static const float default_vec3[] = {0.0f, 0.0f, 0.0f}; static const float default_elements[] = { 1.0f, 0.0f, @@ -5235,48 +5256,13 @@ static void def_fn_input_matrix_4x4(StructRNA *srna) }; PropertyRNA *prop; - prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "custom1"); - RNA_def_property_enum_items(prop, rna_node_combsep_matrix_items); - RNA_def_property_ui_text(prop, "Mode", "Mode of matrix composition"); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); - RNA_def_struct_sdna_from(srna, "NodeInputInt", "storage"); + RNA_def_struct_sdna_from(srna, "NodeInputMatrix4x4", "storage"); - RNA_def_struct_sdna_from(srna, "NodeInputMatrix", "storage"); - - prop = RNA_def_property(srna, "vec0", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "vec0"); - RNA_def_property_array(prop, 3); - RNA_def_property_float_array_default(prop, default_vec0); - RNA_def_property_ui_text(prop, "Vector 0", "Row or column vector"); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); - - prop = RNA_def_property(srna, "vec1", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "vec1"); - RNA_def_property_array(prop, 3); - RNA_def_property_float_array_default(prop, default_vec1); - RNA_def_property_ui_text(prop, "Vector 1", "Row or column vector"); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); - - prop = RNA_def_property(srna, "vec2", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "vec2"); - RNA_def_property_array(prop, 3); - RNA_def_property_float_array_default(prop, default_vec2); - RNA_def_property_ui_text(prop, "Vector 2", "Row or column vector"); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); - - prop = RNA_def_property(srna, "vec3", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "vec3"); - RNA_def_property_array(prop, 3); - RNA_def_property_float_array_default(prop, default_vec3); - RNA_def_property_ui_text(prop, "Vector 3", "Row or column vector"); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); - - prop = RNA_def_property(srna, "elements", PROP_FLOAT, PROP_MATRIX); - RNA_def_property_float_sdna(prop, NULL, "elements"); - RNA_def_property_array(prop, 16); + prop = RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX); + RNA_def_property_float_sdna(prop, NULL, "matrix"); + RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4); RNA_def_property_float_array_default(prop, default_elements); - RNA_def_property_ui_text(prop, "Integer", "Input value used for unconnected socket"); + RNA_def_property_ui_text(prop, "Matrix", "Input value used for unconnected socket"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } @@ -5291,6 +5277,17 @@ static void def_fn_combsep_matrix(StructRNA *srna) RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } +static void def_fn_matrix_3x3_math(StructRNA *srna) +{ + PropertyRNA *prop; + + prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE); + RNA_def_property_enum_sdna(prop, NULL, "custom1"); + RNA_def_property_enum_items(prop, rna_enum_node_matrix_math_items); + RNA_def_property_ui_text(prop, "Operation", ""); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); +} + static void def_fn_matrix_4x4_math(StructRNA *srna) { PropertyRNA *prop; @@ -5299,7 +5296,7 @@ static void def_fn_matrix_4x4_math(StructRNA *srna) RNA_def_property_enum_sdna(prop, NULL, "custom1"); RNA_def_property_enum_items(prop, rna_enum_node_matrix_math_items); RNA_def_property_ui_text(prop, "Operation", ""); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNode_socket_update"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } /* -- Shader Nodes ---------------------------------------------------------- */ diff --git a/source/blender/nodes/NOD_static_types.h b/source/blender/nodes/NOD_static_types.h index 17252dfc62c..edb6a36e7d7 100644 --- a/source/blender/nodes/NOD_static_types.h +++ b/source/blender/nodes/NOD_static_types.h @@ -264,25 +264,29 @@ DefNode(TextureNode, TEX_NODE_PROC+TEX_DISTNOISE, 0, "TEX_DI DefNode(FunctionNode, FN_NODE_ALIGN_EULER_TO_VECTOR, def_fn_align_euler_to_vector, "ALIGN_EULER_TO_VECTOR", AlignEulerToVector, "Align Euler to Vector", "") DefNode(FunctionNode, FN_NODE_BOOLEAN_MATH, def_boolean_math, "BOOLEAN_MATH", BooleanMath, "Boolean Math", "") DefNode(FunctionNode, FN_NODE_COMBINE_COLOR, def_fn_combsep_color, "COMBINE_COLOR", CombineColor, "Combine Color", "") +DefNode(FunctionNode, FN_NODE_COMBINE_MATRIX_3X3, def_fn_combsep_matrix, "COMBINE_MATRIX_3X3", CombineMatrix3x3, "Combine 3x3 Matrix", "") +DefNode(FunctionNode, FN_NODE_COMBINE_MATRIX_4X4, def_fn_combsep_matrix, "COMBINE_MATRIX_4X4", CombineMatrix4x4, "Combine 4x4 Matrix", "") DefNode(FunctionNode, FN_NODE_COMPARE, def_compare, "COMPARE", Compare, "Compare", "") DefNode(FunctionNode, FN_NODE_FLOAT_TO_INT, def_float_to_int, "FLOAT_TO_INT", FloatToInt, "Float to Integer", "") DefNode(FunctionNode, FN_NODE_INPUT_BOOL, def_fn_input_bool, "INPUT_BOOL", InputBool, "Boolean", "") DefNode(FunctionNode, FN_NODE_INPUT_COLOR, def_fn_input_color, "INPUT_COLOR", InputColor, "Color", "") DefNode(FunctionNode, FN_NODE_INPUT_INT, def_fn_input_int, "INPUT_INT", InputInt, "Integer", "") +DefNode(FunctionNode, FN_NODE_INPUT_MATRIX_3X3, def_fn_input_matrix_3x3, "INPUT_MATRIX_3X3", InputMatrix3x3, "3x3 Matrix", "") +DefNode(FunctionNode, FN_NODE_INPUT_MATRIX_4X4, def_fn_input_matrix_4x4, "INPUT_MATRIX_4X4", InputMatrix4x4, "4x4 Matrix", "") DefNode(FunctionNode, FN_NODE_INPUT_SPECIAL_CHARACTERS, 0, "INPUT_SPECIAL_CHARACTERS", InputSpecialCharacters, "Special Characters", "") DefNode(FunctionNode, FN_NODE_INPUT_STRING, def_fn_input_string, "INPUT_STRING", InputString, "String", "") DefNode(FunctionNode, FN_NODE_INPUT_VECTOR, def_fn_input_vector, "INPUT_VECTOR", InputVector, "Vector", "") +DefNode(FunctionNode, FN_NODE_MATRIX_3X3_MATH, def_fn_matrix_3x3_math, "MATRIX_3X3_MATH", Matrix3x3Math, "3x3 Matrix Math", "") +DefNode(FunctionNode, FN_NODE_MATRIX_4X4_MATH, def_fn_matrix_4x4_math, "MATRIX_4X4_MATH", Matrix4x4Math, "4x4 Matrix Math", "") DefNode(FunctionNode, FN_NODE_RANDOM_VALUE, def_fn_random_value, "RANDOM_VALUE", RandomValue, "Random Value", "") DefNode(FunctionNode, FN_NODE_REPLACE_STRING, 0, "REPLACE_STRING", ReplaceString, "Replace String", "") DefNode(FunctionNode, FN_NODE_ROTATE_EULER, def_fn_rotate_euler, "ROTATE_EULER", RotateEuler, "Rotate Euler", "") DefNode(FunctionNode, FN_NODE_SEPARATE_COLOR, def_fn_combsep_color, "SEPARATE_COLOR", SeparateColor, "Separate Color", "") +DefNode(FunctionNode, FN_NODE_SEPARATE_MATRIX_3X3, def_fn_combsep_matrix, "SEPARATE_MATRIX_3X3", SeparateMatrix3x3, "Separate 3x3 Matrix", "") +DefNode(FunctionNode, FN_NODE_SEPARATE_MATRIX_4X4, def_fn_combsep_matrix, "SEPARATE_MATRIX_4X4", SeparateMatrix4x4, "Separate 4x4 Matrix", "") DefNode(FunctionNode, FN_NODE_SLICE_STRING, 0, "SLICE_STRING", SliceString, "Slice String", "") DefNode(FunctionNode, FN_NODE_STRING_LENGTH, 0, "STRING_LENGTH", StringLength, "String Length", "") DefNode(FunctionNode, FN_NODE_VALUE_TO_STRING, 0, "VALUE_TO_STRING", ValueToString, "Value to String", "") -DefNode(FunctionNode, FN_NODE_INPUT_MATRIX_4X4, def_fn_input_matrix_4x4, "INPUT_MATRIX_4X4", InputMatrix4x4, "4x4 Matrix", "") -DefNode(FunctionNode, FN_NODE_SEPARATE_MATRIX_4X4, def_fn_combsep_matrix, "SEPARATE_MATRIX_4X4", SeparateMatrix4x4, "Separate 4x4 Matrix", "") -DefNode(FunctionNode, FN_NODE_COMBINE_MATRIX_4X4, def_fn_combsep_matrix, "COMBINE_MATRIX_4X4", CombineMatrix4x4, "Combine 4x4 Matrix", "") -DefNode(FunctionNode, FN_NODE_MATRIX_4X4_MATH, def_fn_matrix_4x4_math, "MATRIX_4X4_MATH", Matrix4x4Math, "4x4 Matrix Math", "") DefNode(GeometryNode, GEO_NODE_ACCUMULATE_FIELD, def_geo_accumulate_field, "ACCUMULATE_FIELD", AccumulateField, "Accumulate Field", "Add the values of an evaluated field together and output the running total for each element") DefNode(GeometryNode, GEO_NODE_ATTRIBUTE_DOMAIN_SIZE, def_geo_attribute_domain_size, "ATTRIBUTE_DOMAIN_SIZE", AttributeDomainSize, "Domain Size", "Retrieve the number of elements in a geometry for each attribute domain") diff --git a/source/blender/nodes/function/CMakeLists.txt b/source/blender/nodes/function/CMakeLists.txt index 88c78518224..d67b361a5a9 100644 --- a/source/blender/nodes/function/CMakeLists.txt +++ b/source/blender/nodes/function/CMakeLists.txt @@ -21,22 +21,26 @@ set(SRC nodes/node_fn_align_euler_to_vector.cc nodes/node_fn_boolean_math.cc nodes/node_fn_combine_color.cc - nodes/node_fn_combine_matrix.cc + nodes/node_fn_combine_matrix3x3.cc + nodes/node_fn_combine_matrix4x4.cc nodes/node_fn_compare.cc nodes/node_fn_float_to_int.cc nodes/node_fn_input_bool.cc nodes/node_fn_input_color.cc nodes/node_fn_input_int.cc - nodes/node_fn_input_matrix.cc + nodes/node_fn_input_matrix3x3.cc + nodes/node_fn_input_matrix4x4.cc nodes/node_fn_input_special_characters.cc nodes/node_fn_input_string.cc nodes/node_fn_input_vector.cc - nodes/node_fn_matrix_math.cc + nodes/node_fn_matrix3x3_math.cc + nodes/node_fn_matrix4x4_math.cc nodes/node_fn_random_value.cc nodes/node_fn_replace_string.cc nodes/node_fn_rotate_euler.cc nodes/node_fn_separate_color.cc - nodes/node_fn_separate_matrix.cc + nodes/node_fn_separate_matrix3x3.cc + nodes/node_fn_separate_matrix4x4.cc nodes/node_fn_slice_string.cc nodes/node_fn_string_length.cc nodes/node_fn_value_to_string.cc diff --git a/source/blender/nodes/function/node_function_register.cc b/source/blender/nodes/function/node_function_register.cc index 9d0de0c6807..52bd9dd3465 100644 --- a/source/blender/nodes/function/node_function_register.cc +++ b/source/blender/nodes/function/node_function_register.cc @@ -9,21 +9,25 @@ void register_function_nodes() register_node_type_fn_align_euler_to_vector(); register_node_type_fn_boolean_math(); register_node_type_fn_combine_color(); + register_node_type_fn_combine_matrix_3x3(); register_node_type_fn_combine_matrix_4x4(); register_node_type_fn_compare(); register_node_type_fn_float_to_int(); register_node_type_fn_input_bool(); register_node_type_fn_input_color(); register_node_type_fn_input_int(); + register_node_type_fn_input_matrix_3x3(); register_node_type_fn_input_matrix_4x4(); register_node_type_fn_input_special_characters(); register_node_type_fn_input_string(); register_node_type_fn_input_vector(); + register_node_type_fn_matrix_3x3_math(); register_node_type_fn_matrix_4x4_math(); register_node_type_fn_random_value(); register_node_type_fn_replace_string(); register_node_type_fn_rotate_euler(); register_node_type_fn_separate_color(); + register_node_type_fn_separate_matrix_3x3(); register_node_type_fn_separate_matrix_4x4(); register_node_type_fn_slice_string(); register_node_type_fn_string_length(); diff --git a/source/blender/nodes/function/node_function_register.hh b/source/blender/nodes/function/node_function_register.hh index 4104dd983c1..3ac1a588c45 100644 --- a/source/blender/nodes/function/node_function_register.hh +++ b/source/blender/nodes/function/node_function_register.hh @@ -5,21 +5,25 @@ void register_node_type_fn_align_euler_to_vector(); void register_node_type_fn_boolean_math(); void register_node_type_fn_combine_color(); +void register_node_type_fn_combine_matrix_3x3(); void register_node_type_fn_combine_matrix_4x4(); void register_node_type_fn_compare(); void register_node_type_fn_float_to_int(); void register_node_type_fn_input_bool(); void register_node_type_fn_input_color(); void register_node_type_fn_input_int(); +void register_node_type_fn_input_matrix_3x3(); void register_node_type_fn_input_matrix_4x4(); void register_node_type_fn_input_special_characters(); void register_node_type_fn_input_string(); void register_node_type_fn_input_vector(); +void register_node_type_fn_matrix_3x3_math(); void register_node_type_fn_matrix_4x4_math(); void register_node_type_fn_random_value(); void register_node_type_fn_replace_string(); void register_node_type_fn_rotate_euler(); void register_node_type_fn_separate_color(); +void register_node_type_fn_separate_matrix_3x3(); void register_node_type_fn_separate_matrix_4x4(); void register_node_type_fn_slice_string(); void register_node_type_fn_string_length(); diff --git a/source/blender/nodes/function/nodes/node_fn_combine_matrix3x3.cc b/source/blender/nodes/function/nodes/node_fn_combine_matrix3x3.cc new file mode 100644 index 00000000000..25f6ef6f77e --- /dev/null +++ b/source/blender/nodes/function/nodes/node_fn_combine_matrix3x3.cc @@ -0,0 +1,167 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "node_function_util.hh" + +#include "BKE_node_runtime.hh" + +#include "UI_interface.h" +#include "UI_resources.h" + +namespace blender::nodes::node_fn_combine_matrix3x3_cc { + +static void node_declare(NodeDeclarationBuilder &b) +{ + b.is_function_node(); + b.add_input(N_("Vec0")).default_value({1.0f, 0.0f, 0.0f}); + b.add_input(N_("Vec1")).default_value({0.0f, 1.0f, 0.0f}); + b.add_input(N_("Vec2")).default_value({0.0f, 0.0f, 1.0f}); + b.add_input(N_("Row 0 Col 0")).default_value(1.0f); + b.add_input(N_("Row 1 Col 0")).default_value(0.0f); + b.add_input(N_("Row 2 Col 0")).default_value(0.0f); + b.add_input(N_("Row 0 Col 1")).default_value(0.0f); + b.add_input(N_("Row 1 Col 1")).default_value(1.0f); + b.add_input(N_("Row 2 Col 1")).default_value(0.0f); + b.add_input(N_("Row 0 Col 2")).default_value(0.0f); + b.add_input(N_("Row 1 Col 2")).default_value(0.0f); + b.add_input(N_("Row 2 Col 2")).default_value(1.0f); + b.add_output(N_("Matrix")); +}; + +static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) +{ + uiItemR(layout, ptr, "mode", 0, "", ICON_NONE); +} + +static void node_update(bNodeTree *tree, bNode *node) +{ + const NodeCombSepMatrixMode mode = (NodeCombSepMatrixMode)node->custom1; + + const IndexRange vector_sockets(0, 4); + const IndexRange scalar_sockets(3, 9); + const bool show_vector_sockets = ELEM( + mode, NODE_COMBSEP_MATRIX_COLUMNS, NODE_COMBSEP_MATRIX_ROWS); + const bool show_scalar_sockets = ELEM(mode, NODE_COMBSEP_MATRIX_ELEMENTS); + + for (const int i : vector_sockets) { + nodeSetSocketAvailability( + tree, (bNodeSocket *)BLI_findlink(&node->inputs, i), show_vector_sockets); + } + for (const int i : scalar_sockets) { + nodeSetSocketAvailability( + tree, (bNodeSocket *)BLI_findlink(&node->inputs, i), show_scalar_sockets); + } + + switch (mode) { + case NODE_COMBSEP_MATRIX_COLUMNS: + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[0]), "Column 0"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[1]), "Column 1"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[2]), "Column 2"); + break; + case NODE_COMBSEP_MATRIX_ROWS: + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[0]), "Row 0"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[1]), "Row 1"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[2]), "Row 2"); + break; + case NODE_COMBSEP_MATRIX_ELEMENTS: + break; + } +} + +static void node_init(bNodeTree * /*tree*/, bNode *node) +{ + node->custom1 = NODE_COMBSEP_MATRIX_COLUMNS; +} + +static const fn::MultiFunction *get_multi_function(const bNode &bnode) +{ + const NodeCombSepMatrixMode mode = (NodeCombSepMatrixMode)bnode.custom1; + + static fn::CustomMF_SI_SI_SI_SO + columns_to_matrix_fn{ + "columns_to_matrix", + [](const float3 &c0, const float3 &c1, const float3 &c2) { + float4x4 m; + copy_v3_v3(m[0], c0); + copy_v3_v3(m[1], c1); + copy_v3_v3(m[2], c2); + return m; + }}; + static fn::CustomMF_SI_SI_SI_SO rows_to_matrix_fn{ + "rows_to_matrix", + [](const float3 &r0, const float3 &r1, const float3 &r2) { + float4x4 m; + m[0][0] = r0[0]; + m[0][1] = r1[0]; + m[0][2] = r2[0]; + m[1][0] = r0[1]; + m[1][1] = r1[1]; + m[1][2] = r2[1]; + m[2][0] = r0[2]; + m[2][1] = r1[2]; + m[2][2] = r2[2]; + return m; + }}; + using Element = fn::MFParamTag; + using Matrix = fn::MFParamTag; + static fn::CustomMF + elements_to_matrix_fn{ + "elements_to_matrix", + [](float m00, + float m01, + float m02, + float m10, + float m11, + float m12, + float m20, + float m21, + float m22, + float3x3 *result) { + const float elements[] = {m00, m01, m02, m10, m11, m12, m20, m21, m22}; + *result = float3x3(elements); + }}; + + switch (mode) { + case NODE_COMBSEP_MATRIX_COLUMNS: + return &columns_to_matrix_fn; + case NODE_COMBSEP_MATRIX_ROWS: + return &rows_to_matrix_fn; + case NODE_COMBSEP_MATRIX_ELEMENTS: + return &elements_to_matrix_fn; + } + + BLI_assert_unreachable(); + return nullptr; +} + +static void node_build_multi_function(NodeMultiFunctionBuilder &builder) +{ + const fn::MultiFunction *fn = get_multi_function(builder.node()); + builder.set_matching_fn(fn); +} + +} // namespace blender::nodes::node_fn_combine_matrix3x3_cc + +void register_node_type_fn_combine_matrix_3x3(void) +{ + namespace file_ns = blender::nodes::node_fn_combine_matrix3x3_cc; + + static bNodeType ntype; + + fn_node_type_base(&ntype, FN_NODE_COMBINE_MATRIX_3X3, "Combine 3x3 Matrix", NODE_CLASS_CONVERTER); + ntype.declare = file_ns::node_declare; + ntype.updatefunc = file_ns::node_update; + ntype.initfunc = file_ns::node_init; + ntype.build_multi_function = file_ns::node_build_multi_function; + ntype.draw_buttons = file_ns::node_layout; + + nodeRegisterType(&ntype); +} diff --git a/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc b/source/blender/nodes/function/nodes/node_fn_combine_matrix4x4.cc similarity index 98% rename from source/blender/nodes/function/nodes/node_fn_combine_matrix.cc rename to source/blender/nodes/function/nodes/node_fn_combine_matrix4x4.cc index 32624761ed1..0317bfef10a 100644 --- a/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_combine_matrix4x4.cc @@ -108,18 +108,18 @@ static const fn::MultiFunction *get_multi_function(const bNode &bnode) m[0][0] = r0[0]; m[0][1] = r1[0]; m[0][2] = r2[0]; - m[0][3] = 0.0f; + m[0][3] = r3[0]; m[1][0] = r0[1]; m[1][1] = r1[1]; m[1][2] = r2[1]; - m[1][3] = 0.0f; + m[1][3] = r3[1]; m[2][0] = r0[2]; m[2][1] = r1[2]; m[2][2] = r2[2]; - m[2][3] = 0.0f; - m[3][0] = r0[3]; - m[3][1] = r1[3]; - m[3][2] = r2[3]; + m[2][3] = r3[2]; + m[3][0] = 0.0f; + m[3][1] = 0.0f; + m[3][2] = 0.0f; m[3][3] = 1.0f; return m; }}; diff --git a/source/blender/nodes/function/nodes/node_fn_input_matrix.cc b/source/blender/nodes/function/nodes/node_fn_input_matrix.cc deleted file mode 100644 index 6d128996678..00000000000 --- a/source/blender/nodes/function/nodes/node_fn_input_matrix.cc +++ /dev/null @@ -1,114 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "node_function_util.hh" - -#include "BKE_node_runtime.hh" - -#include "UI_interface.h" -#include "UI_resources.h" - -namespace blender::nodes::node_fn_input_matrix4x4_cc { - -NODE_STORAGE_FUNCS(NodeInputMatrix); - -static void node_declare(NodeDeclarationBuilder &b) -{ - b.add_output(N_("Matrix")); -}; - -static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) -{ - const bNode *node = (const bNode *)ptr->data; - const NodeCombSepMatrixMode mode = (NodeCombSepMatrixMode)node->custom1; - - uiItemR(layout, ptr, "mode", 0, "", ICON_NONE); - - switch (mode) { - case NODE_COMBSEP_MATRIX_COLUMNS: - uiItemR(layout, ptr, "vec0", 0, "Column 0", ICON_NONE); - uiItemR(layout, ptr, "vec1", 0, "Column 1", ICON_NONE); - uiItemR(layout, ptr, "vec2", 0, "Column 2", ICON_NONE); - uiItemR(layout, ptr, "vec3", 0, "Column 3", ICON_NONE); - break; - case NODE_COMBSEP_MATRIX_ROWS: - uiItemR(layout, ptr, "vec0", 0, "Row 0", ICON_NONE); - uiItemR(layout, ptr, "vec1", 0, "Row 1", ICON_NONE); - uiItemR(layout, ptr, "vec2", 0, "Row 2", ICON_NONE); - uiItemR(layout, ptr, "vec3", 0, "Row 3", ICON_NONE); - break; - case NODE_COMBSEP_MATRIX_ELEMENTS: - uiItemR(layout, ptr, "elements", 0, "", ICON_NONE); - break; - } -} - -static void node_init(bNodeTree * /*tree*/, bNode *node) -{ - node->custom1 = NODE_COMBSEP_MATRIX_COLUMNS; - - NodeInputMatrix *data = MEM_new(__func__); - copy_v3_v3(data->vec0, float3(1.0f, 0.0f, 0.0f)); - copy_v3_v3(data->vec1, float3(0.0f, 1.0f, 0.0f)); - copy_v3_v3(data->vec2, float3(0.0f, 0.0f, 1.0f)); - copy_v3_v3(data->vec3, float3(0.0f, 0.0f, 0.0f)); - unit_m4(data->elements); - node->storage = data; -} - -static void node_build_multi_function(NodeMultiFunctionBuilder &builder) -{ - const NodeInputMatrix &storage = node_storage(builder.node()); - const NodeCombSepMatrixMode mode = (NodeCombSepMatrixMode)builder.node().custom1; - float4x4 matrix; - switch (mode) { - case NODE_COMBSEP_MATRIX_COLUMNS: - copy_v3_v3(matrix[0], storage.vec0); - matrix[0][3] = 0.0f; - copy_v3_v3(matrix[1], storage.vec1); - matrix[1][3] = 0.0f; - copy_v3_v3(matrix[2], storage.vec2); - matrix[2][3] = 0.0f; - copy_v3_v3(matrix[3], storage.vec3); - matrix[3][3] = 1.0f; - break; - case NODE_COMBSEP_MATRIX_ROWS: - matrix[0][0] = storage.vec0[0]; - matrix[0][1] = storage.vec1[0]; - matrix[0][2] = storage.vec2[0]; - matrix[0][3] = storage.vec3[0]; - matrix[1][0] = storage.vec0[1]; - matrix[1][1] = storage.vec1[1]; - matrix[1][2] = storage.vec2[1]; - matrix[1][3] = storage.vec3[1]; - matrix[2][0] = storage.vec0[2]; - matrix[2][1] = storage.vec1[2]; - matrix[2][2] = storage.vec2[2]; - matrix[2][3] = storage.vec3[2]; - matrix[3][0] = 0.0f; - matrix[3][1] = 0.0f; - matrix[3][2] = 0.0f; - matrix[3][3] = 1.0f; - break; - case NODE_COMBSEP_MATRIX_ELEMENTS: - matrix = float4x4(storage.elements); - break; - } - builder.construct_and_set_matching_fn>(matrix); -} - -} // namespace blender::nodes::node_fn_input_matrix4x4_cc - -void register_node_type_fn_input_matrix_4x4(void) -{ - namespace file_ns = blender::nodes::node_fn_input_matrix4x4_cc; - - static bNodeType ntype; - - fn_node_type_base(&ntype, FN_NODE_INPUT_MATRIX_4X4, "4x4 Matrix", NODE_CLASS_INPUT); - ntype.declare = file_ns::node_declare; - ntype.initfunc = file_ns::node_init; - ntype.build_multi_function = file_ns::node_build_multi_function; - ntype.draw_buttons = file_ns::node_layout; - - nodeRegisterType(&ntype); -} diff --git a/source/blender/nodes/function/nodes/node_fn_input_matrix3x3.cc b/source/blender/nodes/function/nodes/node_fn_input_matrix3x3.cc new file mode 100644 index 00000000000..f8f284b11e1 --- /dev/null +++ b/source/blender/nodes/function/nodes/node_fn_input_matrix3x3.cc @@ -0,0 +1,52 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "node_function_util.hh" + +#include "BKE_node_runtime.hh" + +#include "UI_interface.h" +#include "UI_resources.h" + +namespace blender::nodes::node_fn_input_matrix3x3_cc { + +NODE_STORAGE_FUNCS(NodeInputMatrix3x3); + +static void node_declare(NodeDeclarationBuilder &b) +{ + b.add_output(N_("Matrix")); +}; + +static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) +{ + uiItemR(layout, ptr, "matrix", 0, "", ICON_NONE); +} + +static void node_init(bNodeTree * /*tree*/, bNode *node) +{ + NodeInputMatrix3x3 *data = MEM_new(__func__); + unit_m3(data->matrix); + node->storage = data; +} + +static void node_build_multi_function(NodeMultiFunctionBuilder &builder) +{ + const NodeInputMatrix3x3 &storage = node_storage(builder.node()); + builder.construct_and_set_matching_fn>(float3x3{storage.matrix}); +} + +} // namespace blender::nodes::node_fn_input_matrix3x3_cc + +void register_node_type_fn_input_matrix_3x3(void) +{ + namespace file_ns = blender::nodes::node_fn_input_matrix3x3_cc; + + static bNodeType ntype; + + fn_node_type_base(&ntype, FN_NODE_INPUT_MATRIX_3X3, "3x3 Matrix", NODE_CLASS_INPUT); + ntype.declare = file_ns::node_declare; + ntype.initfunc = file_ns::node_init; + ntype.build_multi_function = file_ns::node_build_multi_function; + ntype.draw_buttons = file_ns::node_layout; + + nodeRegisterType(&ntype); +} diff --git a/source/blender/nodes/function/nodes/node_fn_input_matrix4x4.cc b/source/blender/nodes/function/nodes/node_fn_input_matrix4x4.cc new file mode 100644 index 00000000000..97482ad7b11 --- /dev/null +++ b/source/blender/nodes/function/nodes/node_fn_input_matrix4x4.cc @@ -0,0 +1,52 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "node_function_util.hh" + +#include "BKE_node_runtime.hh" + +#include "UI_interface.h" +#include "UI_resources.h" + +namespace blender::nodes::node_fn_input_matrix4x4_cc { + +NODE_STORAGE_FUNCS(NodeInputMatrix4x4); + +static void node_declare(NodeDeclarationBuilder &b) +{ + b.add_output(N_("Matrix")); +}; + +static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) +{ + uiItemR(layout, ptr, "matrix", 0, "", ICON_NONE); +} + +static void node_init(bNodeTree * /*tree*/, bNode *node) +{ + NodeInputMatrix4x4 *data = MEM_new(__func__); + unit_m4(data->matrix); + node->storage = data; +} + +static void node_build_multi_function(NodeMultiFunctionBuilder &builder) +{ + const NodeInputMatrix4x4 &storage = node_storage(builder.node()); + builder.construct_and_set_matching_fn>(float4x4{storage.matrix}); +} + +} // namespace blender::nodes::node_fn_input_matrix4x4_cc + +void register_node_type_fn_input_matrix_4x4(void) +{ + namespace file_ns = blender::nodes::node_fn_input_matrix4x4_cc; + + static bNodeType ntype; + + fn_node_type_base(&ntype, FN_NODE_INPUT_MATRIX_4X4, "4x4 Matrix", NODE_CLASS_INPUT); + ntype.declare = file_ns::node_declare; + ntype.initfunc = file_ns::node_init; + ntype.build_multi_function = file_ns::node_build_multi_function; + ntype.draw_buttons = file_ns::node_layout; + + nodeRegisterType(&ntype); +} diff --git a/source/blender/nodes/function/nodes/node_fn_matrix3x3_math.cc b/source/blender/nodes/function/nodes/node_fn_matrix3x3_math.cc new file mode 100644 index 00000000000..e98057e23a2 --- /dev/null +++ b/source/blender/nodes/function/nodes/node_fn_matrix3x3_math.cc @@ -0,0 +1,134 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "node_function_util.hh" + +#include "BKE_node_runtime.hh" + +#include "NOD_socket_search_link.hh" + +#include "UI_interface.h" +#include "UI_resources.h" + +namespace blender::math { + +/* XXX These are placeholder functions based on BLI math until SIMD versions are available */ + +inline float3x3 [[nodiscard]] add(const float3x3 &a, const float3x3 &b) +{ + float3x3 r; + add_m3_m3m3(r.ptr(), a.ptr(), b.ptr()); + return r; +} + +inline float3x3 [[nodiscard]] subtract(const float3x3 &a, const float3x3 &b) +{ + float3x3 r; + sub_m3_m3m3(r.ptr(), a.ptr(), b.ptr()); + return r; +} + +} + +namespace blender::nodes::node_fn_matrix3x3_math_cc { + +static void node_declare(NodeDeclarationBuilder &b) +{ + b.is_function_node(); + b.add_input(N_("Matrix")); + b.add_input(N_("Matrix"), "Matrix_001"); + b.add_input(N_("Scale")).default_value(1.0f); + b.add_output(N_("Matrix")); + b.add_output(N_("Value")); +}; + +static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) +{ + uiItemR(layout, ptr, "operation", UI_ITEM_R_SPLIT_EMPTY_NAME, "", ICON_NONE); +} + +static void node_update(bNodeTree *tree, bNode *node) +{ + const NodeMatrixMathOperation op = (NodeMatrixMathOperation)node->custom1; + + bNodeSocket *in_matrix_a = (bNodeSocket *)BLI_findlink(&node->inputs, 0); + bNodeSocket *in_matrix_b = (bNodeSocket *)BLI_findlink(&node->inputs, 1); + bNodeSocket *in_scale = (bNodeSocket *)BLI_findlink(&node->inputs, 2); + bNodeSocket *out_matrix = (bNodeSocket *)BLI_findlink(&node->inputs, 3); + bNodeSocket *out_value = (bNodeSocket *)BLI_findlink(&node->inputs, 4); + + nodeSetSocketAvailability(tree, in_matrix_a, true); + nodeSetSocketAvailability( + tree, + in_matrix_b, + ELEM(op, NODE_MATRIX_MATH_ADD, NODE_MATRIX_MATH_SUBTRACT, NODE_MATRIX_MATH_MULTIPLY)); + nodeSetSocketAvailability(tree, in_scale, ELEM(op, NODE_MATRIX_MATH_SCALAR_MULTIPLY)); + + nodeSetSocketAvailability(tree, + out_matrix, + ELEM(op, + NODE_MATRIX_MATH_ADD, + NODE_MATRIX_MATH_SUBTRACT, + NODE_MATRIX_MATH_SCALAR_MULTIPLY, + NODE_MATRIX_MATH_MULTIPLY, + NODE_MATRIX_MATH_TRANSPOSE, + NODE_MATRIX_MATH_INVERSE)); + nodeSetSocketAvailability( + tree, out_value, ELEM(op, NODE_MATRIX_MATH_DETERMINANT, NODE_MATRIX_MATH_TRACE)); + + /* Labels */ + node_sock_label_clear(in_matrix_a); + node_sock_label_clear(in_matrix_b); + node_sock_label_clear(in_scale); + switch (op) { + } +} + +static void node_init(bNodeTree * /*tree*/, bNode *node) +{ + node->custom1 = NODE_MATRIX_MATH_ADD; +} + +static const fn::MultiFunction *get_multi_function(NodeMatrixMathOperation op) +{ + static auto exec_preset_fast = fn::CustomMF_presets::AllSpanOrSingle(); + static auto exec_preset_slow = fn::CustomMF_presets::Materialized(); + + const fn::MultiFunction *multi_fn = nullptr; + + switch (op) { + case NODE_MATRIX_MATH_ADD: { + static fn::CustomMF_SI_SI_SO fn{ + "add", + [](const float3x3 &a, const float3x3 &b) -> float3x3 { return math::add(a, b); }, + exec_preset_fast}; + return &fn; + } + } + + return nullptr; +} + +static void node_build_multi_function(NodeMultiFunctionBuilder &builder) +{ + const NodeMatrixMathOperation op = (NodeMatrixMathOperation)builder.node().custom1; + const fn::MultiFunction *fn = get_multi_function(op); + builder.set_matching_fn(fn); +} + +} // namespace blender::nodes::node_fn_matrix3x3_math_cc + +void register_node_type_fn_matrix_3x3_math(void) +{ + namespace file_ns = blender::nodes::node_fn_matrix3x3_math_cc; + + static bNodeType ntype; + + fn_node_type_base(&ntype, FN_NODE_MATRIX_3X3_MATH, "3x3 Matrix Math", NODE_CLASS_CONVERTER); + ntype.declare = file_ns::node_declare; + ntype.updatefunc = file_ns::node_update; + ntype.initfunc = file_ns::node_init; + ntype.build_multi_function = file_ns::node_build_multi_function; + ntype.draw_buttons = file_ns::node_layout; + + nodeRegisterType(&ntype); +} diff --git a/source/blender/nodes/function/nodes/node_fn_matrix_math.cc b/source/blender/nodes/function/nodes/node_fn_matrix4x4_math.cc similarity index 98% rename from source/blender/nodes/function/nodes/node_fn_matrix_math.cc rename to source/blender/nodes/function/nodes/node_fn_matrix4x4_math.cc index e52ef200490..5237310db61 100644 --- a/source/blender/nodes/function/nodes/node_fn_matrix_math.cc +++ b/source/blender/nodes/function/nodes/node_fn_matrix4x4_math.cc @@ -93,8 +93,6 @@ static const fn::MultiFunction *get_multi_function(NodeMatrixMathOperation op) static auto exec_preset_fast = fn::CustomMF_presets::AllSpanOrSingle(); static auto exec_preset_slow = fn::CustomMF_presets::Materialized(); - const fn::MultiFunction *multi_fn = nullptr; - switch (op) { case NODE_MATRIX_MATH_ADD: { static fn::CustomMF_SI_SI_SO fn{ diff --git a/source/blender/nodes/function/nodes/node_fn_separate_matrix3x3.cc b/source/blender/nodes/function/nodes/node_fn_separate_matrix3x3.cc new file mode 100644 index 00000000000..dcb051e4162 --- /dev/null +++ b/source/blender/nodes/function/nodes/node_fn_separate_matrix3x3.cc @@ -0,0 +1,246 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "node_function_util.hh" + +#include "BKE_node_runtime.hh" + +#include "UI_interface.h" +#include "UI_resources.h" + +namespace blender::nodes::node_fn_separate_matrix3x3_cc { + +static void node_declare(NodeDeclarationBuilder &b) +{ + b.is_function_node(); + b.add_input(N_("Matrix")).default_value(float4x4::identity()); + b.add_output(N_("Vec0")); + b.add_output(N_("Vec1")); + b.add_output(N_("Vec2")); + b.add_output(N_("Vec3")); + b.add_output(N_("Row 0 Col 0")); + b.add_output(N_("Row 1 Col 0")); + b.add_output(N_("Row 2 Col 0")); + b.add_output(N_("Row 3 Col 0")); + b.add_output(N_("Row 0 Col 1")); + b.add_output(N_("Row 1 Col 1")); + b.add_output(N_("Row 2 Col 1")); + b.add_output(N_("Row 3 Col 1")); + b.add_output(N_("Row 0 Col 2")); + b.add_output(N_("Row 1 Col 2")); + b.add_output(N_("Row 2 Col 2")); + b.add_output(N_("Row 3 Col 2")); + b.add_output(N_("Row 0 Col 3")); + b.add_output(N_("Row 1 Col 3")); + b.add_output(N_("Row 2 Col 3")); + b.add_output(N_("Row 3 Col 3")); +}; + +static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) +{ + uiItemR(layout, ptr, "mode", 0, "", ICON_NONE); +} + +static void node_update(bNodeTree *tree, bNode *node) +{ + const NodeCombSepMatrixMode mode = (NodeCombSepMatrixMode)node->custom1; + + const IndexRange vector_sockets(0, 3); + const IndexRange scalar_sockets(3, 9); + const bool show_vector_sockets = ELEM( + mode, NODE_COMBSEP_MATRIX_COLUMNS, NODE_COMBSEP_MATRIX_ROWS); + const bool show_scalar_sockets = ELEM(mode, NODE_COMBSEP_MATRIX_ELEMENTS); + + for (const int i : vector_sockets) { + nodeSetSocketAvailability( + tree, (bNodeSocket *)BLI_findlink(&node->outputs, i), show_vector_sockets); + } + for (const int i : scalar_sockets) { + nodeSetSocketAvailability( + tree, (bNodeSocket *)BLI_findlink(&node->outputs, i), show_scalar_sockets); + } + + switch (mode) { + case NODE_COMBSEP_MATRIX_COLUMNS: + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[0]), "Column 0"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[1]), "Column 1"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[2]), "Column 2"); + break; + case NODE_COMBSEP_MATRIX_ROWS: + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[0]), "Row 0"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[1]), "Row 1"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[2]), "Row 2"); + break; + case NODE_COMBSEP_MATRIX_ELEMENTS: + break; + } +} + +static void node_init(bNodeTree * /*tree*/, bNode *node) +{ + node->custom1 = NODE_COMBSEP_MATRIX_COLUMNS; +} + +class SeparateColumnsFunction : public fn::MultiFunction { + public: + SeparateColumnsFunction() + { + static fn::MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static fn::MFSignature create_signature() + { + fn::MFSignatureBuilder signature{"Separate Matrix 3x3"}; + signature.single_input("Matrix"); + signature.single_output("Column0"); + signature.single_output("Column1"); + signature.single_output("Column2"); + return signature.build(); + } + + void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override + { + const VArray &matrices = params.readonly_single_input(0, "Matrix"); + MutableSpan col0 = params.uninitialized_single_output(1, "Column0"); + MutableSpan col1 = params.uninitialized_single_output(2, "Column1"); + MutableSpan col2 = params.uninitialized_single_output(3, "Column2"); + + for (int64_t i : mask) { + const float3x3 &mat = matrices[i]; + col0[i] = float3(mat[0]); + col1[i] = float3(mat[1]); + col2[i] = float3(mat[2]); + } + } +}; + +class SeparateRowsFunction : public fn::MultiFunction { + public: + SeparateRowsFunction() + { + static fn::MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static fn::MFSignature create_signature() + { + fn::MFSignatureBuilder signature{"Separate Matrix 3x3"}; + signature.single_input("Matrix"); + signature.single_output("Row0"); + signature.single_output("Row1"); + signature.single_output("Row2"); + return signature.build(); + } + + void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override + { + const VArray &matrices = params.readonly_single_input(0, "Matrix"); + MutableSpan row0 = params.uninitialized_single_output(1, "Row0"); + MutableSpan row1 = params.uninitialized_single_output(2, "Row1"); + MutableSpan row2 = params.uninitialized_single_output(3, "Row2"); + + for (int64_t i : mask) { + const float3x3 &mat = matrices[i]; + row0[i] = float3(mat[0][0], mat[1][0], mat[2][0]); + row1[i] = float3(mat[0][1], mat[1][1], mat[2][1]); + row2[i] = float3(mat[0][2], mat[1][2], mat[2][2]); + } + } +}; + +class SeparateElementsFunction : public fn::MultiFunction { + public: + SeparateElementsFunction() + { + static fn::MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static fn::MFSignature create_signature() + { + fn::MFSignatureBuilder signature{"Separate Matrix 3x3"}; + signature.single_input("Matrix"); + signature.single_output("Row0Column0"); + signature.single_output("Row0Column1"); + signature.single_output("Row0Column2"); + signature.single_output("Row1Column0"); + signature.single_output("Row1Column1"); + signature.single_output("Row1Column2"); + signature.single_output("Row2Column0"); + signature.single_output("Row2Column1"); + signature.single_output("Row2Column2"); + return signature.build(); + } + + void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override + { + const VArray &matrices = params.readonly_single_input(0, "Matrix"); + MutableSpan m00 = params.uninitialized_single_output(0, "Row0Column0"); + MutableSpan m10 = params.uninitialized_single_output(1, "Row0Column1"); + MutableSpan m20 = params.uninitialized_single_output(2, "Row0Column2"); + MutableSpan m01 = params.uninitialized_single_output(3, "Row1Column0"); + MutableSpan m11 = params.uninitialized_single_output(4, "Row1Column1"); + MutableSpan m21 = params.uninitialized_single_output(5, "Row1Column2"); + MutableSpan m02 = params.uninitialized_single_output(6, "Row2Column0"); + MutableSpan m12 = params.uninitialized_single_output(7, "Row2Column1"); + MutableSpan m22 = params.uninitialized_single_output(8, "Row2Column2"); + + for (int64_t i : mask) { + const float3x3 &mat = matrices[i]; + m00[i] = mat[0][0]; + m01[i] = mat[0][1]; + m02[i] = mat[0][2]; + m10[i] = mat[1][0]; + m11[i] = mat[1][1]; + m12[i] = mat[1][2]; + m20[i] = mat[2][0]; + m21[i] = mat[2][1]; + m22[i] = mat[2][2]; + } + } +}; + +static void node_build_multi_function(NodeMultiFunctionBuilder &builder) +{ + const NodeCombSepMatrixMode mode = (NodeCombSepMatrixMode)builder.node().custom1; + + switch (mode) { + case NODE_COMBSEP_MATRIX_COLUMNS: { + static SeparateColumnsFunction fn; + builder.set_matching_fn(fn); + break; + } + case NODE_COMBSEP_MATRIX_ROWS: { + static SeparateRowsFunction fn; + builder.set_matching_fn(fn); + break; + } + case NODE_COMBSEP_MATRIX_ELEMENTS: { + static SeparateElementsFunction fn; + builder.set_matching_fn(fn); + break; + } + default: { + BLI_assert_unreachable(); + break; + } + } +} + +} // namespace blender::nodes::node_fn_separate_matrix3x3_cc + +void register_node_type_fn_separate_matrix_3x3(void) +{ + namespace file_ns = blender::nodes::node_fn_separate_matrix3x3_cc; + + static bNodeType ntype; + + fn_node_type_base(&ntype, FN_NODE_SEPARATE_MATRIX_3X3, "Separate 3x3 Matrix", NODE_CLASS_CONVERTER); + ntype.declare = file_ns::node_declare; + ntype.updatefunc = file_ns::node_update; + ntype.initfunc = file_ns::node_init; + ntype.build_multi_function = file_ns::node_build_multi_function; + ntype.draw_buttons = file_ns::node_layout; + + nodeRegisterType(&ntype); +} diff --git a/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc b/source/blender/nodes/function/nodes/node_fn_separate_matrix4x4.cc similarity index 97% rename from source/blender/nodes/function/nodes/node_fn_separate_matrix.cc rename to source/blender/nodes/function/nodes/node_fn_separate_matrix4x4.cc index e074e739ce4..75a39fee261 100644 --- a/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_separate_matrix4x4.cc @@ -51,10 +51,12 @@ static void node_update(bNodeTree *tree, bNode *node) const bool show_scalar_sockets = ELEM(mode, NODE_COMBSEP_MATRIX_ELEMENTS); for (const int i : vector_sockets) { - nodeSetSocketAvailability(tree, &node->output_socket(i), show_vector_sockets); + nodeSetSocketAvailability( + tree, (bNodeSocket *)BLI_findlink(&node->outputs, i), show_vector_sockets); } for (const int i : scalar_sockets) { - nodeSetSocketAvailability(tree, &node->output_socket(i), show_scalar_sockets); + nodeSetSocketAvailability( + tree, (bNodeSocket *)BLI_findlink(&node->outputs, i), show_scalar_sockets); } switch (mode) { -- 2.30.2 From 83e4fef23c843a2c31fbe130d3d9c3054c34afed Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Fri, 16 Dec 2022 14:48:55 +0000 Subject: [PATCH 18/33] Revert "Matrix input mode for the instance-on-points node." This reverts commit eea512fbcc653117d1bda9f61abeeda43367582b. Should be decided separately if a matrix input is better suited for the instance-on-points node or other existing nodes. --- source/blender/makesdna/DNA_node_types.h | 5 -- source/blender/makesrna/intern/rna_nodetree.c | 16 ------- source/blender/nodes/NOD_static_types.h | 2 +- .../nodes/node_fn_combine_matrix4x4.cc | 22 ++++----- .../function/nodes/node_fn_matrix4x4_math.cc | 26 +++++----- .../nodes/node_fn_separate_matrix4x4.cc | 16 +++---- .../nodes/node_geo_instance_on_points.cc | 48 ++----------------- 7 files changed, 35 insertions(+), 100 deletions(-) diff --git a/source/blender/makesdna/DNA_node_types.h b/source/blender/makesdna/DNA_node_types.h index 2fa4ff9cc33..2d8d8966057 100644 --- a/source/blender/makesdna/DNA_node_types.h +++ b/source/blender/makesdna/DNA_node_types.h @@ -2395,8 +2395,3 @@ typedef enum NodeCombSepMatrixMode { NODE_COMBSEP_MATRIX_ROWS = 1, NODE_COMBSEP_MATRIX_ELEMENTS = 2, } NodeCombSepMatrixMode; - -typedef enum GeometryNodeTransformInputMode { - GEO_NODE_TRANSFORM_INPUT_MATRIX = 0, - GEO_NODE_TRANSFORM_INPUT_LOCROTSCALE = 1, -} GeometryNodeTransformInputMode; diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c index 536f9b2bae1..1134c6fc8a7 100644 --- a/source/blender/makesrna/intern/rna_nodetree.c +++ b/source/blender/makesrna/intern/rna_nodetree.c @@ -562,11 +562,6 @@ static EnumPropertyItem rna_node_geometry_mesh_circle_fill_type_items[] = { {GEO_NODE_MESH_CIRCLE_FILL_TRIANGLE_FAN, "TRIANGLE_FAN", 0, "Triangles", ""}, {0, NULL, 0, NULL, NULL}, }; - -static const EnumPropertyItem rna_node_geometry_transform_input_mode_items[] = { - {GEO_NODE_TRANSFORM_INPUT_MATRIX, "LEFT", ICON_NONE, "Matrix", "Use instance transforms matrix"}, - {GEO_NODE_TRANSFORM_INPUT_LOCROTSCALE, "LOCROTSCALE", ICON_NONE, "LocRotScale", "Use instance location, rotation, and scale"}, - {0, NULL, 0, NULL, NULL}}; #endif #ifndef RNA_RUNTIME @@ -11015,17 +11010,6 @@ static void def_geo_field_at_index(StructRNA *srna) RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_GeometryNode_socket_update"); } -static void def_geo_instance_on_points(StructRNA *srna) -{ - PropertyRNA *prop; - - prop = RNA_def_property(srna, "transform_mode", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "custom1"); - RNA_def_property_enum_items(prop, rna_node_geometry_transform_input_mode_items); - RNA_def_property_ui_text(prop, "Transform Mode", "Mode of defining transform for instances"); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_GeometryNode_socket_update"); -} - static void def_geo_interpolate_domain(StructRNA *srna) { PropertyRNA *prop; diff --git a/source/blender/nodes/NOD_static_types.h b/source/blender/nodes/NOD_static_types.h index edb6a36e7d7..271edbfe07a 100644 --- a/source/blender/nodes/NOD_static_types.h +++ b/source/blender/nodes/NOD_static_types.h @@ -356,7 +356,7 @@ DefNode(GeometryNode, GEO_NODE_INPUT_SPLINE_CYCLIC, 0, "INPUT_SPLINE_CYCLIC",Inp DefNode(GeometryNode, GEO_NODE_INPUT_SPLINE_LENGTH, 0, "SPLINE_LENGTH", SplineLength, "Spline Length", "Retrieve the total length of each spline, as a distance or as a number of points") DefNode(GeometryNode, GEO_NODE_INPUT_SPLINE_RESOLUTION, 0, "INPUT_SPLINE_RESOLUTION", InputSplineResolution, "Spline Resolution", "Retrieve the number of evaluated points that will be generated for every control point on curves") DefNode(GeometryNode, GEO_NODE_INPUT_TANGENT, 0, "INPUT_TANGENT", InputTangent, "Curve Tangent", "Retrieve the direction of curves at each control point") -DefNode(GeometryNode, GEO_NODE_INSTANCE_ON_POINTS, def_geo_instance_on_points, "INSTANCE_ON_POINTS", InstanceOnPoints, "Instance on Points", "Generate a reference to geometry at each of the input points, without duplicating its underlying data") +DefNode(GeometryNode, GEO_NODE_INSTANCE_ON_POINTS, 0, "INSTANCE_ON_POINTS", InstanceOnPoints, "Instance on Points", "Generate a reference to geometry at each of the input points, without duplicating its underlying data") DefNode(GeometryNode, GEO_NODE_INSTANCES_TO_POINTS, 0, "INSTANCES_TO_POINTS",InstancesToPoints, "Instances to Points","Generate points at the origins of instances.\nNote: Nested instances are not affected by this node") DefNode(GeometryNode, GEO_NODE_INTERPOLATE_DOMAIN, def_geo_interpolate_domain, "FIELD_ON_DOMAIN", FieldOnDomain, "Interpolate Domain", "Retrieve values from a field on a different domain besides the domain from the context") DefNode(GeometryNode, GEO_NODE_IS_VIEWPORT, 0, "IS_VIEWPORT", IsViewport, "Is Viewport", "Retrieve whether the nodes are being evaluated for the viewport rather than the final render") diff --git a/source/blender/nodes/function/nodes/node_fn_combine_matrix4x4.cc b/source/blender/nodes/function/nodes/node_fn_combine_matrix4x4.cc index 0317bfef10a..7a18c0ac84d 100644 --- a/source/blender/nodes/function/nodes/node_fn_combine_matrix4x4.cc +++ b/source/blender/nodes/function/nodes/node_fn_combine_matrix4x4.cc @@ -51,26 +51,24 @@ static void node_update(bNodeTree *tree, bNode *node) const bool show_scalar_sockets = ELEM(mode, NODE_COMBSEP_MATRIX_ELEMENTS); for (const int i : vector_sockets) { - nodeSetSocketAvailability( - tree, (bNodeSocket *)BLI_findlink(&node->inputs, i), show_vector_sockets); + nodeSetSocketAvailability(tree, &node->input_socket(i), show_vector_sockets); } for (const int i : scalar_sockets) { - nodeSetSocketAvailability( - tree, (bNodeSocket *)BLI_findlink(&node->inputs, i), show_scalar_sockets); + nodeSetSocketAvailability(tree, &node->input_socket(i), show_scalar_sockets); } switch (mode) { case NODE_COMBSEP_MATRIX_COLUMNS: - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[0]), "Column 0"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[1]), "Column 1"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[2]), "Column 2"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[3]), "Column 3"); + node_sock_label(&node->input_socket(vector_sockets[0]), "Column 0"); + node_sock_label(&node->input_socket(vector_sockets[1]), "Column 1"); + node_sock_label(&node->input_socket(vector_sockets[2]), "Column 2"); + node_sock_label(&node->input_socket(vector_sockets[3]), "Column 3"); break; case NODE_COMBSEP_MATRIX_ROWS: - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[0]), "Row 0"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[1]), "Row 1"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[2]), "Row 2"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[3]), "Row 3"); + node_sock_label(&node->input_socket(vector_sockets[0]), "Row 0"); + node_sock_label(&node->input_socket(vector_sockets[1]), "Row 1"); + node_sock_label(&node->input_socket(vector_sockets[2]), "Row 2"); + node_sock_label(&node->input_socket(vector_sockets[3]), "Row 3"); break; case NODE_COMBSEP_MATRIX_ELEMENTS: break; diff --git a/source/blender/nodes/function/nodes/node_fn_matrix4x4_math.cc b/source/blender/nodes/function/nodes/node_fn_matrix4x4_math.cc index 5237310db61..e7229bdb407 100644 --- a/source/blender/nodes/function/nodes/node_fn_matrix4x4_math.cc +++ b/source/blender/nodes/function/nodes/node_fn_matrix4x4_math.cc @@ -50,21 +50,21 @@ static void node_update(bNodeTree *tree, bNode *node) { const NodeMatrixMathOperation op = (NodeMatrixMathOperation)node->custom1; - bNodeSocket *in_matrix_a = (bNodeSocket *)BLI_findlink(&node->inputs, 0); - bNodeSocket *in_matrix_b = (bNodeSocket *)BLI_findlink(&node->inputs, 1); - bNodeSocket *in_scale = (bNodeSocket *)BLI_findlink(&node->inputs, 2); - bNodeSocket *out_matrix = (bNodeSocket *)BLI_findlink(&node->inputs, 3); - bNodeSocket *out_value = (bNodeSocket *)BLI_findlink(&node->inputs, 4); + bNodeSocket *inMatrixA = &node->input_socket(0); + bNodeSocket *inMatrixB = &node->input_socket(1); + bNodeSocket *inScale = &node->input_socket(2); + bNodeSocket *outMatrix = &node->output_socket(3); + bNodeSocket *outValue = &node->output_socket(4); - nodeSetSocketAvailability(tree, in_matrix_a, true); + nodeSetSocketAvailability(tree, inMatrixA, true); nodeSetSocketAvailability( tree, - in_matrix_b, + inMatrixB, ELEM(op, NODE_MATRIX_MATH_ADD, NODE_MATRIX_MATH_SUBTRACT, NODE_MATRIX_MATH_MULTIPLY)); - nodeSetSocketAvailability(tree, in_scale, ELEM(op, NODE_MATRIX_MATH_SCALAR_MULTIPLY)); + nodeSetSocketAvailability(tree, inScale, ELEM(op, NODE_MATRIX_MATH_SCALAR_MULTIPLY)); nodeSetSocketAvailability(tree, - out_matrix, + outMatrix, ELEM(op, NODE_MATRIX_MATH_ADD, NODE_MATRIX_MATH_SUBTRACT, @@ -73,12 +73,12 @@ static void node_update(bNodeTree *tree, bNode *node) NODE_MATRIX_MATH_TRANSPOSE, NODE_MATRIX_MATH_INVERSE)); nodeSetSocketAvailability( - tree, out_value, ELEM(op, NODE_MATRIX_MATH_DETERMINANT, NODE_MATRIX_MATH_TRACE)); + tree, outValue, ELEM(op, NODE_MATRIX_MATH_DETERMINANT, NODE_MATRIX_MATH_TRACE)); /* Labels */ - node_sock_label_clear(in_matrix_a); - node_sock_label_clear(in_matrix_b); - node_sock_label_clear(in_scale); + node_sock_label_clear(inMatrixA); + node_sock_label_clear(inMatrixB); + node_sock_label_clear(inScale); switch (op) { } } diff --git a/source/blender/nodes/function/nodes/node_fn_separate_matrix4x4.cc b/source/blender/nodes/function/nodes/node_fn_separate_matrix4x4.cc index 75a39fee261..d97f54701a8 100644 --- a/source/blender/nodes/function/nodes/node_fn_separate_matrix4x4.cc +++ b/source/blender/nodes/function/nodes/node_fn_separate_matrix4x4.cc @@ -61,16 +61,16 @@ static void node_update(bNodeTree *tree, bNode *node) switch (mode) { case NODE_COMBSEP_MATRIX_COLUMNS: - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[0]), "Column 0"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[1]), "Column 1"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[2]), "Column 2"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[3]), "Column 3"); + node_sock_label(&node->output_socket(vector_sockets[0]), "Column 0"); + node_sock_label(&node->output_socket(vector_sockets[1]), "Column 1"); + node_sock_label(&node->output_socket(vector_sockets[2]), "Column 2"); + node_sock_label(&node->output_socket(vector_sockets[3]), "Column 3"); break; case NODE_COMBSEP_MATRIX_ROWS: - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[0]), "Row 0"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[1]), "Row 1"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[2]), "Row 2"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[3]), "Row 3"); + node_sock_label(&node->output_socket(vector_sockets[0]), "Row 0"); + node_sock_label(&node->output_socket(vector_sockets[1]), "Row 1"); + node_sock_label(&node->output_socket(vector_sockets[2]), "Row 2"); + node_sock_label(&node->output_socket(vector_sockets[3]), "Row 3"); break; case NODE_COMBSEP_MATRIX_ELEMENTS: break; diff --git a/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc b/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc index 90a308f219c..64546684186 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc @@ -40,33 +40,10 @@ static void node_declare(NodeDeclarationBuilder &b) .subtype(PROP_XYZ) .supports_field() .description(N_("Scale of the instances")); - b.add_input(N_("Matrix")) - .default_value(float4x4::identity()) - .supports_field() - .description(N_("Transform matrix of the instances")); b.add_output(N_("Instances")); } -static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) -{ - uiItemR(layout, ptr, "transform_mode", 0, "", ICON_NONE); -} - -static void node_update(bNodeTree *tree, bNode *node) -{ - const GeometryNodeTransformInputMode transform_mode = (GeometryNodeTransformInputMode) - node->custom1; - - bNodeSocket *in_rotation = nodeFindSocket(node, SOCK_IN, "Rotation"); - bNodeSocket *in_scale = nodeFindSocket(node, SOCK_IN, "Scale"); - bNodeSocket *in_matrix = nodeFindSocket(node, SOCK_IN, "Matrix"); - - nodeSetSocketAvailability(tree, in_rotation, transform_mode == GEO_NODE_TRANSFORM_INPUT_LOCROTSCALE); - nodeSetSocketAvailability(tree, in_scale, transform_mode == GEO_NODE_TRANSFORM_INPUT_LOCROTSCALE); - nodeSetSocketAvailability(tree, in_matrix, transform_mode == GEO_NODE_TRANSFORM_INPUT_MATRIX); -} - static void add_instances_from_component( bke::Instances &dst_component, const GeometryComponent &src_component, @@ -76,14 +53,11 @@ static void add_instances_from_component( { const eAttrDomain domain = ATTR_DOMAIN_POINT; const int domain_num = src_component.attribute_domain_size(domain); - const GeometryNodeTransformInputMode transform_mode = - (GeometryNodeTransformInputMode)params.node().custom1; VArray pick_instance; VArray indices; VArray rotations; VArray scales; - VArray matrices; bke::GeometryFieldContext field_context{src_component, domain}; const Field selection_field = params.get_input>("Selection"); @@ -93,15 +67,8 @@ static void add_instances_from_component( * selected indices should be copied. */ evaluator.add(params.get_input>("Pick Instance"), &pick_instance); evaluator.add(params.get_input>("Instance Index"), &indices); - switch (transform_mode) { - case GEO_NODE_TRANSFORM_INPUT_MATRIX: - evaluator.add(params.get_input>("Matrix"), &matrices); - break; - case GEO_NODE_TRANSFORM_INPUT_LOCROTSCALE: - evaluator.add(params.get_input>("Rotation"), &rotations); - evaluator.add(params.get_input>("Scale"), &scales); - break; - } + evaluator.add(params.get_input>("Rotation"), &rotations); + evaluator.add(params.get_input>("Scale"), &scales); evaluator.evaluate(); const IndexMask selection = evaluator.get_evaluated_selection_as_mask(); @@ -147,14 +114,7 @@ static void add_instances_from_component( /* Compute base transform for every instances. */ float4x4 &dst_transform = dst_transforms[range_i]; - switch (transform_mode) { - case GEO_NODE_TRANSFORM_INPUT_MATRIX: - dst_transform = matrices[i]; - break; - case GEO_NODE_TRANSFORM_INPUT_LOCROTSCALE: - dst_transform = float4x4::from_loc_eul_scale(positions[i], rotations[i], scales[i]); - break; - } + dst_transform = float4x4::from_loc_eul_scale(positions[i], rotations[i], scales[i]); /* Reference that will be used by this new instance. */ int dst_handle = empty_reference_handle; @@ -276,8 +236,6 @@ void register_node_type_geo_instance_on_points() geo_node_type_base( &ntype, GEO_NODE_INSTANCE_ON_POINTS, "Instance on Points", NODE_CLASS_GEOMETRY); ntype.declare = file_ns::node_declare; - ntype.updatefunc = file_ns::node_update; - ntype.draw_buttons = file_ns::node_layout; ntype.geometry_node_execute = file_ns::node_geo_exec; nodeRegisterType(&ntype); } -- 2.30.2 From 95f1b7c90490f082fe052b8c32defc1aec530fa3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Mon, 19 Dec 2022 11:09:27 +0100 Subject: [PATCH 19/33] Fix incorrect output socket indices in math nodes. --- source/blender/nodes/function/nodes/node_fn_matrix3x3_math.cc | 4 ++-- source/blender/nodes/function/nodes/node_fn_matrix4x4_math.cc | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/source/blender/nodes/function/nodes/node_fn_matrix3x3_math.cc b/source/blender/nodes/function/nodes/node_fn_matrix3x3_math.cc index e98057e23a2..a00405b69ad 100644 --- a/source/blender/nodes/function/nodes/node_fn_matrix3x3_math.cc +++ b/source/blender/nodes/function/nodes/node_fn_matrix3x3_math.cc @@ -53,8 +53,8 @@ static void node_update(bNodeTree *tree, bNode *node) bNodeSocket *in_matrix_a = (bNodeSocket *)BLI_findlink(&node->inputs, 0); bNodeSocket *in_matrix_b = (bNodeSocket *)BLI_findlink(&node->inputs, 1); bNodeSocket *in_scale = (bNodeSocket *)BLI_findlink(&node->inputs, 2); - bNodeSocket *out_matrix = (bNodeSocket *)BLI_findlink(&node->inputs, 3); - bNodeSocket *out_value = (bNodeSocket *)BLI_findlink(&node->inputs, 4); + bNodeSocket *out_matrix = (bNodeSocket *)BLI_findlink(&node->inputs, 0); + bNodeSocket *out_value = (bNodeSocket *)BLI_findlink(&node->inputs, 1); nodeSetSocketAvailability(tree, in_matrix_a, true); nodeSetSocketAvailability( diff --git a/source/blender/nodes/function/nodes/node_fn_matrix4x4_math.cc b/source/blender/nodes/function/nodes/node_fn_matrix4x4_math.cc index e7229bdb407..8b24f62ef9a 100644 --- a/source/blender/nodes/function/nodes/node_fn_matrix4x4_math.cc +++ b/source/blender/nodes/function/nodes/node_fn_matrix4x4_math.cc @@ -53,8 +53,8 @@ static void node_update(bNodeTree *tree, bNode *node) bNodeSocket *inMatrixA = &node->input_socket(0); bNodeSocket *inMatrixB = &node->input_socket(1); bNodeSocket *inScale = &node->input_socket(2); - bNodeSocket *outMatrix = &node->output_socket(3); - bNodeSocket *outValue = &node->output_socket(4); + bNodeSocket *outMatrix = &node->output_socket(0); + bNodeSocket *outValue = &node->output_socket(1); nodeSetSocketAvailability(tree, inMatrixA, true); nodeSetSocketAvailability( -- 2.30.2 From 1b90ba3d046fb9d96b0037346b3109a25d9ef3d6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Mon, 19 Dec 2022 15:36:36 +0100 Subject: [PATCH 20/33] Use correct storage callbacks for matrix input nodes. --- source/blender/nodes/function/nodes/node_fn_input_matrix3x3.cc | 2 ++ source/blender/nodes/function/nodes/node_fn_input_matrix4x4.cc | 2 ++ 2 files changed, 4 insertions(+) diff --git a/source/blender/nodes/function/nodes/node_fn_input_matrix3x3.cc b/source/blender/nodes/function/nodes/node_fn_input_matrix3x3.cc index f8f284b11e1..9cae438d571 100644 --- a/source/blender/nodes/function/nodes/node_fn_input_matrix3x3.cc +++ b/source/blender/nodes/function/nodes/node_fn_input_matrix3x3.cc @@ -43,6 +43,8 @@ void register_node_type_fn_input_matrix_3x3(void) static bNodeType ntype; fn_node_type_base(&ntype, FN_NODE_INPUT_MATRIX_3X3, "3x3 Matrix", NODE_CLASS_INPUT); + node_type_storage( + &ntype, "NodeInputMatrix3x3", node_free_standard_storage, node_copy_standard_storage); ntype.declare = file_ns::node_declare; ntype.initfunc = file_ns::node_init; ntype.build_multi_function = file_ns::node_build_multi_function; diff --git a/source/blender/nodes/function/nodes/node_fn_input_matrix4x4.cc b/source/blender/nodes/function/nodes/node_fn_input_matrix4x4.cc index 97482ad7b11..0bbf545f07e 100644 --- a/source/blender/nodes/function/nodes/node_fn_input_matrix4x4.cc +++ b/source/blender/nodes/function/nodes/node_fn_input_matrix4x4.cc @@ -43,6 +43,8 @@ void register_node_type_fn_input_matrix_4x4(void) static bNodeType ntype; fn_node_type_base(&ntype, FN_NODE_INPUT_MATRIX_4X4, "4x4 Matrix", NODE_CLASS_INPUT); + node_type_storage( + &ntype, "NodeInputMatrix4x4", node_free_standard_storage, node_copy_standard_storage); ntype.declare = file_ns::node_declare; ntype.initfunc = file_ns::node_init; ntype.build_multi_function = file_ns::node_build_multi_function; -- 2.30.2 From ccaeb31e46273a5e8f562df87e21fc0c71aa8387 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Mon, 19 Dec 2022 15:40:35 +0100 Subject: [PATCH 21/33] Use the large size preset for matrix input nodes to accomodate all the columns. --- source/blender/nodes/function/nodes/node_fn_input_matrix3x3.cc | 2 ++ source/blender/nodes/function/nodes/node_fn_input_matrix4x4.cc | 2 ++ 2 files changed, 4 insertions(+) diff --git a/source/blender/nodes/function/nodes/node_fn_input_matrix3x3.cc b/source/blender/nodes/function/nodes/node_fn_input_matrix3x3.cc index 9cae438d571..c9a120fd4ad 100644 --- a/source/blender/nodes/function/nodes/node_fn_input_matrix3x3.cc +++ b/source/blender/nodes/function/nodes/node_fn_input_matrix3x3.cc @@ -49,6 +49,8 @@ void register_node_type_fn_input_matrix_3x3(void) ntype.initfunc = file_ns::node_init; ntype.build_multi_function = file_ns::node_build_multi_function; ntype.draw_buttons = file_ns::node_layout; + /* Matrix columns need more horizontal space */ + node_type_size_preset(&ntype, NODE_SIZE_LARGE); nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/function/nodes/node_fn_input_matrix4x4.cc b/source/blender/nodes/function/nodes/node_fn_input_matrix4x4.cc index 0bbf545f07e..52597a489e2 100644 --- a/source/blender/nodes/function/nodes/node_fn_input_matrix4x4.cc +++ b/source/blender/nodes/function/nodes/node_fn_input_matrix4x4.cc @@ -49,6 +49,8 @@ void register_node_type_fn_input_matrix_4x4(void) ntype.initfunc = file_ns::node_init; ntype.build_multi_function = file_ns::node_build_multi_function; ntype.draw_buttons = file_ns::node_layout; + /* Matrix columns need more horizontal space */ + node_type_size_preset(&ntype, NODE_SIZE_LARGE); nodeRegisterType(&ntype); } -- 2.30.2 From b2825c41766b1bec1c4bb8122703e3b9bd6ca5ea Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Mon, 19 Dec 2022 15:57:27 +0100 Subject: [PATCH 22/33] Fixed socket lookup functions in CombineMatrix4x4 node. --- .../nodes/node_fn_combine_matrix4x4.cc | 22 ++++++++++--------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/source/blender/nodes/function/nodes/node_fn_combine_matrix4x4.cc b/source/blender/nodes/function/nodes/node_fn_combine_matrix4x4.cc index 7a18c0ac84d..0317bfef10a 100644 --- a/source/blender/nodes/function/nodes/node_fn_combine_matrix4x4.cc +++ b/source/blender/nodes/function/nodes/node_fn_combine_matrix4x4.cc @@ -51,24 +51,26 @@ static void node_update(bNodeTree *tree, bNode *node) const bool show_scalar_sockets = ELEM(mode, NODE_COMBSEP_MATRIX_ELEMENTS); for (const int i : vector_sockets) { - nodeSetSocketAvailability(tree, &node->input_socket(i), show_vector_sockets); + nodeSetSocketAvailability( + tree, (bNodeSocket *)BLI_findlink(&node->inputs, i), show_vector_sockets); } for (const int i : scalar_sockets) { - nodeSetSocketAvailability(tree, &node->input_socket(i), show_scalar_sockets); + nodeSetSocketAvailability( + tree, (bNodeSocket *)BLI_findlink(&node->inputs, i), show_scalar_sockets); } switch (mode) { case NODE_COMBSEP_MATRIX_COLUMNS: - node_sock_label(&node->input_socket(vector_sockets[0]), "Column 0"); - node_sock_label(&node->input_socket(vector_sockets[1]), "Column 1"); - node_sock_label(&node->input_socket(vector_sockets[2]), "Column 2"); - node_sock_label(&node->input_socket(vector_sockets[3]), "Column 3"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[0]), "Column 0"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[1]), "Column 1"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[2]), "Column 2"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[3]), "Column 3"); break; case NODE_COMBSEP_MATRIX_ROWS: - node_sock_label(&node->input_socket(vector_sockets[0]), "Row 0"); - node_sock_label(&node->input_socket(vector_sockets[1]), "Row 1"); - node_sock_label(&node->input_socket(vector_sockets[2]), "Row 2"); - node_sock_label(&node->input_socket(vector_sockets[3]), "Row 3"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[0]), "Row 0"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[1]), "Row 1"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[2]), "Row 2"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[3]), "Row 3"); break; case NODE_COMBSEP_MATRIX_ELEMENTS: break; -- 2.30.2 From ddb172eef3abd94f8a8044c237115d5e70eff522 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Mon, 19 Dec 2022 17:28:13 +0100 Subject: [PATCH 23/33] Fixed incorrect socket lookup in a few places. --- .../function/nodes/node_fn_matrix3x3_math.cc | 4 +-- .../function/nodes/node_fn_matrix4x4_math.cc | 26 +++++++++---------- .../nodes/node_fn_separate_matrix3x3.cc | 20 +++++--------- .../nodes/node_fn_separate_matrix4x4.cc | 16 ++++++------ 4 files changed, 29 insertions(+), 37 deletions(-) diff --git a/source/blender/nodes/function/nodes/node_fn_matrix3x3_math.cc b/source/blender/nodes/function/nodes/node_fn_matrix3x3_math.cc index a00405b69ad..24d97870fc8 100644 --- a/source/blender/nodes/function/nodes/node_fn_matrix3x3_math.cc +++ b/source/blender/nodes/function/nodes/node_fn_matrix3x3_math.cc @@ -53,8 +53,8 @@ static void node_update(bNodeTree *tree, bNode *node) bNodeSocket *in_matrix_a = (bNodeSocket *)BLI_findlink(&node->inputs, 0); bNodeSocket *in_matrix_b = (bNodeSocket *)BLI_findlink(&node->inputs, 1); bNodeSocket *in_scale = (bNodeSocket *)BLI_findlink(&node->inputs, 2); - bNodeSocket *out_matrix = (bNodeSocket *)BLI_findlink(&node->inputs, 0); - bNodeSocket *out_value = (bNodeSocket *)BLI_findlink(&node->inputs, 1); + bNodeSocket *out_matrix = (bNodeSocket *)BLI_findlink(&node->outputs, 0); + bNodeSocket *out_value = (bNodeSocket *)BLI_findlink(&node->outputs, 1); nodeSetSocketAvailability(tree, in_matrix_a, true); nodeSetSocketAvailability( diff --git a/source/blender/nodes/function/nodes/node_fn_matrix4x4_math.cc b/source/blender/nodes/function/nodes/node_fn_matrix4x4_math.cc index 8b24f62ef9a..20895eaaedf 100644 --- a/source/blender/nodes/function/nodes/node_fn_matrix4x4_math.cc +++ b/source/blender/nodes/function/nodes/node_fn_matrix4x4_math.cc @@ -50,21 +50,21 @@ static void node_update(bNodeTree *tree, bNode *node) { const NodeMatrixMathOperation op = (NodeMatrixMathOperation)node->custom1; - bNodeSocket *inMatrixA = &node->input_socket(0); - bNodeSocket *inMatrixB = &node->input_socket(1); - bNodeSocket *inScale = &node->input_socket(2); - bNodeSocket *outMatrix = &node->output_socket(0); - bNodeSocket *outValue = &node->output_socket(1); + bNodeSocket *in_matrix_a = (bNodeSocket *)BLI_findlink(&node->inputs, 0); + bNodeSocket *in_matrix_b = (bNodeSocket *)BLI_findlink(&node->inputs, 1); + bNodeSocket *in_scale = (bNodeSocket *)BLI_findlink(&node->inputs, 2); + bNodeSocket *out_matrix = (bNodeSocket *)BLI_findlink(&node->outputs, 0); + bNodeSocket *out_value = (bNodeSocket *)BLI_findlink(&node->outputs, 1); - nodeSetSocketAvailability(tree, inMatrixA, true); + nodeSetSocketAvailability(tree, in_matrix_a, true); nodeSetSocketAvailability( tree, - inMatrixB, + in_matrix_b, ELEM(op, NODE_MATRIX_MATH_ADD, NODE_MATRIX_MATH_SUBTRACT, NODE_MATRIX_MATH_MULTIPLY)); - nodeSetSocketAvailability(tree, inScale, ELEM(op, NODE_MATRIX_MATH_SCALAR_MULTIPLY)); + nodeSetSocketAvailability(tree, in_scale, ELEM(op, NODE_MATRIX_MATH_SCALAR_MULTIPLY)); nodeSetSocketAvailability(tree, - outMatrix, + out_matrix, ELEM(op, NODE_MATRIX_MATH_ADD, NODE_MATRIX_MATH_SUBTRACT, @@ -73,12 +73,12 @@ static void node_update(bNodeTree *tree, bNode *node) NODE_MATRIX_MATH_TRANSPOSE, NODE_MATRIX_MATH_INVERSE)); nodeSetSocketAvailability( - tree, outValue, ELEM(op, NODE_MATRIX_MATH_DETERMINANT, NODE_MATRIX_MATH_TRACE)); + tree, out_value, ELEM(op, NODE_MATRIX_MATH_DETERMINANT, NODE_MATRIX_MATH_TRACE)); /* Labels */ - node_sock_label_clear(inMatrixA); - node_sock_label_clear(inMatrixB); - node_sock_label_clear(inScale); + node_sock_label_clear(in_matrix_a); + node_sock_label_clear(in_matrix_b); + node_sock_label_clear(in_scale); switch (op) { } } diff --git a/source/blender/nodes/function/nodes/node_fn_separate_matrix3x3.cc b/source/blender/nodes/function/nodes/node_fn_separate_matrix3x3.cc index dcb051e4162..fa9efc79225 100644 --- a/source/blender/nodes/function/nodes/node_fn_separate_matrix3x3.cc +++ b/source/blender/nodes/function/nodes/node_fn_separate_matrix3x3.cc @@ -16,23 +16,15 @@ static void node_declare(NodeDeclarationBuilder &b) b.add_output(N_("Vec0")); b.add_output(N_("Vec1")); b.add_output(N_("Vec2")); - b.add_output(N_("Vec3")); b.add_output(N_("Row 0 Col 0")); b.add_output(N_("Row 1 Col 0")); b.add_output(N_("Row 2 Col 0")); - b.add_output(N_("Row 3 Col 0")); b.add_output(N_("Row 0 Col 1")); b.add_output(N_("Row 1 Col 1")); b.add_output(N_("Row 2 Col 1")); - b.add_output(N_("Row 3 Col 1")); b.add_output(N_("Row 0 Col 2")); b.add_output(N_("Row 1 Col 2")); b.add_output(N_("Row 2 Col 2")); - b.add_output(N_("Row 3 Col 2")); - b.add_output(N_("Row 0 Col 3")); - b.add_output(N_("Row 1 Col 3")); - b.add_output(N_("Row 2 Col 3")); - b.add_output(N_("Row 3 Col 3")); }; static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) @@ -61,14 +53,14 @@ static void node_update(bNodeTree *tree, bNode *node) switch (mode) { case NODE_COMBSEP_MATRIX_COLUMNS: - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[0]), "Column 0"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[1]), "Column 1"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[2]), "Column 2"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->outputs, vector_sockets[0]), "Column 0"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->outputs, vector_sockets[1]), "Column 1"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->outputs, vector_sockets[2]), "Column 2"); break; case NODE_COMBSEP_MATRIX_ROWS: - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[0]), "Row 0"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[1]), "Row 1"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[2]), "Row 2"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->outputs, vector_sockets[0]), "Row 0"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->outputs, vector_sockets[1]), "Row 1"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->outputs, vector_sockets[2]), "Row 2"); break; case NODE_COMBSEP_MATRIX_ELEMENTS: break; diff --git a/source/blender/nodes/function/nodes/node_fn_separate_matrix4x4.cc b/source/blender/nodes/function/nodes/node_fn_separate_matrix4x4.cc index d97f54701a8..34f79e26e89 100644 --- a/source/blender/nodes/function/nodes/node_fn_separate_matrix4x4.cc +++ b/source/blender/nodes/function/nodes/node_fn_separate_matrix4x4.cc @@ -61,16 +61,16 @@ static void node_update(bNodeTree *tree, bNode *node) switch (mode) { case NODE_COMBSEP_MATRIX_COLUMNS: - node_sock_label(&node->output_socket(vector_sockets[0]), "Column 0"); - node_sock_label(&node->output_socket(vector_sockets[1]), "Column 1"); - node_sock_label(&node->output_socket(vector_sockets[2]), "Column 2"); - node_sock_label(&node->output_socket(vector_sockets[3]), "Column 3"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->outputs, vector_sockets[0]), "Column 0"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->outputs, vector_sockets[1]), "Column 1"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->outputs, vector_sockets[2]), "Column 2"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->outputs, vector_sockets[3]), "Column 3"); break; case NODE_COMBSEP_MATRIX_ROWS: - node_sock_label(&node->output_socket(vector_sockets[0]), "Row 0"); - node_sock_label(&node->output_socket(vector_sockets[1]), "Row 1"); - node_sock_label(&node->output_socket(vector_sockets[2]), "Row 2"); - node_sock_label(&node->output_socket(vector_sockets[3]), "Row 3"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->outputs, vector_sockets[0]), "Row 0"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->outputs, vector_sockets[1]), "Row 1"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->outputs, vector_sockets[2]), "Row 2"); + node_sock_label((bNodeSocket *)BLI_findlink(&node->outputs, vector_sockets[3]), "Row 3"); break; case NODE_COMBSEP_MATRIX_ELEMENTS: break; -- 2.30.2 From 8ee84bc82dcb36135baa82f119ce2a5c3f75c04a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Thu, 22 Dec 2022 08:20:01 +0100 Subject: [PATCH 24/33] Added a few more nodes for affine (de)composition. --- .../startup/bl_ui/node_add_menu_geometry.py | 5 ++ source/blender/blenkernel/BKE_node.h | 5 ++ source/blender/nodes/NOD_static_types.h | 5 ++ source/blender/nodes/function/CMakeLists.txt | 5 ++ .../nodes/function/node_function_register.cc | 5 ++ .../nodes/function/node_function_register.hh | 5 ++ .../nodes/node_fn_decompose_matrix3x3.cc | 70 ++++++++++++++++++ .../nodes/node_fn_decompose_matrix4x4.cc | 74 +++++++++++++++++++ .../nodes/node_fn_rotate_matrix3x3.cc | 44 +++++++++++ .../function/nodes/node_fn_scale_matrix3x3.cc | 46 ++++++++++++ .../nodes/node_fn_translate_matrix4x4.cc | 42 +++++++++++ 11 files changed, 306 insertions(+) create mode 100644 source/blender/nodes/function/nodes/node_fn_decompose_matrix3x3.cc create mode 100644 source/blender/nodes/function/nodes/node_fn_decompose_matrix4x4.cc create mode 100644 source/blender/nodes/function/nodes/node_fn_rotate_matrix3x3.cc create mode 100644 source/blender/nodes/function/nodes/node_fn_scale_matrix3x3.cc create mode 100644 source/blender/nodes/function/nodes/node_fn_translate_matrix4x4.cc diff --git a/release/scripts/startup/bl_ui/node_add_menu_geometry.py b/release/scripts/startup/bl_ui/node_add_menu_geometry.py index 9a6b304e1d6..caa92659e95 100644 --- a/release/scripts/startup/bl_ui/node_add_menu_geometry.py +++ b/release/scripts/startup/bl_ui/node_add_menu_geometry.py @@ -207,8 +207,13 @@ class NODE_MT_category_GEO_MATRIX(Menu): node_add_menu.add_node_type(layout, "FunctionNodeCombineMatrix4x4") node_add_menu.add_node_type(layout, "FunctionNodeSeparateMatrix3x3") node_add_menu.add_node_type(layout, "FunctionNodeSeparateMatrix4x4") + node_add_menu.add_node_type(layout, "FunctionNodeDecomposeMatrix3x3") + node_add_menu.add_node_type(layout, "FunctionNodeDecomposeMatrix4x4") node_add_menu.add_node_type(layout, "FunctionNodeMatrix3x3Math") node_add_menu.add_node_type(layout, "FunctionNodeMatrix4x4Math") + node_add_menu.add_node_type(layout, "FunctionNodeRotateMatrix3x3") + node_add_menu.add_node_type(layout, "FunctionNodeScaleMatrix3x3") + node_add_menu.add_node_type(layout, "FunctionNodeTranslateMatrix4x4") node_add_menu.draw_assets_for_catalog(layout, self.bl_label) diff --git a/source/blender/blenkernel/BKE_node.h b/source/blender/blenkernel/BKE_node.h index f2c08c60d85..7b15de30ba7 100644 --- a/source/blender/blenkernel/BKE_node.h +++ b/source/blender/blenkernel/BKE_node.h @@ -1581,6 +1581,11 @@ struct TexResult; #define FN_NODE_COMBINE_MATRIX_4X4 1228 #define FN_NODE_MATRIX_3X3_MATH 1229 #define FN_NODE_MATRIX_4X4_MATH 1230 +#define FN_NODE_DECOMPOSE_MATRIX_3X3 1231 +#define FN_NODE_DECOMPOSE_MATRIX_4X4 1232 +#define FN_NODE_ROTATE_MATRIX_3X3 1233 +#define FN_NODE_SCALE_MATRIX_3X3 1234 +#define FN_NODE_TRANSLATE_MATRIX_4X4 1235 /** \} */ diff --git a/source/blender/nodes/NOD_static_types.h b/source/blender/nodes/NOD_static_types.h index ab76e6a1175..36991bd328e 100644 --- a/source/blender/nodes/NOD_static_types.h +++ b/source/blender/nodes/NOD_static_types.h @@ -267,6 +267,8 @@ DefNode(FunctionNode, FN_NODE_COMBINE_COLOR, def_fn_combsep_color, "COMBINE_COLO DefNode(FunctionNode, FN_NODE_COMBINE_MATRIX_3X3, def_fn_combsep_matrix, "COMBINE_MATRIX_3X3", CombineMatrix3x3, "Combine 3x3 Matrix", "") DefNode(FunctionNode, FN_NODE_COMBINE_MATRIX_4X4, def_fn_combsep_matrix, "COMBINE_MATRIX_4X4", CombineMatrix4x4, "Combine 4x4 Matrix", "") DefNode(FunctionNode, FN_NODE_COMPARE, def_compare, "COMPARE", Compare, "Compare", "") +DefNode(FunctionNode, FN_NODE_DECOMPOSE_MATRIX_3X3, 0, "DECOMPOSE_MATRIX_3X3", DecomposeMatrix3x3, "Decompose 3x3 Matrix", "") +DefNode(FunctionNode, FN_NODE_DECOMPOSE_MATRIX_4X4, 0, "DECOMPOSE_MATRIX_4X4", DecomposeMatrix4x4, "Decompose 4x4 Matrix", "") DefNode(FunctionNode, FN_NODE_FLOAT_TO_INT, def_float_to_int, "FLOAT_TO_INT", FloatToInt, "Float to Integer", "") DefNode(FunctionNode, FN_NODE_INPUT_BOOL, def_fn_input_bool, "INPUT_BOOL", InputBool, "Boolean", "") DefNode(FunctionNode, FN_NODE_INPUT_COLOR, def_fn_input_color, "INPUT_COLOR", InputColor, "Color", "") @@ -281,11 +283,14 @@ DefNode(FunctionNode, FN_NODE_MATRIX_4X4_MATH, def_fn_matrix_4x4_math, "MATRIX_4 DefNode(FunctionNode, FN_NODE_RANDOM_VALUE, def_fn_random_value, "RANDOM_VALUE", RandomValue, "Random Value", "") DefNode(FunctionNode, FN_NODE_REPLACE_STRING, 0, "REPLACE_STRING", ReplaceString, "Replace String", "") DefNode(FunctionNode, FN_NODE_ROTATE_EULER, def_fn_rotate_euler, "ROTATE_EULER", RotateEuler, "Rotate Euler", "") +DefNode(FunctionNode, FN_NODE_ROTATE_MATRIX_3X3, 0, "ROTATE_MATRIX_3X3", RotateMatrix3x3, "Rotate Matrix", "") +DefNode(FunctionNode, FN_NODE_SCALE_MATRIX_3X3, 0, "SCALE_MATRIX_3X3", ScaleMatrix3x3, "Scale Matrix", "") DefNode(FunctionNode, FN_NODE_SEPARATE_COLOR, def_fn_combsep_color, "SEPARATE_COLOR", SeparateColor, "Separate Color", "") DefNode(FunctionNode, FN_NODE_SEPARATE_MATRIX_3X3, def_fn_combsep_matrix, "SEPARATE_MATRIX_3X3", SeparateMatrix3x3, "Separate 3x3 Matrix", "") DefNode(FunctionNode, FN_NODE_SEPARATE_MATRIX_4X4, def_fn_combsep_matrix, "SEPARATE_MATRIX_4X4", SeparateMatrix4x4, "Separate 4x4 Matrix", "") DefNode(FunctionNode, FN_NODE_SLICE_STRING, 0, "SLICE_STRING", SliceString, "Slice String", "") DefNode(FunctionNode, FN_NODE_STRING_LENGTH, 0, "STRING_LENGTH", StringLength, "String Length", "") +DefNode(FunctionNode, FN_NODE_TRANSLATE_MATRIX_4X4, 0, "TRANSLATE_MATRIX_4X4", TranslateMatrix4x4, "Translate Matrix", "") DefNode(FunctionNode, FN_NODE_VALUE_TO_STRING, 0, "VALUE_TO_STRING", ValueToString, "Value to String", "") DefNode(GeometryNode, GEO_NODE_ACCUMULATE_FIELD, def_geo_accumulate_field, "ACCUMULATE_FIELD", AccumulateField, "Accumulate Field", "Add the values of an evaluated field together and output the running total for each element") diff --git a/source/blender/nodes/function/CMakeLists.txt b/source/blender/nodes/function/CMakeLists.txt index d67b361a5a9..dde3d3a5379 100644 --- a/source/blender/nodes/function/CMakeLists.txt +++ b/source/blender/nodes/function/CMakeLists.txt @@ -24,6 +24,8 @@ set(SRC nodes/node_fn_combine_matrix3x3.cc nodes/node_fn_combine_matrix4x4.cc nodes/node_fn_compare.cc + nodes/node_fn_decompose_matrix3x3.cc + nodes/node_fn_decompose_matrix4x4.cc nodes/node_fn_float_to_int.cc nodes/node_fn_input_bool.cc nodes/node_fn_input_color.cc @@ -38,11 +40,14 @@ set(SRC nodes/node_fn_random_value.cc nodes/node_fn_replace_string.cc nodes/node_fn_rotate_euler.cc + nodes/node_fn_rotate_matrix3x3.cc + nodes/node_fn_scale_matrix3x3.cc nodes/node_fn_separate_color.cc nodes/node_fn_separate_matrix3x3.cc nodes/node_fn_separate_matrix4x4.cc nodes/node_fn_slice_string.cc nodes/node_fn_string_length.cc + nodes/node_fn_translate_matrix4x4.cc nodes/node_fn_value_to_string.cc node_function_register.cc diff --git a/source/blender/nodes/function/node_function_register.cc b/source/blender/nodes/function/node_function_register.cc index 52bd9dd3465..6251a0eab07 100644 --- a/source/blender/nodes/function/node_function_register.cc +++ b/source/blender/nodes/function/node_function_register.cc @@ -12,6 +12,8 @@ void register_function_nodes() register_node_type_fn_combine_matrix_3x3(); register_node_type_fn_combine_matrix_4x4(); register_node_type_fn_compare(); + register_node_type_fn_decompose_matrix_3x3(); + register_node_type_fn_decompose_matrix_4x4(); register_node_type_fn_float_to_int(); register_node_type_fn_input_bool(); register_node_type_fn_input_color(); @@ -26,10 +28,13 @@ void register_function_nodes() register_node_type_fn_random_value(); register_node_type_fn_replace_string(); register_node_type_fn_rotate_euler(); + register_node_type_fn_rotate_matrix_3x3(); + register_node_type_fn_scale_matrix_3x3(); register_node_type_fn_separate_color(); register_node_type_fn_separate_matrix_3x3(); register_node_type_fn_separate_matrix_4x4(); register_node_type_fn_slice_string(); register_node_type_fn_string_length(); + register_node_type_fn_translate_matrix_4x4(); register_node_type_fn_value_to_string(); } diff --git a/source/blender/nodes/function/node_function_register.hh b/source/blender/nodes/function/node_function_register.hh index 3ac1a588c45..0495dc3d77f 100644 --- a/source/blender/nodes/function/node_function_register.hh +++ b/source/blender/nodes/function/node_function_register.hh @@ -8,6 +8,8 @@ void register_node_type_fn_combine_color(); void register_node_type_fn_combine_matrix_3x3(); void register_node_type_fn_combine_matrix_4x4(); void register_node_type_fn_compare(); +void register_node_type_fn_decompose_matrix_3x3(); +void register_node_type_fn_decompose_matrix_4x4(); void register_node_type_fn_float_to_int(); void register_node_type_fn_input_bool(); void register_node_type_fn_input_color(); @@ -22,9 +24,12 @@ void register_node_type_fn_matrix_4x4_math(); void register_node_type_fn_random_value(); void register_node_type_fn_replace_string(); void register_node_type_fn_rotate_euler(); +void register_node_type_fn_rotate_matrix_3x3(); +void register_node_type_fn_scale_matrix_3x3(); void register_node_type_fn_separate_color(); void register_node_type_fn_separate_matrix_3x3(); void register_node_type_fn_separate_matrix_4x4(); void register_node_type_fn_slice_string(); void register_node_type_fn_string_length(); +void register_node_type_fn_translate_matrix_4x4(); void register_node_type_fn_value_to_string(); diff --git a/source/blender/nodes/function/nodes/node_fn_decompose_matrix3x3.cc b/source/blender/nodes/function/nodes/node_fn_decompose_matrix3x3.cc new file mode 100644 index 00000000000..888246d294a --- /dev/null +++ b/source/blender/nodes/function/nodes/node_fn_decompose_matrix3x3.cc @@ -0,0 +1,70 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "node_function_util.hh" + +#include "BKE_node_runtime.hh" + +#include "UI_interface.h" +#include "UI_resources.h" + +namespace blender::nodes::node_fn_decompose_matrix3x3_cc { + +static void node_declare(NodeDeclarationBuilder &b) +{ + b.is_function_node(); + b.add_input(N_("Matrix")); + b.add_output(N_("Rotation")); + b.add_output(N_("Scale")); +}; + +class DecomposeMatrix3x3Function : public fn::MultiFunction { + public: + DecomposeMatrix3x3Function() + { + static fn::MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static fn::MFSignature create_signature() + { + fn::MFSignatureBuilder signature{"Decompose Matrix 3x3"}; + signature.single_input("Matrix"); + signature.single_output("Rotation"); + signature.single_output("Scale"); + return signature.build(); + } + + void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override + { + const VArray &matrices = params.readonly_single_input(0, "Matrix"); + MutableSpan rotations = params.uninitialized_single_output(0, "Rotation"); + MutableSpan scales = params.uninitialized_single_output(1, "Scale"); + + for (int64_t i : mask) { + const float3x3 &mat = matrices[i]; + mat3_to_eul(rotations[i], mat.ptr()); + mat3_to_size(scales[i], mat.ptr()); + } + } +}; + +static void node_build_multi_function(NodeMultiFunctionBuilder &builder) +{ + static DecomposeMatrix3x3Function decompose_matrix_fn; + builder.set_matching_fn(&decompose_matrix_fn); +} + +} // namespace blender::nodes::node_fn_decompose_matrix3x3_cc + +void register_node_type_fn_decompose_matrix_3x3(void) +{ + namespace file_ns = blender::nodes::node_fn_decompose_matrix3x3_cc; + + static bNodeType ntype; + + fn_node_type_base(&ntype, FN_NODE_DECOMPOSE_MATRIX_3X3, "Decompose 3x3 Matrix", NODE_CLASS_CONVERTER); + ntype.declare = file_ns::node_declare; + ntype.build_multi_function = file_ns::node_build_multi_function; + + nodeRegisterType(&ntype); +} diff --git a/source/blender/nodes/function/nodes/node_fn_decompose_matrix4x4.cc b/source/blender/nodes/function/nodes/node_fn_decompose_matrix4x4.cc new file mode 100644 index 00000000000..18b53e92836 --- /dev/null +++ b/source/blender/nodes/function/nodes/node_fn_decompose_matrix4x4.cc @@ -0,0 +1,74 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "node_function_util.hh" + +#include "BKE_node_runtime.hh" + +#include "UI_interface.h" +#include "UI_resources.h" + +namespace blender::nodes::node_fn_decompose_matrix4x4_cc { + +static void node_declare(NodeDeclarationBuilder &b) +{ + b.is_function_node(); + b.add_input(N_("Matrix")); + b.add_output(N_("Translation")); + b.add_output(N_("Rotation")); + b.add_output(N_("Scale")); +}; + +class DecomposeMatrix4x4Function : public fn::MultiFunction { + public: + DecomposeMatrix4x4Function() + { + static fn::MFSignature signature = create_signature(); + this->set_signature(&signature); + } + + static fn::MFSignature create_signature() + { + fn::MFSignatureBuilder signature{"Decompose Matrix 3x3"}; + signature.single_input("Matrix"); + signature.single_output("Translation"); + signature.single_output("Rotation"); + signature.single_output("Scale"); + return signature.build(); + } + + void call(IndexMask mask, fn::MFParams params, fn::MFContext /*context*/) const override + { + const VArray &matrices = params.readonly_single_input(0, "Matrix"); + MutableSpan translations = params.uninitialized_single_output(0, "Translation"); + MutableSpan rotations = params.uninitialized_single_output(0, "Rotation"); + MutableSpan scales = params.uninitialized_single_output(1, "Scale"); + + for (int64_t i : mask) { + const float4x4 &mat = matrices[i]; + copy_v3_v3(translations[i], mat[3]); + mat4_to_eul(rotations[i], mat.ptr()); + mat4_to_size(scales[i], mat.ptr()); + } + } +}; + +static void node_build_multi_function(NodeMultiFunctionBuilder &builder) +{ + static DecomposeMatrix4x4Function decompose_matrix_fn; + builder.set_matching_fn(&decompose_matrix_fn); +} + +} // namespace blender::nodes::node_fn_decompose_matrix4x4_cc + +void register_node_type_fn_decompose_matrix_4x4(void) +{ + namespace file_ns = blender::nodes::node_fn_decompose_matrix4x4_cc; + + static bNodeType ntype; + + fn_node_type_base(&ntype, FN_NODE_DECOMPOSE_MATRIX_4X4, "Decompose 4x4 Matrix", NODE_CLASS_CONVERTER); + ntype.declare = file_ns::node_declare; + ntype.build_multi_function = file_ns::node_build_multi_function; + + nodeRegisterType(&ntype); +} diff --git a/source/blender/nodes/function/nodes/node_fn_rotate_matrix3x3.cc b/source/blender/nodes/function/nodes/node_fn_rotate_matrix3x3.cc new file mode 100644 index 00000000000..ef2e19483c5 --- /dev/null +++ b/source/blender/nodes/function/nodes/node_fn_rotate_matrix3x3.cc @@ -0,0 +1,44 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "node_function_util.hh" + +#include "BKE_node_runtime.hh" + +#include "UI_interface.h" +#include "UI_resources.h" + +namespace blender::nodes::node_fn_rotate_matrix3x3_cc { + +static void node_declare(NodeDeclarationBuilder &b) +{ + b.is_function_node(); + b.add_input(N_("Matrix")); + b.add_input(N_("Rotation")); + b.add_output(N_("Matrix")); +}; + +static void node_build_multi_function(NodeMultiFunctionBuilder &builder) +{ + static fn::CustomMF_SI_SI_SO rotate_matrix_fn{ + "rotate_matrix", [](const float3x3 &mat, const float3 &rot) { + float3x3 rot_mat; + eulO_to_mat3(rot_mat.values, rot, EULER_ORDER_DEFAULT); + return rot_mat * mat; + }}; + builder.set_matching_fn(&rotate_matrix_fn); +} + +} // namespace blender::nodes::node_fn_rotate_matrix3x3_cc + +void register_node_type_fn_rotate_matrix_3x3(void) +{ + namespace file_ns = blender::nodes::node_fn_rotate_matrix3x3_cc; + + static bNodeType ntype; + + fn_node_type_base(&ntype, FN_NODE_ROTATE_MATRIX_3X3, "Rotate 3x3 Matrix", NODE_CLASS_CONVERTER); + ntype.declare = file_ns::node_declare; + ntype.build_multi_function = file_ns::node_build_multi_function; + + nodeRegisterType(&ntype); +} diff --git a/source/blender/nodes/function/nodes/node_fn_scale_matrix3x3.cc b/source/blender/nodes/function/nodes/node_fn_scale_matrix3x3.cc new file mode 100644 index 00000000000..1f14b1555b2 --- /dev/null +++ b/source/blender/nodes/function/nodes/node_fn_scale_matrix3x3.cc @@ -0,0 +1,46 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "node_function_util.hh" + +#include "BKE_node_runtime.hh" + +#include "UI_interface.h" +#include "UI_resources.h" + +namespace blender::nodes::node_fn_scale_matrix3x3_cc { + +static void node_declare(NodeDeclarationBuilder &b) +{ + b.is_function_node(); + b.add_input(N_("Matrix")); + b.add_input(N_("Scale")); + b.add_output(N_("Matrix")); +}; + +static void node_build_multi_function(NodeMultiFunctionBuilder &builder) +{ + static fn::CustomMF_SI_SI_SO scale_matrix_fn{ + "scale_matrix", [](const float3x3 &mat, const float3 &scale) { + float3x3 result; + mul_v3_v3fl(result.values[0], mat[0], scale[0]); + mul_v3_v3fl(result.values[1], mat[1], scale[1]); + mul_v3_v3fl(result.values[2], mat[2], scale[2]); + return result; + }}; + builder.set_matching_fn(&scale_matrix_fn); +} + +} // namespace blender::nodes::node_fn_scale_matrix3x3_cc + +void register_node_type_fn_scale_matrix_3x3(void) +{ + namespace file_ns = blender::nodes::node_fn_scale_matrix3x3_cc; + + static bNodeType ntype; + + fn_node_type_base(&ntype, FN_NODE_SCALE_MATRIX_3X3, "Scale 3x3 Matrix", NODE_CLASS_CONVERTER); + ntype.declare = file_ns::node_declare; + ntype.build_multi_function = file_ns::node_build_multi_function; + + nodeRegisterType(&ntype); +} diff --git a/source/blender/nodes/function/nodes/node_fn_translate_matrix4x4.cc b/source/blender/nodes/function/nodes/node_fn_translate_matrix4x4.cc new file mode 100644 index 00000000000..5f36e5cb5f2 --- /dev/null +++ b/source/blender/nodes/function/nodes/node_fn_translate_matrix4x4.cc @@ -0,0 +1,42 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "node_function_util.hh" + +#include "BKE_node_runtime.hh" + +#include "UI_interface.h" +#include "UI_resources.h" + +namespace blender::nodes::node_fn_translate_matrix4x4_cc { + +static void node_declare(NodeDeclarationBuilder &b) +{ + b.is_function_node(); + b.add_input(N_("Matrix")); + b.add_input(N_("Translation")); + b.add_output(N_("Matrix")); +}; + +static void node_build_multi_function(NodeMultiFunctionBuilder &builder) +{ + static fn::CustomMF_SI_SI_SO translate_matrix_fn{ + "translate_matrix", [](const float4x4 &mat, const float3 &vec) { + return float4x4::from_location(vec) * mat; + }}; + builder.set_matching_fn(&translate_matrix_fn); +} + +} // namespace blender::nodes::node_fn_translate_matrix4x4_cc + +void register_node_type_fn_translate_matrix_4x4(void) +{ + namespace file_ns = blender::nodes::node_fn_translate_matrix4x4_cc; + + static bNodeType ntype; + + fn_node_type_base(&ntype, FN_NODE_TRANSLATE_MATRIX_4X4, "Translate 4x4 Matrix", NODE_CLASS_CONVERTER); + ntype.declare = file_ns::node_declare; + ntype.build_multi_function = file_ns::node_build_multi_function; + + nodeRegisterType(&ntype); +} -- 2.30.2 From 49b22cc1876883c3c04df5baa4bd737b67bfa188 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Fri, 3 Mar 2023 11:33:47 +0100 Subject: [PATCH 25/33] Fix crash when socket UI creates an empty layout. --- source/blender/editors/interface/interface_layout.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/blender/editors/interface/interface_layout.cc b/source/blender/editors/interface/interface_layout.cc index c2a78686608..fcc388ff39c 100644 --- a/source/blender/editors/interface/interface_layout.cc +++ b/source/blender/editors/interface/interface_layout.cc @@ -5823,7 +5823,7 @@ void uiLayoutSetTooltipFunc(uiLayout *layout, } } - if (!arg_used) { + if (!arg_used && free_arg) { /* Free the original copy of arg in case the layout is empty. */ free_arg(arg); } -- 2.30.2 From cdd86e85f6cb3468c7af7e9ec67135e8a72006ee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Fri, 3 Mar 2023 11:43:04 +0100 Subject: [PATCH 26/33] Moved the matrix nodes menu into the Utilities category. --- .../startup/bl_ui/node_add_menu_geometry.py | 44 +++++++++---------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/scripts/startup/bl_ui/node_add_menu_geometry.py b/scripts/startup/bl_ui/node_add_menu_geometry.py index 65b33699f1a..eb0f1ee54c7 100644 --- a/scripts/startup/bl_ui/node_add_menu_geometry.py +++ b/scripts/startup/bl_ui/node_add_menu_geometry.py @@ -314,26 +314,6 @@ class NODE_MT_geometry_node_GEO_MATERIAL(Menu): node_add_menu.draw_assets_for_catalog(layout, self.bl_label) -class NODE_MT_category_GEO_MATRIX(Menu): - bl_idname = "NODE_MT_category_GEO_MATRIX" - bl_label = "Matrix" - - def draw(self, _context): - layout = self.layout - node_add_menu.add_node_type(layout, "FunctionNodeCombineMatrix3x3") - node_add_menu.add_node_type(layout, "FunctionNodeCombineMatrix4x4") - node_add_menu.add_node_type(layout, "FunctionNodeSeparateMatrix3x3") - node_add_menu.add_node_type(layout, "FunctionNodeSeparateMatrix4x4") - node_add_menu.add_node_type(layout, "FunctionNodeDecomposeMatrix3x3") - node_add_menu.add_node_type(layout, "FunctionNodeDecomposeMatrix4x4") - node_add_menu.add_node_type(layout, "FunctionNodeMatrix3x3Math") - node_add_menu.add_node_type(layout, "FunctionNodeMatrix4x4Math") - node_add_menu.add_node_type(layout, "FunctionNodeRotateMatrix3x3") - node_add_menu.add_node_type(layout, "FunctionNodeScaleMatrix3x3") - node_add_menu.add_node_type(layout, "FunctionNodeTranslateMatrix4x4") - node_add_menu.draw_assets_for_catalog(layout, self.bl_label) - - class NODE_MT_geometry_node_GEO_MESH(Menu): bl_idname = "NODE_MT_geometry_node_GEO_MESH" bl_label = "Mesh" @@ -526,6 +506,7 @@ class NODE_MT_category_GEO_UTILITIES(Menu): layout.separator() layout.menu("NODE_MT_category_GEO_UTILITIES_FIELD") layout.menu("NODE_MT_category_GEO_UTILITIES_MATH") + layout.menu("NODE_MT_category_GEO_UTILITIES_MATRIX") layout.menu("NODE_MT_category_GEO_UTILITIES_ROTATION") layout.separator() node_add_menu.add_node_type(layout, "FunctionNodeRandomValue") @@ -573,6 +554,26 @@ class NODE_MT_category_GEO_UTILITIES_MATH(Menu): node_add_menu.draw_assets_for_catalog(layout, self.bl_label) +class NODE_MT_category_GEO_UTILITIES_MATRIX(Menu): + bl_idname = "NODE_MT_category_GEO_UTILITIES_MATRIX" + bl_label = "Matrix" + + def draw(self, _context): + layout = self.layout + node_add_menu.add_node_type(layout, "FunctionNodeCombineMatrix3x3") + node_add_menu.add_node_type(layout, "FunctionNodeCombineMatrix4x4") + node_add_menu.add_node_type(layout, "FunctionNodeSeparateMatrix3x3") + node_add_menu.add_node_type(layout, "FunctionNodeSeparateMatrix4x4") + node_add_menu.add_node_type(layout, "FunctionNodeDecomposeMatrix3x3") + node_add_menu.add_node_type(layout, "FunctionNodeDecomposeMatrix4x4") + node_add_menu.add_node_type(layout, "FunctionNodeMatrix3x3Math") + node_add_menu.add_node_type(layout, "FunctionNodeMatrix4x4Math") + node_add_menu.add_node_type(layout, "FunctionNodeRotateMatrix3x3") + node_add_menu.add_node_type(layout, "FunctionNodeScaleMatrix3x3") + node_add_menu.add_node_type(layout, "FunctionNodeTranslateMatrix4x4") + node_add_menu.draw_assets_for_catalog(layout, self.bl_label) + + class NODE_MT_category_GEO_UV(Menu): bl_idname = "NODE_MT_category_GEO_UV" bl_label = "UV" @@ -649,7 +650,6 @@ class NODE_MT_geometry_node_add_all(Menu): layout.separator() layout.menu("NODE_MT_geometry_node_GEO_CURVE") layout.menu("NODE_MT_geometry_node_GEO_INSTANCE") - layout.menu("NODE_MT_category_GEO_MATRIX") layout.menu("NODE_MT_geometry_node_GEO_MESH") layout.menu("NODE_MT_category_GEO_POINT") layout.menu("NODE_MT_category_GEO_VOLUME") @@ -684,7 +684,6 @@ classes = ( NODE_MT_geometry_node_GEO_GEOMETRY_OPERATIONS, NODE_MT_geometry_node_GEO_GEOMETRY_SAMPLE, NODE_MT_geometry_node_GEO_INSTANCE, - NODE_MT_category_GEO_MATRIX, NODE_MT_geometry_node_GEO_MESH, NODE_MT_geometry_node_GEO_MESH_READ, NODE_MT_geometry_node_GEO_MESH_SAMPLE, @@ -703,6 +702,7 @@ classes = ( NODE_MT_category_GEO_VECTOR, NODE_MT_category_GEO_UTILITIES_FIELD, NODE_MT_category_GEO_UTILITIES_MATH, + NODE_MT_category_GEO_UTILITIES_MATRIX, NODE_MT_category_GEO_UTILITIES_ROTATION, NODE_MT_category_GEO_GROUP, NODE_MT_category_GEO_LAYOUT, -- 2.30.2 From bfde6c8a9cb29025bedc11a06518ddae2ed99087 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Fri, 3 Mar 2023 12:39:00 +0100 Subject: [PATCH 27/33] Removed the 2x2 and 3x3 matrix types. Having different matrix types is likely to be confusing for users and complicates node trees by requiring conversions. For now there will be only a the 4x4 matrix type, which can encode 3x3 and 2x2 matrices as well at the cost of some performance. Eventually a generic socket type could make this easier and allow the introduction of additional matrix types without too much inconvenience for users. --- .../startup/bl_ui/node_add_menu_geometry.py | 8 +- source/blender/blenkernel/BKE_node.h | 19 +- source/blender/blenkernel/intern/node.cc | 27 -- .../intern/node_tree_field_inferencing.cc | 2 +- source/blender/editors/space_node/drawnode.cc | 6 - .../editors/space_node/node_relationships.cc | 6 - .../editors/space_node/node_templates.cc | 5 - source/blender/makesdna/DNA_node_types.h | 18 +- source/blender/makesrna/intern/rna_nodetree.c | 180 -------------- source/blender/modifiers/intern/MOD_nodes.cc | 26 +- .../blender/nodes/NOD_socket_declarations.hh | 50 ---- source/blender/nodes/NOD_static_types.h | 9 +- source/blender/nodes/function/CMakeLists.txt | 9 +- .../nodes/function/node_function_register.cc | 9 +- .../nodes/function/node_function_register.hh | 9 +- .../nodes/node_fn_combine_matrix3x3.cc | 153 ------------ .../nodes/node_fn_decompose_matrix3x3.cc | 66 ----- .../function/nodes/node_fn_input_matrix3x3.cc | 56 ----- .../function/nodes/node_fn_matrix3x3_math.cc | 109 --------- .../nodes/node_fn_rotate_matrix3x3.cc | 41 ---- .../nodes/node_fn_rotate_matrix4x4.cc | 41 ++++ ...atrix3x3.cc => node_fn_scale_matrix4x4.cc} | 20 +- .../nodes/node_fn_separate_matrix3x3.cc | 230 ------------------ .../nodes/geometry/node_geometry_tree.cc | 1 - .../nodes/geometry/node_geometry_util.cc | 2 - source/blender/nodes/intern/node_common.cc | 5 - source/blender/nodes/intern/node_socket.cc | 78 ------ .../nodes/intern/node_socket_declarations.cc | 46 ---- 28 files changed, 71 insertions(+), 1160 deletions(-) delete mode 100644 source/blender/nodes/function/nodes/node_fn_combine_matrix3x3.cc delete mode 100644 source/blender/nodes/function/nodes/node_fn_decompose_matrix3x3.cc delete mode 100644 source/blender/nodes/function/nodes/node_fn_input_matrix3x3.cc delete mode 100644 source/blender/nodes/function/nodes/node_fn_matrix3x3_math.cc delete mode 100644 source/blender/nodes/function/nodes/node_fn_rotate_matrix3x3.cc create mode 100644 source/blender/nodes/function/nodes/node_fn_rotate_matrix4x4.cc rename source/blender/nodes/function/nodes/{node_fn_scale_matrix3x3.cc => node_fn_scale_matrix4x4.cc} (58%) delete mode 100644 source/blender/nodes/function/nodes/node_fn_separate_matrix3x3.cc diff --git a/scripts/startup/bl_ui/node_add_menu_geometry.py b/scripts/startup/bl_ui/node_add_menu_geometry.py index eb0f1ee54c7..48321b00358 100644 --- a/scripts/startup/bl_ui/node_add_menu_geometry.py +++ b/scripts/startup/bl_ui/node_add_menu_geometry.py @@ -560,16 +560,12 @@ class NODE_MT_category_GEO_UTILITIES_MATRIX(Menu): def draw(self, _context): layout = self.layout - node_add_menu.add_node_type(layout, "FunctionNodeCombineMatrix3x3") node_add_menu.add_node_type(layout, "FunctionNodeCombineMatrix4x4") - node_add_menu.add_node_type(layout, "FunctionNodeSeparateMatrix3x3") node_add_menu.add_node_type(layout, "FunctionNodeSeparateMatrix4x4") - node_add_menu.add_node_type(layout, "FunctionNodeDecomposeMatrix3x3") node_add_menu.add_node_type(layout, "FunctionNodeDecomposeMatrix4x4") - node_add_menu.add_node_type(layout, "FunctionNodeMatrix3x3Math") node_add_menu.add_node_type(layout, "FunctionNodeMatrix4x4Math") - node_add_menu.add_node_type(layout, "FunctionNodeRotateMatrix3x3") - node_add_menu.add_node_type(layout, "FunctionNodeScaleMatrix3x3") + node_add_menu.add_node_type(layout, "FunctionNodeRotateMatrix4x4") + node_add_menu.add_node_type(layout, "FunctionNodeScaleMatrix4x4") node_add_menu.add_node_type(layout, "FunctionNodeTranslateMatrix4x4") node_add_menu.draw_assets_for_catalog(layout, self.bl_label) diff --git a/source/blender/blenkernel/BKE_node.h b/source/blender/blenkernel/BKE_node.h index 68310175492..809f0ea8966 100644 --- a/source/blender/blenkernel/BKE_node.h +++ b/source/blender/blenkernel/BKE_node.h @@ -1580,19 +1580,14 @@ void BKE_nodetree_remove_layer_n(struct bNodeTree *ntree, struct Scene *scene, i #define FN_NODE_INPUT_INT 1220 #define FN_NODE_SEPARATE_COLOR 1221 #define FN_NODE_COMBINE_COLOR 1222 -#define FN_NODE_INPUT_MATRIX_3X3 1223 #define FN_NODE_INPUT_MATRIX_4X4 1224 -#define FN_NODE_SEPARATE_MATRIX_3X3 1225 -#define FN_NODE_SEPARATE_MATRIX_4X4 1226 -#define FN_NODE_COMBINE_MATRIX_3X3 1227 -#define FN_NODE_COMBINE_MATRIX_4X4 1228 -#define FN_NODE_MATRIX_3X3_MATH 1229 -#define FN_NODE_MATRIX_4X4_MATH 1230 -#define FN_NODE_DECOMPOSE_MATRIX_3X3 1231 -#define FN_NODE_DECOMPOSE_MATRIX_4X4 1232 -#define FN_NODE_ROTATE_MATRIX_3X3 1233 -#define FN_NODE_SCALE_MATRIX_3X3 1234 -#define FN_NODE_TRANSLATE_MATRIX_4X4 1235 +#define FN_NODE_SEPARATE_MATRIX_4X4 1225 +#define FN_NODE_COMBINE_MATRIX_4X4 1226 +#define FN_NODE_MATRIX_4X4_MATH 1227 +#define FN_NODE_DECOMPOSE_MATRIX_4X4 1228 +#define FN_NODE_ROTATE_MATRIX_4X4 1229 +#define FN_NODE_SCALE_MATRIX_4X4 1230 +#define FN_NODE_TRANSLATE_MATRIX_4X4 1231 /** \} */ diff --git a/source/blender/blenkernel/intern/node.cc b/source/blender/blenkernel/intern/node.cc index 009c7773a4b..61f7b492bbc 100644 --- a/source/blender/blenkernel/intern/node.cc +++ b/source/blender/blenkernel/intern/node.cc @@ -317,8 +317,6 @@ static void library_foreach_node_socket(LibraryForeachIDData *data, bNodeSocket case SOCK_CUSTOM: case SOCK_SHADER: case SOCK_GEOMETRY: - case SOCK_MATRIX_2X2: - case SOCK_MATRIX_3X3: case SOCK_MATRIX_4X4: break; } @@ -459,12 +457,6 @@ static void write_node_socket_default_value(BlendWriter *writer, bNodeSocket *so case SOCK_MATERIAL: BLO_write_struct(writer, bNodeSocketValueMaterial, sock->default_value); break; - case SOCK_MATRIX_2X2: - BLO_write_struct(writer, bNodeSocketValueMatrix2x2, sock->default_value); - break; - case SOCK_MATRIX_3X3: - BLO_write_struct(writer, bNodeSocketValueMatrix3x3, sock->default_value); - break; case SOCK_MATRIX_4X4: BLO_write_struct(writer, bNodeSocketValueMatrix4x4, sock->default_value); break; @@ -893,7 +885,6 @@ static void lib_link_node_socket(BlendLibReader *reader, Library *lib, bNodeSock case SOCK_CUSTOM: case SOCK_SHADER: case SOCK_GEOMETRY: - case SOCK_MATRIX_3X3: case SOCK_MATRIX_4X4: break; } @@ -994,8 +985,6 @@ static void expand_node_socket(BlendExpander *expander, bNodeSocket *sock) case SOCK_CUSTOM: case SOCK_SHADER: case SOCK_GEOMETRY: - case SOCK_MATRIX_2X2: - case SOCK_MATRIX_3X3: case SOCK_MATRIX_4X4: break; } @@ -1613,8 +1602,6 @@ static void socket_id_user_increment(bNodeSocket *sock) case SOCK_CUSTOM: case SOCK_SHADER: case SOCK_GEOMETRY: - case SOCK_MATRIX_2X2: - case SOCK_MATRIX_3X3: case SOCK_MATRIX_4X4: break; } @@ -1675,8 +1662,6 @@ static bool socket_id_user_decrement(bNodeSocket *sock) case SOCK_CUSTOM: case SOCK_SHADER: case SOCK_GEOMETRY: - case SOCK_MATRIX_2X2: - case SOCK_MATRIX_3X3: case SOCK_MATRIX_4X4: break; } @@ -1822,10 +1807,6 @@ const char *nodeStaticSocketType(const int type, const int subtype) return "NodeSocketTexture"; case SOCK_MATERIAL: return "NodeSocketMaterial"; - case SOCK_MATRIX_2X2: - return "NodeSocketMatrix2x2"; - case SOCK_MATRIX_3X3: - return "NodeSocketMatrix3x3"; case SOCK_MATRIX_4X4: return "NodeSocketMatrix4x4"; } @@ -1905,10 +1886,6 @@ const char *nodeStaticSocketInterfaceType(const int type, const int subtype) return "NodeSocketInterfaceTexture"; case SOCK_MATERIAL: return "NodeSocketInterfaceMaterial"; - case SOCK_MATRIX_2X2: - return "NodeSocketInterfaceMatrix2x2"; - case SOCK_MATRIX_3X3: - return "NodeSocketInterfaceMatrix3x3"; case SOCK_MATRIX_4X4: return "NodeSocketInterfaceMatrix4x4"; } @@ -1944,10 +1921,6 @@ const char *nodeStaticSocketLabel(const int type, const int /*subtype*/) return "Texture"; case SOCK_MATERIAL: return "Material"; - case SOCK_MATRIX_2X2: - return "2x2 Matrix"; - case SOCK_MATRIX_3X3: - return "3x3 Matrix"; case SOCK_MATRIX_4X4: return "4x4 Matrix"; } diff --git a/source/blender/blenkernel/intern/node_tree_field_inferencing.cc b/source/blender/blenkernel/intern/node_tree_field_inferencing.cc index 39b84fb396d..adc4a7096d4 100644 --- a/source/blender/blenkernel/intern/node_tree_field_inferencing.cc +++ b/source/blender/blenkernel/intern/node_tree_field_inferencing.cc @@ -20,7 +20,7 @@ using nodes::SocketDeclaration; static bool is_field_socket_type(eNodeSocketDatatype type) { - return ELEM(type, SOCK_FLOAT, SOCK_INT, SOCK_BOOLEAN, SOCK_VECTOR, SOCK_RGBA, SOCK_MATRIX_3X3, SOCK_MATRIX_4X4); + return ELEM(type, SOCK_FLOAT, SOCK_INT, SOCK_BOOLEAN, SOCK_VECTOR, SOCK_RGBA, SOCK_MATRIX_4X4); } static bool is_field_socket_type(const bNodeSocket &socket) diff --git a/source/blender/editors/space_node/drawnode.cc b/source/blender/editors/space_node/drawnode.cc index 38182a041be..a0282843d66 100644 --- a/source/blender/editors/space_node/drawnode.cc +++ b/source/blender/editors/space_node/drawnode.cc @@ -1200,8 +1200,6 @@ static const float std_node_socket_colors[][4] = { {0.96, 0.96, 0.96, 1.0}, /* SOCK_COLLECTION */ {0.62, 0.31, 0.64, 1.0}, /* SOCK_TEXTURE */ {0.92, 0.46, 0.51, 1.0}, /* SOCK_MATERIAL */ - {0.01, 0.61, 0.66, 1.0}, /* SOCK_MATRIX_2X2 */ - {0.01, 0.61, 0.66, 1.0}, /* SOCK_MATRIX_3X3 */ {0.01, 0.61, 0.66, 1.0}, /* SOCK_MATRIX_4X4 */ }; @@ -1324,8 +1322,6 @@ static void std_node_socket_draw( } } break; - case SOCK_MATRIX_2X2: - case SOCK_MATRIX_3X3: case SOCK_MATRIX_4X4: if (sock->flag & SOCK_COMPACT) { uiTemplateComponentMenu(layout, ptr, "default_value", text); @@ -1465,8 +1461,6 @@ static void std_node_socket_interface_draw(bContext * /*C*/, uiLayout *layout, P uiItemR(sub, ptr, "max_value", DEFAULT_FLAGS, IFACE_("Max"), ICON_NONE); break; } - case SOCK_MATRIX_2X2: - case SOCK_MATRIX_3X3: case SOCK_MATRIX_4X4: { uiItemR(col, ptr, "default_value", DEFAULT_FLAGS, IFACE_("Default"), ICON_NONE); uiLayout *sub = uiLayoutColumn(col, true); diff --git a/source/blender/editors/space_node/node_relationships.cc b/source/blender/editors/space_node/node_relationships.cc index 19abe12b9de..56c96e057b6 100644 --- a/source/blender/editors/space_node/node_relationships.cc +++ b/source/blender/editors/space_node/node_relationships.cc @@ -448,10 +448,6 @@ static eCustomDataType socket_type_to_custom_data_type(const eNodeSocketDatatype return CD_PROP_INT32; case SOCK_VECTOR: return CD_PROP_FLOAT3; - case SOCK_MATRIX_2X2: - return CD_PROP_FLOAT2X2; - case SOCK_MATRIX_3X3: - return CD_PROP_FLOAT3X3; case SOCK_MATRIX_4X4: return CD_PROP_FLOAT4X4; case SOCK_BOOLEAN: @@ -2224,8 +2220,6 @@ static int get_main_socket_priority(const bNodeSocket *socket) case SOCK_COLLECTION: case SOCK_TEXTURE: case SOCK_MATERIAL: - case SOCK_MATRIX_2X2: - case SOCK_MATRIX_3X3: case SOCK_MATRIX_4X4: return 6; } diff --git a/source/blender/editors/space_node/node_templates.cc b/source/blender/editors/space_node/node_templates.cc index 7de6e67f922..53051760847 100644 --- a/source/blender/editors/space_node/node_templates.cc +++ b/source/blender/editors/space_node/node_templates.cc @@ -381,9 +381,6 @@ static Vector ui_node_link_items(NodeLinkArg *arg, else if (dynamic_cast(&socket_decl)) { item.socket_type = SOCK_VECTOR; } - else if (dynamic_cast(&socket_decl)) { - item.socket_type = SOCK_MATRIX_3X3; - } else if (dynamic_cast(&socket_decl)) { item.socket_type = SOCK_MATRIX_4X4; } @@ -867,8 +864,6 @@ static void ui_node_draw_input( else { switch (input.type) { case SOCK_VECTOR: - case SOCK_MATRIX_2X2: - case SOCK_MATRIX_3X3: case SOCK_MATRIX_4X4: uiItemS(sub); sub = uiLayoutColumn(sub, true); diff --git a/source/blender/makesdna/DNA_node_types.h b/source/blender/makesdna/DNA_node_types.h index 523a3ea4ae9..8215fd50fe7 100644 --- a/source/blender/makesdna/DNA_node_types.h +++ b/source/blender/makesdna/DNA_node_types.h @@ -235,9 +235,7 @@ typedef enum eNodeSocketDatatype { SOCK_COLLECTION = 11, SOCK_TEXTURE = 12, SOCK_MATERIAL = 13, - SOCK_MATRIX_2X2 = 14, - SOCK_MATRIX_3X3 = 15, - SOCK_MATRIX_4X4 = 16, + SOCK_MATRIX_4X4 = 14, } eNodeSocketDatatype; /** Socket shape. */ @@ -717,16 +715,6 @@ typedef struct bNodeSocketValueVector { float min, max; } bNodeSocketValueVector; -typedef struct bNodeSocketValueMatrix2x2 { - float value[2][2]; - float min, max; -} bNodeSocketValueMatrix2x2; - -typedef struct bNodeSocketValueMatrix3x3 { - float value[3][3]; - float min, max; -} bNodeSocketValueMatrix3x3; - typedef struct bNodeSocketValueMatrix4x4 { float value[4][4]; float min, max; @@ -1638,10 +1626,6 @@ typedef struct NodeShaderMix { char _pad[3]; } NodeShaderMix; -typedef struct NodeInputMatrix3x3 { - float matrix[3][3]; -} NodeInputMatrix3x3; - typedef struct NodeInputMatrix4x4 { float matrix[4][4]; } NodeInputMatrix4x4; diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c index de53c87a905..923c8870d74 100644 --- a/source/blender/makesrna/intern/rna_nodetree.c +++ b/source/blender/makesrna/intern/rna_nodetree.c @@ -62,8 +62,6 @@ static const EnumPropertyItem node_socket_data_type_items[] = { {SOCK_INT, "INT", 0, "Integer", ""}, {SOCK_BOOLEAN, "BOOLEAN", 0, "Boolean", ""}, {SOCK_VECTOR, "VECTOR", 0, "Vector", ""}, - {SOCK_MATRIX_2X2, "MATRIX2x2", 0, "2x2 Matrix", ""}, - {SOCK_MATRIX_3X3, "MATRIX3x3", 0, "3x3 Matrix", ""}, {SOCK_MATRIX_4X4, "MATRIX4x4", 0, "4x4 Matrix", ""}, {SOCK_STRING, "STRING", 0, "String", ""}, {SOCK_RGBA, "RGBA", 0, "Color", ""}, @@ -92,8 +90,6 @@ static const EnumPropertyItem node_socket_type_items[] = { {SOCK_INT, "INT", 0, "Integer", ""}, {SOCK_BOOLEAN, "BOOLEAN", 0, "Boolean", ""}, {SOCK_VECTOR, "VECTOR", 0, "Vector", ""}, - {SOCK_MATRIX_2X2, "MATRIX2x2", 0, "2x2 Matrix", ""}, - {SOCK_MATRIX_3X3, "MATRIX3x3", 0, "3x3 Matrix", ""}, {SOCK_MATRIX_4X4, "MATRIX4x4", 0, "4x4 Matrix", ""}, {SOCK_STRING, "STRING", 0, "String", ""}, {SOCK_RGBA, "RGBA", 0, "RGBA", ""}, @@ -3295,22 +3291,6 @@ static void rna_NodeSocketStandard_vector_range( *softmax = dval->max; } -static void rna_NodeSocketStandard_matrix3x3_range( - PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax) -{ - bNodeSocket *sock = ptr->data; - bNodeSocketValueMatrix3x3 *dval = sock->default_value; - - if (dval->max < dval->min) { - dval->max = dval->min; - } - - *min = -FLT_MAX; - *max = FLT_MAX; - *softmin = dval->min; - *softmax = dval->max; -} - static void rna_NodeSocketStandard_matrix4x4_range( PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax) { @@ -3327,22 +3307,6 @@ static void rna_NodeSocketStandard_matrix4x4_range( *softmax = dval->max; } -static void rna_NodeSocketStandard_matrix2x2_range( - PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax) -{ - bNodeSocket *sock = ptr->data; - bNodeSocketValueMatrix2x2 *dval = sock->default_value; - - if (dval->max < dval->min) { - dval->max = dval->min; - } - - *min = -FLT_MAX; - *max = FLT_MAX; - *softmin = dval->min; - *softmax = dval->max; -} - /* using a context update function here, to avoid searching the node if possible */ static void rna_NodeSocketStandard_value_update(struct bContext *C, PointerRNA *ptr) { @@ -5273,31 +5237,6 @@ static void def_fn_combsep_color(StructRNA *srna) RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } -static void def_fn_input_matrix_3x3(StructRNA *srna) -{ - static const float default_elements[] = { - 1.0f, - 0.0f, - 0.0f, - 0.0f, - 1.0f, - 0.0f, - 0.0f, - 0.0f, - 1.0f, - }; - PropertyRNA *prop; - - RNA_def_struct_sdna_from(srna, "NodeInputMatrix3x3", "storage"); - - prop = RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX); - RNA_def_property_float_sdna(prop, NULL, "matrix"); - RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_3x3); - RNA_def_property_float_array_default(prop, default_elements); - RNA_def_property_ui_text(prop, "Matrix", "Input value used for unconnected socket"); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); -} - static void def_fn_input_matrix_4x4(StructRNA *srna) { static const float default_elements[] = { @@ -5341,17 +5280,6 @@ static void def_fn_combsep_matrix(StructRNA *srna) RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } -static void def_fn_matrix_3x3_math(StructRNA *srna) -{ - PropertyRNA *prop; - - prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE); - RNA_def_property_enum_sdna(prop, NULL, "custom1"); - RNA_def_property_enum_items(prop, rna_enum_node_matrix_math_items); - RNA_def_property_ui_text(prop, "Operation", ""); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); -} - static void def_fn_matrix_4x4_math(StructRNA *srna) { PropertyRNA *prop; @@ -11728,112 +11656,6 @@ static void rna_def_node_socket_vector(BlenderRNA *brna, RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); } -static void rna_def_node_socket_matrix2x2(BlenderRNA *brna, - const char *identifier, - const char *interface_idname) -{ - StructRNA *srna; - PropertyRNA *prop; - const float value_default[] = {1.0f, 0.0f, 0.0f, 1.0f}; - - srna = RNA_def_struct(brna, identifier, "NodeSocketStandard"); - RNA_def_struct_ui_text(srna, "Matrix 2x2 Node Socket", "2x2 matrix socket of a node"); - RNA_def_struct_sdna(srna, "bNodeSocket"); - - RNA_def_struct_sdna_from(srna, "bNodeSocketValueMatrix2x2", "default_value"); - - prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_MATRIX); - RNA_def_property_float_sdna(prop, NULL, "value"); - RNA_def_property_float_array_default(prop, value_default); - RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketStandard_matrix2x2_range"); - RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket"); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update"); - RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE); - - RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); - - /* socket interface */ - srna = RNA_def_struct(brna, interface_idname, "NodeSocketInterfaceStandard"); - RNA_def_struct_ui_text(srna, "Matrix 2x2 Node Socket Interface", "2x2 matrix socket of a node"); - RNA_def_struct_sdna(srna, "bNodeSocket"); - - RNA_def_struct_sdna_from(srna, "bNodeSocketValueMatrix2x2", "default_value"); - - prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_MATRIX); - RNA_def_property_float_sdna(prop, NULL, "value"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketStandard_matrix2x2_range"); - RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket"); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketInterface_update"); - - prop = RNA_def_property(srna, "min_value", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "min"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_ui_text(prop, "Minimum Value", "Minimum value"); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketInterface_update"); - - prop = RNA_def_property(srna, "max_value", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "max"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_ui_text(prop, "Maximum Value", "Maximum value"); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketInterface_update"); - - RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); -} - -static void rna_def_node_socket_matrix3x3(BlenderRNA *brna, - const char *identifier, - const char *interface_idname) -{ - StructRNA *srna; - PropertyRNA *prop; - const float value_default[] = {1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f}; - - srna = RNA_def_struct(brna, identifier, "NodeSocketStandard"); - RNA_def_struct_ui_text(srna, "Matrix 3x3 Node Socket", "3x3 matrix socket of a node"); - RNA_def_struct_sdna(srna, "bNodeSocket"); - - RNA_def_struct_sdna_from(srna, "bNodeSocketValueMatrix3x3", "default_value"); - - prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_MATRIX); - RNA_def_property_float_sdna(prop, NULL, "value"); - RNA_def_property_float_array_default(prop, value_default); - RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketStandard_matrix3x3_range"); - RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket"); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update"); - RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE); - - RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); - - /* socket interface */ - srna = RNA_def_struct(brna, interface_idname, "NodeSocketInterfaceStandard"); - RNA_def_struct_ui_text(srna, "Matrix 3x3 Node Socket Interface", "3x3 matrix socket of a node"); - RNA_def_struct_sdna(srna, "bNodeSocket"); - - RNA_def_struct_sdna_from(srna, "bNodeSocketValueMatrix3x3", "default_value"); - - prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_MATRIX); - RNA_def_property_float_sdna(prop, NULL, "value"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketStandard_matrix3x3_range"); - RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket"); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketInterface_update"); - - prop = RNA_def_property(srna, "min_value", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "min"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_ui_text(prop, "Minimum Value", "Minimum value"); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketInterface_update"); - - prop = RNA_def_property(srna, "max_value", PROP_FLOAT, PROP_NONE); - RNA_def_property_float_sdna(prop, NULL, "max"); - RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_ui_text(prop, "Maximum Value", "Maximum value"); - RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketInterface_update"); - - RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); -} - static void rna_def_node_socket_matrix4x4(BlenderRNA *brna, const char *identifier, const char *interface_idname) @@ -12343,8 +12165,6 @@ static void rna_def_node_socket_standard_types(BlenderRNA *brna) rna_def_node_socket_vector( brna, "NodeSocketVectorXYZ", "NodeSocketInterfaceVectorXYZ", PROP_XYZ); - rna_def_node_socket_matrix2x2(brna, "NodeSocketMatrix2x2", "NodeSocketInterfaceMatrix2x2"); - rna_def_node_socket_matrix3x3(brna, "NodeSocketMatrix3x3", "NodeSocketInterfaceMatrix3x3"); rna_def_node_socket_matrix4x4(brna, "NodeSocketMatrix4x4", "NodeSocketInterfaceMatrix4x4"); rna_def_node_socket_color(brna, "NodeSocketColor", "NodeSocketInterfaceColor"); diff --git a/source/blender/modifiers/intern/MOD_nodes.cc b/source/blender/modifiers/intern/MOD_nodes.cc index c34e22c4dd3..e19732c5800 100644 --- a/source/blender/modifiers/intern/MOD_nodes.cc +++ b/source/blender/modifiers/intern/MOD_nodes.cc @@ -419,7 +419,7 @@ static const std::string attribute_name_suffix = "_attribute_name"; */ static bool socket_type_has_attribute_toggle(const bNodeSocket &socket) { - return ELEM(socket.type, SOCK_FLOAT, SOCK_VECTOR, SOCK_BOOLEAN, SOCK_RGBA, SOCK_INT, SOCK_MATRIX_3X3, SOCK_MATRIX_4X4); + return ELEM(socket.type, SOCK_FLOAT, SOCK_VECTOR, SOCK_BOOLEAN, SOCK_RGBA, SOCK_INT, SOCK_MATRIX_4X4); } /** @@ -477,22 +477,6 @@ id_property_create_from_socket(const bNodeSocket &socket) } return property; } - case SOCK_MATRIX_3X3: { - const bNodeSocketValueMatrix3x3 *value = static_cast( - socket.default_value); - const Span default_value_span((float *)value->value, 9); - auto property = bke::idprop::create(socket.identifier, default_value_span); - IDPropertyUIDataFloat *ui_data = (IDPropertyUIDataFloat *)IDP_ui_data_ensure(property.get()); - ui_data->base.rna_subtype = PROP_MATRIX; - ui_data->min = ui_data->soft_min = double(value->min); - ui_data->max = ui_data->soft_max = double(value->max); - ui_data->default_array = (double *)MEM_mallocN(sizeof(double[9]), "mod_prop_default"); - ui_data->default_array_len = 9; - for (const int i : IndexRange(9)) { - ui_data->default_array[i] = double(default_value_span[i]); - } - return property; - } case SOCK_MATRIX_4X4: { const bNodeSocketValueMatrix4x4 *value = static_cast( socket.default_value); @@ -586,8 +570,6 @@ static bool id_property_type_matches_socket(const bNodeSocket &socket, const IDP return property.type == IDP_INT; case SOCK_VECTOR: return property.type == IDP_ARRAY && property.subtype == IDP_FLOAT && property.len == 3; - case SOCK_MATRIX_3X3: - return property.type == IDP_ARRAY && property.subtype == IDP_FLOAT && property.len == 9; case SOCK_MATRIX_4X4: return property.type == IDP_ARRAY && property.subtype == IDP_FLOAT && property.len == 16; case SOCK_RGBA: @@ -634,12 +616,6 @@ static void init_socket_cpp_value_from_property(const IDProperty &property, new (r_value) ValueOrField(value); break; } - case SOCK_MATRIX_3X3: { - float3x3 value; - copy_m3_m3(value.ptr(), (const float (*)[3])IDP_Array(&property)); - new (r_value) ValueOrField(value); - break; - } case SOCK_MATRIX_4X4: { float4x4 value; copy_m4_m4(value.ptr(), (const float(*)[4])IDP_Array(&property)); diff --git a/source/blender/nodes/NOD_socket_declarations.hh b/source/blender/nodes/NOD_socket_declarations.hh index e1780df41c8..5e25acfe023 100644 --- a/source/blender/nodes/NOD_socket_declarations.hh +++ b/source/blender/nodes/NOD_socket_declarations.hh @@ -94,32 +94,6 @@ class VectorBuilder : public SocketDeclarationBuilder { VectorBuilder &compact(); }; -class Matrix3x3Builder; - -class Matrix3x3 : public SocketDeclaration { - private: - float3x3 default_value_ = float3x3::identity(); - float soft_min_value_ = -FLT_MAX; - float soft_max_value_ = FLT_MAX; - - friend Matrix3x3Builder; - - public: - using Builder = Matrix3x3Builder; - - bNodeSocket &build(bNodeTree &ntree, bNode &node) const override; - bool matches(const bNodeSocket &socket) const override; - bNodeSocket &update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket &socket) const override; - bool can_connect(const bNodeSocket &socket) const override; -}; - -class Matrix3x3Builder : public SocketDeclarationBuilder { - public: - Matrix3x3Builder &default_value(const float3x3 &value); - Matrix3x3Builder &min(float min); - Matrix3x3Builder &max(float max); -}; - class Matrix4x4Builder; class Matrix4x4 : public SocketDeclaration { @@ -396,30 +370,6 @@ inline VectorBuilder &VectorBuilder::compact() /** \} */ -/* -------------------------------------------------------------------- */ -/** \name #Matrix3x3Builder Inline Methods - * \{ */ - -inline Matrix3x3Builder &Matrix3x3Builder::default_value(const float3x3 &value) -{ - decl_->default_value_ = value; - return *this; -} - -inline Matrix3x3Builder &Matrix3x3Builder::min(const float min) -{ - decl_->soft_min_value_ = min; - return *this; -} - -inline Matrix3x3Builder &Matrix3x3Builder::max(const float max) -{ - decl_->soft_max_value_ = max; - return *this; -} - -/** \} */ - /* -------------------------------------------------------------------- */ /** \name #Matrix4x4Builder Inline Methods * \{ */ diff --git a/source/blender/nodes/NOD_static_types.h b/source/blender/nodes/NOD_static_types.h index 419c29383ae..5d686d6ccf1 100644 --- a/source/blender/nodes/NOD_static_types.h +++ b/source/blender/nodes/NOD_static_types.h @@ -264,29 +264,24 @@ DefNode(TextureNode, TEX_NODE_PROC+TEX_DISTNOISE, 0, "TEX_DI DefNode(FunctionNode, FN_NODE_ALIGN_EULER_TO_VECTOR, def_fn_align_euler_to_vector, "ALIGN_EULER_TO_VECTOR", AlignEulerToVector, "Align Euler to Vector", "") DefNode(FunctionNode, FN_NODE_BOOLEAN_MATH, def_boolean_math, "BOOLEAN_MATH", BooleanMath, "Boolean Math", "") DefNode(FunctionNode, FN_NODE_COMBINE_COLOR, def_fn_combsep_color, "COMBINE_COLOR", CombineColor, "Combine Color", "") -DefNode(FunctionNode, FN_NODE_COMBINE_MATRIX_3X3, def_fn_combsep_matrix, "COMBINE_MATRIX_3X3", CombineMatrix3x3, "Combine 3x3 Matrix", "") DefNode(FunctionNode, FN_NODE_COMBINE_MATRIX_4X4, def_fn_combsep_matrix, "COMBINE_MATRIX_4X4", CombineMatrix4x4, "Combine 4x4 Matrix", "") DefNode(FunctionNode, FN_NODE_COMPARE, def_compare, "COMPARE", Compare, "Compare", "") -DefNode(FunctionNode, FN_NODE_DECOMPOSE_MATRIX_3X3, 0, "DECOMPOSE_MATRIX_3X3", DecomposeMatrix3x3, "Decompose 3x3 Matrix", "") DefNode(FunctionNode, FN_NODE_DECOMPOSE_MATRIX_4X4, 0, "DECOMPOSE_MATRIX_4X4", DecomposeMatrix4x4, "Decompose 4x4 Matrix", "") DefNode(FunctionNode, FN_NODE_FLOAT_TO_INT, def_float_to_int, "FLOAT_TO_INT", FloatToInt, "Float to Integer", "") DefNode(FunctionNode, FN_NODE_INPUT_BOOL, def_fn_input_bool, "INPUT_BOOL", InputBool, "Boolean", "") DefNode(FunctionNode, FN_NODE_INPUT_COLOR, def_fn_input_color, "INPUT_COLOR", InputColor, "Color", "") DefNode(FunctionNode, FN_NODE_INPUT_INT, def_fn_input_int, "INPUT_INT", InputInt, "Integer", "") -DefNode(FunctionNode, FN_NODE_INPUT_MATRIX_3X3, def_fn_input_matrix_3x3, "INPUT_MATRIX_3X3", InputMatrix3x3, "3x3 Matrix", "") DefNode(FunctionNode, FN_NODE_INPUT_MATRIX_4X4, def_fn_input_matrix_4x4, "INPUT_MATRIX_4X4", InputMatrix4x4, "4x4 Matrix", "") DefNode(FunctionNode, FN_NODE_INPUT_SPECIAL_CHARACTERS, 0, "INPUT_SPECIAL_CHARACTERS", InputSpecialCharacters, "Special Characters", "") DefNode(FunctionNode, FN_NODE_INPUT_STRING, def_fn_input_string, "INPUT_STRING", InputString, "String", "") DefNode(FunctionNode, FN_NODE_INPUT_VECTOR, def_fn_input_vector, "INPUT_VECTOR", InputVector, "Vector", "") -DefNode(FunctionNode, FN_NODE_MATRIX_3X3_MATH, def_fn_matrix_3x3_math, "MATRIX_3X3_MATH", Matrix3x3Math, "3x3 Matrix Math", "") DefNode(FunctionNode, FN_NODE_MATRIX_4X4_MATH, def_fn_matrix_4x4_math, "MATRIX_4X4_MATH", Matrix4x4Math, "4x4 Matrix Math", "") DefNode(FunctionNode, FN_NODE_RANDOM_VALUE, def_fn_random_value, "RANDOM_VALUE", RandomValue, "Random Value", "") DefNode(FunctionNode, FN_NODE_REPLACE_STRING, 0, "REPLACE_STRING", ReplaceString, "Replace String", "") DefNode(FunctionNode, FN_NODE_ROTATE_EULER, def_fn_rotate_euler, "ROTATE_EULER", RotateEuler, "Rotate Euler", "") -DefNode(FunctionNode, FN_NODE_ROTATE_MATRIX_3X3, 0, "ROTATE_MATRIX_3X3", RotateMatrix3x3, "Rotate Matrix", "") -DefNode(FunctionNode, FN_NODE_SCALE_MATRIX_3X3, 0, "SCALE_MATRIX_3X3", ScaleMatrix3x3, "Scale Matrix", "") +DefNode(FunctionNode, FN_NODE_ROTATE_MATRIX_4X4, 0, "ROTATE_MATRIX_4X4", RotateMatrix4x4, "Rotate Matrix", "") +DefNode(FunctionNode, FN_NODE_SCALE_MATRIX_4X4, 0, "SCALE_MATRIX_4X4", ScaleMatrix4x4, "Scale Matrix", "") DefNode(FunctionNode, FN_NODE_SEPARATE_COLOR, def_fn_combsep_color, "SEPARATE_COLOR", SeparateColor, "Separate Color", "") -DefNode(FunctionNode, FN_NODE_SEPARATE_MATRIX_3X3, def_fn_combsep_matrix, "SEPARATE_MATRIX_3X3", SeparateMatrix3x3, "Separate 3x3 Matrix", "") DefNode(FunctionNode, FN_NODE_SEPARATE_MATRIX_4X4, def_fn_combsep_matrix, "SEPARATE_MATRIX_4X4", SeparateMatrix4x4, "Separate 4x4 Matrix", "") DefNode(FunctionNode, FN_NODE_SLICE_STRING, 0, "SLICE_STRING", SliceString, "Slice String", "") DefNode(FunctionNode, FN_NODE_STRING_LENGTH, 0, "STRING_LENGTH", StringLength, "String Length", "") diff --git a/source/blender/nodes/function/CMakeLists.txt b/source/blender/nodes/function/CMakeLists.txt index 026f4cda3e0..03c9129f2d7 100644 --- a/source/blender/nodes/function/CMakeLists.txt +++ b/source/blender/nodes/function/CMakeLists.txt @@ -23,29 +23,24 @@ set(SRC nodes/node_fn_align_euler_to_vector.cc nodes/node_fn_boolean_math.cc nodes/node_fn_combine_color.cc - nodes/node_fn_combine_matrix3x3.cc nodes/node_fn_combine_matrix4x4.cc nodes/node_fn_compare.cc - nodes/node_fn_decompose_matrix3x3.cc nodes/node_fn_decompose_matrix4x4.cc nodes/node_fn_float_to_int.cc nodes/node_fn_input_bool.cc nodes/node_fn_input_color.cc nodes/node_fn_input_int.cc - nodes/node_fn_input_matrix3x3.cc nodes/node_fn_input_matrix4x4.cc nodes/node_fn_input_special_characters.cc nodes/node_fn_input_string.cc nodes/node_fn_input_vector.cc - nodes/node_fn_matrix3x3_math.cc nodes/node_fn_matrix4x4_math.cc nodes/node_fn_random_value.cc nodes/node_fn_replace_string.cc nodes/node_fn_rotate_euler.cc - nodes/node_fn_rotate_matrix3x3.cc - nodes/node_fn_scale_matrix3x3.cc + nodes/node_fn_rotate_matrix4x4.cc + nodes/node_fn_scale_matrix4x4.cc nodes/node_fn_separate_color.cc - nodes/node_fn_separate_matrix3x3.cc nodes/node_fn_separate_matrix4x4.cc nodes/node_fn_slice_string.cc nodes/node_fn_string_length.cc diff --git a/source/blender/nodes/function/node_function_register.cc b/source/blender/nodes/function/node_function_register.cc index 6251a0eab07..50354981e35 100644 --- a/source/blender/nodes/function/node_function_register.cc +++ b/source/blender/nodes/function/node_function_register.cc @@ -9,29 +9,24 @@ void register_function_nodes() register_node_type_fn_align_euler_to_vector(); register_node_type_fn_boolean_math(); register_node_type_fn_combine_color(); - register_node_type_fn_combine_matrix_3x3(); register_node_type_fn_combine_matrix_4x4(); register_node_type_fn_compare(); - register_node_type_fn_decompose_matrix_3x3(); register_node_type_fn_decompose_matrix_4x4(); register_node_type_fn_float_to_int(); register_node_type_fn_input_bool(); register_node_type_fn_input_color(); register_node_type_fn_input_int(); - register_node_type_fn_input_matrix_3x3(); register_node_type_fn_input_matrix_4x4(); register_node_type_fn_input_special_characters(); register_node_type_fn_input_string(); register_node_type_fn_input_vector(); - register_node_type_fn_matrix_3x3_math(); register_node_type_fn_matrix_4x4_math(); register_node_type_fn_random_value(); register_node_type_fn_replace_string(); register_node_type_fn_rotate_euler(); - register_node_type_fn_rotate_matrix_3x3(); - register_node_type_fn_scale_matrix_3x3(); + register_node_type_fn_rotate_matrix_4x4(); + register_node_type_fn_scale_matrix_4x4(); register_node_type_fn_separate_color(); - register_node_type_fn_separate_matrix_3x3(); register_node_type_fn_separate_matrix_4x4(); register_node_type_fn_slice_string(); register_node_type_fn_string_length(); diff --git a/source/blender/nodes/function/node_function_register.hh b/source/blender/nodes/function/node_function_register.hh index 0495dc3d77f..79c67fc060a 100644 --- a/source/blender/nodes/function/node_function_register.hh +++ b/source/blender/nodes/function/node_function_register.hh @@ -5,29 +5,24 @@ void register_node_type_fn_align_euler_to_vector(); void register_node_type_fn_boolean_math(); void register_node_type_fn_combine_color(); -void register_node_type_fn_combine_matrix_3x3(); void register_node_type_fn_combine_matrix_4x4(); void register_node_type_fn_compare(); -void register_node_type_fn_decompose_matrix_3x3(); void register_node_type_fn_decompose_matrix_4x4(); void register_node_type_fn_float_to_int(); void register_node_type_fn_input_bool(); void register_node_type_fn_input_color(); void register_node_type_fn_input_int(); -void register_node_type_fn_input_matrix_3x3(); void register_node_type_fn_input_matrix_4x4(); void register_node_type_fn_input_special_characters(); void register_node_type_fn_input_string(); void register_node_type_fn_input_vector(); -void register_node_type_fn_matrix_3x3_math(); void register_node_type_fn_matrix_4x4_math(); void register_node_type_fn_random_value(); void register_node_type_fn_replace_string(); void register_node_type_fn_rotate_euler(); -void register_node_type_fn_rotate_matrix_3x3(); -void register_node_type_fn_scale_matrix_3x3(); +void register_node_type_fn_rotate_matrix_4x4(); +void register_node_type_fn_scale_matrix_4x4(); void register_node_type_fn_separate_color(); -void register_node_type_fn_separate_matrix_3x3(); void register_node_type_fn_separate_matrix_4x4(); void register_node_type_fn_slice_string(); void register_node_type_fn_string_length(); diff --git a/source/blender/nodes/function/nodes/node_fn_combine_matrix3x3.cc b/source/blender/nodes/function/nodes/node_fn_combine_matrix3x3.cc deleted file mode 100644 index b5a71a29a71..00000000000 --- a/source/blender/nodes/function/nodes/node_fn_combine_matrix3x3.cc +++ /dev/null @@ -1,153 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "node_function_util.hh" - -#include "UI_interface.h" -#include "UI_resources.h" - -namespace blender::nodes::node_fn_combine_matrix3x3_cc { - -static void node_declare(NodeDeclarationBuilder &b) -{ - b.is_function_node(); - b.add_input(N_("Vec0")).default_value({1.0f, 0.0f, 0.0f}); - b.add_input(N_("Vec1")).default_value({0.0f, 1.0f, 0.0f}); - b.add_input(N_("Vec2")).default_value({0.0f, 0.0f, 1.0f}); - b.add_input(N_("Row 0 Col 0")).default_value(1.0f); - b.add_input(N_("Row 1 Col 0")).default_value(0.0f); - b.add_input(N_("Row 2 Col 0")).default_value(0.0f); - b.add_input(N_("Row 0 Col 1")).default_value(0.0f); - b.add_input(N_("Row 1 Col 1")).default_value(1.0f); - b.add_input(N_("Row 2 Col 1")).default_value(0.0f); - b.add_input(N_("Row 0 Col 2")).default_value(0.0f); - b.add_input(N_("Row 1 Col 2")).default_value(0.0f); - b.add_input(N_("Row 2 Col 2")).default_value(1.0f); - b.add_output(N_("Matrix")); -}; - -static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) -{ - uiItemR(layout, ptr, "mode", 0, "", ICON_NONE); -} - -static void node_update(bNodeTree *tree, bNode *node) -{ - const NodeCombSepMatrixMode mode = (NodeCombSepMatrixMode)node->custom1; - - const IndexRange vector_sockets(0, 4); - const IndexRange scalar_sockets(3, 9); - const bool show_vector_sockets = ELEM( - mode, NODE_COMBSEP_MATRIX_COLUMNS, NODE_COMBSEP_MATRIX_ROWS); - const bool show_scalar_sockets = ELEM(mode, NODE_COMBSEP_MATRIX_ELEMENTS); - - for (const int i : vector_sockets) { - nodeSetSocketAvailability( - tree, (bNodeSocket *)BLI_findlink(&node->inputs, i), show_vector_sockets); - } - for (const int i : scalar_sockets) { - nodeSetSocketAvailability( - tree, (bNodeSocket *)BLI_findlink(&node->inputs, i), show_scalar_sockets); - } - - switch (mode) { - case NODE_COMBSEP_MATRIX_COLUMNS: - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[0]), "Column 0"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[1]), "Column 1"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[2]), "Column 2"); - break; - case NODE_COMBSEP_MATRIX_ROWS: - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[0]), "Row 0"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[1]), "Row 1"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->inputs, vector_sockets[2]), "Row 2"); - break; - case NODE_COMBSEP_MATRIX_ELEMENTS: - break; - } -} - -static void node_init(bNodeTree * /*tree*/, bNode *node) -{ - node->custom1 = NODE_COMBSEP_MATRIX_COLUMNS; -} - -static const mf::MultiFunction *get_multi_function(const bNode &bnode) -{ - const NodeCombSepMatrixMode mode = (NodeCombSepMatrixMode)bnode.custom1; - - static auto columns_fn = mf::build::SI3_SO( - "columns_to_matrix", [](const float3 &c0, const float3 &c1, const float3 &c2) { - float4x4 m; - m.view()[0] = float4(c0, 0.0f); - m.view()[1] = float4(c1, 0.0f); - m.view()[2] = float4(c2, 0.0f); - return m; - }); - static auto rows_fn = mf::build::SI3_SO( - "rows_to_matrix", [](const float3 &r0, const float3 &r1, const float3 &r2) { - float4x4 m; - m[0][0] = r0[0]; - m[0][1] = r1[0]; - m[0][2] = r2[0]; - m[1][0] = r0[1]; - m[1][1] = r1[1]; - m[1][2] = r2[1]; - m[2][0] = r0[2]; - m[2][1] = r1[2]; - m[2][2] = r2[2]; - return m; - }); - static auto exec_preset = mf::build::exec_presets::AllSpanOrSingle(); - static auto elements_fn = - mf::build::detail::build_multi_function_with_n_inputs_one_output( - "elements_to_matrix", - [](float m00, - float m01, - float m02, - float m10, - float m11, - float m12, - float m20, - float m21, - float m22) { - const float elements[] = {m00, m01, m02, m10, m11, m12, m20, m21, m22}; - return float3x3(elements); - }, - exec_preset, - TypeSequence()); - - switch (mode) { - case NODE_COMBSEP_MATRIX_COLUMNS: - return &columns_fn; - case NODE_COMBSEP_MATRIX_ROWS: - return &rows_fn; - case NODE_COMBSEP_MATRIX_ELEMENTS: - return &elements_fn; - } - - BLI_assert_unreachable(); - return nullptr; -} - -static void node_build_multi_function(NodeMultiFunctionBuilder &builder) -{ - const mf::MultiFunction *fn = get_multi_function(builder.node()); - builder.set_matching_fn(fn); -} - -} // namespace blender::nodes::node_fn_combine_matrix3x3_cc - -void register_node_type_fn_combine_matrix_3x3(void) -{ - namespace file_ns = blender::nodes::node_fn_combine_matrix3x3_cc; - - static bNodeType ntype; - - fn_node_type_base(&ntype, FN_NODE_COMBINE_MATRIX_3X3, "Combine 3x3 Matrix", NODE_CLASS_CONVERTER); - ntype.declare = file_ns::node_declare; - ntype.updatefunc = file_ns::node_update; - ntype.initfunc = file_ns::node_init; - ntype.build_multi_function = file_ns::node_build_multi_function; - ntype.draw_buttons = file_ns::node_layout; - - nodeRegisterType(&ntype); -} diff --git a/source/blender/nodes/function/nodes/node_fn_decompose_matrix3x3.cc b/source/blender/nodes/function/nodes/node_fn_decompose_matrix3x3.cc deleted file mode 100644 index 1f109e73f1e..00000000000 --- a/source/blender/nodes/function/nodes/node_fn_decompose_matrix3x3.cc +++ /dev/null @@ -1,66 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "node_function_util.hh" - -#include "BLI_math_matrix.h" -#include "BLI_math_rotation.h" - -namespace blender::nodes::node_fn_decompose_matrix3x3_cc { - -static void node_declare(NodeDeclarationBuilder &b) -{ - b.is_function_node(); - b.add_input(N_("Matrix")); - b.add_output(N_("Rotation")); - b.add_output(N_("Scale")); -}; - -class DecomposeMatrix3x3Function : public mf::MultiFunction { - public: - DecomposeMatrix3x3Function() - { - static const mf::Signature signature = []() { - mf::Signature signature; - mf::SignatureBuilder builder{"Decompose Matrix 3x3", signature}; - builder.single_input("Matrix"); - builder.single_output("Rotation"); - builder.single_output("Scale"); - return signature; - }(); - this->set_signature(&signature); - } - - void call(IndexMask mask, mf::Params params, mf::Context /*context*/) const override - { - const VArray &matrices = params.readonly_single_input(0, "Matrix"); - MutableSpan rotations = params.uninitialized_single_output(0, "Rotation"); - MutableSpan scales = params.uninitialized_single_output(1, "Scale"); - - for (int64_t i : mask) { - const float3x3 &mat = matrices[i]; - mat3_to_eul(rotations[i], mat.ptr()); - mat3_to_size(scales[i], mat.ptr()); - } - } -}; - -static void node_build_multi_function(NodeMultiFunctionBuilder &builder) -{ - static DecomposeMatrix3x3Function decompose_matrix_fn; - builder.set_matching_fn(&decompose_matrix_fn); -} - -} // namespace blender::nodes::node_fn_decompose_matrix3x3_cc - -void register_node_type_fn_decompose_matrix_3x3(void) -{ - namespace file_ns = blender::nodes::node_fn_decompose_matrix3x3_cc; - - static bNodeType ntype; - - fn_node_type_base(&ntype, FN_NODE_DECOMPOSE_MATRIX_3X3, "Decompose 3x3 Matrix", NODE_CLASS_CONVERTER); - ntype.declare = file_ns::node_declare; - ntype.build_multi_function = file_ns::node_build_multi_function; - - nodeRegisterType(&ntype); -} diff --git a/source/blender/nodes/function/nodes/node_fn_input_matrix3x3.cc b/source/blender/nodes/function/nodes/node_fn_input_matrix3x3.cc deleted file mode 100644 index d257df8bc30..00000000000 --- a/source/blender/nodes/function/nodes/node_fn_input_matrix3x3.cc +++ /dev/null @@ -1,56 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "node_function_util.hh" - -#include "BLI_math_matrix.h" - -#include "UI_interface.h" -#include "UI_resources.h" - -namespace blender::nodes::node_fn_input_matrix3x3_cc { - -NODE_STORAGE_FUNCS(NodeInputMatrix3x3); - -static void node_declare(NodeDeclarationBuilder &b) -{ - b.add_output(N_("Matrix")); -}; - -static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) -{ - uiItemR(layout, ptr, "matrix", 0, "", ICON_NONE); -} - -static void node_init(bNodeTree * /*tree*/, bNode *node) -{ - NodeInputMatrix3x3 *data = MEM_new(__func__); - unit_m3(data->matrix); - node->storage = data; -} - -static void node_build_multi_function(NodeMultiFunctionBuilder &builder) -{ - const NodeInputMatrix3x3 &storage = node_storage(builder.node()); - builder.construct_and_set_matching_fn>(float3x3{storage.matrix}); -} - -} // namespace blender::nodes::node_fn_input_matrix3x3_cc - -void register_node_type_fn_input_matrix_3x3(void) -{ - namespace file_ns = blender::nodes::node_fn_input_matrix3x3_cc; - - static bNodeType ntype; - - fn_node_type_base(&ntype, FN_NODE_INPUT_MATRIX_3X3, "3x3 Matrix", NODE_CLASS_INPUT); - node_type_storage( - &ntype, "NodeInputMatrix3x3", node_free_standard_storage, node_copy_standard_storage); - ntype.declare = file_ns::node_declare; - ntype.initfunc = file_ns::node_init; - ntype.build_multi_function = file_ns::node_build_multi_function; - ntype.draw_buttons = file_ns::node_layout; - /* Matrix columns need more horizontal space */ - node_type_size_preset(&ntype, NODE_SIZE_LARGE); - - nodeRegisterType(&ntype); -} diff --git a/source/blender/nodes/function/nodes/node_fn_matrix3x3_math.cc b/source/blender/nodes/function/nodes/node_fn_matrix3x3_math.cc deleted file mode 100644 index 06bf8516d3f..00000000000 --- a/source/blender/nodes/function/nodes/node_fn_matrix3x3_math.cc +++ /dev/null @@ -1,109 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "node_function_util.hh" - -#include "BLI_math_matrix.h" - -#include "NOD_socket_search_link.hh" - -#include "UI_interface.h" -#include "UI_resources.h" - -namespace blender::nodes::node_fn_matrix3x3_math_cc { - -static void node_declare(NodeDeclarationBuilder &b) -{ - b.is_function_node(); - b.add_input(N_("Matrix")); - b.add_input(N_("Matrix"), "Matrix_001"); - b.add_input(N_("Scale")).default_value(1.0f); - b.add_output(N_("Matrix")); - b.add_output(N_("Value")); -}; - -static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) -{ - uiItemR(layout, ptr, "operation", UI_ITEM_R_SPLIT_EMPTY_NAME, "", ICON_NONE); -} - -static void node_update(bNodeTree *tree, bNode *node) -{ - const NodeMatrixMathOperation op = (NodeMatrixMathOperation)node->custom1; - - bNodeSocket *in_matrix_a = (bNodeSocket *)BLI_findlink(&node->inputs, 0); - bNodeSocket *in_matrix_b = (bNodeSocket *)BLI_findlink(&node->inputs, 1); - bNodeSocket *in_scale = (bNodeSocket *)BLI_findlink(&node->inputs, 2); - bNodeSocket *out_matrix = (bNodeSocket *)BLI_findlink(&node->outputs, 0); - bNodeSocket *out_value = (bNodeSocket *)BLI_findlink(&node->outputs, 1); - - nodeSetSocketAvailability(tree, in_matrix_a, true); - nodeSetSocketAvailability( - tree, - in_matrix_b, - ELEM(op, NODE_MATRIX_MATH_ADD, NODE_MATRIX_MATH_SUBTRACT, NODE_MATRIX_MATH_MULTIPLY)); - nodeSetSocketAvailability(tree, in_scale, ELEM(op, NODE_MATRIX_MATH_SCALAR_MULTIPLY)); - - nodeSetSocketAvailability(tree, - out_matrix, - ELEM(op, - NODE_MATRIX_MATH_ADD, - NODE_MATRIX_MATH_SUBTRACT, - NODE_MATRIX_MATH_SCALAR_MULTIPLY, - NODE_MATRIX_MATH_MULTIPLY, - NODE_MATRIX_MATH_TRANSPOSE, - NODE_MATRIX_MATH_INVERSE)); - nodeSetSocketAvailability( - tree, out_value, ELEM(op, NODE_MATRIX_MATH_DETERMINANT, NODE_MATRIX_MATH_TRACE)); - - /* Labels */ - node_sock_label_clear(in_matrix_a); - node_sock_label_clear(in_matrix_b); - node_sock_label_clear(in_scale); -} - -static void node_init(bNodeTree * /*tree*/, bNode *node) -{ - node->custom1 = NODE_MATRIX_MATH_ADD; -} - -static const mf::MultiFunction *get_multi_function(NodeMatrixMathOperation op) -{ - static auto exec_preset = mf::build::exec_presets::AllSpanOrSingle(); - - switch (op) { - case NODE_MATRIX_MATH_ADD: { - static auto fn = mf::build::SI2_SO( - "add", - [](const float3x3 &a, const float3x3 &b) -> float3x3 { return a + b; }, - exec_preset); - return &fn; - } - } - - return nullptr; -} - -static void node_build_multi_function(NodeMultiFunctionBuilder &builder) -{ - const NodeMatrixMathOperation op = (NodeMatrixMathOperation)builder.node().custom1; - const mf::MultiFunction *fn = get_multi_function(op); - builder.set_matching_fn(fn); -} - -} // namespace blender::nodes::node_fn_matrix3x3_math_cc - -void register_node_type_fn_matrix_3x3_math(void) -{ - namespace file_ns = blender::nodes::node_fn_matrix3x3_math_cc; - - static bNodeType ntype; - - fn_node_type_base(&ntype, FN_NODE_MATRIX_3X3_MATH, "3x3 Matrix Math", NODE_CLASS_CONVERTER); - ntype.declare = file_ns::node_declare; - ntype.updatefunc = file_ns::node_update; - ntype.initfunc = file_ns::node_init; - ntype.build_multi_function = file_ns::node_build_multi_function; - ntype.draw_buttons = file_ns::node_layout; - - nodeRegisterType(&ntype); -} diff --git a/source/blender/nodes/function/nodes/node_fn_rotate_matrix3x3.cc b/source/blender/nodes/function/nodes/node_fn_rotate_matrix3x3.cc deleted file mode 100644 index 36d67e7075e..00000000000 --- a/source/blender/nodes/function/nodes/node_fn_rotate_matrix3x3.cc +++ /dev/null @@ -1,41 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "node_function_util.hh" - -#include "BLI_math_rotation.h" - -namespace blender::nodes::node_fn_rotate_matrix3x3_cc { - -static void node_declare(NodeDeclarationBuilder &b) -{ - b.is_function_node(); - b.add_input(N_("Matrix")); - b.add_input(N_("Rotation")); - b.add_output(N_("Matrix")); -}; - -static void node_build_multi_function(NodeMultiFunctionBuilder &builder) -{ - static auto fn = mf::build::SI2_SO( - "rotate_matrix", [](const float3x3 &mat, const float3 &rot) { - float3x3 rot_mat; - eulO_to_mat3(rot_mat.ptr(), rot, EULER_ORDER_DEFAULT); - return rot_mat * mat; - }); - builder.set_matching_fn(&fn); -} - -} // namespace blender::nodes::node_fn_rotate_matrix3x3_cc - -void register_node_type_fn_rotate_matrix_3x3(void) -{ - namespace file_ns = blender::nodes::node_fn_rotate_matrix3x3_cc; - - static bNodeType ntype; - - fn_node_type_base(&ntype, FN_NODE_ROTATE_MATRIX_3X3, "Rotate 3x3 Matrix", NODE_CLASS_CONVERTER); - ntype.declare = file_ns::node_declare; - ntype.build_multi_function = file_ns::node_build_multi_function; - - nodeRegisterType(&ntype); -} diff --git a/source/blender/nodes/function/nodes/node_fn_rotate_matrix4x4.cc b/source/blender/nodes/function/nodes/node_fn_rotate_matrix4x4.cc new file mode 100644 index 00000000000..506de77520b --- /dev/null +++ b/source/blender/nodes/function/nodes/node_fn_rotate_matrix4x4.cc @@ -0,0 +1,41 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "node_function_util.hh" + +#include "BLI_math_rotation.h" + +namespace blender::nodes::node_fn_rotate_matrix4x4_cc { + +static void node_declare(NodeDeclarationBuilder &b) +{ + b.is_function_node(); + b.add_input(N_("Matrix")); + b.add_input(N_("Rotation")); + b.add_output(N_("Matrix")); +}; + +static void node_build_multi_function(NodeMultiFunctionBuilder &builder) +{ + static auto fn = mf::build::SI2_SO( + "rotate_matrix", [](const float4x4 &mat, const float3 &rot) { + float4x4 rot_mat; + eulO_to_mat4(rot_mat.ptr(), rot, EULER_ORDER_DEFAULT); + return rot_mat * mat; + }); + builder.set_matching_fn(&fn); +} + +} // namespace blender::nodes::node_fn_rotate_matrix4x4_cc + +void register_node_type_fn_rotate_matrix_4x4(void) +{ + namespace file_ns = blender::nodes::node_fn_rotate_matrix4x4_cc; + + static bNodeType ntype; + + fn_node_type_base(&ntype, FN_NODE_ROTATE_MATRIX_4X4, "Rotate 4x4 Matrix", NODE_CLASS_CONVERTER); + ntype.declare = file_ns::node_declare; + ntype.build_multi_function = file_ns::node_build_multi_function; + + nodeRegisterType(&ntype); +} diff --git a/source/blender/nodes/function/nodes/node_fn_scale_matrix3x3.cc b/source/blender/nodes/function/nodes/node_fn_scale_matrix4x4.cc similarity index 58% rename from source/blender/nodes/function/nodes/node_fn_scale_matrix3x3.cc rename to source/blender/nodes/function/nodes/node_fn_scale_matrix4x4.cc index a657886f8e4..14c02a97b59 100644 --- a/source/blender/nodes/function/nodes/node_fn_scale_matrix3x3.cc +++ b/source/blender/nodes/function/nodes/node_fn_scale_matrix4x4.cc @@ -4,21 +4,21 @@ #include "BLI_math_vector.h" -namespace blender::nodes::node_fn_scale_matrix3x3_cc { +namespace blender::nodes::node_fn_scale_matrix4x4_cc { static void node_declare(NodeDeclarationBuilder &b) { b.is_function_node(); - b.add_input(N_("Matrix")); + b.add_input(N_("Matrix")); b.add_input(N_("Scale")); - b.add_output(N_("Matrix")); + b.add_output(N_("Matrix")); }; static void node_build_multi_function(NodeMultiFunctionBuilder &builder) { - static auto fn = mf::build::SI2_SO( - "scale_matrix", [](const float3x3 &mat, const float3 &scale) { - float3x3 result; + static auto fn = mf::build::SI2_SO( + "scale_matrix", [](const float4x4 &mat, const float3 &scale) { + float4x4 result; mul_v3_v3fl(result.view()[0], mat[0], scale[0]); mul_v3_v3fl(result.view()[1], mat[1], scale[1]); mul_v3_v3fl(result.view()[2], mat[2], scale[2]); @@ -27,15 +27,15 @@ static void node_build_multi_function(NodeMultiFunctionBuilder &builder) builder.set_matching_fn(&fn); } -} // namespace blender::nodes::node_fn_scale_matrix3x3_cc +} // namespace blender::nodes::node_fn_scale_matrix4x4_cc -void register_node_type_fn_scale_matrix_3x3(void) +void register_node_type_fn_scale_matrix_4x4(void) { - namespace file_ns = blender::nodes::node_fn_scale_matrix3x3_cc; + namespace file_ns = blender::nodes::node_fn_scale_matrix4x4_cc; static bNodeType ntype; - fn_node_type_base(&ntype, FN_NODE_SCALE_MATRIX_3X3, "Scale 3x3 Matrix", NODE_CLASS_CONVERTER); + fn_node_type_base(&ntype, FN_NODE_SCALE_MATRIX_4X4, "Scale 4x4 Matrix", NODE_CLASS_CONVERTER); ntype.declare = file_ns::node_declare; ntype.build_multi_function = file_ns::node_build_multi_function; diff --git a/source/blender/nodes/function/nodes/node_fn_separate_matrix3x3.cc b/source/blender/nodes/function/nodes/node_fn_separate_matrix3x3.cc deleted file mode 100644 index f420ffd3829..00000000000 --- a/source/blender/nodes/function/nodes/node_fn_separate_matrix3x3.cc +++ /dev/null @@ -1,230 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "node_function_util.hh" - -#include "UI_interface.h" -#include "UI_resources.h" - -namespace blender::nodes::node_fn_separate_matrix3x3_cc { - -static void node_declare(NodeDeclarationBuilder &b) -{ - b.is_function_node(); - b.add_input(N_("Matrix")).default_value(float4x4::identity()); - b.add_output(N_("Vec0")); - b.add_output(N_("Vec1")); - b.add_output(N_("Vec2")); - b.add_output(N_("Row 0 Col 0")); - b.add_output(N_("Row 1 Col 0")); - b.add_output(N_("Row 2 Col 0")); - b.add_output(N_("Row 0 Col 1")); - b.add_output(N_("Row 1 Col 1")); - b.add_output(N_("Row 2 Col 1")); - b.add_output(N_("Row 0 Col 2")); - b.add_output(N_("Row 1 Col 2")); - b.add_output(N_("Row 2 Col 2")); -}; - -static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) -{ - uiItemR(layout, ptr, "mode", 0, "", ICON_NONE); -} - -static void node_update(bNodeTree *tree, bNode *node) -{ - const NodeCombSepMatrixMode mode = (NodeCombSepMatrixMode)node->custom1; - - const IndexRange vector_sockets(0, 3); - const IndexRange scalar_sockets(3, 9); - const bool show_vector_sockets = ELEM( - mode, NODE_COMBSEP_MATRIX_COLUMNS, NODE_COMBSEP_MATRIX_ROWS); - const bool show_scalar_sockets = ELEM(mode, NODE_COMBSEP_MATRIX_ELEMENTS); - - for (const int i : vector_sockets) { - nodeSetSocketAvailability( - tree, (bNodeSocket *)BLI_findlink(&node->outputs, i), show_vector_sockets); - } - for (const int i : scalar_sockets) { - nodeSetSocketAvailability( - tree, (bNodeSocket *)BLI_findlink(&node->outputs, i), show_scalar_sockets); - } - - switch (mode) { - case NODE_COMBSEP_MATRIX_COLUMNS: - node_sock_label((bNodeSocket *)BLI_findlink(&node->outputs, vector_sockets[0]), "Column 0"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->outputs, vector_sockets[1]), "Column 1"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->outputs, vector_sockets[2]), "Column 2"); - break; - case NODE_COMBSEP_MATRIX_ROWS: - node_sock_label((bNodeSocket *)BLI_findlink(&node->outputs, vector_sockets[0]), "Row 0"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->outputs, vector_sockets[1]), "Row 1"); - node_sock_label((bNodeSocket *)BLI_findlink(&node->outputs, vector_sockets[2]), "Row 2"); - break; - case NODE_COMBSEP_MATRIX_ELEMENTS: - break; - } -} - -static void node_init(bNodeTree * /*tree*/, bNode *node) -{ - node->custom1 = NODE_COMBSEP_MATRIX_COLUMNS; -} - -class SeparateColumnsFunction : public mf::MultiFunction { - public: - SeparateColumnsFunction() - { - static const mf::Signature signature = []() { - mf::Signature signature; - mf::SignatureBuilder builder{"Separate Matrix 3x3", signature}; - builder.single_input("Matrix"); - builder.single_output("Column0"); - builder.single_output("Column1"); - builder.single_output("Column2"); - return signature; - }(); - this->set_signature(&signature); - } - - void call(IndexMask mask, mf::Params params, mf::Context /*context*/) const override - { - const VArray &matrices = params.readonly_single_input(0, "Matrix"); - MutableSpan col0 = params.uninitialized_single_output(1, "Column0"); - MutableSpan col1 = params.uninitialized_single_output(2, "Column1"); - MutableSpan col2 = params.uninitialized_single_output(3, "Column2"); - - for (int64_t i : mask) { - const float3x3 &mat = matrices[i]; - col0[i] = float3(mat[0]); - col1[i] = float3(mat[1]); - col2[i] = float3(mat[2]); - } - } -}; - -class SeparateRowsFunction : public mf::MultiFunction { - public: - SeparateRowsFunction() - { - static const mf::Signature signature = []() { - mf::Signature signature; - mf::SignatureBuilder builder{"Separate Matrix 3x3", signature}; - builder.single_input("Matrix"); - builder.single_output("Row0"); - builder.single_output("Row1"); - builder.single_output("Row2"); - return signature; - }(); - this->set_signature(&signature); - } - - void call(IndexMask mask, mf::Params params, mf::Context /*context*/) const override - { - const VArray &matrices = params.readonly_single_input(0, "Matrix"); - MutableSpan row0 = params.uninitialized_single_output(1, "Row0"); - MutableSpan row1 = params.uninitialized_single_output(2, "Row1"); - MutableSpan row2 = params.uninitialized_single_output(3, "Row2"); - - for (int64_t i : mask) { - const float3x3 &mat = matrices[i]; - row0[i] = float3(mat[0][0], mat[1][0], mat[2][0]); - row1[i] = float3(mat[0][1], mat[1][1], mat[2][1]); - row2[i] = float3(mat[0][2], mat[1][2], mat[2][2]); - } - } -}; - -class SeparateElementsFunction : public mf::MultiFunction { - public: - SeparateElementsFunction() - { - static const mf::Signature signature = []() { - mf::Signature signature; - mf::SignatureBuilder builder{"Separate Matrix 3x3", signature}; - builder.single_input("Matrix"); - builder.single_output("Row0Column0"); - builder.single_output("Row0Column1"); - builder.single_output("Row0Column2"); - builder.single_output("Row1Column0"); - builder.single_output("Row1Column1"); - builder.single_output("Row1Column2"); - builder.single_output("Row2Column0"); - builder.single_output("Row2Column1"); - builder.single_output("Row2Column2"); - return signature; - }(); - this->set_signature(&signature); - } - - void call(IndexMask mask, mf::Params params, mf::Context /*context*/) const override - { - const VArray &matrices = params.readonly_single_input(0, "Matrix"); - MutableSpan m00 = params.uninitialized_single_output(0, "Row0Column0"); - MutableSpan m10 = params.uninitialized_single_output(1, "Row0Column1"); - MutableSpan m20 = params.uninitialized_single_output(2, "Row0Column2"); - MutableSpan m01 = params.uninitialized_single_output(3, "Row1Column0"); - MutableSpan m11 = params.uninitialized_single_output(4, "Row1Column1"); - MutableSpan m21 = params.uninitialized_single_output(5, "Row1Column2"); - MutableSpan m02 = params.uninitialized_single_output(6, "Row2Column0"); - MutableSpan m12 = params.uninitialized_single_output(7, "Row2Column1"); - MutableSpan m22 = params.uninitialized_single_output(8, "Row2Column2"); - - for (int64_t i : mask) { - const float3x3 &mat = matrices[i]; - m00[i] = mat[0][0]; - m01[i] = mat[0][1]; - m02[i] = mat[0][2]; - m10[i] = mat[1][0]; - m11[i] = mat[1][1]; - m12[i] = mat[1][2]; - m20[i] = mat[2][0]; - m21[i] = mat[2][1]; - m22[i] = mat[2][2]; - } - } -}; - -static void node_build_multi_function(NodeMultiFunctionBuilder &builder) -{ - const NodeCombSepMatrixMode mode = (NodeCombSepMatrixMode)builder.node().custom1; - - switch (mode) { - case NODE_COMBSEP_MATRIX_COLUMNS: { - static SeparateColumnsFunction fn; - builder.set_matching_fn(fn); - break; - } - case NODE_COMBSEP_MATRIX_ROWS: { - static SeparateRowsFunction fn; - builder.set_matching_fn(fn); - break; - } - case NODE_COMBSEP_MATRIX_ELEMENTS: { - static SeparateElementsFunction fn; - builder.set_matching_fn(fn); - break; - } - default: { - BLI_assert_unreachable(); - break; - } - } -} - -} // namespace blender::nodes::node_fn_separate_matrix3x3_cc - -void register_node_type_fn_separate_matrix_3x3(void) -{ - namespace file_ns = blender::nodes::node_fn_separate_matrix3x3_cc; - - static bNodeType ntype; - - fn_node_type_base(&ntype, FN_NODE_SEPARATE_MATRIX_3X3, "Separate 3x3 Matrix", NODE_CLASS_CONVERTER); - ntype.declare = file_ns::node_declare; - ntype.updatefunc = file_ns::node_update; - ntype.initfunc = file_ns::node_init; - ntype.build_multi_function = file_ns::node_build_multi_function; - ntype.draw_buttons = file_ns::node_layout; - - nodeRegisterType(&ntype); -} diff --git a/source/blender/nodes/geometry/node_geometry_tree.cc b/source/blender/nodes/geometry/node_geometry_tree.cc index f118d9021cd..17afdb75ba9 100644 --- a/source/blender/nodes/geometry/node_geometry_tree.cc +++ b/source/blender/nodes/geometry/node_geometry_tree.cc @@ -103,7 +103,6 @@ static bool geometry_node_tree_socket_type_valid(bNodeTreeType * /*treetype*/, SOCK_TEXTURE, SOCK_IMAGE, SOCK_MATERIAL, - SOCK_MATRIX_3X3, SOCK_MATRIX_4X4); } diff --git a/source/blender/nodes/geometry/node_geometry_util.cc b/source/blender/nodes/geometry/node_geometry_util.cc index 21650d484c5..69508968461 100644 --- a/source/blender/nodes/geometry/node_geometry_util.cc +++ b/source/blender/nodes/geometry/node_geometry_util.cc @@ -22,8 +22,6 @@ std::optional node_data_type_to_custom_data_type(const eNodeSoc return CD_PROP_FLOAT; case SOCK_VECTOR: return CD_PROP_FLOAT3; - case SOCK_MATRIX_3X3: - return CD_PROP_FLOAT3X3; case SOCK_MATRIX_4X4: return CD_PROP_FLOAT4X4; case SOCK_RGBA: diff --git a/source/blender/nodes/intern/node_common.cc b/source/blender/nodes/intern/node_common.cc index cbfd21ba2ef..44c4db7cb91 100644 --- a/source/blender/nodes/intern/node_common.cc +++ b/source/blender/nodes/intern/node_common.cc @@ -148,11 +148,6 @@ static SocketDeclarationPtr declaration_for_interface_socket(const bNodeSocket & dst = std::move(decl); break; } - case SOCK_MATRIX_3X3: { - std::unique_ptr decl = std::make_unique(); - dst = std::move(decl); - break; - } case SOCK_MATRIX_4X4: { std::unique_ptr decl = std::make_unique(); dst = std::move(decl); diff --git a/source/blender/nodes/intern/node_socket.cc b/source/blender/nodes/intern/node_socket.cc index 2f1c6ebbdad..a6fabc0b309 100644 --- a/source/blender/nodes/intern/node_socket.cc +++ b/source/blender/nodes/intern/node_socket.cc @@ -80,31 +80,6 @@ struct bNodeSocket *node_add_socket_from_template(struct bNodeTree *ntree, dval->max = stemp->max; break; } - case SOCK_MATRIX_2X2: { - bNodeSocketValueMatrix2x2 *dval = (bNodeSocketValueMatrix2x2 *)sock->default_value; - dval->value[0][0] = stemp->val1; - dval->value[0][1] = 0.0f; - dval->value[1][0] = 0.0f; - dval->value[1][1] = stemp->val1; - dval->min = stemp->min; - dval->max = stemp->max; - break; - } - case SOCK_MATRIX_3X3: { - bNodeSocketValueMatrix3x3 *dval = (bNodeSocketValueMatrix3x3 *)sock->default_value; - dval->value[0][0] = stemp->val1; - dval->value[0][1] = 0.0f; - dval->value[0][2] = 0.0f; - dval->value[1][0] = 0.0f; - dval->value[1][1] = stemp->val1; - dval->value[1][2] = 0.0f; - dval->value[2][0] = 0.0f; - dval->value[2][1] = 0.0f; - dval->value[2][2] = stemp->val1; - dval->min = stemp->min; - dval->max = stemp->max; - break; - } case SOCK_MATRIX_4X4: { bNodeSocketValueMatrix4x4 *dval = (bNodeSocketValueMatrix4x4 *)sock->default_value; dval->value[0][0] = stemp->val1; @@ -399,29 +374,6 @@ void node_socket_init_default_value(bNodeSocket *sock) sock->default_value = dval; break; } - case SOCK_MATRIX_2X2: { - static float default_value[][2] = {{1.0f, 0.0f}, {0.0f, 1.0f}}; - bNodeSocketValueMatrix2x2 *dval = MEM_cnew( - "node socket value matrix 2x2"); - copy_m2_m2(dval->value, default_value); - dval->min = -FLT_MAX; - dval->max = FLT_MAX; - - sock->default_value = dval; - break; - } - case SOCK_MATRIX_3X3: { - static float default_value[][3] = { - {1.0f, 0.0f, 0.0f}, {0.0f, 1.0f, 0.0f}, {0.0f, 0.0f, 1.0f}}; - bNodeSocketValueMatrix3x3 *dval = MEM_cnew( - "node socket value matrix 3x3"); - copy_m3_m3(dval->value, default_value); - dval->min = -FLT_MAX; - dval->max = FLT_MAX; - - sock->default_value = dval; - break; - } case SOCK_MATRIX_4X4: { static float default_value[][4] = {{1.0f, 0.0f, 0.0f, 0.0f}, {0.0f, 1.0f, 0.0f, 0.0f}, @@ -536,18 +488,6 @@ void node_socket_copy_default_value(bNodeSocket *to, const bNodeSocket *from) *toval = *fromval; break; } - case SOCK_MATRIX_2X2: { - bNodeSocketValueMatrix2x2 *toval = (bNodeSocketValueMatrix2x2 *)to->default_value; - bNodeSocketValueMatrix2x2 *fromval = (bNodeSocketValueMatrix2x2 *)from->default_value; - *toval = *fromval; - break; - } - case SOCK_MATRIX_3X3: { - bNodeSocketValueMatrix3x3 *toval = (bNodeSocketValueMatrix3x3 *)to->default_value; - bNodeSocketValueMatrix3x3 *fromval = (bNodeSocketValueMatrix3x3 *)from->default_value; - *toval = *fromval; - break; - } case SOCK_MATRIX_4X4: { bNodeSocketValueMatrix4x4 *toval = (bNodeSocketValueMatrix4x4 *)to->default_value; bNodeSocketValueMatrix4x4 *fromval = (bNodeSocketValueMatrix4x4 *)from->default_value; @@ -773,22 +713,6 @@ static bNodeSocketType *make_socket_type_vector(PropertySubType subtype) return socktype; } -static bNodeSocketType *make_socket_type_matrix3x3() -{ - bNodeSocketType *socktype = make_standard_socket_type(SOCK_MATRIX_3X3, PROP_MATRIX); - socktype->base_cpp_type = &blender::CPPType::get(); - socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) { - *(blender::float3x3 *)r_value = float3x3(((bNodeSocketValueMatrix3x3 *)socket.default_value)->value); - }; - socktype->geometry_nodes_cpp_type = &blender::CPPType::get>(); - socktype->get_geometry_nodes_cpp_value = [](const bNodeSocket &socket, void *r_value) { - blender::float3x3 value; - socket.typeinfo->get_base_cpp_value(socket, &value); - new (r_value) ValueOrField(value); - }; - return socktype; -} - static bNodeSocketType *make_socket_type_matrix4x4() { bNodeSocketType *socktype = make_standard_socket_type(SOCK_MATRIX_4X4, PROP_MATRIX); @@ -939,8 +863,6 @@ void register_standard_node_socket_types() nodeRegisterSocketType(make_socket_type_vector(PROP_EULER)); nodeRegisterSocketType(make_socket_type_vector(PROP_XYZ)); - nodeRegisterSocketType(make_standard_socket_type(SOCK_MATRIX_2X2, PROP_MATRIX)); - nodeRegisterSocketType(make_socket_type_matrix3x3()); nodeRegisterSocketType(make_socket_type_matrix4x4()); nodeRegisterSocketType(make_socket_type_rgba()); diff --git a/source/blender/nodes/intern/node_socket_declarations.cc b/source/blender/nodes/intern/node_socket_declarations.cc index 6399223c244..0964f3ee0dc 100644 --- a/source/blender/nodes/intern/node_socket_declarations.cc +++ b/source/blender/nodes/intern/node_socket_declarations.cc @@ -273,52 +273,6 @@ bNodeSocket &Vector::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket /** \} */ -/* -------------------------------------------------------------------- */ -/** \name #Matrix3x3 - * \{ */ - -bNodeSocket &Matrix3x3::build(bNodeTree &ntree, bNode &node) const -{ - bNodeSocket &socket = *nodeAddStaticSocket( - &ntree, &node, in_out, SOCK_MATRIX_3X3, PROP_MATRIX, identifier.c_str(), name.c_str()); - this->set_common_flags(socket); - bNodeSocketValueMatrix3x3 &value = *(bNodeSocketValueMatrix3x3 *)socket.default_value; - copy_m3_m3(value.value, default_value_.ptr()); - value.min = soft_min_value_; - value.max = soft_max_value_; - return socket; -} - -bool Matrix3x3::matches(const bNodeSocket &socket) const -{ - if (!this->matches_common_data(socket)) { - return false; - } - if (socket.type != SOCK_MATRIX_3X3) { - return false; - } - return true; -} - -bool Matrix3x3::can_connect(const bNodeSocket &socket) const -{ - return sockets_can_connect(*this, socket) && socket.type == SOCK_MATRIX_3X3; -} - -bNodeSocket &Matrix3x3::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket &socket) const -{ - if (socket.type != SOCK_MATRIX_3X3) { - BLI_assert(socket.in_out == in_out); - return this->build(ntree, node); - } - this->set_common_flags(socket); - bNodeSocketValueMatrix3x3 &value = *(bNodeSocketValueMatrix3x3 *)socket.default_value; - STRNCPY(socket.name, name.c_str()); - return socket; -} - -/** \} */ - /* -------------------------------------------------------------------- */ /** \name #Matrix4x4 * \{ */ -- 2.30.2 From 79ff2f88e21ad35cbdd72f5548d01efac645bc12 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Fri, 3 Mar 2023 14:14:56 +0100 Subject: [PATCH 28/33] Renamed matrix nodes without the 4x4 suffix. Matrix nodes should be generic enough to work with all kinds of matrices. Right now that will only be 4x4 matrices but the nodes don't need that in their names. --- .../startup/bl_ui/node_add_menu_geometry.py | 14 +++++++------- source/blender/blenkernel/BKE_node.h | 16 ++++++++-------- source/blender/makesdna/DNA_node_types.h | 4 ++-- source/blender/makesrna/intern/rna_nodetree.c | 6 +++--- source/blender/nodes/NOD_static_types.h | 16 ++++++++-------- source/blender/nodes/function/CMakeLists.txt | 16 ++++++++-------- .../nodes/function/node_function_register.cc | 16 ++++++++-------- .../nodes/function/node_function_register.hh | 16 ++++++++-------- ..._matrix4x4.cc => node_fn_combine_matrix.cc} | 10 +++++----- ...atrix4x4.cc => node_fn_decompose_matrix.cc} | 10 +++++----- ...ut_matrix4x4.cc => node_fn_input_matrix.cc} | 18 +++++++++--------- ...atrix4x4_math.cc => node_fn_matrix_math.cc} | 10 +++++----- ...e_matrix4x4.cc => node_fn_rotate_matrix.cc} | 10 +++++----- ...le_matrix4x4.cc => node_fn_scale_matrix.cc} | 10 +++++----- ...matrix4x4.cc => node_fn_separate_matrix.cc} | 10 +++++----- ...atrix4x4.cc => node_fn_translate_matrix.cc} | 10 +++++----- 16 files changed, 96 insertions(+), 96 deletions(-) rename source/blender/nodes/function/nodes/{node_fn_combine_matrix4x4.cc => node_fn_combine_matrix.cc} (94%) rename source/blender/nodes/function/nodes/{node_fn_decompose_matrix4x4.cc => node_fn_decompose_matrix.cc} (85%) rename source/blender/nodes/function/nodes/{node_fn_input_matrix4x4.cc => node_fn_input_matrix.cc} (64%) rename source/blender/nodes/function/nodes/{node_fn_matrix4x4_math.cc => node_fn_matrix_math.cc} (91%) rename source/blender/nodes/function/nodes/{node_fn_rotate_matrix4x4.cc => node_fn_rotate_matrix.cc} (72%) rename source/blender/nodes/function/nodes/{node_fn_scale_matrix4x4.cc => node_fn_scale_matrix.cc} (74%) rename source/blender/nodes/function/nodes/{node_fn_separate_matrix4x4.cc => node_fn_separate_matrix.cc} (96%) rename source/blender/nodes/function/nodes/{node_fn_translate_matrix4x4.cc => node_fn_translate_matrix.cc} (73%) diff --git a/scripts/startup/bl_ui/node_add_menu_geometry.py b/scripts/startup/bl_ui/node_add_menu_geometry.py index 48321b00358..a9b1f8a361e 100644 --- a/scripts/startup/bl_ui/node_add_menu_geometry.py +++ b/scripts/startup/bl_ui/node_add_menu_geometry.py @@ -560,13 +560,13 @@ class NODE_MT_category_GEO_UTILITIES_MATRIX(Menu): def draw(self, _context): layout = self.layout - node_add_menu.add_node_type(layout, "FunctionNodeCombineMatrix4x4") - node_add_menu.add_node_type(layout, "FunctionNodeSeparateMatrix4x4") - node_add_menu.add_node_type(layout, "FunctionNodeDecomposeMatrix4x4") - node_add_menu.add_node_type(layout, "FunctionNodeMatrix4x4Math") - node_add_menu.add_node_type(layout, "FunctionNodeRotateMatrix4x4") - node_add_menu.add_node_type(layout, "FunctionNodeScaleMatrix4x4") - node_add_menu.add_node_type(layout, "FunctionNodeTranslateMatrix4x4") + node_add_menu.add_node_type(layout, "FunctionNodeCombineMatrix") + node_add_menu.add_node_type(layout, "FunctionNodeSeparateMatrix") + node_add_menu.add_node_type(layout, "FunctionNodeDecomposeMatrix") + node_add_menu.add_node_type(layout, "FunctionNodeMatrixMath") + node_add_menu.add_node_type(layout, "FunctionNodeRotateMatrix") + node_add_menu.add_node_type(layout, "FunctionNodeScaleMatrix") + node_add_menu.add_node_type(layout, "FunctionNodeTranslateMatrix") node_add_menu.draw_assets_for_catalog(layout, self.bl_label) diff --git a/source/blender/blenkernel/BKE_node.h b/source/blender/blenkernel/BKE_node.h index 809f0ea8966..49ba1e5ba20 100644 --- a/source/blender/blenkernel/BKE_node.h +++ b/source/blender/blenkernel/BKE_node.h @@ -1580,14 +1580,14 @@ void BKE_nodetree_remove_layer_n(struct bNodeTree *ntree, struct Scene *scene, i #define FN_NODE_INPUT_INT 1220 #define FN_NODE_SEPARATE_COLOR 1221 #define FN_NODE_COMBINE_COLOR 1222 -#define FN_NODE_INPUT_MATRIX_4X4 1224 -#define FN_NODE_SEPARATE_MATRIX_4X4 1225 -#define FN_NODE_COMBINE_MATRIX_4X4 1226 -#define FN_NODE_MATRIX_4X4_MATH 1227 -#define FN_NODE_DECOMPOSE_MATRIX_4X4 1228 -#define FN_NODE_ROTATE_MATRIX_4X4 1229 -#define FN_NODE_SCALE_MATRIX_4X4 1230 -#define FN_NODE_TRANSLATE_MATRIX_4X4 1231 +#define FN_NODE_INPUT_MATRIX 1224 +#define FN_NODE_SEPARATE_MATRIX 1225 +#define FN_NODE_COMBINE_MATRIX 1226 +#define FN_NODE_MATRIX_MATH 1227 +#define FN_NODE_DECOMPOSE_MATRIX 1228 +#define FN_NODE_ROTATE_MATRIX 1229 +#define FN_NODE_SCALE_MATRIX 1230 +#define FN_NODE_TRANSLATE_MATRIX 1231 /** \} */ diff --git a/source/blender/makesdna/DNA_node_types.h b/source/blender/makesdna/DNA_node_types.h index 8215fd50fe7..2dae3e733ec 100644 --- a/source/blender/makesdna/DNA_node_types.h +++ b/source/blender/makesdna/DNA_node_types.h @@ -1626,9 +1626,9 @@ typedef struct NodeShaderMix { char _pad[3]; } NodeShaderMix; -typedef struct NodeInputMatrix4x4 { +typedef struct NodeInputMatrix { float matrix[4][4]; -} NodeInputMatrix4x4; +} NodeInputMatrix; /* script node mode */ #define NODE_SCRIPT_INTERNAL 0 diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c index 923c8870d74..5dcf1815707 100644 --- a/source/blender/makesrna/intern/rna_nodetree.c +++ b/source/blender/makesrna/intern/rna_nodetree.c @@ -5237,7 +5237,7 @@ static void def_fn_combsep_color(StructRNA *srna) RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } -static void def_fn_input_matrix_4x4(StructRNA *srna) +static void def_fn_input_matrix(StructRNA *srna) { static const float default_elements[] = { 1.0f, @@ -5259,7 +5259,7 @@ static void def_fn_input_matrix_4x4(StructRNA *srna) }; PropertyRNA *prop; - RNA_def_struct_sdna_from(srna, "NodeInputMatrix4x4", "storage"); + RNA_def_struct_sdna_from(srna, "NodeInputMatrix", "storage"); prop = RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX); RNA_def_property_float_sdna(prop, NULL, "matrix"); @@ -5280,7 +5280,7 @@ static void def_fn_combsep_matrix(StructRNA *srna) RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } -static void def_fn_matrix_4x4_math(StructRNA *srna) +static void def_fn_matrix_math(StructRNA *srna) { PropertyRNA *prop; diff --git a/source/blender/nodes/NOD_static_types.h b/source/blender/nodes/NOD_static_types.h index 5d686d6ccf1..d30cf90ccea 100644 --- a/source/blender/nodes/NOD_static_types.h +++ b/source/blender/nodes/NOD_static_types.h @@ -264,28 +264,28 @@ DefNode(TextureNode, TEX_NODE_PROC+TEX_DISTNOISE, 0, "TEX_DI DefNode(FunctionNode, FN_NODE_ALIGN_EULER_TO_VECTOR, def_fn_align_euler_to_vector, "ALIGN_EULER_TO_VECTOR", AlignEulerToVector, "Align Euler to Vector", "") DefNode(FunctionNode, FN_NODE_BOOLEAN_MATH, def_boolean_math, "BOOLEAN_MATH", BooleanMath, "Boolean Math", "") DefNode(FunctionNode, FN_NODE_COMBINE_COLOR, def_fn_combsep_color, "COMBINE_COLOR", CombineColor, "Combine Color", "") -DefNode(FunctionNode, FN_NODE_COMBINE_MATRIX_4X4, def_fn_combsep_matrix, "COMBINE_MATRIX_4X4", CombineMatrix4x4, "Combine 4x4 Matrix", "") +DefNode(FunctionNode, FN_NODE_COMBINE_MATRIX, def_fn_combsep_matrix, "COMBINE_MATRIX", CombineMatrix, "Combine Matrix", "") DefNode(FunctionNode, FN_NODE_COMPARE, def_compare, "COMPARE", Compare, "Compare", "") -DefNode(FunctionNode, FN_NODE_DECOMPOSE_MATRIX_4X4, 0, "DECOMPOSE_MATRIX_4X4", DecomposeMatrix4x4, "Decompose 4x4 Matrix", "") +DefNode(FunctionNode, FN_NODE_DECOMPOSE_MATRIX, 0, "DECOMPOSE_MATRIX", DecomposeMatrix, "Decompose Matrix", "") DefNode(FunctionNode, FN_NODE_FLOAT_TO_INT, def_float_to_int, "FLOAT_TO_INT", FloatToInt, "Float to Integer", "") DefNode(FunctionNode, FN_NODE_INPUT_BOOL, def_fn_input_bool, "INPUT_BOOL", InputBool, "Boolean", "") DefNode(FunctionNode, FN_NODE_INPUT_COLOR, def_fn_input_color, "INPUT_COLOR", InputColor, "Color", "") DefNode(FunctionNode, FN_NODE_INPUT_INT, def_fn_input_int, "INPUT_INT", InputInt, "Integer", "") -DefNode(FunctionNode, FN_NODE_INPUT_MATRIX_4X4, def_fn_input_matrix_4x4, "INPUT_MATRIX_4X4", InputMatrix4x4, "4x4 Matrix", "") +DefNode(FunctionNode, FN_NODE_INPUT_MATRIX, def_fn_input_matrix, "INPUT_MATRIX", InputMatrix, "Matrix", "") DefNode(FunctionNode, FN_NODE_INPUT_SPECIAL_CHARACTERS, 0, "INPUT_SPECIAL_CHARACTERS", InputSpecialCharacters, "Special Characters", "") DefNode(FunctionNode, FN_NODE_INPUT_STRING, def_fn_input_string, "INPUT_STRING", InputString, "String", "") DefNode(FunctionNode, FN_NODE_INPUT_VECTOR, def_fn_input_vector, "INPUT_VECTOR", InputVector, "Vector", "") -DefNode(FunctionNode, FN_NODE_MATRIX_4X4_MATH, def_fn_matrix_4x4_math, "MATRIX_4X4_MATH", Matrix4x4Math, "4x4 Matrix Math", "") +DefNode(FunctionNode, FN_NODE_MATRIX_MATH, def_fn_matrix_math, "MATRIX_MATH", MatrixMath, "Matrix Math", "") DefNode(FunctionNode, FN_NODE_RANDOM_VALUE, def_fn_random_value, "RANDOM_VALUE", RandomValue, "Random Value", "") DefNode(FunctionNode, FN_NODE_REPLACE_STRING, 0, "REPLACE_STRING", ReplaceString, "Replace String", "") DefNode(FunctionNode, FN_NODE_ROTATE_EULER, def_fn_rotate_euler, "ROTATE_EULER", RotateEuler, "Rotate Euler", "") -DefNode(FunctionNode, FN_NODE_ROTATE_MATRIX_4X4, 0, "ROTATE_MATRIX_4X4", RotateMatrix4x4, "Rotate Matrix", "") -DefNode(FunctionNode, FN_NODE_SCALE_MATRIX_4X4, 0, "SCALE_MATRIX_4X4", ScaleMatrix4x4, "Scale Matrix", "") +DefNode(FunctionNode, FN_NODE_ROTATE_MATRIX, 0, "ROTATE_MATRIX", RotateMatrix, "Rotate Matrix", "") +DefNode(FunctionNode, FN_NODE_SCALE_MATRIX, 0, "SCALE_MATRIX", ScaleMatrix, "Scale Matrix", "") DefNode(FunctionNode, FN_NODE_SEPARATE_COLOR, def_fn_combsep_color, "SEPARATE_COLOR", SeparateColor, "Separate Color", "") -DefNode(FunctionNode, FN_NODE_SEPARATE_MATRIX_4X4, def_fn_combsep_matrix, "SEPARATE_MATRIX_4X4", SeparateMatrix4x4, "Separate 4x4 Matrix", "") +DefNode(FunctionNode, FN_NODE_SEPARATE_MATRIX, def_fn_combsep_matrix, "SEPARATE_MATRIX", SeparateMatrix, "Separate Matrix", "") DefNode(FunctionNode, FN_NODE_SLICE_STRING, 0, "SLICE_STRING", SliceString, "Slice String", "") DefNode(FunctionNode, FN_NODE_STRING_LENGTH, 0, "STRING_LENGTH", StringLength, "String Length", "") -DefNode(FunctionNode, FN_NODE_TRANSLATE_MATRIX_4X4, 0, "TRANSLATE_MATRIX_4X4", TranslateMatrix4x4, "Translate Matrix", "") +DefNode(FunctionNode, FN_NODE_TRANSLATE_MATRIX, 0, "TRANSLATE_MATRIX", TranslateMatrix, "Translate Matrix", "") DefNode(FunctionNode, FN_NODE_VALUE_TO_STRING, 0, "VALUE_TO_STRING", ValueToString, "Value to String", "") DefNode(GeometryNode, GEO_NODE_ACCUMULATE_FIELD, def_geo_accumulate_field, "ACCUMULATE_FIELD", AccumulateField, "Accumulate Field", "Add the values of an evaluated field together and output the running total for each element") diff --git a/source/blender/nodes/function/CMakeLists.txt b/source/blender/nodes/function/CMakeLists.txt index 03c9129f2d7..9c8bc3b8771 100644 --- a/source/blender/nodes/function/CMakeLists.txt +++ b/source/blender/nodes/function/CMakeLists.txt @@ -23,28 +23,28 @@ set(SRC nodes/node_fn_align_euler_to_vector.cc nodes/node_fn_boolean_math.cc nodes/node_fn_combine_color.cc - nodes/node_fn_combine_matrix4x4.cc + nodes/node_fn_combine_matrix.cc nodes/node_fn_compare.cc - nodes/node_fn_decompose_matrix4x4.cc + nodes/node_fn_decompose_matrix.cc nodes/node_fn_float_to_int.cc nodes/node_fn_input_bool.cc nodes/node_fn_input_color.cc nodes/node_fn_input_int.cc - nodes/node_fn_input_matrix4x4.cc + nodes/node_fn_input_matrix.cc nodes/node_fn_input_special_characters.cc nodes/node_fn_input_string.cc nodes/node_fn_input_vector.cc - nodes/node_fn_matrix4x4_math.cc + nodes/node_fn_matrix_math.cc nodes/node_fn_random_value.cc nodes/node_fn_replace_string.cc nodes/node_fn_rotate_euler.cc - nodes/node_fn_rotate_matrix4x4.cc - nodes/node_fn_scale_matrix4x4.cc + nodes/node_fn_rotate_matrix.cc + nodes/node_fn_scale_matrix.cc nodes/node_fn_separate_color.cc - nodes/node_fn_separate_matrix4x4.cc + nodes/node_fn_separate_matrix.cc nodes/node_fn_slice_string.cc nodes/node_fn_string_length.cc - nodes/node_fn_translate_matrix4x4.cc + nodes/node_fn_translate_matrix.cc nodes/node_fn_value_to_string.cc node_function_register.cc diff --git a/source/blender/nodes/function/node_function_register.cc b/source/blender/nodes/function/node_function_register.cc index 50354981e35..8b615321f51 100644 --- a/source/blender/nodes/function/node_function_register.cc +++ b/source/blender/nodes/function/node_function_register.cc @@ -9,27 +9,27 @@ void register_function_nodes() register_node_type_fn_align_euler_to_vector(); register_node_type_fn_boolean_math(); register_node_type_fn_combine_color(); - register_node_type_fn_combine_matrix_4x4(); + register_node_type_fn_combine_matrix(); register_node_type_fn_compare(); - register_node_type_fn_decompose_matrix_4x4(); + register_node_type_fn_decompose_matrix(); register_node_type_fn_float_to_int(); register_node_type_fn_input_bool(); register_node_type_fn_input_color(); register_node_type_fn_input_int(); - register_node_type_fn_input_matrix_4x4(); + register_node_type_fn_input_matrix(); register_node_type_fn_input_special_characters(); register_node_type_fn_input_string(); register_node_type_fn_input_vector(); - register_node_type_fn_matrix_4x4_math(); + register_node_type_fn_matrix_math(); register_node_type_fn_random_value(); register_node_type_fn_replace_string(); register_node_type_fn_rotate_euler(); - register_node_type_fn_rotate_matrix_4x4(); - register_node_type_fn_scale_matrix_4x4(); + register_node_type_fn_rotate_matrix(); + register_node_type_fn_scale_matrix(); register_node_type_fn_separate_color(); - register_node_type_fn_separate_matrix_4x4(); + register_node_type_fn_separate_matrix(); register_node_type_fn_slice_string(); register_node_type_fn_string_length(); - register_node_type_fn_translate_matrix_4x4(); + register_node_type_fn_translate_matrix(); register_node_type_fn_value_to_string(); } diff --git a/source/blender/nodes/function/node_function_register.hh b/source/blender/nodes/function/node_function_register.hh index 79c67fc060a..13f3bd69682 100644 --- a/source/blender/nodes/function/node_function_register.hh +++ b/source/blender/nodes/function/node_function_register.hh @@ -5,26 +5,26 @@ void register_node_type_fn_align_euler_to_vector(); void register_node_type_fn_boolean_math(); void register_node_type_fn_combine_color(); -void register_node_type_fn_combine_matrix_4x4(); +void register_node_type_fn_combine_matrix(); void register_node_type_fn_compare(); -void register_node_type_fn_decompose_matrix_4x4(); +void register_node_type_fn_decompose_matrix(); void register_node_type_fn_float_to_int(); void register_node_type_fn_input_bool(); void register_node_type_fn_input_color(); void register_node_type_fn_input_int(); -void register_node_type_fn_input_matrix_4x4(); +void register_node_type_fn_input_matrix(); void register_node_type_fn_input_special_characters(); void register_node_type_fn_input_string(); void register_node_type_fn_input_vector(); -void register_node_type_fn_matrix_4x4_math(); +void register_node_type_fn_matrix_math(); void register_node_type_fn_random_value(); void register_node_type_fn_replace_string(); void register_node_type_fn_rotate_euler(); -void register_node_type_fn_rotate_matrix_4x4(); -void register_node_type_fn_scale_matrix_4x4(); +void register_node_type_fn_rotate_matrix(); +void register_node_type_fn_scale_matrix(); void register_node_type_fn_separate_color(); -void register_node_type_fn_separate_matrix_4x4(); +void register_node_type_fn_separate_matrix(); void register_node_type_fn_slice_string(); void register_node_type_fn_string_length(); -void register_node_type_fn_translate_matrix_4x4(); +void register_node_type_fn_translate_matrix(); void register_node_type_fn_value_to_string(); diff --git a/source/blender/nodes/function/nodes/node_fn_combine_matrix4x4.cc b/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc similarity index 94% rename from source/blender/nodes/function/nodes/node_fn_combine_matrix4x4.cc rename to source/blender/nodes/function/nodes/node_fn_combine_matrix.cc index d7669702bca..a7ca3947f4e 100644 --- a/source/blender/nodes/function/nodes/node_fn_combine_matrix4x4.cc +++ b/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc @@ -5,7 +5,7 @@ #include "UI_interface.h" #include "UI_resources.h" -namespace blender::nodes::node_fn_combine_matrix4x4_cc { +namespace blender::nodes::node_fn_combine_matrix_cc { static void node_declare(NodeDeclarationBuilder &b) { @@ -162,15 +162,15 @@ static void node_build_multi_function(NodeMultiFunctionBuilder &builder) builder.set_matching_fn(fn); } -} // namespace blender::nodes::node_fn_combine_matrix4x4_cc +} // namespace blender::nodes::node_fn_combine_matrix_cc -void register_node_type_fn_combine_matrix_4x4(void) +void register_node_type_fn_combine_matrix(void) { - namespace file_ns = blender::nodes::node_fn_combine_matrix4x4_cc; + namespace file_ns = blender::nodes::node_fn_combine_matrix_cc; static bNodeType ntype; - fn_node_type_base(&ntype, FN_NODE_COMBINE_MATRIX_4X4, "Combine 4x4 Matrix", NODE_CLASS_CONVERTER); + fn_node_type_base(&ntype, FN_NODE_COMBINE_MATRIX, "Combine Matrix", NODE_CLASS_CONVERTER); ntype.declare = file_ns::node_declare; ntype.updatefunc = file_ns::node_update; ntype.initfunc = file_ns::node_init; diff --git a/source/blender/nodes/function/nodes/node_fn_decompose_matrix4x4.cc b/source/blender/nodes/function/nodes/node_fn_decompose_matrix.cc similarity index 85% rename from source/blender/nodes/function/nodes/node_fn_decompose_matrix4x4.cc rename to source/blender/nodes/function/nodes/node_fn_decompose_matrix.cc index 5f0bf473cce..2276e4dcbee 100644 --- a/source/blender/nodes/function/nodes/node_fn_decompose_matrix4x4.cc +++ b/source/blender/nodes/function/nodes/node_fn_decompose_matrix.cc @@ -6,7 +6,7 @@ #include "BLI_math_rotation.h" #include "BLI_math_vector.h" -namespace blender::nodes::node_fn_decompose_matrix4x4_cc { +namespace blender::nodes::node_fn_decompose_matrix_cc { static void node_declare(NodeDeclarationBuilder &b) { @@ -55,15 +55,15 @@ static void node_build_multi_function(NodeMultiFunctionBuilder &builder) builder.set_matching_fn(&decompose_matrix_fn); } -} // namespace blender::nodes::node_fn_decompose_matrix4x4_cc +} // namespace blender::nodes::node_fn_decompose_matrix_cc -void register_node_type_fn_decompose_matrix_4x4(void) +void register_node_type_fn_decompose_matrix(void) { - namespace file_ns = blender::nodes::node_fn_decompose_matrix4x4_cc; + namespace file_ns = blender::nodes::node_fn_decompose_matrix_cc; static bNodeType ntype; - fn_node_type_base(&ntype, FN_NODE_DECOMPOSE_MATRIX_4X4, "Decompose 4x4 Matrix", NODE_CLASS_CONVERTER); + fn_node_type_base(&ntype, FN_NODE_DECOMPOSE_MATRIX, "Decompose Matrix", NODE_CLASS_CONVERTER); ntype.declare = file_ns::node_declare; ntype.build_multi_function = file_ns::node_build_multi_function; diff --git a/source/blender/nodes/function/nodes/node_fn_input_matrix4x4.cc b/source/blender/nodes/function/nodes/node_fn_input_matrix.cc similarity index 64% rename from source/blender/nodes/function/nodes/node_fn_input_matrix4x4.cc rename to source/blender/nodes/function/nodes/node_fn_input_matrix.cc index 3936c9bd261..993812c3550 100644 --- a/source/blender/nodes/function/nodes/node_fn_input_matrix4x4.cc +++ b/source/blender/nodes/function/nodes/node_fn_input_matrix.cc @@ -7,9 +7,9 @@ #include "UI_interface.h" #include "UI_resources.h" -namespace blender::nodes::node_fn_input_matrix4x4_cc { +namespace blender::nodes::node_fn_input_matrix_cc { -NODE_STORAGE_FUNCS(NodeInputMatrix4x4); +NODE_STORAGE_FUNCS(NodeInputMatrix); static void node_declare(NodeDeclarationBuilder &b) { @@ -23,28 +23,28 @@ static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) static void node_init(bNodeTree * /*tree*/, bNode *node) { - NodeInputMatrix4x4 *data = MEM_new(__func__); + NodeInputMatrix *data = MEM_new(__func__); unit_m4(data->matrix); node->storage = data; } static void node_build_multi_function(NodeMultiFunctionBuilder &builder) { - const NodeInputMatrix4x4 &storage = node_storage(builder.node()); + const NodeInputMatrix &storage = node_storage(builder.node()); builder.construct_and_set_matching_fn>(float4x4{storage.matrix}); } -} // namespace blender::nodes::node_fn_input_matrix4x4_cc +} // namespace blender::nodes::node_fn_input_matrix_cc -void register_node_type_fn_input_matrix_4x4(void) +void register_node_type_fn_input_matrix(void) { - namespace file_ns = blender::nodes::node_fn_input_matrix4x4_cc; + namespace file_ns = blender::nodes::node_fn_input_matrix_cc; static bNodeType ntype; - fn_node_type_base(&ntype, FN_NODE_INPUT_MATRIX_4X4, "4x4 Matrix", NODE_CLASS_INPUT); + fn_node_type_base(&ntype, FN_NODE_INPUT_MATRIX, "Matrix", NODE_CLASS_INPUT); node_type_storage( - &ntype, "NodeInputMatrix4x4", node_free_standard_storage, node_copy_standard_storage); + &ntype, "NodeInputMatrix", node_free_standard_storage, node_copy_standard_storage); ntype.declare = file_ns::node_declare; ntype.initfunc = file_ns::node_init; ntype.build_multi_function = file_ns::node_build_multi_function; diff --git a/source/blender/nodes/function/nodes/node_fn_matrix4x4_math.cc b/source/blender/nodes/function/nodes/node_fn_matrix_math.cc similarity index 91% rename from source/blender/nodes/function/nodes/node_fn_matrix4x4_math.cc rename to source/blender/nodes/function/nodes/node_fn_matrix_math.cc index 7db5ffe0f1c..8f1c69b95ba 100644 --- a/source/blender/nodes/function/nodes/node_fn_matrix4x4_math.cc +++ b/source/blender/nodes/function/nodes/node_fn_matrix_math.cc @@ -7,7 +7,7 @@ #include "UI_interface.h" #include "UI_resources.h" -namespace blender::nodes::node_fn_matrix4x4_math_cc { +namespace blender::nodes::node_fn_matrix_math_cc { static void node_declare(NodeDeclarationBuilder &b) { @@ -88,15 +88,15 @@ static void node_build_multi_function(NodeMultiFunctionBuilder &builder) builder.set_matching_fn(fn); } -} // namespace blender::nodes::node_fn_matrix4x4_math_cc +} // namespace blender::nodes::node_fn_matrix_math_cc -void register_node_type_fn_matrix_4x4_math(void) +void register_node_type_fn_matrix_math(void) { - namespace file_ns = blender::nodes::node_fn_matrix4x4_math_cc; + namespace file_ns = blender::nodes::node_fn_matrix_math_cc; static bNodeType ntype; - fn_node_type_base(&ntype, FN_NODE_MATRIX_4X4_MATH, "4x4 Matrix Math", NODE_CLASS_CONVERTER); + fn_node_type_base(&ntype, FN_NODE_MATRIX_MATH, "Matrix Math", NODE_CLASS_CONVERTER); ntype.declare = file_ns::node_declare; ntype.updatefunc = file_ns::node_update; ntype.initfunc = file_ns::node_init; diff --git a/source/blender/nodes/function/nodes/node_fn_rotate_matrix4x4.cc b/source/blender/nodes/function/nodes/node_fn_rotate_matrix.cc similarity index 72% rename from source/blender/nodes/function/nodes/node_fn_rotate_matrix4x4.cc rename to source/blender/nodes/function/nodes/node_fn_rotate_matrix.cc index 506de77520b..e4753e4cb56 100644 --- a/source/blender/nodes/function/nodes/node_fn_rotate_matrix4x4.cc +++ b/source/blender/nodes/function/nodes/node_fn_rotate_matrix.cc @@ -4,7 +4,7 @@ #include "BLI_math_rotation.h" -namespace blender::nodes::node_fn_rotate_matrix4x4_cc { +namespace blender::nodes::node_fn_rotate_matrix_cc { static void node_declare(NodeDeclarationBuilder &b) { @@ -25,15 +25,15 @@ static void node_build_multi_function(NodeMultiFunctionBuilder &builder) builder.set_matching_fn(&fn); } -} // namespace blender::nodes::node_fn_rotate_matrix4x4_cc +} // namespace blender::nodes::node_fn_rotate_matrix_cc -void register_node_type_fn_rotate_matrix_4x4(void) +void register_node_type_fn_rotate_matrix(void) { - namespace file_ns = blender::nodes::node_fn_rotate_matrix4x4_cc; + namespace file_ns = blender::nodes::node_fn_rotate_matrix_cc; static bNodeType ntype; - fn_node_type_base(&ntype, FN_NODE_ROTATE_MATRIX_4X4, "Rotate 4x4 Matrix", NODE_CLASS_CONVERTER); + fn_node_type_base(&ntype, FN_NODE_ROTATE_MATRIX, "Rotate Matrix", NODE_CLASS_CONVERTER); ntype.declare = file_ns::node_declare; ntype.build_multi_function = file_ns::node_build_multi_function; diff --git a/source/blender/nodes/function/nodes/node_fn_scale_matrix4x4.cc b/source/blender/nodes/function/nodes/node_fn_scale_matrix.cc similarity index 74% rename from source/blender/nodes/function/nodes/node_fn_scale_matrix4x4.cc rename to source/blender/nodes/function/nodes/node_fn_scale_matrix.cc index 14c02a97b59..f95a2db6af2 100644 --- a/source/blender/nodes/function/nodes/node_fn_scale_matrix4x4.cc +++ b/source/blender/nodes/function/nodes/node_fn_scale_matrix.cc @@ -4,7 +4,7 @@ #include "BLI_math_vector.h" -namespace blender::nodes::node_fn_scale_matrix4x4_cc { +namespace blender::nodes::node_fn_scale_matrix_cc { static void node_declare(NodeDeclarationBuilder &b) { @@ -27,15 +27,15 @@ static void node_build_multi_function(NodeMultiFunctionBuilder &builder) builder.set_matching_fn(&fn); } -} // namespace blender::nodes::node_fn_scale_matrix4x4_cc +} // namespace blender::nodes::node_fn_scale_matrix_cc -void register_node_type_fn_scale_matrix_4x4(void) +void register_node_type_fn_scale_matrix(void) { - namespace file_ns = blender::nodes::node_fn_scale_matrix4x4_cc; + namespace file_ns = blender::nodes::node_fn_scale_matrix_cc; static bNodeType ntype; - fn_node_type_base(&ntype, FN_NODE_SCALE_MATRIX_4X4, "Scale 4x4 Matrix", NODE_CLASS_CONVERTER); + fn_node_type_base(&ntype, FN_NODE_SCALE_MATRIX, "Scale Matrix", NODE_CLASS_CONVERTER); ntype.declare = file_ns::node_declare; ntype.build_multi_function = file_ns::node_build_multi_function; diff --git a/source/blender/nodes/function/nodes/node_fn_separate_matrix4x4.cc b/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc similarity index 96% rename from source/blender/nodes/function/nodes/node_fn_separate_matrix4x4.cc rename to source/blender/nodes/function/nodes/node_fn_separate_matrix.cc index 39bcae2b995..79e935ce13d 100644 --- a/source/blender/nodes/function/nodes/node_fn_separate_matrix4x4.cc +++ b/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc @@ -5,7 +5,7 @@ #include "UI_interface.h" #include "UI_resources.h" -namespace blender::nodes::node_fn_separate_matrix4x4_cc { +namespace blender::nodes::node_fn_separate_matrix_cc { static void node_declare(NodeDeclarationBuilder &b) { @@ -248,15 +248,15 @@ static void node_build_multi_function(NodeMultiFunctionBuilder &builder) } } -} // namespace blender::nodes::node_fn_separate_matrix4x4_cc +} // namespace blender::nodes::node_fn_separate_matrix_cc -void register_node_type_fn_separate_matrix_4x4(void) +void register_node_type_fn_separate_matrix(void) { - namespace file_ns = blender::nodes::node_fn_separate_matrix4x4_cc; + namespace file_ns = blender::nodes::node_fn_separate_matrix_cc; static bNodeType ntype; - fn_node_type_base(&ntype, FN_NODE_SEPARATE_MATRIX_4X4, "Separate 4x4 Matrix", NODE_CLASS_CONVERTER); + fn_node_type_base(&ntype, FN_NODE_SEPARATE_MATRIX, "Separate Matrix", NODE_CLASS_CONVERTER); ntype.declare = file_ns::node_declare; ntype.updatefunc = file_ns::node_update; ntype.initfunc = file_ns::node_init; diff --git a/source/blender/nodes/function/nodes/node_fn_translate_matrix4x4.cc b/source/blender/nodes/function/nodes/node_fn_translate_matrix.cc similarity index 73% rename from source/blender/nodes/function/nodes/node_fn_translate_matrix4x4.cc rename to source/blender/nodes/function/nodes/node_fn_translate_matrix.cc index b5a6ec9a4f6..daeb55d53dc 100644 --- a/source/blender/nodes/function/nodes/node_fn_translate_matrix4x4.cc +++ b/source/blender/nodes/function/nodes/node_fn_translate_matrix.cc @@ -2,7 +2,7 @@ #include "node_function_util.hh" -namespace blender::nodes::node_fn_translate_matrix4x4_cc { +namespace blender::nodes::node_fn_translate_matrix_cc { static void node_declare(NodeDeclarationBuilder &b) { @@ -26,15 +26,15 @@ static void node_build_multi_function(NodeMultiFunctionBuilder &builder) builder.set_matching_fn(&fn); } -} // namespace blender::nodes::node_fn_translate_matrix4x4_cc +} // namespace blender::nodes::node_fn_translate_matrix_cc -void register_node_type_fn_translate_matrix_4x4(void) +void register_node_type_fn_translate_matrix(void) { - namespace file_ns = blender::nodes::node_fn_translate_matrix4x4_cc; + namespace file_ns = blender::nodes::node_fn_translate_matrix_cc; static bNodeType ntype; - fn_node_type_base(&ntype, FN_NODE_TRANSLATE_MATRIX_4X4, "Translate 4x4 Matrix", NODE_CLASS_CONVERTER); + fn_node_type_base(&ntype, FN_NODE_TRANSLATE_MATRIX, "Translate Matrix", NODE_CLASS_CONVERTER); ntype.declare = file_ns::node_declare; ntype.build_multi_function = file_ns::node_build_multi_function; -- 2.30.2 From 4580828dd9699d36f402057a83e9f18cffd90524 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Fri, 3 Mar 2023 14:16:27 +0100 Subject: [PATCH 29/33] Fix indexing errors in the matrix decompose node. --- .../nodes/function/nodes/node_fn_decompose_matrix.cc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/source/blender/nodes/function/nodes/node_fn_decompose_matrix.cc b/source/blender/nodes/function/nodes/node_fn_decompose_matrix.cc index 2276e4dcbee..249c87cb986 100644 --- a/source/blender/nodes/function/nodes/node_fn_decompose_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_decompose_matrix.cc @@ -36,9 +36,9 @@ class DecomposeMatrix4x4Function : public mf::MultiFunction { void call(IndexMask mask, mf::Params params, mf::Context /*context*/) const override { const VArray &matrices = params.readonly_single_input(0, "Matrix"); - MutableSpan translations = params.uninitialized_single_output(0, "Translation"); - MutableSpan rotations = params.uninitialized_single_output(0, "Rotation"); - MutableSpan scales = params.uninitialized_single_output(1, "Scale"); + MutableSpan translations = params.uninitialized_single_output(1, "Translation"); + MutableSpan rotations = params.uninitialized_single_output(2, "Rotation"); + MutableSpan scales = params.uninitialized_single_output(3, "Scale"); for (int64_t i : mask) { const float4x4 &mat = matrices[i]; -- 2.30.2 From ddad2b8337d01f251e147840c042731d089e7734 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Fri, 3 Mar 2023 14:38:59 +0100 Subject: [PATCH 30/33] Implemented remaining matrix math operations. --- .../function/nodes/node_fn_matrix_math.cc | 51 +++++++++++++++++++ 1 file changed, 51 insertions(+) diff --git a/source/blender/nodes/function/nodes/node_fn_matrix_math.cc b/source/blender/nodes/function/nodes/node_fn_matrix_math.cc index 8f1c69b95ba..ed2c1fb7003 100644 --- a/source/blender/nodes/function/nodes/node_fn_matrix_math.cc +++ b/source/blender/nodes/function/nodes/node_fn_matrix_math.cc @@ -2,6 +2,8 @@ #include "node_function_util.hh" +#include "BLI_math_matrix.hh" + #include "NOD_socket_search_link.hh" #include "UI_interface.h" @@ -76,6 +78,55 @@ static const mf::MultiFunction *get_multi_function(NodeMatrixMathOperation op) exec_preset); return &fn; } + case NODE_MATRIX_MATH_SUBTRACT: { + static auto fn = mf::build::SI2_SO( + "subtract", + [](const float4x4 &a, const float4x4 &b) -> float4x4 { return a - b; }, + exec_preset); + return &fn; + } + case NODE_MATRIX_MATH_SCALAR_MULTIPLY: { + static auto fn = mf::build::SI2_SO( + "scalar_multiply", + [](const float4x4 &a, const float &s) -> float4x4 { return a * s; }, + exec_preset); + return &fn; + } + case NODE_MATRIX_MATH_MULTIPLY: { + static auto fn = mf::build::SI2_SO( + "multiply", + [](const float4x4 &a, const float4x4 &b) -> float4x4 { return a * b; }, + exec_preset); + return &fn; + } + case NODE_MATRIX_MATH_TRANSPOSE: { + static auto fn = mf::build::SI1_SO( + "transpose", + [](const float4x4 &a) -> float4x4 { return math::transpose(a); }, + exec_preset); + return &fn; + } + case NODE_MATRIX_MATH_INVERSE: { + static auto fn = mf::build::SI1_SO( + "inverse", + [](const float4x4 &a) -> float4x4 { return math::invert(a); }, + exec_preset); + return &fn; + } + case NODE_MATRIX_MATH_DETERMINANT: { + static auto fn = mf::build::SI1_SO( + "determinant", + [](const float4x4 &a) -> float { return math::determinant(a); }, + exec_preset); + return &fn; + } + case NODE_MATRIX_MATH_TRACE: { + static auto fn = mf::build::SI1_SO( + "trace", + [](const float4x4 &a) -> float { return a[0][0] + a[1][1] + a[2][2] + a[3][3]; }, + exec_preset); + return &fn; + } } return nullptr; -- 2.30.2 From 95875b8cc7811ce09a42cc79f589d3f1a3d9c533 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Fri, 3 Mar 2023 16:06:01 +0100 Subject: [PATCH 31/33] Added a transform node for applying matrices to vectors. --- .../startup/bl_ui/node_add_menu_geometry.py | 1 + source/blender/blenkernel/BKE_node.h | 1 + source/blender/makesdna/DNA_node_types.h | 6 ++ source/blender/makesrna/intern/rna_nodetree.c | 18 ++++ source/blender/nodes/NOD_static_types.h | 1 + source/blender/nodes/function/CMakeLists.txt | 1 + .../nodes/function/node_function_register.cc | 1 + .../nodes/function/node_function_register.hh | 1 + .../nodes/node_fn_matrix_transform.cc | 87 +++++++++++++++++++ 9 files changed, 117 insertions(+) create mode 100644 source/blender/nodes/function/nodes/node_fn_matrix_transform.cc diff --git a/scripts/startup/bl_ui/node_add_menu_geometry.py b/scripts/startup/bl_ui/node_add_menu_geometry.py index a9b1f8a361e..d27235b469a 100644 --- a/scripts/startup/bl_ui/node_add_menu_geometry.py +++ b/scripts/startup/bl_ui/node_add_menu_geometry.py @@ -564,6 +564,7 @@ class NODE_MT_category_GEO_UTILITIES_MATRIX(Menu): node_add_menu.add_node_type(layout, "FunctionNodeSeparateMatrix") node_add_menu.add_node_type(layout, "FunctionNodeDecomposeMatrix") node_add_menu.add_node_type(layout, "FunctionNodeMatrixMath") + node_add_menu.add_node_type(layout, "FunctionNodeMatrixTransform") node_add_menu.add_node_type(layout, "FunctionNodeRotateMatrix") node_add_menu.add_node_type(layout, "FunctionNodeScaleMatrix") node_add_menu.add_node_type(layout, "FunctionNodeTranslateMatrix") diff --git a/source/blender/blenkernel/BKE_node.h b/source/blender/blenkernel/BKE_node.h index 49ba1e5ba20..24212ad0b95 100644 --- a/source/blender/blenkernel/BKE_node.h +++ b/source/blender/blenkernel/BKE_node.h @@ -1588,6 +1588,7 @@ void BKE_nodetree_remove_layer_n(struct bNodeTree *ntree, struct Scene *scene, i #define FN_NODE_ROTATE_MATRIX 1229 #define FN_NODE_SCALE_MATRIX 1230 #define FN_NODE_TRANSLATE_MATRIX 1231 +#define FN_NODE_MATRIX_TRANSFORM 1232 /** \} */ diff --git a/source/blender/makesdna/DNA_node_types.h b/source/blender/makesdna/DNA_node_types.h index 2dae3e733ec..c7d6835141d 100644 --- a/source/blender/makesdna/DNA_node_types.h +++ b/source/blender/makesdna/DNA_node_types.h @@ -1919,6 +1919,12 @@ typedef enum NodeMatrixMathOperation { //NODE_MATRIX_MATH_IS_ORTHOGONAL = 10, } NodeMatrixMathOperation; +typedef enum NodeMatrixTransformVectorMode { + NODE_MATRIX_TRANSFORM_POINT = 0, + NODE_MATRIX_TRANSFORM_DIRECTION = 1, + NODE_MATRIX_TRANSFORM_NORMAL = 2, +} NodeMatrixTransformVectorMode; + typedef enum NodeBooleanMathOperation { NODE_BOOLEAN_MATH_AND = 0, NODE_BOOLEAN_MATH_OR = 1, diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c index 5dcf1815707..2685442d086 100644 --- a/source/blender/makesrna/intern/rna_nodetree.c +++ b/source/blender/makesrna/intern/rna_nodetree.c @@ -308,6 +308,13 @@ const EnumPropertyItem rna_enum_node_matrix_math_items[] = { {0, NULL, 0, NULL, NULL}, }; +const EnumPropertyItem rna_enum_node_matrix_transform_vector_mode_items[] = { + {NODE_MATRIX_TRANSFORM_POINT, "POINT", 0, "Point", "Apply translation, rotation and scale"}, + {NODE_MATRIX_TRANSFORM_DIRECTION, "DIRECTION", 0, "Direction", "Apply only rotation and scale"}, + {NODE_MATRIX_TRANSFORM_NORMAL, "NORMAL", 0, "Normal", "Apply inverse transpose of the matrix for surface normals"}, + {0, NULL, 0, NULL, NULL}, +}; + const EnumPropertyItem rna_enum_node_boolean_math_items[] = { {NODE_BOOLEAN_MATH_AND, "AND", 0, "And", "True when both inputs are true"}, {NODE_BOOLEAN_MATH_OR, "OR", 0, "Or", "True when at least one input is true"}, @@ -5291,6 +5298,17 @@ static void def_fn_matrix_math(StructRNA *srna) RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); } +static void def_fn_matrix_transform(StructRNA *srna) +{ + PropertyRNA *prop; + + prop = RNA_def_property(srna, "vector_mode", PROP_ENUM, PROP_NONE); + RNA_def_property_enum_sdna(prop, NULL, "custom1"); + RNA_def_property_enum_items(prop, rna_enum_node_matrix_transform_vector_mode_items); + RNA_def_property_ui_text(prop, "Vector Mode", ""); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_socket_update"); +} + /* -- Shader Nodes ---------------------------------------------------------- */ static void def_sh_output(StructRNA *srna) diff --git a/source/blender/nodes/NOD_static_types.h b/source/blender/nodes/NOD_static_types.h index d30cf90ccea..e4a8a6ef7f3 100644 --- a/source/blender/nodes/NOD_static_types.h +++ b/source/blender/nodes/NOD_static_types.h @@ -276,6 +276,7 @@ DefNode(FunctionNode, FN_NODE_INPUT_SPECIAL_CHARACTERS, 0, "INPUT_SPECIAL_CHARAC DefNode(FunctionNode, FN_NODE_INPUT_STRING, def_fn_input_string, "INPUT_STRING", InputString, "String", "") DefNode(FunctionNode, FN_NODE_INPUT_VECTOR, def_fn_input_vector, "INPUT_VECTOR", InputVector, "Vector", "") DefNode(FunctionNode, FN_NODE_MATRIX_MATH, def_fn_matrix_math, "MATRIX_MATH", MatrixMath, "Matrix Math", "") +DefNode(FunctionNode, FN_NODE_MATRIX_TRANSFORM, def_fn_matrix_transform, "MATRIX_TRANSFORM", MatrixTransform, "Matrix Transform", "") DefNode(FunctionNode, FN_NODE_RANDOM_VALUE, def_fn_random_value, "RANDOM_VALUE", RandomValue, "Random Value", "") DefNode(FunctionNode, FN_NODE_REPLACE_STRING, 0, "REPLACE_STRING", ReplaceString, "Replace String", "") DefNode(FunctionNode, FN_NODE_ROTATE_EULER, def_fn_rotate_euler, "ROTATE_EULER", RotateEuler, "Rotate Euler", "") diff --git a/source/blender/nodes/function/CMakeLists.txt b/source/blender/nodes/function/CMakeLists.txt index 9c8bc3b8771..0185fd7f67d 100644 --- a/source/blender/nodes/function/CMakeLists.txt +++ b/source/blender/nodes/function/CMakeLists.txt @@ -35,6 +35,7 @@ set(SRC nodes/node_fn_input_string.cc nodes/node_fn_input_vector.cc nodes/node_fn_matrix_math.cc + nodes/node_fn_matrix_transform.cc nodes/node_fn_random_value.cc nodes/node_fn_replace_string.cc nodes/node_fn_rotate_euler.cc diff --git a/source/blender/nodes/function/node_function_register.cc b/source/blender/nodes/function/node_function_register.cc index 8b615321f51..69fb4579d2e 100644 --- a/source/blender/nodes/function/node_function_register.cc +++ b/source/blender/nodes/function/node_function_register.cc @@ -21,6 +21,7 @@ void register_function_nodes() register_node_type_fn_input_string(); register_node_type_fn_input_vector(); register_node_type_fn_matrix_math(); + register_node_type_fn_matrix_transform(); register_node_type_fn_random_value(); register_node_type_fn_replace_string(); register_node_type_fn_rotate_euler(); diff --git a/source/blender/nodes/function/node_function_register.hh b/source/blender/nodes/function/node_function_register.hh index 13f3bd69682..3b599f4ee51 100644 --- a/source/blender/nodes/function/node_function_register.hh +++ b/source/blender/nodes/function/node_function_register.hh @@ -17,6 +17,7 @@ void register_node_type_fn_input_special_characters(); void register_node_type_fn_input_string(); void register_node_type_fn_input_vector(); void register_node_type_fn_matrix_math(); +void register_node_type_fn_matrix_transform(); void register_node_type_fn_random_value(); void register_node_type_fn_replace_string(); void register_node_type_fn_rotate_euler(); diff --git a/source/blender/nodes/function/nodes/node_fn_matrix_transform.cc b/source/blender/nodes/function/nodes/node_fn_matrix_transform.cc new file mode 100644 index 00000000000..20c9f807884 --- /dev/null +++ b/source/blender/nodes/function/nodes/node_fn_matrix_transform.cc @@ -0,0 +1,87 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "node_function_util.hh" + +#include "BLI_math_matrix.hh" + +#include "UI_interface.h" +#include "UI_resources.h" + +namespace blender::nodes::node_fn_matrix_transform_cc { + +static void node_declare(NodeDeclarationBuilder &b) +{ + b.is_function_node(); + b.add_input(N_("Matrix")); + b.add_input(N_("Vector")); + b.add_output(N_("Vector")); +}; + +static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) +{ + uiItemR(layout, ptr, "vector_mode", UI_ITEM_R_SPLIT_EMPTY_NAME, "", ICON_NONE); +} + +static void node_init(bNodeTree * /*tree*/, bNode *node) +{ + node->custom1 = NODE_MATRIX_TRANSFORM_POINT; +} + +static const mf::MultiFunction *get_multi_function(NodeMatrixTransformVectorMode vector_mode) +{ + static auto exec_preset = mf::build::exec_presets::AllSpanOrSingle(); + + switch (vector_mode) { + case NODE_MATRIX_TRANSFORM_POINT: { + static auto fn = mf::build::SI2_SO( + "transform_point", + [](const float4x4 &m, const float3 &v) -> float3 { return math::transform_point(m, v); }, + exec_preset); + return &fn; + } + case NODE_MATRIX_TRANSFORM_DIRECTION: { + static auto fn = mf::build::SI2_SO( + "transform_direction", + [](const float4x4 &m, const float3 &v) -> float3 { return math::transform_direction(m, v); }, + exec_preset); + return &fn; + } + case NODE_MATRIX_TRANSFORM_NORMAL: { + static auto fn = mf::build::SI2_SO( + "transform_normal", + [](const float4x4 &m, const float3 &v) -> float3 { + const float3x3 transpose_inverse = math::transpose( + math::invert(float3x3(m.view<3, 3>()))); + return math::transform_direction(transpose_inverse, v); + }, + exec_preset); + return &fn; + } + } + + return nullptr; +} + +static void node_build_multi_function(NodeMultiFunctionBuilder &builder) +{ + const NodeMatrixTransformVectorMode vector_mode = (NodeMatrixTransformVectorMode)builder.node().custom1; + const mf::MultiFunction *fn = get_multi_function(vector_mode); + builder.set_matching_fn(fn); +} + +} // namespace blender::nodes::node_fn_matrix_transform_cc + +void register_node_type_fn_matrix_transform(void) +{ + namespace file_ns = blender::nodes::node_fn_matrix_transform_cc; + + static bNodeType ntype; + + fn_node_type_base(&ntype, FN_NODE_MATRIX_TRANSFORM, "Matrix Transform", NODE_CLASS_CONVERTER); + ntype.declare = file_ns::node_declare; + ntype.initfunc = file_ns::node_init; + ntype.draw_buttons = file_ns::node_layout; + ntype.build_multi_function = file_ns::node_build_multi_function; + + nodeRegisterType(&ntype); +} -- 2.30.2 From 4f74ca2b792d9c9e485436f613b02856b65dcfd8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Fri, 3 Mar 2023 16:41:01 +0100 Subject: [PATCH 32/33] Renamed matrix socket type as well by removing the 4x4 suffix. --- source/blender/blenkernel/intern/node.cc | 26 ++++++++--------- .../intern/node_tree_field_inferencing.cc | 2 +- source/blender/editors/space_node/drawnode.cc | 6 ++-- .../editors/space_node/node_relationships.cc | 4 +-- .../editors/space_node/node_templates.cc | 6 ++-- source/blender/makesdna/DNA_node_types.h | 6 ++-- source/blender/makesrna/intern/rna_nodetree.c | 28 +++++++++---------- source/blender/modifiers/intern/MOD_nodes.cc | 10 +++---- .../blender/nodes/NOD_socket_declarations.hh | 24 ++++++++-------- .../function/nodes/node_fn_combine_matrix.cc | 2 +- .../nodes/node_fn_decompose_matrix.cc | 8 +++--- .../function/nodes/node_fn_input_matrix.cc | 2 +- .../function/nodes/node_fn_matrix_math.cc | 6 ++-- .../nodes/node_fn_matrix_transform.cc | 2 +- .../function/nodes/node_fn_rotate_matrix.cc | 4 +-- .../function/nodes/node_fn_scale_matrix.cc | 4 +-- .../function/nodes/node_fn_separate_matrix.cc | 2 +- .../nodes/node_fn_translate_matrix.cc | 4 +-- .../nodes/geometry/node_geometry_tree.cc | 2 +- .../nodes/geometry/node_geometry_util.cc | 2 +- source/blender/nodes/intern/node_common.cc | 4 +-- source/blender/nodes/intern/node_socket.cc | 22 +++++++-------- .../nodes/intern/node_socket_declarations.cc | 22 +++++++-------- 23 files changed, 99 insertions(+), 99 deletions(-) diff --git a/source/blender/blenkernel/intern/node.cc b/source/blender/blenkernel/intern/node.cc index 61f7b492bbc..d7aa43b35e1 100644 --- a/source/blender/blenkernel/intern/node.cc +++ b/source/blender/blenkernel/intern/node.cc @@ -317,7 +317,7 @@ static void library_foreach_node_socket(LibraryForeachIDData *data, bNodeSocket case SOCK_CUSTOM: case SOCK_SHADER: case SOCK_GEOMETRY: - case SOCK_MATRIX_4X4: + case SOCK_MATRIX: break; } } @@ -457,8 +457,8 @@ static void write_node_socket_default_value(BlendWriter *writer, bNodeSocket *so case SOCK_MATERIAL: BLO_write_struct(writer, bNodeSocketValueMaterial, sock->default_value); break; - case SOCK_MATRIX_4X4: - BLO_write_struct(writer, bNodeSocketValueMatrix4x4, sock->default_value); + case SOCK_MATRIX: + BLO_write_struct(writer, bNodeSocketValueMatrix, sock->default_value); break; case SOCK_CUSTOM: /* Custom node sockets where default_value is defined uses custom properties for storage. */ @@ -885,7 +885,7 @@ static void lib_link_node_socket(BlendLibReader *reader, Library *lib, bNodeSock case SOCK_CUSTOM: case SOCK_SHADER: case SOCK_GEOMETRY: - case SOCK_MATRIX_4X4: + case SOCK_MATRIX: break; } } @@ -985,7 +985,7 @@ static void expand_node_socket(BlendExpander *expander, bNodeSocket *sock) case SOCK_CUSTOM: case SOCK_SHADER: case SOCK_GEOMETRY: - case SOCK_MATRIX_4X4: + case SOCK_MATRIX: break; } } @@ -1602,7 +1602,7 @@ static void socket_id_user_increment(bNodeSocket *sock) case SOCK_CUSTOM: case SOCK_SHADER: case SOCK_GEOMETRY: - case SOCK_MATRIX_4X4: + case SOCK_MATRIX: break; } } @@ -1662,7 +1662,7 @@ static bool socket_id_user_decrement(bNodeSocket *sock) case SOCK_CUSTOM: case SOCK_SHADER: case SOCK_GEOMETRY: - case SOCK_MATRIX_4X4: + case SOCK_MATRIX: break; } return false; @@ -1807,8 +1807,8 @@ const char *nodeStaticSocketType(const int type, const int subtype) return "NodeSocketTexture"; case SOCK_MATERIAL: return "NodeSocketMaterial"; - case SOCK_MATRIX_4X4: - return "NodeSocketMatrix4x4"; + case SOCK_MATRIX: + return "NodeSocketMatrix"; } return nullptr; } @@ -1886,8 +1886,8 @@ const char *nodeStaticSocketInterfaceType(const int type, const int subtype) return "NodeSocketInterfaceTexture"; case SOCK_MATERIAL: return "NodeSocketInterfaceMaterial"; - case SOCK_MATRIX_4X4: - return "NodeSocketInterfaceMatrix4x4"; + case SOCK_MATRIX: + return "NodeSocketInterfaceMatrix"; } return nullptr; } @@ -1921,8 +1921,8 @@ const char *nodeStaticSocketLabel(const int type, const int /*subtype*/) return "Texture"; case SOCK_MATERIAL: return "Material"; - case SOCK_MATRIX_4X4: - return "4x4 Matrix"; + case SOCK_MATRIX: + return "Matrix"; } return nullptr; } diff --git a/source/blender/blenkernel/intern/node_tree_field_inferencing.cc b/source/blender/blenkernel/intern/node_tree_field_inferencing.cc index adc4a7096d4..8b5f6e52445 100644 --- a/source/blender/blenkernel/intern/node_tree_field_inferencing.cc +++ b/source/blender/blenkernel/intern/node_tree_field_inferencing.cc @@ -20,7 +20,7 @@ using nodes::SocketDeclaration; static bool is_field_socket_type(eNodeSocketDatatype type) { - return ELEM(type, SOCK_FLOAT, SOCK_INT, SOCK_BOOLEAN, SOCK_VECTOR, SOCK_RGBA, SOCK_MATRIX_4X4); + return ELEM(type, SOCK_FLOAT, SOCK_INT, SOCK_BOOLEAN, SOCK_VECTOR, SOCK_RGBA, SOCK_MATRIX); } static bool is_field_socket_type(const bNodeSocket &socket) diff --git a/source/blender/editors/space_node/drawnode.cc b/source/blender/editors/space_node/drawnode.cc index a0282843d66..22c67700179 100644 --- a/source/blender/editors/space_node/drawnode.cc +++ b/source/blender/editors/space_node/drawnode.cc @@ -1200,7 +1200,7 @@ static const float std_node_socket_colors[][4] = { {0.96, 0.96, 0.96, 1.0}, /* SOCK_COLLECTION */ {0.62, 0.31, 0.64, 1.0}, /* SOCK_TEXTURE */ {0.92, 0.46, 0.51, 1.0}, /* SOCK_MATERIAL */ - {0.01, 0.61, 0.66, 1.0}, /* SOCK_MATRIX_4X4 */ + {0.01, 0.61, 0.66, 1.0}, /* SOCK_MATRIX */ }; /* common color callbacks for standard types */ @@ -1322,7 +1322,7 @@ static void std_node_socket_draw( } } break; - case SOCK_MATRIX_4X4: + case SOCK_MATRIX: if (sock->flag & SOCK_COMPACT) { uiTemplateComponentMenu(layout, ptr, "default_value", text); } @@ -1461,7 +1461,7 @@ static void std_node_socket_interface_draw(bContext * /*C*/, uiLayout *layout, P uiItemR(sub, ptr, "max_value", DEFAULT_FLAGS, IFACE_("Max"), ICON_NONE); break; } - case SOCK_MATRIX_4X4: { + case SOCK_MATRIX: { uiItemR(col, ptr, "default_value", DEFAULT_FLAGS, IFACE_("Default"), ICON_NONE); uiLayout *sub = uiLayoutColumn(col, true); uiItemR(sub, ptr, "min_value", DEFAULT_FLAGS, IFACE_("Min"), ICON_NONE); diff --git a/source/blender/editors/space_node/node_relationships.cc b/source/blender/editors/space_node/node_relationships.cc index 56c96e057b6..eb8d34edc90 100644 --- a/source/blender/editors/space_node/node_relationships.cc +++ b/source/blender/editors/space_node/node_relationships.cc @@ -448,7 +448,7 @@ static eCustomDataType socket_type_to_custom_data_type(const eNodeSocketDatatype return CD_PROP_INT32; case SOCK_VECTOR: return CD_PROP_FLOAT3; - case SOCK_MATRIX_4X4: + case SOCK_MATRIX: return CD_PROP_FLOAT4X4; case SOCK_BOOLEAN: return CD_PROP_BOOL; @@ -2220,7 +2220,7 @@ static int get_main_socket_priority(const bNodeSocket *socket) case SOCK_COLLECTION: case SOCK_TEXTURE: case SOCK_MATERIAL: - case SOCK_MATRIX_4X4: + case SOCK_MATRIX: return 6; } return -1; diff --git a/source/blender/editors/space_node/node_templates.cc b/source/blender/editors/space_node/node_templates.cc index 53051760847..0b71b028fe4 100644 --- a/source/blender/editors/space_node/node_templates.cc +++ b/source/blender/editors/space_node/node_templates.cc @@ -381,8 +381,8 @@ static Vector ui_node_link_items(NodeLinkArg *arg, else if (dynamic_cast(&socket_decl)) { item.socket_type = SOCK_VECTOR; } - else if (dynamic_cast(&socket_decl)) { - item.socket_type = SOCK_MATRIX_4X4; + else if (dynamic_cast(&socket_decl)) { + item.socket_type = SOCK_MATRIX; } else if (dynamic_cast(&socket_decl)) { item.socket_type = SOCK_RGBA; @@ -864,7 +864,7 @@ static void ui_node_draw_input( else { switch (input.type) { case SOCK_VECTOR: - case SOCK_MATRIX_4X4: + case SOCK_MATRIX: uiItemS(sub); sub = uiLayoutColumn(sub, true); ATTR_FALLTHROUGH; diff --git a/source/blender/makesdna/DNA_node_types.h b/source/blender/makesdna/DNA_node_types.h index c7d6835141d..ee257c0d1c7 100644 --- a/source/blender/makesdna/DNA_node_types.h +++ b/source/blender/makesdna/DNA_node_types.h @@ -235,7 +235,7 @@ typedef enum eNodeSocketDatatype { SOCK_COLLECTION = 11, SOCK_TEXTURE = 12, SOCK_MATERIAL = 13, - SOCK_MATRIX_4X4 = 14, + SOCK_MATRIX = 14, } eNodeSocketDatatype; /** Socket shape. */ @@ -715,10 +715,10 @@ typedef struct bNodeSocketValueVector { float min, max; } bNodeSocketValueVector; -typedef struct bNodeSocketValueMatrix4x4 { +typedef struct bNodeSocketValueMatrix { float value[4][4]; float min, max; -} bNodeSocketValueMatrix4x4; +} bNodeSocketValueMatrix; typedef struct bNodeSocketValueRGBA { float value[4]; diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c index 2685442d086..ab9114bfcd3 100644 --- a/source/blender/makesrna/intern/rna_nodetree.c +++ b/source/blender/makesrna/intern/rna_nodetree.c @@ -62,7 +62,7 @@ static const EnumPropertyItem node_socket_data_type_items[] = { {SOCK_INT, "INT", 0, "Integer", ""}, {SOCK_BOOLEAN, "BOOLEAN", 0, "Boolean", ""}, {SOCK_VECTOR, "VECTOR", 0, "Vector", ""}, - {SOCK_MATRIX_4X4, "MATRIX4x4", 0, "4x4 Matrix", ""}, + {SOCK_MATRIX, "MATRIX", 0, "Matrix", ""}, {SOCK_STRING, "STRING", 0, "String", ""}, {SOCK_RGBA, "RGBA", 0, "Color", ""}, {SOCK_OBJECT, "OBJECT", 0, "Object", ""}, @@ -90,7 +90,7 @@ static const EnumPropertyItem node_socket_type_items[] = { {SOCK_INT, "INT", 0, "Integer", ""}, {SOCK_BOOLEAN, "BOOLEAN", 0, "Boolean", ""}, {SOCK_VECTOR, "VECTOR", 0, "Vector", ""}, - {SOCK_MATRIX_4X4, "MATRIX4x4", 0, "4x4 Matrix", ""}, + {SOCK_MATRIX, "MATRIX", 0, "Matrix", ""}, {SOCK_STRING, "STRING", 0, "String", ""}, {SOCK_RGBA, "RGBA", 0, "RGBA", ""}, {SOCK_SHADER, "SHADER", 0, "Shader", ""}, @@ -3298,11 +3298,11 @@ static void rna_NodeSocketStandard_vector_range( *softmax = dval->max; } -static void rna_NodeSocketStandard_matrix4x4_range( +static void rna_NodeSocketStandard_matrix_range( PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax) { bNodeSocket *sock = ptr->data; - bNodeSocketValueMatrix4x4 *dval = sock->default_value; + bNodeSocketValueMatrix *dval = sock->default_value; if (dval->max < dval->min) { dval->max = dval->min; @@ -11674,9 +11674,9 @@ static void rna_def_node_socket_vector(BlenderRNA *brna, RNA_def_struct_sdna_from(srna, "bNodeSocket", NULL); } -static void rna_def_node_socket_matrix4x4(BlenderRNA *brna, - const char *identifier, - const char *interface_idname) +static void rna_def_node_socket_matrix(BlenderRNA *brna, + const char *identifier, + const char *interface_idname) { StructRNA *srna; PropertyRNA *prop; @@ -11698,15 +11698,15 @@ static void rna_def_node_socket_matrix4x4(BlenderRNA *brna, 1.0f}; srna = RNA_def_struct(brna, identifier, "NodeSocketStandard"); - RNA_def_struct_ui_text(srna, "Matrix 4x4 Node Socket", "4x4 matrix socket of a node"); + RNA_def_struct_ui_text(srna, "Matrix Node Socket", "Matrix socket of a node"); RNA_def_struct_sdna(srna, "bNodeSocket"); - RNA_def_struct_sdna_from(srna, "bNodeSocketValueMatrix4x4", "default_value"); + RNA_def_struct_sdna_from(srna, "bNodeSocketValueMatrix", "default_value"); prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_MATRIX); RNA_def_property_float_sdna(prop, NULL, "value"); RNA_def_property_float_array_default(prop, value_default); - RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketStandard_matrix4x4_range"); + RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketStandard_matrix_range"); RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update"); RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE); @@ -11715,15 +11715,15 @@ static void rna_def_node_socket_matrix4x4(BlenderRNA *brna, /* socket interface */ srna = RNA_def_struct(brna, interface_idname, "NodeSocketInterfaceStandard"); - RNA_def_struct_ui_text(srna, "Matrix 4x4 Node Socket Interface", "4x4 matrix socket of a node"); + RNA_def_struct_ui_text(srna, "Matrix Node Socket Interface", "Matrix socket of a node"); RNA_def_struct_sdna(srna, "bNodeSocket"); - RNA_def_struct_sdna_from(srna, "bNodeSocketValueMatrix4x4", "default_value"); + RNA_def_struct_sdna_from(srna, "bNodeSocketValueMatrix", "default_value"); prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_MATRIX); RNA_def_property_float_sdna(prop, NULL, "value"); RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); - RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketStandard_matrix4x4_range"); + RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketStandard_matrix_range"); RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket"); RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketInterface_update"); @@ -12183,7 +12183,7 @@ static void rna_def_node_socket_standard_types(BlenderRNA *brna) rna_def_node_socket_vector( brna, "NodeSocketVectorXYZ", "NodeSocketInterfaceVectorXYZ", PROP_XYZ); - rna_def_node_socket_matrix4x4(brna, "NodeSocketMatrix4x4", "NodeSocketInterfaceMatrix4x4"); + rna_def_node_socket_matrix(brna, "NodeSocketMatrix", "NodeSocketInterfaceMatrix"); rna_def_node_socket_color(brna, "NodeSocketColor", "NodeSocketInterfaceColor"); diff --git a/source/blender/modifiers/intern/MOD_nodes.cc b/source/blender/modifiers/intern/MOD_nodes.cc index e19732c5800..c2bc0a0376c 100644 --- a/source/blender/modifiers/intern/MOD_nodes.cc +++ b/source/blender/modifiers/intern/MOD_nodes.cc @@ -419,7 +419,7 @@ static const std::string attribute_name_suffix = "_attribute_name"; */ static bool socket_type_has_attribute_toggle(const bNodeSocket &socket) { - return ELEM(socket.type, SOCK_FLOAT, SOCK_VECTOR, SOCK_BOOLEAN, SOCK_RGBA, SOCK_INT, SOCK_MATRIX_4X4); + return ELEM(socket.type, SOCK_FLOAT, SOCK_VECTOR, SOCK_BOOLEAN, SOCK_RGBA, SOCK_INT, SOCK_MATRIX); } /** @@ -477,8 +477,8 @@ id_property_create_from_socket(const bNodeSocket &socket) } return property; } - case SOCK_MATRIX_4X4: { - const bNodeSocketValueMatrix4x4 *value = static_cast( + case SOCK_MATRIX: { + const bNodeSocketValueMatrix *value = static_cast( socket.default_value); const Span default_value_span((float *)value->value, 16); auto property = bke::idprop::create(socket.identifier, default_value_span); @@ -570,7 +570,7 @@ static bool id_property_type_matches_socket(const bNodeSocket &socket, const IDP return property.type == IDP_INT; case SOCK_VECTOR: return property.type == IDP_ARRAY && property.subtype == IDP_FLOAT && property.len == 3; - case SOCK_MATRIX_4X4: + case SOCK_MATRIX: return property.type == IDP_ARRAY && property.subtype == IDP_FLOAT && property.len == 16; case SOCK_RGBA: return property.type == IDP_ARRAY && property.subtype == IDP_FLOAT && property.len == 4; @@ -616,7 +616,7 @@ static void init_socket_cpp_value_from_property(const IDProperty &property, new (r_value) ValueOrField(value); break; } - case SOCK_MATRIX_4X4: { + case SOCK_MATRIX: { float4x4 value; copy_m4_m4(value.ptr(), (const float(*)[4])IDP_Array(&property)); new (r_value) ValueOrField(value); diff --git a/source/blender/nodes/NOD_socket_declarations.hh b/source/blender/nodes/NOD_socket_declarations.hh index 5e25acfe023..94b676f81ee 100644 --- a/source/blender/nodes/NOD_socket_declarations.hh +++ b/source/blender/nodes/NOD_socket_declarations.hh @@ -94,18 +94,18 @@ class VectorBuilder : public SocketDeclarationBuilder { VectorBuilder &compact(); }; -class Matrix4x4Builder; +class MatrixBuilder; -class Matrix4x4 : public SocketDeclaration { +class Matrix : public SocketDeclaration { private: float4x4 default_value_ = float4x4::identity(); float soft_min_value_ = -FLT_MAX; float soft_max_value_ = FLT_MAX; - friend Matrix4x4Builder; + friend MatrixBuilder; public: - using Builder = Matrix4x4Builder; + using Builder = MatrixBuilder; bNodeSocket &build(bNodeTree &ntree, bNode &node) const override; bool matches(const bNodeSocket &socket) const override; @@ -113,11 +113,11 @@ class Matrix4x4 : public SocketDeclaration { bool can_connect(const bNodeSocket &socket) const override; }; -class Matrix4x4Builder : public SocketDeclarationBuilder { +class MatrixBuilder : public SocketDeclarationBuilder { public: - Matrix4x4Builder &default_value(const float4x4 &value); - Matrix4x4Builder &min(float min); - Matrix4x4Builder &max(float max); + MatrixBuilder &default_value(const float4x4 &value); + MatrixBuilder &min(float min); + MatrixBuilder &max(float max); }; class BoolBuilder; @@ -371,22 +371,22 @@ inline VectorBuilder &VectorBuilder::compact() /** \} */ /* -------------------------------------------------------------------- */ -/** \name #Matrix4x4Builder Inline Methods +/** \name #MatrixBuilder Inline Methods * \{ */ -inline Matrix4x4Builder &Matrix4x4Builder::default_value(const float4x4 &value) +inline MatrixBuilder &MatrixBuilder::default_value(const float4x4 &value) { decl_->default_value_ = value; return *this; } -inline Matrix4x4Builder &Matrix4x4Builder::min(const float min) +inline MatrixBuilder &MatrixBuilder::min(const float min) { decl_->soft_min_value_ = min; return *this; } -inline Matrix4x4Builder &Matrix4x4Builder::max(const float max) +inline MatrixBuilder &MatrixBuilder::max(const float max) { decl_->soft_max_value_ = max; return *this; diff --git a/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc b/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc index a7ca3947f4e..9c119afbf75 100644 --- a/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_combine_matrix.cc @@ -30,7 +30,7 @@ static void node_declare(NodeDeclarationBuilder &b) b.add_input(N_("Row 1 Col 3")).default_value(0.0f); b.add_input(N_("Row 2 Col 3")).default_value(0.0f); b.add_input(N_("Row 3 Col 3")).default_value(1.0f); - b.add_output(N_("Matrix")); + b.add_output(N_("Matrix")); }; static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) diff --git a/source/blender/nodes/function/nodes/node_fn_decompose_matrix.cc b/source/blender/nodes/function/nodes/node_fn_decompose_matrix.cc index 249c87cb986..2c6379705fc 100644 --- a/source/blender/nodes/function/nodes/node_fn_decompose_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_decompose_matrix.cc @@ -11,15 +11,15 @@ namespace blender::nodes::node_fn_decompose_matrix_cc { static void node_declare(NodeDeclarationBuilder &b) { b.is_function_node(); - b.add_input(N_("Matrix")); + b.add_input(N_("Matrix")); b.add_output(N_("Translation")); b.add_output(N_("Rotation")); b.add_output(N_("Scale")); }; -class DecomposeMatrix4x4Function : public mf::MultiFunction { +class DecomposeMatrixFunction : public mf::MultiFunction { public: - DecomposeMatrix4x4Function() + DecomposeMatrixFunction() { static const mf::Signature signature = []() { mf::Signature signature; @@ -51,7 +51,7 @@ class DecomposeMatrix4x4Function : public mf::MultiFunction { static void node_build_multi_function(NodeMultiFunctionBuilder &builder) { - static DecomposeMatrix4x4Function decompose_matrix_fn; + static DecomposeMatrixFunction decompose_matrix_fn; builder.set_matching_fn(&decompose_matrix_fn); } diff --git a/source/blender/nodes/function/nodes/node_fn_input_matrix.cc b/source/blender/nodes/function/nodes/node_fn_input_matrix.cc index 993812c3550..41708346665 100644 --- a/source/blender/nodes/function/nodes/node_fn_input_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_input_matrix.cc @@ -13,7 +13,7 @@ NODE_STORAGE_FUNCS(NodeInputMatrix); static void node_declare(NodeDeclarationBuilder &b) { - b.add_output(N_("Matrix")); + b.add_output(N_("Matrix")); }; static void node_layout(uiLayout *layout, bContext * /*C*/, PointerRNA *ptr) diff --git a/source/blender/nodes/function/nodes/node_fn_matrix_math.cc b/source/blender/nodes/function/nodes/node_fn_matrix_math.cc index ed2c1fb7003..0e8e3c046b5 100644 --- a/source/blender/nodes/function/nodes/node_fn_matrix_math.cc +++ b/source/blender/nodes/function/nodes/node_fn_matrix_math.cc @@ -14,10 +14,10 @@ namespace blender::nodes::node_fn_matrix_math_cc { static void node_declare(NodeDeclarationBuilder &b) { b.is_function_node(); - b.add_input(N_("Matrix")); - b.add_input(N_("Matrix"), "Matrix_001"); + b.add_input(N_("Matrix")); + b.add_input(N_("Matrix"), "Matrix_001"); b.add_input(N_("Scale")).default_value(1.0f); - b.add_output(N_("Matrix")); + b.add_output(N_("Matrix")); b.add_output(N_("Value")); }; diff --git a/source/blender/nodes/function/nodes/node_fn_matrix_transform.cc b/source/blender/nodes/function/nodes/node_fn_matrix_transform.cc index 20c9f807884..688632c03bb 100644 --- a/source/blender/nodes/function/nodes/node_fn_matrix_transform.cc +++ b/source/blender/nodes/function/nodes/node_fn_matrix_transform.cc @@ -12,7 +12,7 @@ namespace blender::nodes::node_fn_matrix_transform_cc { static void node_declare(NodeDeclarationBuilder &b) { b.is_function_node(); - b.add_input(N_("Matrix")); + b.add_input(N_("Matrix")); b.add_input(N_("Vector")); b.add_output(N_("Vector")); }; diff --git a/source/blender/nodes/function/nodes/node_fn_rotate_matrix.cc b/source/blender/nodes/function/nodes/node_fn_rotate_matrix.cc index e4753e4cb56..3d8c645f298 100644 --- a/source/blender/nodes/function/nodes/node_fn_rotate_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_rotate_matrix.cc @@ -9,9 +9,9 @@ namespace blender::nodes::node_fn_rotate_matrix_cc { static void node_declare(NodeDeclarationBuilder &b) { b.is_function_node(); - b.add_input(N_("Matrix")); + b.add_input(N_("Matrix")); b.add_input(N_("Rotation")); - b.add_output(N_("Matrix")); + b.add_output(N_("Matrix")); }; static void node_build_multi_function(NodeMultiFunctionBuilder &builder) diff --git a/source/blender/nodes/function/nodes/node_fn_scale_matrix.cc b/source/blender/nodes/function/nodes/node_fn_scale_matrix.cc index f95a2db6af2..9e309d5860e 100644 --- a/source/blender/nodes/function/nodes/node_fn_scale_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_scale_matrix.cc @@ -9,9 +9,9 @@ namespace blender::nodes::node_fn_scale_matrix_cc { static void node_declare(NodeDeclarationBuilder &b) { b.is_function_node(); - b.add_input(N_("Matrix")); + b.add_input(N_("Matrix")); b.add_input(N_("Scale")); - b.add_output(N_("Matrix")); + b.add_output(N_("Matrix")); }; static void node_build_multi_function(NodeMultiFunctionBuilder &builder) diff --git a/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc b/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc index 79e935ce13d..6147f7a7be4 100644 --- a/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_separate_matrix.cc @@ -10,7 +10,7 @@ namespace blender::nodes::node_fn_separate_matrix_cc { static void node_declare(NodeDeclarationBuilder &b) { b.is_function_node(); - b.add_input(N_("Matrix")).default_value(float4x4::identity()); + b.add_input(N_("Matrix")).default_value(float4x4::identity()); b.add_output(N_("Vec0")); b.add_output(N_("Vec1")); b.add_output(N_("Vec2")); diff --git a/source/blender/nodes/function/nodes/node_fn_translate_matrix.cc b/source/blender/nodes/function/nodes/node_fn_translate_matrix.cc index daeb55d53dc..91b0fbf60fc 100644 --- a/source/blender/nodes/function/nodes/node_fn_translate_matrix.cc +++ b/source/blender/nodes/function/nodes/node_fn_translate_matrix.cc @@ -7,9 +7,9 @@ namespace blender::nodes::node_fn_translate_matrix_cc { static void node_declare(NodeDeclarationBuilder &b) { b.is_function_node(); - b.add_input(N_("Matrix")); + b.add_input(N_("Matrix")); b.add_input(N_("Translation")); - b.add_output(N_("Matrix")); + b.add_output(N_("Matrix")); }; static void node_build_multi_function(NodeMultiFunctionBuilder &builder) diff --git a/source/blender/nodes/geometry/node_geometry_tree.cc b/source/blender/nodes/geometry/node_geometry_tree.cc index 17afdb75ba9..c6c05a550c5 100644 --- a/source/blender/nodes/geometry/node_geometry_tree.cc +++ b/source/blender/nodes/geometry/node_geometry_tree.cc @@ -103,7 +103,7 @@ static bool geometry_node_tree_socket_type_valid(bNodeTreeType * /*treetype*/, SOCK_TEXTURE, SOCK_IMAGE, SOCK_MATERIAL, - SOCK_MATRIX_4X4); + SOCK_MATRIX); } void register_node_tree_type_geo() diff --git a/source/blender/nodes/geometry/node_geometry_util.cc b/source/blender/nodes/geometry/node_geometry_util.cc index 69508968461..b60b138e3fb 100644 --- a/source/blender/nodes/geometry/node_geometry_util.cc +++ b/source/blender/nodes/geometry/node_geometry_util.cc @@ -22,7 +22,7 @@ std::optional node_data_type_to_custom_data_type(const eNodeSoc return CD_PROP_FLOAT; case SOCK_VECTOR: return CD_PROP_FLOAT3; - case SOCK_MATRIX_4X4: + case SOCK_MATRIX: return CD_PROP_FLOAT4X4; case SOCK_RGBA: return CD_PROP_COLOR; diff --git a/source/blender/nodes/intern/node_common.cc b/source/blender/nodes/intern/node_common.cc index 44c4db7cb91..58445c5e434 100644 --- a/source/blender/nodes/intern/node_common.cc +++ b/source/blender/nodes/intern/node_common.cc @@ -148,8 +148,8 @@ static SocketDeclarationPtr declaration_for_interface_socket(const bNodeSocket & dst = std::move(decl); break; } - case SOCK_MATRIX_4X4: { - std::unique_ptr decl = std::make_unique(); + case SOCK_MATRIX: { + std::unique_ptr decl = std::make_unique(); dst = std::move(decl); break; } diff --git a/source/blender/nodes/intern/node_socket.cc b/source/blender/nodes/intern/node_socket.cc index a6fabc0b309..577a35bd885 100644 --- a/source/blender/nodes/intern/node_socket.cc +++ b/source/blender/nodes/intern/node_socket.cc @@ -80,8 +80,8 @@ struct bNodeSocket *node_add_socket_from_template(struct bNodeTree *ntree, dval->max = stemp->max; break; } - case SOCK_MATRIX_4X4: { - bNodeSocketValueMatrix4x4 *dval = (bNodeSocketValueMatrix4x4 *)sock->default_value; + case SOCK_MATRIX: { + bNodeSocketValueMatrix *dval = (bNodeSocketValueMatrix *)sock->default_value; dval->value[0][0] = stemp->val1; dval->value[0][1] = 0.0f; dval->value[0][2] = 0.0f; @@ -374,12 +374,12 @@ void node_socket_init_default_value(bNodeSocket *sock) sock->default_value = dval; break; } - case SOCK_MATRIX_4X4: { + case SOCK_MATRIX: { static float default_value[][4] = {{1.0f, 0.0f, 0.0f, 0.0f}, {0.0f, 1.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 1.0f, 0.0f}, {0.0f, 0.0f, 0.0f, 1.0f}}; - bNodeSocketValueMatrix4x4 *dval = MEM_cnew( + bNodeSocketValueMatrix *dval = MEM_cnew( "node socket value vector"); copy_m4_m4(dval->value, default_value); dval->min = -FLT_MAX; @@ -488,9 +488,9 @@ void node_socket_copy_default_value(bNodeSocket *to, const bNodeSocket *from) *toval = *fromval; break; } - case SOCK_MATRIX_4X4: { - bNodeSocketValueMatrix4x4 *toval = (bNodeSocketValueMatrix4x4 *)to->default_value; - bNodeSocketValueMatrix4x4 *fromval = (bNodeSocketValueMatrix4x4 *)from->default_value; + case SOCK_MATRIX: { + bNodeSocketValueMatrix *toval = (bNodeSocketValueMatrix *)to->default_value; + bNodeSocketValueMatrix *fromval = (bNodeSocketValueMatrix *)from->default_value; *toval = *fromval; break; } @@ -713,12 +713,12 @@ static bNodeSocketType *make_socket_type_vector(PropertySubType subtype) return socktype; } -static bNodeSocketType *make_socket_type_matrix4x4() +static bNodeSocketType *make_socket_type_matrix() { - bNodeSocketType *socktype = make_standard_socket_type(SOCK_MATRIX_4X4, PROP_MATRIX); + bNodeSocketType *socktype = make_standard_socket_type(SOCK_MATRIX, PROP_MATRIX); socktype->base_cpp_type = &blender::CPPType::get(); socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) { - *(blender::float4x4 *)r_value = float4x4(((bNodeSocketValueMatrix4x4 *)socket.default_value)->value); + *(blender::float4x4 *)r_value = float4x4(((bNodeSocketValueMatrix *)socket.default_value)->value); }; socktype->geometry_nodes_cpp_type = &blender::CPPType::get>(); socktype->get_geometry_nodes_cpp_value = [](const bNodeSocket &socket, void *r_value) { @@ -863,7 +863,7 @@ void register_standard_node_socket_types() nodeRegisterSocketType(make_socket_type_vector(PROP_EULER)); nodeRegisterSocketType(make_socket_type_vector(PROP_XYZ)); - nodeRegisterSocketType(make_socket_type_matrix4x4()); + nodeRegisterSocketType(make_socket_type_matrix()); nodeRegisterSocketType(make_socket_type_rgba()); diff --git a/source/blender/nodes/intern/node_socket_declarations.cc b/source/blender/nodes/intern/node_socket_declarations.cc index 0964f3ee0dc..6b39de9300a 100644 --- a/source/blender/nodes/intern/node_socket_declarations.cc +++ b/source/blender/nodes/intern/node_socket_declarations.cc @@ -274,45 +274,45 @@ bNodeSocket &Vector::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket /** \} */ /* -------------------------------------------------------------------- */ -/** \name #Matrix4x4 +/** \name #Matrix * \{ */ -bNodeSocket &Matrix4x4::build(bNodeTree &ntree, bNode &node) const +bNodeSocket &Matrix::build(bNodeTree &ntree, bNode &node) const { bNodeSocket &socket = *nodeAddStaticSocket( - &ntree, &node, in_out, SOCK_MATRIX_4X4, PROP_MATRIX, identifier.c_str(), name.c_str()); + &ntree, &node, in_out, SOCK_MATRIX, PROP_MATRIX, identifier.c_str(), name.c_str()); this->set_common_flags(socket); - bNodeSocketValueMatrix4x4 &value = *(bNodeSocketValueMatrix4x4 *)socket.default_value; + bNodeSocketValueMatrix &value = *(bNodeSocketValueMatrix *)socket.default_value; copy_m4_m4(value.value, default_value_.ptr()); value.min = soft_min_value_; value.max = soft_max_value_; return socket; } -bool Matrix4x4::matches(const bNodeSocket &socket) const +bool Matrix::matches(const bNodeSocket &socket) const { if (!this->matches_common_data(socket)) { return false; } - if (socket.type != SOCK_MATRIX_4X4) { + if (socket.type != SOCK_MATRIX) { return false; } return true; } -bool Matrix4x4::can_connect(const bNodeSocket &socket) const +bool Matrix::can_connect(const bNodeSocket &socket) const { - return sockets_can_connect(*this, socket) && socket.type == SOCK_MATRIX_4X4; + return sockets_can_connect(*this, socket) && socket.type == SOCK_MATRIX; } -bNodeSocket &Matrix4x4::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket &socket) const +bNodeSocket &Matrix::update_or_build(bNodeTree &ntree, bNode &node, bNodeSocket &socket) const { - if (socket.type != SOCK_MATRIX_4X4) { + if (socket.type != SOCK_MATRIX) { BLI_assert(socket.in_out == in_out); return this->build(ntree, node); } this->set_common_flags(socket); - bNodeSocketValueMatrix4x4 &value = *(bNodeSocketValueMatrix4x4 *)socket.default_value; + /*bNodeSocketValueMatrix &value = *(bNodeSocketValueMatrix *)socket.default_value;*/ STRNCPY(socket.name, name.c_str()); return socket; } -- 2.30.2 From 997dbf8cc5ff050de62e0e047e722c7e32aa86ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20T=C3=B6nne?= Date: Fri, 3 Mar 2023 16:57:31 +0100 Subject: [PATCH 33/33] Fixed outdated matrix input menu entry. --- scripts/startup/bl_ui/node_add_menu_geometry.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/scripts/startup/bl_ui/node_add_menu_geometry.py b/scripts/startup/bl_ui/node_add_menu_geometry.py index d27235b469a..8bc256aeac2 100644 --- a/scripts/startup/bl_ui/node_add_menu_geometry.py +++ b/scripts/startup/bl_ui/node_add_menu_geometry.py @@ -246,8 +246,7 @@ class NODE_MT_geometry_node_GEO_INPUT_CONSTANT(Menu): node_add_menu.add_node_type(layout, "GeometryNodeInputImage") node_add_menu.add_node_type(layout, "FunctionNodeInputInt") node_add_menu.add_node_type(layout, "GeometryNodeInputMaterial") - node_add_menu.add_node_type(layout, "FunctionNodeInputMatrix3x3") - node_add_menu.add_node_type(layout, "FunctionNodeInputMatrix4x4") + node_add_menu.add_node_type(layout, "FunctionNodeInputMatrix") node_add_menu.add_node_type(layout, "FunctionNodeInputString") node_add_menu.add_node_type(layout, "ShaderNodeValue") node_add_menu.add_node_type(layout, "FunctionNodeInputVector") -- 2.30.2