blender
/
blender
136
406
Fork 590
Code Issues 6.2k Pull Requests 764 Projects 19 Wiki Activity

Matrix operations and sockets for geometry nodes #105408

Closed
Lukas Tönne wants to merge 37 commits from LukasTonne/blender:nodes-matrix-types into main
pull from: LukasTonne/blender:nodes-matrix-types
merge into: blender:main

When changing the target branch, be careful to rebase the branch in your fork to match. See documentation.
Conversation 10 Commits 37 Files Changed 35 +71 -1160
28 changed files with 71 additions and 1160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit bfde6c8a9c - Show all commits

8
scripts/startup/bl_ui/node_add_menu_geometry.py
View File

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

19
source/blender/blenkernel/BKE_node.h
View File

@ -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
/** \} */

27
source/blender/blenkernel/intern/node.cc
View File

@ -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";
}

2
source/blender/blenkernel/intern/node_tree_field_inferencing.cc
View File

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

6
source/blender/editors/space_node/drawnode.cc
View File

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

6
source/blender/editors/space_node/node_relationships.cc
View File

@ -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;
}

5
source/blender/editors/space_node/node_templates.cc
View File

@ -381,9 +381,6 @@ static Vector<NodeLinkItem> ui_node_link_items(NodeLinkArg *arg,
else if (dynamic_cast<const decl::Vector *>(&socket_decl)) {
item.socket_type = SOCK_VECTOR;
}
else if (dynamic_cast<const decl::Matrix3x3 *>(&socket_decl)) {
item.socket_type = SOCK_MATRIX_3X3;
}
else if (dynamic_cast<const decl::Matrix4x4 *>(&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);

18
source/blender/makesdna/DNA_node_types.h
View File

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

180
source/blender/makesrna/intern/rna_nodetree.c
View File

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

26
source/blender/modifiers/intern/MOD_nodes.cc
View File

@ -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<const bNodeSocketValueMatrix3x3 *>(
socket.default_value);
const Span<float> 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<const bNodeSocketValueMatrix4x4 *>(
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<float3>(value);
break;
}
case SOCK_MATRIX_3X3: {
float3x3 value;
copy_m3_m3(value.ptr(), (const float (*)[3])IDP_Array(&property));
new (r_value) ValueOrField<float3x3>(value);
break;
}
case SOCK_MATRIX_4X4: {
float4x4 value;
copy_m4_m4(value.ptr(), (const float(*)[4])IDP_Array(&property));

50
source/blender/nodes/NOD_socket_declarations.hh
View File

@ -94,32 +94,6 @@ class VectorBuilder : public SocketDeclarationBuilder<Vector> {
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<Matrix3x3> {
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
* \{ */

9
source/blender/nodes/NOD_static_types.h
View File

@ -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", "")

9
source/blender/nodes/function/CMakeLists.txt
View File

@ -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

9
source/blender/nodes/function/node_function_register.cc
View File

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

9
source/blender/nodes/function/node_function_register.hh
View File

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

153
source/blender/nodes/function/nodes/node_fn_combine_matrix3x3.cc
View File

@ -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<decl::Vector>(N_("Vec0")).default_value({1.0f, 0.0f, 0.0f});
b.add_input<decl::Vector>(N_("Vec1")).default_value({0.0f, 1.0f, 0.0f});
b.add_input<decl::Vector>(N_("Vec2")).default_value({0.0f, 0.0f, 1.0f});
b.add_input<decl::Float>(N_("Row 0 Col 0")).default_value(1.0f);
b.add_input<decl::Float>(N_("Row 1 Col 0")).default_value(0.0f);
b.add_input<decl::Float>(N_("Row 2 Col 0")).default_value(0.0f);
b.add_input<decl::Float>(N_("Row 0 Col 1")).default_value(0.0f);
b.add_input<decl::Float>(N_("Row 1 Col 1")).default_value(1.0f);
b.add_input<decl::Float>(N_("Row 2 Col 1")).default_value(0.0f);
b.add_input<decl::Float>(N_("Row 0 Col 2")).default_value(0.0f);
b.add_input<decl::Float>(N_("Row 1 Col 2")).default_value(0.0f);
b.add_input<decl::Float>(N_("Row 2 Col 2")).default_value(1.0f);
b.add_output<decl::Matrix3x3>(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<float3, float3, float3, float3x3>(
"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<float3, float3, float3, float3x3>(
"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<float3x3>(
"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<float, float, float, float, float, float, float, float, float>());
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);
}

66
source/blender/nodes/function/nodes/node_fn_decompose_matrix3x3.cc
View File

@ -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<decl::Matrix3x3>(N_("Matrix"));
b.add_output<decl::Vector>(N_("Rotation"));
b.add_output<decl::Vector>(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<float3x3>("Matrix");
builder.single_output<float3>("Rotation");
builder.single_output<float3>("Scale");
return signature;
}();
this->set_signature(&signature);
}
void call(IndexMask mask, mf::Params params, mf::Context /*context*/) const override
{
const VArray<float3x3> &matrices = params.readonly_single_input<float3x3>(0, "Matrix");
MutableSpan<float3> rotations = params.uninitialized_single_output<float3>(0, "Rotation");
MutableSpan<float3> scales = params.uninitialized_single_output<float3>(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);
}

56
source/blender/nodes/function/nodes/node_fn_input_matrix3x3.cc
View File

@ -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<decl::Matrix4x4>(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<NodeInputMatrix3x3>(__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<mf::CustomMF_Constant<float3x3>>(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);
}

109
source/blender/nodes/function/nodes/node_fn_matrix3x3_math.cc
View File

@ -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<decl::Matrix4x4>(N_("Matrix"));
b.add_input<decl::Matrix4x4>(N_("Matrix"), "Matrix_001");
b.add_input<decl::Float>(N_("Scale")).default_value(1.0f);
b.add_output<decl::Matrix4x4>(N_("Matrix"));
b.add_output<decl::Float>(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<float3x3, float3x3, float3x3>(
"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);
}

41
source/blender/nodes/function/nodes/node_fn_rotate_matrix3x3.cc
View File

@ -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<decl::Matrix3x3>(N_("Matrix"));
b.add_input<decl::Vector>(N_("Rotation"));
b.add_output<decl::Matrix3x3>(N_("Matrix"));
};
static void node_build_multi_function(NodeMultiFunctionBuilder &builder)
{
static auto fn = mf::build::SI2_SO<float3x3, float3, float3x3>(
"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);
}

41
source/blender/nodes/function/nodes/node_fn_rotate_matrix4x4.cc Normal file
View File

@ -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<decl::Matrix4x4>(N_("Matrix"));
b.add_input<decl::Vector>(N_("Rotation"));
b.add_output<decl::Matrix4x4>(N_("Matrix"));
};
static void node_build_multi_function(NodeMultiFunctionBuilder &builder)
{
static auto fn = mf::build::SI2_SO<float4x4, float3, float4x4>(
"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);
}

20
source/blender/nodes/function/nodes/node_fn_scale_matrix3x3.cc → source/blender/nodes/function/nodes/node_fn_scale_matrix4x4.cc
View File

@ -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<decl::Matrix3x3>(N_("Matrix"));
b.add_input<decl::Matrix4x4>(N_("Matrix"));
b.add_input<decl::Vector>(N_("Scale"));
b.add_output<decl::Matrix3x3>(N_("Matrix"));
b.add_output<decl::Matrix4x4>(N_("Matrix"));
};
static void node_build_multi_function(NodeMultiFunctionBuilder &builder)
{
static auto fn = mf::build::SI2_SO<float3x3, float3, float3x3>(
"scale_matrix", [](const float3x3 &mat, const float3 &scale) {
float3x3 result;
static auto fn = mf::build::SI2_SO<float4x4, float3, float4x4>(
"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;

230
source/blender/nodes/function/nodes/node_fn_separate_matrix3x3.cc
View File

@ -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<decl::Matrix4x4>(N_("Matrix")).default_value(float4x4::identity());
b.add_output<decl::Vector>(N_("Vec0"));
b.add_output<decl::Vector>(N_("Vec1"));
b.add_output<decl::Vector>(N_("Vec2"));
b.add_output<decl::Float>(N_("Row 0 Col 0"));
b.add_output<decl::Float>(N_("Row 1 Col 0"));
b.add_output<decl::Float>(N_("Row 2 Col 0"));
b.add_output<decl::Float>(N_("Row 0 Col 1"));
b.add_output<decl::Float>(N_("Row 1 Col 1"));
b.add_output<decl::Float>(N_("Row 2 Col 1"));
b.add_output<decl::Float>(N_("Row 0 Col 2"));
b.add_output<decl::Float>(N_("Row 1 Col 2"));
b.add_output<decl::Float>(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<float3x3>("Matrix");
builder.single_output<float3>("Column0");
builder.single_output<float3>("Column1");
builder.single_output<float3>("Column2");
return signature;
}();
this->set_signature(&signature);
}
void call(IndexMask mask, mf::Params params, mf::Context /*context*/) const override
{
const VArray<float3x3> &matrices = params.readonly_single_input<float3x3>(0, "Matrix");
MutableSpan<float3> col0 = params.uninitialized_single_output<float3>(1, "Column0");
MutableSpan<float3> col1 = params.uninitialized_single_output<float3>(2, "Column1");
MutableSpan<float3> col2 = params.uninitialized_single_output<float3>(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<float3x3>("Matrix");
builder.single_output<float3>("Row0");
builder.single_output<float3>("Row1");
builder.single_output<float3>("Row2");
return signature;
}();
this->set_signature(&signature);
}
void call(IndexMask mask, mf::Params params, mf::Context /*context*/) const override
{
const VArray<float3x3> &matrices = params.readonly_single_input<float3x3>(0, "Matrix");
MutableSpan<float3> row0 = params.uninitialized_single_output<float3>(1, "Row0");
MutableSpan<float3> row1 = params.uninitialized_single_output<float3>(2, "Row1");
MutableSpan<float3> row2 = params.uninitialized_single_output<float3>(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<float3x3>("Matrix");
builder.single_output<float>("Row0Column0");
builder.single_output<float>("Row0Column1");
builder.single_output<float>("Row0Column2");
builder.single_output<float>("Row1Column0");
builder.single_output<float>("Row1Column1");
builder.single_output<float>("Row1Column2");
builder.single_output<float>("Row2Column0");
builder.single_output<float>("Row2Column1");
builder.single_output<float>("Row2Column2");
return signature;
}();
this->set_signature(&signature);
}
void call(IndexMask mask, mf::Params params, mf::Context /*context*/) const override
{
const VArray<float3x3> &matrices = params.readonly_single_input<float3x3>(0, "Matrix");
MutableSpan<float> m00 = params.uninitialized_single_output<float>(0, "Row0Column0");
MutableSpan<float> m10 = params.uninitialized_single_output<float>(1, "Row0Column1");
MutableSpan<float> m20 = params.uninitialized_single_output<float>(2, "Row0Column2");
MutableSpan<float> m01 = params.uninitialized_single_output<float>(3, "Row1Column0");
MutableSpan<float> m11 = params.uninitialized_single_output<float>(4, "Row1Column1");
MutableSpan<float> m21 = params.uninitialized_single_output<float>(5, "Row1Column2");
MutableSpan<float> m02 = params.uninitialized_single_output<float>(6, "Row2Column0");
MutableSpan<float> m12 = params.uninitialized_single_output<float>(7, "Row2Column1");
MutableSpan<float> m22 = params.uninitialized_single_output<float>(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);
}

1
source/blender/nodes/geometry/node_geometry_tree.cc
View File

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

2
source/blender/nodes/geometry/node_geometry_util.cc
View File

@ -22,8 +22,6 @@ std::optional<eCustomDataType> 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:

5
source/blender/nodes/intern/node_common.cc
View File

@ -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::Matrix3x3> decl = std::make_unique<decl::Matrix3x3>();
dst = std::move(decl);
break;
}
case SOCK_MATRIX_4X4: {
std::unique_ptr<decl::Matrix4x4> decl = std::make_unique<decl::Matrix4x4>();
dst = std::move(decl);

78
source/blender/nodes/intern/node_socket.cc
View File

@ -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<bNodeSocketValueMatrix2x2>(
"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<bNodeSocketValueMatrix3x3>(
"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<blender::float3x3>();
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<ValueOrField<blender::float3x3>>();
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<blender::float3x3>(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());

46
source/blender/nodes/intern/node_socket_declarations.cc
View File

@ -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
* \{ */