diff options
Diffstat (limited to 'source/blender/nodes')
17 files changed, 788 insertions, 186 deletions
diff --git a/source/blender/nodes/CMakeLists.txt b/source/blender/nodes/CMakeLists.txt index 31b5e922dab..2381e499eee 100644 --- a/source/blender/nodes/CMakeLists.txt +++ b/source/blender/nodes/CMakeLists.txt @@ -30,6 +30,7 @@ set(INC ../blenlib ../blentranslation ../depsgraph + ../functions ../gpu ../imbuf ../makesdna @@ -37,6 +38,7 @@ set(INC ../render/extern/include ../../../intern/glew-mx ../../../intern/guardedalloc + ../../../intern/sky/include ) set(INC_SYS @@ -176,7 +178,7 @@ set(SRC shader/nodes/node_shader_light_path.c shader/nodes/node_shader_map_range.c shader/nodes/node_shader_mapping.c - shader/nodes/node_shader_math.c + shader/nodes/node_shader_math.cc shader/nodes/node_shader_mixRgb.c shader/nodes/node_shader_mix_shader.c shader/nodes/node_shader_normal.c @@ -192,7 +194,7 @@ set(SRC shader/nodes/node_shader_script.c shader/nodes/node_shader_sepcombHSV.c shader/nodes/node_shader_sepcombRGB.c - shader/nodes/node_shader_sepcombXYZ.c + shader/nodes/node_shader_sepcombXYZ.cc shader/nodes/node_shader_shaderToRgb.c shader/nodes/node_shader_squeeze.c shader/nodes/node_shader_subsurface_scattering.c @@ -214,10 +216,10 @@ set(SRC shader/nodes/node_shader_uvAlongStroke.c shader/nodes/node_shader_uvmap.c shader/nodes/node_shader_valToRgb.c - shader/nodes/node_shader_value.c + shader/nodes/node_shader_value.cc shader/nodes/node_shader_vectTransform.c shader/nodes/node_shader_vector_displacement.c - shader/nodes/node_shader_vector_math.c + shader/nodes/node_shader_vector_math.cc shader/nodes/node_shader_vector_rotate.c shader/nodes/node_shader_vertex_color.c shader/nodes/node_shader_volume_absorption.c @@ -277,7 +279,7 @@ set(SRC intern/node_util.c composite/node_composite_util.h - function/node_function_util.h + function/node_function_util.hh shader/node_shader_util.h simulation/node_simulation_util.h texture/node_texture_util.h @@ -296,6 +298,8 @@ set(SRC ) set(LIB + bf_functions + bf_intern_sky ) if(WITH_PYTHON) diff --git a/source/blender/nodes/function/node_function_util.cc b/source/blender/nodes/function/node_function_util.cc index 0927ba335fe..342c330a8fa 100644 --- a/source/blender/nodes/function/node_function_util.cc +++ b/source/blender/nodes/function/node_function_util.cc @@ -14,7 +14,7 @@ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ -#include "node_function_util.h" +#include "node_function_util.hh" #include "node_util.h" bool fn_node_poll_default(bNodeType *UNUSED(ntype), bNodeTree *ntree) diff --git a/source/blender/nodes/function/node_function_util.h b/source/blender/nodes/function/node_function_util.hh index 85e252f9bdd..938cb5dd593 100644 --- a/source/blender/nodes/function/node_function_util.h +++ b/source/blender/nodes/function/node_function_util.hh @@ -19,6 +19,7 @@ #include <string.h> +#include "BLI_float3.hh" #include "BLI_utildefines.h" #include "MEM_guardedalloc.h" @@ -26,6 +27,7 @@ #include "DNA_node_types.h" #include "BKE_node.h" +#include "BKE_node_tree_multi_function.hh" #include "BLT_translation.h" @@ -33,6 +35,8 @@ #include "node_util.h" +#include "FN_multi_function_builder.hh" + void fn_node_type_base( struct bNodeType *ntype, int type, const char *name, short nclass, short flag); bool fn_node_poll_default(struct bNodeType *ntype, struct bNodeTree *ntree); diff --git a/source/blender/nodes/function/nodes/node_fn_boolean_math.cc b/source/blender/nodes/function/nodes/node_fn_boolean_math.cc index 615ad4c6733..3a145311a08 100644 --- a/source/blender/nodes/function/nodes/node_fn_boolean_math.cc +++ b/source/blender/nodes/function/nodes/node_fn_boolean_math.cc @@ -19,7 +19,7 @@ #include "RNA_enum_types.h" -#include "node_function_util.h" +#include "node_function_util.hh" static bNodeSocketTemplate fn_node_boolean_math_in[] = { {SOCK_BOOLEAN, N_("Boolean")}, @@ -50,6 +50,33 @@ static void node_boolean_math_label(bNodeTree *UNUSED(ntree), bNode *node, char BLI_strncpy(label, IFACE_(name), maxlen); } +static const blender::fn::MultiFunction &get_multi_function(bNode &bnode) +{ + static blender::fn::CustomMF_SI_SI_SO<bool, bool, bool> and_fn{ + "And", [](bool a, bool b) { return a && b; }}; + static blender::fn::CustomMF_SI_SI_SO<bool, bool, bool> or_fn{ + "Or", [](bool a, bool b) { return a || b; }}; + static blender::fn::CustomMF_SI_SO<bool, bool> not_fn{"Not", [](bool a) { return !a; }}; + + switch (bnode.custom1) { + case NODE_BOOLEAN_MATH_AND: + return and_fn; + case NODE_BOOLEAN_MATH_OR: + return or_fn; + case NODE_BOOLEAN_MATH_NOT: + return not_fn; + } + + BLI_assert(false); + return blender::fn::dummy_multi_function; +} + +static void node_boolean_expand_in_mf_network(blender::bke::NodeMFNetworkBuilder &builder) +{ + const blender::fn::MultiFunction &fn = get_multi_function(builder.bnode()); + builder.set_matching_fn(fn); +} + void register_node_type_fn_boolean_math() { static bNodeType ntype; @@ -58,5 +85,6 @@ void register_node_type_fn_boolean_math() node_type_socket_templates(&ntype, fn_node_boolean_math_in, fn_node_boolean_math_out); node_type_label(&ntype, node_boolean_math_label); node_type_update(&ntype, node_boolean_math_update); + ntype.expand_in_mf_network = node_boolean_expand_in_mf_network; nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/function/nodes/node_fn_combine_strings.cc b/source/blender/nodes/function/nodes/node_fn_combine_strings.cc index 1b6091451d9..a880933bc12 100644 --- a/source/blender/nodes/function/nodes/node_fn_combine_strings.cc +++ b/source/blender/nodes/function/nodes/node_fn_combine_strings.cc @@ -1,4 +1,20 @@ -#include "node_function_util.h" +/* + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "node_function_util.hh" static bNodeSocketTemplate fn_node_combine_strings_in[] = { {SOCK_STRING, N_("A")}, @@ -11,11 +27,20 @@ static bNodeSocketTemplate fn_node_combine_strings_out[] = { {-1, ""}, }; +static void fn_node_combine_strings_expand_in_mf_network( + blender::bke::NodeMFNetworkBuilder &builder) +{ + static blender::fn::CustomMF_SI_SI_SO<std::string, std::string, std::string> combine_fn{ + "Combine Strings", [](const std::string &a, const std::string &b) { return a + b; }}; + builder.set_matching_fn(combine_fn); +} + void register_node_type_fn_combine_strings() { static bNodeType ntype; fn_node_type_base(&ntype, FN_NODE_COMBINE_STRINGS, "Combine Strings", 0, 0); node_type_socket_templates(&ntype, fn_node_combine_strings_in, fn_node_combine_strings_out); + ntype.expand_in_mf_network = fn_node_combine_strings_expand_in_mf_network; nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/function/nodes/node_fn_float_compare.cc b/source/blender/nodes/function/nodes/node_fn_float_compare.cc index 9788402850b..fb2c4d88caf 100644 --- a/source/blender/nodes/function/nodes/node_fn_float_compare.cc +++ b/source/blender/nodes/function/nodes/node_fn_float_compare.cc @@ -14,12 +14,14 @@ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ +#include <cmath> + #include "BLI_listbase.h" #include "BLI_string.h" #include "RNA_enum_types.h" -#include "node_function_util.h" +#include "node_function_util.hh" static bNodeSocketTemplate fn_node_float_compare_in[] = { {SOCK_FLOAT, N_("A"), 0.0f, 0.0f, 0.0f, 0.0f, -10000.0f, 10000.0f}, @@ -54,6 +56,46 @@ static void node_float_compare_label(bNodeTree *UNUSED(ntree), BLI_strncpy(label, IFACE_(name), maxlen); } +static const blender::fn::MultiFunction &get_multi_function(bNode &node) +{ + static blender::fn::CustomMF_SI_SI_SO<float, float, bool> less_than_fn{ + "Less Than", [](float a, float b) { return a < b; }}; + static blender::fn::CustomMF_SI_SI_SO<float, float, bool> less_equal_fn{ + "Less Equal", [](float a, float b) { return a <= b; }}; + static blender::fn::CustomMF_SI_SI_SO<float, float, bool> greater_than_fn{ + "Greater Than", [](float a, float b) { return a > b; }}; + static blender::fn::CustomMF_SI_SI_SO<float, float, bool> greater_equal_fn{ + "Greater Equal", [](float a, float b) { return a >= b; }}; + static blender::fn::CustomMF_SI_SI_SI_SO<float, float, float, bool> equal_fn{ + "Equal", [](float a, float b, float epsilon) { return std::abs(a - b) <= epsilon; }}; + static blender::fn::CustomMF_SI_SI_SI_SO<float, float, float, bool> not_equal_fn{ + "Not Equal", [](float a, float b, float epsilon) { return std::abs(a - b) > epsilon; }}; + + switch (node.custom1) { + case NODE_FLOAT_COMPARE_LESS_THAN: + return less_than_fn; + case NODE_FLOAT_COMPARE_LESS_EQUAL: + return less_equal_fn; + case NODE_FLOAT_COMPARE_GREATER_THAN: + return greater_than_fn; + case NODE_FLOAT_COMPARE_GREATER_EQUAL: + return greater_equal_fn; + case NODE_FLOAT_COMPARE_EQUAL: + return equal_fn; + case NODE_FLOAT_COMPARE_NOT_EQUAL: + return not_equal_fn; + } + + BLI_assert(false); + return blender::fn::dummy_multi_function; +} + +static void node_float_compare_expand_in_mf_network(blender::bke::NodeMFNetworkBuilder &builder) +{ + const blender::fn::MultiFunction &fn = get_multi_function(builder.bnode()); + builder.set_matching_fn(fn); +} + void register_node_type_fn_float_compare() { static bNodeType ntype; @@ -62,5 +104,6 @@ void register_node_type_fn_float_compare() node_type_socket_templates(&ntype, fn_node_float_compare_in, fn_node_float_compare_out); node_type_label(&ntype, node_float_compare_label); node_type_update(&ntype, node_float_compare_update); + ntype.expand_in_mf_network = node_float_compare_expand_in_mf_network; nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/function/nodes/node_fn_group_instance_id.cc b/source/blender/nodes/function/nodes/node_fn_group_instance_id.cc index 2ac86ee2407..c61c941ee0d 100644 --- a/source/blender/nodes/function/nodes/node_fn_group_instance_id.cc +++ b/source/blender/nodes/function/nodes/node_fn_group_instance_id.cc @@ -1,15 +1,45 @@ -#include "node_function_util.h" +/* + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "node_function_util.hh" static bNodeSocketTemplate fn_node_group_instance_id_out[] = { {SOCK_STRING, N_("Identifier")}, {-1, ""}, }; +static void fn_node_group_instance_id_expand_in_mf_network( + blender::bke::NodeMFNetworkBuilder &builder) +{ + const blender::bke::DNode &node = builder.dnode(); + std::string id = "/"; + for (const blender::bke::DParentNode *parent = node.parent(); parent; + parent = parent->parent()) { + id = "/" + parent->node_ref().name() + id; + } + builder.construct_and_set_matching_fn<blender::fn::CustomMF_Constant<std::string>>( + std::move(id)); +} + void register_node_type_fn_group_instance_id() { static bNodeType ntype; fn_node_type_base(&ntype, FN_NODE_GROUP_INSTANCE_ID, "Group Instance ID", 0, 0); node_type_socket_templates(&ntype, nullptr, fn_node_group_instance_id_out); + ntype.expand_in_mf_network = fn_node_group_instance_id_expand_in_mf_network; nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/function/nodes/node_fn_switch.cc b/source/blender/nodes/function/nodes/node_fn_switch.cc index cb721058875..281ddb05c76 100644 --- a/source/blender/nodes/function/nodes/node_fn_switch.cc +++ b/source/blender/nodes/function/nodes/node_fn_switch.cc @@ -15,7 +15,7 @@ */ #include "BLI_listbase.h" -#include "node_function_util.h" +#include "node_function_util.hh" static bNodeSocketTemplate fn_node_switch_in[] = { {SOCK_BOOLEAN, N_("Switch")}, diff --git a/source/blender/nodes/intern/node_socket.cc b/source/blender/nodes/intern/node_socket.cc index b23511c3bdb..02124465dda 100644 --- a/source/blender/nodes/intern/node_socket.cc +++ b/source/blender/nodes/intern/node_socket.cc @@ -25,6 +25,8 @@ #include "DNA_node_types.h" +#include "BLI_color.hh" +#include "BLI_float3.hh" #include "BLI_listbase.h" #include "BLI_math.h" #include "BLI_string.h" @@ -32,6 +34,7 @@ #include "BKE_lib_id.h" #include "BKE_node.h" +#include "BKE_node_tree_multi_function.hh" #include "RNA_access.h" #include "RNA_types.h" @@ -510,35 +513,105 @@ static bNodeSocketType *make_socket_type_control_flow(int type) return stype; } +static bNodeSocketType *make_socket_type_bool() +{ + bNodeSocketType *socktype = make_standard_socket_type(SOCK_BOOLEAN, PROP_NONE); + socktype->get_mf_data_type = []() { return blender::fn::MFDataType::ForSingle<bool>(); }; + socktype->expand_in_mf_network = [](blender::bke::SocketMFNetworkBuilder &builder) { + bool value = builder.socket_default_value<bNodeSocketValueBoolean>()->value; + builder.set_constant_value(value); + }; + return socktype; +} + +static bNodeSocketType *make_socket_type_float(PropertySubType subtype) +{ + bNodeSocketType *socktype = make_standard_socket_type(SOCK_FLOAT, subtype); + socktype->get_mf_data_type = []() { return blender::fn::MFDataType::ForSingle<float>(); }; + socktype->expand_in_mf_network = [](blender::bke::SocketMFNetworkBuilder &builder) { + float value = builder.socket_default_value<bNodeSocketValueFloat>()->value; + builder.set_constant_value(value); + }; + return socktype; +} + +static bNodeSocketType *make_socket_type_int(PropertySubType subtype) +{ + bNodeSocketType *socktype = make_standard_socket_type(SOCK_INT, subtype); + socktype->get_mf_data_type = []() { return blender::fn::MFDataType::ForSingle<int>(); }; + socktype->expand_in_mf_network = [](blender::bke::SocketMFNetworkBuilder &builder) { + int value = builder.socket_default_value<bNodeSocketValueInt>()->value; + builder.set_constant_value(value); + }; + return socktype; +} + +static bNodeSocketType *make_socket_type_vector(PropertySubType subtype) +{ + bNodeSocketType *socktype = make_standard_socket_type(SOCK_VECTOR, subtype); + socktype->get_mf_data_type = []() { + return blender::fn::MFDataType::ForSingle<blender::float3>(); + }; + socktype->expand_in_mf_network = [](blender::bke::SocketMFNetworkBuilder &builder) { + blender::float3 value = builder.socket_default_value<bNodeSocketValueVector>()->value; + builder.set_constant_value(value); + }; + return socktype; +} + +static bNodeSocketType *make_socket_type_rgba() +{ + bNodeSocketType *socktype = make_standard_socket_type(SOCK_RGBA, PROP_NONE); + socktype->get_mf_data_type = []() { + return blender::fn::MFDataType::ForSingle<blender::Color4f>(); + }; + socktype->expand_in_mf_network = [](blender::bke::SocketMFNetworkBuilder &builder) { + blender::Color4f value = builder.socket_default_value<bNodeSocketValueRGBA>()->value; + builder.set_constant_value(value); + }; + return socktype; +} + +static bNodeSocketType *make_socket_type_string() +{ + bNodeSocketType *socktype = make_standard_socket_type(SOCK_STRING, PROP_NONE); + socktype->get_mf_data_type = []() { return blender::fn::MFDataType::ForSingle<std::string>(); }; + socktype->expand_in_mf_network = [](blender::bke::SocketMFNetworkBuilder &builder) { + std::string value = builder.socket_default_value<bNodeSocketValueString>()->value; + builder.set_constant_value(value); + }; + return socktype; +} + void register_standard_node_socket_types(void) { /* draw callbacks are set in drawnode.c to avoid bad-level calls */ - nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_NONE)); - nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_UNSIGNED)); - nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_PERCENTAGE)); - nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_FACTOR)); - nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_ANGLE)); - nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_TIME)); + nodeRegisterSocketType(make_socket_type_float(PROP_NONE)); + nodeRegisterSocketType(make_socket_type_float(PROP_UNSIGNED)); + nodeRegisterSocketType(make_socket_type_float(PROP_PERCENTAGE)); + nodeRegisterSocketType(make_socket_type_float(PROP_FACTOR)); + nodeRegisterSocketType(make_socket_type_float(PROP_ANGLE)); + nodeRegisterSocketType(make_socket_type_float(PROP_TIME)); - nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_NONE)); - nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_UNSIGNED)); - nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_PERCENTAGE)); - nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_FACTOR)); + nodeRegisterSocketType(make_socket_type_int(PROP_NONE)); + nodeRegisterSocketType(make_socket_type_int(PROP_UNSIGNED)); + nodeRegisterSocketType(make_socket_type_int(PROP_PERCENTAGE)); + nodeRegisterSocketType(make_socket_type_int(PROP_FACTOR)); - nodeRegisterSocketType(make_standard_socket_type(SOCK_BOOLEAN, PROP_NONE)); + nodeRegisterSocketType(make_socket_type_bool()); - nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_NONE)); - nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_TRANSLATION)); - nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_DIRECTION)); - nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_VELOCITY)); - nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_ACCELERATION)); - nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_EULER)); - nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_XYZ)); + nodeRegisterSocketType(make_socket_type_vector(PROP_NONE)); + nodeRegisterSocketType(make_socket_type_vector(PROP_TRANSLATION)); + nodeRegisterSocketType(make_socket_type_vector(PROP_DIRECTION)); + nodeRegisterSocketType(make_socket_type_vector(PROP_VELOCITY)); + nodeRegisterSocketType(make_socket_type_vector(PROP_ACCELERATION)); + nodeRegisterSocketType(make_socket_type_vector(PROP_EULER)); + nodeRegisterSocketType(make_socket_type_vector(PROP_XYZ)); - nodeRegisterSocketType(make_standard_socket_type(SOCK_RGBA, PROP_NONE)); + nodeRegisterSocketType(make_socket_type_rgba()); - nodeRegisterSocketType(make_standard_socket_type(SOCK_STRING, PROP_NONE)); + nodeRegisterSocketType(make_socket_type_string()); nodeRegisterSocketType(make_standard_socket_type(SOCK_SHADER, PROP_NONE)); diff --git a/source/blender/nodes/shader/node_shader_util.h b/source/blender/nodes/shader/node_shader_util.h index fbb9979cdfa..fc262544b4f 100644 --- a/source/blender/nodes/shader/node_shader_util.h +++ b/source/blender/nodes/shader/node_shader_util.h @@ -70,6 +70,12 @@ #include "GPU_uniformbuffer.h" #ifdef __cplusplus +# include "FN_multi_function_builder.hh" + +# include "BKE_node_tree_multi_function.hh" + +# include "BLI_float3.hh" + extern "C" { #endif diff --git a/source/blender/nodes/shader/nodes/node_shader_math.c b/source/blender/nodes/shader/nodes/node_shader_math.c deleted file mode 100644 index 8abebbf5081..00000000000 --- a/source/blender/nodes/shader/nodes/node_shader_math.c +++ /dev/null @@ -1,115 +0,0 @@ -/* - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - * - * The Original Code is Copyright (C) 2005 Blender Foundation. - * All rights reserved. - */ - -/** \file - * \ingroup shdnodes - */ - -#include "node_shader_util.h" - -/* **************** SCALAR MATH ******************** */ -static bNodeSocketTemplate sh_node_math_in[] = { - {SOCK_FLOAT, N_("Value"), 0.5f, 0.5f, 0.5f, 1.0f, -10000.0f, 10000.0f, PROP_NONE}, - {SOCK_FLOAT, N_("Value"), 0.5f, 0.5f, 0.5f, 1.0f, -10000.0f, 10000.0f, PROP_NONE}, - {SOCK_FLOAT, N_("Value"), 0.0f, 0.5f, 0.5f, 1.0f, -10000.0f, 10000.0f, PROP_NONE}, - {-1, ""}}; - -static bNodeSocketTemplate sh_node_math_out[] = {{SOCK_FLOAT, N_("Value")}, {-1, ""}}; - -static int gpu_shader_math(GPUMaterial *mat, - bNode *node, - bNodeExecData *UNUSED(execdata), - GPUNodeStack *in, - GPUNodeStack *out) -{ - static const char *names[] = { - [NODE_MATH_ADD] = "math_add", - [NODE_MATH_SUBTRACT] = "math_subtract", - [NODE_MATH_MULTIPLY] = "math_multiply", - [NODE_MATH_DIVIDE] = "math_divide", - [NODE_MATH_MULTIPLY_ADD] = "math_multiply_add", - - [NODE_MATH_POWER] = "math_power", - [NODE_MATH_LOGARITHM] = "math_logarithm", - [NODE_MATH_EXPONENT] = "math_exponent", - [NODE_MATH_SQRT] = "math_sqrt", - [NODE_MATH_INV_SQRT] = "math_inversesqrt", - [NODE_MATH_ABSOLUTE] = "math_absolute", - [NODE_MATH_RADIANS] = "math_radians", - [NODE_MATH_DEGREES] = "math_degrees", - - [NODE_MATH_MINIMUM] = "math_minimum", - [NODE_MATH_MAXIMUM] = "math_maximum", - [NODE_MATH_LESS_THAN] = "math_less_than", - [NODE_MATH_GREATER_THAN] = "math_greater_than", - [NODE_MATH_SIGN] = "math_sign", - [NODE_MATH_COMPARE] = "math_compare", - [NODE_MATH_SMOOTH_MIN] = "math_smoothmin", - [NODE_MATH_SMOOTH_MAX] = "math_smoothmax", - - [NODE_MATH_ROUND] = "math_round", - [NODE_MATH_FLOOR] = "math_floor", - [NODE_MATH_CEIL] = "math_ceil", - [NODE_MATH_FRACTION] = "math_fraction", - [NODE_MATH_MODULO] = "math_modulo", - [NODE_MATH_TRUNC] = "math_trunc", - [NODE_MATH_SNAP] = "math_snap", - [NODE_MATH_WRAP] = "math_wrap", - [NODE_MATH_PINGPONG] = "math_pingpong", - - [NODE_MATH_SINE] = "math_sine", - [NODE_MATH_COSINE] = "math_cosine", - [NODE_MATH_TANGENT] = "math_tangent", - [NODE_MATH_SINH] = "math_sinh", - [NODE_MATH_COSH] = "math_cosh", - [NODE_MATH_TANH] = "math_tanh", - [NODE_MATH_ARCSINE] = "math_arcsine", - [NODE_MATH_ARCCOSINE] = "math_arccosine", - [NODE_MATH_ARCTANGENT] = "math_arctangent", - [NODE_MATH_ARCTAN2] = "math_arctan2", - }; - - if (node->custom1 < ARRAY_SIZE(names) && names[node->custom1]) { - int ret = GPU_stack_link(mat, node, names[node->custom1], in, out); - - if (ret && node->custom2 & SHD_MATH_CLAMP) { - float min[3] = {0.0f, 0.0f, 0.0f}; - float max[3] = {1.0f, 1.0f, 1.0f}; - GPU_link( - mat, "clamp_value", out[0].link, GPU_constant(min), GPU_constant(max), &out[0].link); - } - return ret; - } - else { - return 0; - } -} - -void register_node_type_sh_math(void) -{ - static bNodeType ntype; - - sh_fn_node_type_base(&ntype, SH_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, 0); - node_type_socket_templates(&ntype, sh_node_math_in, sh_node_math_out); - node_type_label(&ntype, node_math_label); - node_type_gpu(&ntype, gpu_shader_math); - node_type_update(&ntype, node_math_update); - - nodeRegisterType(&ntype); -} diff --git a/source/blender/nodes/shader/nodes/node_shader_math.cc b/source/blender/nodes/shader/nodes/node_shader_math.cc new file mode 100644 index 00000000000..a0eb5099f9d --- /dev/null +++ b/source/blender/nodes/shader/nodes/node_shader_math.cc @@ -0,0 +1,196 @@ +/* + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * The Original Code is Copyright (C) 2005 Blender Foundation. + * All rights reserved. + */ + +/** \file + * \ingroup shdnodes + */ + +#include "node_shader_util.h" + +/* **************** SCALAR MATH ******************** */ +static bNodeSocketTemplate sh_node_math_in[] = { + {SOCK_FLOAT, N_("Value"), 0.5f, 0.5f, 0.5f, 1.0f, -10000.0f, 10000.0f, PROP_NONE}, + {SOCK_FLOAT, N_("Value"), 0.5f, 0.5f, 0.5f, 1.0f, -10000.0f, 10000.0f, PROP_NONE}, + {SOCK_FLOAT, N_("Value"), 0.0f, 0.5f, 0.5f, 1.0f, -10000.0f, 10000.0f, PROP_NONE}, + {-1, ""}}; + +static bNodeSocketTemplate sh_node_math_out[] = {{SOCK_FLOAT, N_("Value")}, {-1, ""}}; + +static const char *gpu_shader_get_name(int mode) +{ + switch (mode) { + case NODE_MATH_ADD: + return "math_add"; + case NODE_MATH_SUBTRACT: + return "math_subtract"; + case NODE_MATH_MULTIPLY: + return "math_multiply"; + case NODE_MATH_DIVIDE: + return "math_divide"; + case NODE_MATH_MULTIPLY_ADD: + return "math_multiply_add"; + + case NODE_MATH_POWER: + return "math_power"; + case NODE_MATH_LOGARITHM: + return "math_logarithm"; + case NODE_MATH_EXPONENT: + return "math_exponent"; + case NODE_MATH_SQRT: + return "math_sqrt"; + case NODE_MATH_INV_SQRT: + return "math_inversesqrt"; + case NODE_MATH_ABSOLUTE: + return "math_absolute"; + case NODE_MATH_RADIANS: + return "math_radians"; + case NODE_MATH_DEGREES: + return "math_degrees"; + + case NODE_MATH_MINIMUM: + return "math_minimum"; + case NODE_MATH_MAXIMUM: + return "math_maximum"; + case NODE_MATH_LESS_THAN: + return "math_less_than"; + case NODE_MATH_GREATER_THAN: + return "math_greater_than"; + case NODE_MATH_SIGN: + return "math_sign"; + case NODE_MATH_COMPARE: + return "math_compare"; + case NODE_MATH_SMOOTH_MIN: + return "math_smoothmin"; + case NODE_MATH_SMOOTH_MAX: + return "math_smoothmax"; + + case NODE_MATH_ROUND: + return "math_round"; + case NODE_MATH_FLOOR: + return "math_floor"; + case NODE_MATH_CEIL: + return "math_ceil"; + case NODE_MATH_FRACTION: + return "math_fraction"; + case NODE_MATH_MODULO: + return "math_modulo"; + case NODE_MATH_TRUNC: + return "math_trunc"; + case NODE_MATH_SNAP: + return "math_snap"; + case NODE_MATH_WRAP: + return "math_wrap"; + case NODE_MATH_PINGPONG: + return "math_pingpong"; + + case NODE_MATH_SINE: + return "math_sine"; + case NODE_MATH_COSINE: + return "math_cosine"; + case NODE_MATH_TANGENT: + return "math_tangent"; + case NODE_MATH_SINH: + return "math_sinh"; + case NODE_MATH_COSH: + return "math_cosh"; + case NODE_MATH_TANH: + return "math_tanh"; + case NODE_MATH_ARCSINE: + return "math_arcsine"; + case NODE_MATH_ARCCOSINE: + return "math_arccosine"; + case NODE_MATH_ARCTANGENT: + return "math_arctangent"; + case NODE_MATH_ARCTAN2: + return "math_arctan2"; + } + return nullptr; +} + +static int gpu_shader_math(GPUMaterial *mat, + bNode *node, + bNodeExecData *UNUSED(execdata), + GPUNodeStack *in, + GPUNodeStack *out) +{ + const char *name = gpu_shader_get_name(node->custom1); + if (name != nullptr) { + int ret = GPU_stack_link(mat, node, name, in, out); + + if (ret && node->custom2 & SHD_MATH_CLAMP) { + float min[3] = {0.0f, 0.0f, 0.0f}; + float max[3] = {1.0f, 1.0f, 1.0f}; + GPU_link( + mat, "clamp_value", out[0].link, GPU_constant(min), GPU_constant(max), &out[0].link); + } + return ret; + } + else { + return 0; + } +} + +static void sh_node_math_expand_in_mf_network(blender::bke::NodeMFNetworkBuilder &builder) +{ + /* TODO: Implement clamp and other operations. */ + const int mode = builder.bnode().custom1; + switch (mode) { + case NODE_MATH_ADD: { + static blender::fn::CustomMF_SI_SI_SO<float, float, float> fn{ + "Add", [](float a, float b) { return a + b; }}; + builder.set_matching_fn(fn); + break; + } + case NODE_MATH_SUBTRACT: { + static blender::fn::CustomMF_SI_SI_SO<float, float, float> fn{ + "Subtract", [](float a, float b) { return a - b; }}; + builder.set_matching_fn(fn); + break; + } + case NODE_MATH_MULTIPLY: { + static blender::fn::CustomMF_SI_SI_SO<float, float, float> fn{ + "Multiply", [](float a, float b) { return a * b; }}; + builder.set_matching_fn(fn); + break; + } + case NODE_MATH_DIVIDE: { + static blender::fn::CustomMF_SI_SI_SO<float, float, float> fn{ + "Divide", [](float a, float b) { return (b != 0.0f) ? a / b : 0.0f; }}; + builder.set_matching_fn(fn); + break; + } + default: + BLI_assert(false); + break; + } +} + +void register_node_type_sh_math(void) +{ + static bNodeType ntype; + + sh_fn_node_type_base(&ntype, SH_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, 0); + node_type_socket_templates(&ntype, sh_node_math_in, sh_node_math_out); + node_type_label(&ntype, node_math_label); + node_type_gpu(&ntype, gpu_shader_math); + node_type_update(&ntype, node_math_update); + ntype.expand_in_mf_network = sh_node_math_expand_in_mf_network; + + nodeRegisterType(&ntype); +} diff --git a/source/blender/nodes/shader/nodes/node_shader_sepcombXYZ.c b/source/blender/nodes/shader/nodes/node_shader_sepcombXYZ.cc index 429b1a3e818..4dbe10f3982 100644 --- a/source/blender/nodes/shader/nodes/node_shader_sepcombXYZ.c +++ b/source/blender/nodes/shader/nodes/node_shader_sepcombXYZ.cc @@ -44,6 +44,42 @@ static int gpu_shader_sepxyz(GPUMaterial *mat, return GPU_stack_link(mat, node, "separate_xyz", in, out); } +class MF_SeparateXYZ : public blender::fn::MultiFunction { + public: + MF_SeparateXYZ() + { + blender::fn::MFSignatureBuilder signature = this->get_builder("Separate XYZ"); + signature.single_input<blender::float3>("XYZ"); + signature.single_output<float>("X"); + signature.single_output<float>("Y"); + signature.single_output<float>("Z"); + } + + void call(blender::IndexMask mask, + blender::fn::MFParams params, + blender::fn::MFContext UNUSED(context)) const override + { + blender::fn::VSpan<blender::float3> vectors = params.readonly_single_input<blender::float3>( + 0, "XYZ"); + blender::MutableSpan<float> xs = params.uninitialized_single_output<float>(1, "X"); + blender::MutableSpan<float> ys = params.uninitialized_single_output<float>(2, "Y"); + blender::MutableSpan<float> zs = params.uninitialized_single_output<float>(3, "Z"); + + for (uint i : mask) { + blender::float3 xyz = vectors[i]; + xs[i] = xyz.x; + ys[i] = xyz.y; + zs[i] = xyz.z; + } + } +}; + +static void sh_node_sepxyz_expand_in_mf_network(blender::bke::NodeMFNetworkBuilder &builder) +{ + static MF_SeparateXYZ separate_fn; + builder.set_matching_fn(separate_fn); +} + void register_node_type_sh_sepxyz(void) { static bNodeType ntype; @@ -51,6 +87,7 @@ void register_node_type_sh_sepxyz(void) sh_fn_node_type_base(&ntype, SH_NODE_SEPXYZ, "Separate XYZ", NODE_CLASS_CONVERTOR, 0); node_type_socket_templates(&ntype, sh_node_sepxyz_in, sh_node_sepxyz_out); node_type_gpu(&ntype, gpu_shader_sepxyz); + ntype.expand_in_mf_network = sh_node_sepxyz_expand_in_mf_network; nodeRegisterType(&ntype); } @@ -76,6 +113,39 @@ static int gpu_shader_combxyz(GPUMaterial *mat, return GPU_stack_link(mat, node, "combine_xyz", in, out); } +class MF_CombineXYZ : public blender::fn::MultiFunction { + public: + MF_CombineXYZ() + { + blender::fn::MFSignatureBuilder signature = this->get_builder("Combine XYZ"); + signature.single_input<float>("X"); + signature.single_input<float>("Y"); + signature.single_input<float>("Z"); + signature.single_output<blender::float3>("XYZ"); + } + + void call(blender::IndexMask mask, + blender::fn::MFParams params, + blender::fn::MFContext UNUSED(context)) const override + { + blender::fn::VSpan<float> xs = params.readonly_single_input<float>(0, "X"); + blender::fn::VSpan<float> ys = params.readonly_single_input<float>(1, "Y"); + blender::fn::VSpan<float> zs = params.readonly_single_input<float>(2, "Z"); + blender::MutableSpan<blender::float3> vectors = + params.uninitialized_single_output<blender::float3>(3, "XYZ"); + + for (uint i : mask) { + vectors[i] = {xs[i], ys[i], zs[i]}; + } + } +}; + +static void sh_node_combxyz_expand_in_mf_network(blender::bke::NodeMFNetworkBuilder &builder) +{ + static MF_CombineXYZ combine_fn; + builder.set_matching_fn(combine_fn); +} + void register_node_type_sh_combxyz(void) { static bNodeType ntype; @@ -83,6 +153,7 @@ void register_node_type_sh_combxyz(void) sh_fn_node_type_base(&ntype, SH_NODE_COMBXYZ, "Combine XYZ", NODE_CLASS_CONVERTOR, 0); node_type_socket_templates(&ntype, sh_node_combxyz_in, sh_node_combxyz_out); node_type_gpu(&ntype, gpu_shader_combxyz); + ntype.expand_in_mf_network = sh_node_combxyz_expand_in_mf_network; nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_sky.c b/source/blender/nodes/shader/nodes/node_shader_tex_sky.c index 0daa948c139..d2c4413b862 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_sky.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_sky.c @@ -18,6 +18,7 @@ */ #include "../node_shader_util.h" +#include "sky_model.h" /* **************** OUTPUT ******************** */ @@ -43,9 +44,10 @@ static void node_shader_init_tex_sky(bNodeTree *UNUSED(ntree), bNode *node) tex->ground_albedo = 0.3f; tex->sun_disc = true; tex->sun_size = DEG2RADF(0.545); + tex->sun_intensity = 1.0f; tex->sun_elevation = M_PI_2; tex->sun_rotation = 0.0f; - tex->altitude = 0; + tex->altitude = 0.0f; tex->air_density = 1.0f; tex->dust_density = 1.0f; tex->ozone_density = 1.0f; @@ -53,19 +55,172 @@ static void node_shader_init_tex_sky(bNodeTree *UNUSED(ntree), bNode *node) node->storage = tex; } +typedef struct SkyModelPreetham { + float config_Y[5], config_x[5], config_y[5]; /* named after xyY color space */ + float radiance[3]; +} SkyModelPreetham; + +typedef struct XYZ_to_RGB /* transposed imbuf_xyz_to_rgb, passed as 3x vec3 */ +{ + float r[3], g[3], b[3]; +} XYZ_to_RGB; + +static float sky_perez_function(const float *lam, float theta, float gamma) +{ + float ctheta = cosf(theta); + float cgamma = cosf(gamma); + + return (1.0 + lam[0] * expf(lam[1] / ctheta)) * + (1.0 + lam[2] * expf(lam[3] * gamma) + lam[4] * cgamma * cgamma); +} + +static void sky_precompute_old(SkyModelPreetham *sunsky, const float sun_angles[], float turbidity) +{ + float theta = sun_angles[0]; + float theta2 = theta * theta; + float theta3 = theta2 * theta; + float T = turbidity; + float T2 = T * T; + float chi = (4.0f / 9.0f - T / 120.0f) * (M_PI - 2.0f * theta); + + sunsky->radiance[0] = (4.0453f * T - 4.9710f) * tanf(chi) - 0.2155f * T + 2.4192f; + sunsky->radiance[0] *= 0.06f; + + sunsky->radiance[1] = (0.00166f * theta3 - 0.00375f * theta2 + 0.00209f * theta) * T2 + + (-0.02903f * theta3 + 0.06377f * theta2 - 0.03202f * theta + 0.00394f) * + T + + (0.11693f * theta3 - 0.21196f * theta2 + 0.06052f * theta + 0.25886f); + + sunsky->radiance[2] = (0.00275f * theta3 - 0.00610f * theta2 + 0.00317f * theta) * T2 + + (-0.04214f * theta3 + 0.08970f * theta2 - 0.04153f * theta + 0.00516f) * + T + + (0.15346f * theta3 - 0.26756f * theta2 + 0.06670f * theta + 0.26688f); + + sunsky->config_Y[0] = (0.1787f * T - 1.4630f); + sunsky->config_Y[1] = (-0.3554f * T + 0.4275f); + sunsky->config_Y[2] = (-0.0227f * T + 5.3251f); + sunsky->config_Y[3] = (0.1206f * T - 2.5771f); + sunsky->config_Y[4] = (-0.0670f * T + 0.3703f); + + sunsky->config_x[0] = (-0.0193f * T - 0.2592f); + sunsky->config_x[1] = (-0.0665f * T + 0.0008f); + sunsky->config_x[2] = (-0.0004f * T + 0.2125f); + sunsky->config_x[3] = (-0.0641f * T - 0.8989f); + sunsky->config_x[4] = (-0.0033f * T + 0.0452f); + + sunsky->config_y[0] = (-0.0167f * T - 0.2608f); + sunsky->config_y[1] = (-0.0950f * T + 0.0092f); + sunsky->config_y[2] = (-0.0079f * T + 0.2102f); + sunsky->config_y[3] = (-0.0441f * T - 1.6537f); + sunsky->config_y[4] = (-0.0109f * T + 0.0529f); + + sunsky->radiance[0] /= sky_perez_function(sunsky->config_Y, 0, theta); + sunsky->radiance[1] /= sky_perez_function(sunsky->config_x, 0, theta); + sunsky->radiance[2] /= sky_perez_function(sunsky->config_y, 0, theta); +} + +static void get_XYZ_to_RGB_for_gpu(XYZ_to_RGB *data) +{ + const float *xyz_to_rgb = IMB_colormangement_get_xyz_to_rgb(); + data->r[0] = xyz_to_rgb[0]; + data->r[1] = xyz_to_rgb[3]; + data->r[2] = xyz_to_rgb[6]; + data->g[0] = xyz_to_rgb[1]; + data->g[1] = xyz_to_rgb[4]; + data->g[2] = xyz_to_rgb[7]; + data->b[0] = xyz_to_rgb[2]; + data->b[1] = xyz_to_rgb[5]; + data->b[2] = xyz_to_rgb[8]; +} + static int node_shader_gpu_tex_sky(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { - if (!in[0].link) { - in[0].link = GPU_attribute(mat, CD_ORCO, ""); + node_shader_gpu_default_tex_coord(mat, node, &in[0].link); + node_shader_gpu_tex_mapping(mat, node, in, out); + NodeTexSky *tex = (NodeTexSky *)node->storage; + float sun_angles[2]; /* [0]=theta=zenith angle [1]=phi=azimuth */ + sun_angles[0] = acosf(tex->sun_direction[2]); + sun_angles[1] = atan2f(tex->sun_direction[0], tex->sun_direction[1]); + + if (tex->sky_model == 0) { + /* Preetham */ + SkyModelPreetham sunsky; + sky_precompute_old(&sunsky, sun_angles, tex->turbidity); + XYZ_to_RGB xyz_to_rgb; + get_XYZ_to_RGB_for_gpu(&xyz_to_rgb); + return GPU_stack_link(mat, + node, + "node_tex_sky_preetham", + in, + out, + /* Pass config_Y/x/y as 3x(vec4+float) */ + GPU_uniform(&sunsky.config_Y[0]), + GPU_uniform(&sunsky.config_Y[4]), + GPU_uniform(&sunsky.config_x[0]), + GPU_uniform(&sunsky.config_x[4]), + GPU_uniform(&sunsky.config_y[0]), + GPU_uniform(&sunsky.config_y[4]), + GPU_uniform(sun_angles), + GPU_uniform(sunsky.radiance), + GPU_uniform(xyz_to_rgb.r), + GPU_uniform(xyz_to_rgb.g), + GPU_uniform(xyz_to_rgb.b)); + } + else if (tex->sky_model == 1) { + /* Hosek / Wilkie */ + sun_angles[0] = fmin(M_PI_2, sun_angles[0]); /* clamp to horizon */ + SKY_ArHosekSkyModelState *sky_state = SKY_arhosek_xyz_skymodelstate_alloc_init( + tex->turbidity, tex->ground_albedo, fmax(0.0, M_PI_2 - sun_angles[0])); + /* Pass sky_state->configs[3][9] as 3*(vec4+vec4)+vec3 */ + float config_x07[8], config_y07[8], config_z07[8], config_xyz8[3]; + for (int i = 0; i < 8; ++i) { + config_x07[i] = (float)sky_state->configs[0][i]; + config_y07[i] = (float)sky_state->configs[1][i]; + config_z07[i] = (float)sky_state->configs[2][i]; + } + for (int i = 0; i < 3; ++i) { + config_xyz8[i] = (float)sky_state->configs[i][8]; + } + float radiance[3]; + for (int i = 0; i < 3; i++) { + radiance[i] = sky_state->radiances[i] * (2 * M_PI / 683); + } + SKY_arhosekskymodelstate_free(sky_state); + XYZ_to_RGB xyz_to_rgb; + get_XYZ_to_RGB_for_gpu(&xyz_to_rgb); + return GPU_stack_link(mat, + node, + "node_tex_sky_hosekwilkie", + in, + out, + GPU_uniform(&config_x07[0]), + GPU_uniform(&config_x07[4]), + GPU_uniform(&config_y07[0]), + GPU_uniform(&config_y07[4]), + GPU_uniform(&config_z07[0]), + GPU_uniform(&config_z07[4]), + GPU_uniform(config_xyz8), + GPU_uniform(sun_angles), + GPU_uniform(radiance), + GPU_uniform(xyz_to_rgb.r), + GPU_uniform(xyz_to_rgb.g), + GPU_uniform(xyz_to_rgb.b)); + } + else { + return GPU_stack_link(mat, node, "node_tex_sky_nishita", in, out); } +} - node_shader_gpu_tex_mapping(mat, node, in, out); +static void node_shader_update_sky(bNodeTree *UNUSED(ntree), bNode *node) +{ + bNodeSocket *sockVector = nodeFindSocket(node, SOCK_IN, "Vector"); - return GPU_stack_link(mat, node, "node_tex_sky", in, out); + NodeTexSky *tex = (NodeTexSky *)node->storage; + nodeSetSocketAvailability(sockVector, !(tex->sky_model == 2 && tex->sun_disc == 1)); } /* node type definition */ @@ -79,6 +234,8 @@ void register_node_type_sh_tex_sky(void) node_type_init(&ntype, node_shader_init_tex_sky); node_type_storage(&ntype, "NodeTexSky", node_free_standard_storage, node_copy_standard_storage); node_type_gpu(&ntype, node_shader_gpu_tex_sky); + /* remove Vector input for Nishita */ + node_type_update(&ntype, node_shader_update_sky); nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_value.c b/source/blender/nodes/shader/nodes/node_shader_value.cc index c32e9e1d581..64701018d63 100644 --- a/source/blender/nodes/shader/nodes/node_shader_value.c +++ b/source/blender/nodes/shader/nodes/node_shader_value.cc @@ -39,13 +39,21 @@ static int gpu_shader_value(GPUMaterial *mat, return GPU_stack_link(mat, node, "set_value", in, out, link); } +static void sh_node_value_expand_in_mf_network(blender::bke::NodeMFNetworkBuilder &builder) +{ + const bNodeSocket *bsocket = builder.dnode().output(0).bsocket(); + const bNodeSocketValueFloat *value = (const bNodeSocketValueFloat *)bsocket->default_value; + builder.construct_and_set_matching_fn<blender::fn::CustomMF_Constant<float>>(value->value); +} + void register_node_type_sh_value(void) { static bNodeType ntype; - sh_node_type_base(&ntype, SH_NODE_VALUE, "Value", NODE_CLASS_INPUT, 0); + sh_fn_node_type_base(&ntype, SH_NODE_VALUE, "Value", NODE_CLASS_INPUT, 0); node_type_socket_templates(&ntype, NULL, sh_node_value_out); node_type_gpu(&ntype, gpu_shader_value); + ntype.expand_in_mf_network = sh_node_value_expand_in_mf_network; nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_vector_math.c b/source/blender/nodes/shader/nodes/node_shader_vector_math.cc index b719fe03d9b..414d05e996a 100644 --- a/source/blender/nodes/shader/nodes/node_shader_vector_math.c +++ b/source/blender/nodes/shader/nodes/node_shader_vector_math.cc @@ -34,44 +34,74 @@ static bNodeSocketTemplate sh_node_vector_math_in[] = { static bNodeSocketTemplate sh_node_vector_math_out[] = { {SOCK_VECTOR, N_("Vector")}, {SOCK_FLOAT, N_("Value")}, {-1, ""}}; +static const char *gpu_shader_get_name(int mode) +{ + switch (mode) { + case NODE_VECTOR_MATH_ADD: + return "vector_math_add"; + case NODE_VECTOR_MATH_SUBTRACT: + return "vector_math_subtract"; + case NODE_VECTOR_MATH_MULTIPLY: + return "vector_math_multiply"; + case NODE_VECTOR_MATH_DIVIDE: + return "vector_math_divide"; + + case NODE_VECTOR_MATH_CROSS_PRODUCT: + return "vector_math_cross"; + case NODE_VECTOR_MATH_PROJECT: + return "vector_math_project"; + case NODE_VECTOR_MATH_REFLECT: + return "vector_math_reflect"; + case NODE_VECTOR_MATH_DOT_PRODUCT: + return "vector_math_dot"; + + case NODE_VECTOR_MATH_DISTANCE: + return "vector_math_distance"; + case NODE_VECTOR_MATH_LENGTH: + return "vector_math_length"; + case NODE_VECTOR_MATH_SCALE: + return "vector_math_scale"; + case NODE_VECTOR_MATH_NORMALIZE: + return "vector_math_normalize"; + + case NODE_VECTOR_MATH_SNAP: + return "vector_math_snap"; + case NODE_VECTOR_MATH_FLOOR: + return "vector_math_floor"; + case NODE_VECTOR_MATH_CEIL: + return "vector_math_ceil"; + case NODE_VECTOR_MATH_MODULO: + return "vector_math_modulo"; + case NODE_VECTOR_MATH_FRACTION: + return "vector_math_fraction"; + case NODE_VECTOR_MATH_ABSOLUTE: + return "vector_math_absolute"; + case NODE_VECTOR_MATH_MINIMUM: + return "vector_math_minimum"; + case NODE_VECTOR_MATH_MAXIMUM: + return "vector_math_maximum"; + case NODE_VECTOR_MATH_WRAP: + return "vector_math_wrap"; + case NODE_VECTOR_MATH_SINE: + return "vector_math_sine"; + case NODE_VECTOR_MATH_COSINE: + return "vector_math_cosine"; + case NODE_VECTOR_MATH_TANGENT: + return "vector_math_tangent"; + } + + return nullptr; +} + static int gpu_shader_vector_math(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { - static const char *names[] = { - [NODE_VECTOR_MATH_ADD] = "vector_math_add", - [NODE_VECTOR_MATH_SUBTRACT] = "vector_math_subtract", - [NODE_VECTOR_MATH_MULTIPLY] = "vector_math_multiply", - [NODE_VECTOR_MATH_DIVIDE] = "vector_math_divide", - - [NODE_VECTOR_MATH_CROSS_PRODUCT] = "vector_math_cross", - [NODE_VECTOR_MATH_PROJECT] = "vector_math_project", - [NODE_VECTOR_MATH_REFLECT] = "vector_math_reflect", - [NODE_VECTOR_MATH_DOT_PRODUCT] = "vector_math_dot", - - [NODE_VECTOR_MATH_DISTANCE] = "vector_math_distance", - [NODE_VECTOR_MATH_LENGTH] = "vector_math_length", - [NODE_VECTOR_MATH_SCALE] = "vector_math_scale", - [NODE_VECTOR_MATH_NORMALIZE] = "vector_math_normalize", - - [NODE_VECTOR_MATH_SNAP] = "vector_math_snap", - [NODE_VECTOR_MATH_FLOOR] = "vector_math_floor", - [NODE_VECTOR_MATH_CEIL] = "vector_math_ceil", - [NODE_VECTOR_MATH_MODULO] = "vector_math_modulo", - [NODE_VECTOR_MATH_FRACTION] = "vector_math_fraction", - [NODE_VECTOR_MATH_ABSOLUTE] = "vector_math_absolute", - [NODE_VECTOR_MATH_MINIMUM] = "vector_math_minimum", - [NODE_VECTOR_MATH_MAXIMUM] = "vector_math_maximum", - [NODE_VECTOR_MATH_WRAP] = "vector_math_wrap", - [NODE_VECTOR_MATH_SINE] = "vector_math_sine", - [NODE_VECTOR_MATH_COSINE] = "vector_math_cosine", - [NODE_VECTOR_MATH_TANGENT] = "vector_math_tangent", - }; - - if (node->custom1 < ARRAY_SIZE(names) && names[node->custom1]) { - return GPU_stack_link(mat, node, names[node->custom1], in, out); + const char *name = gpu_shader_get_name(node->custom1); + if (name != nullptr) { + return GPU_stack_link(mat, node, name, in, out); } else { return 0; @@ -80,8 +110,8 @@ static int gpu_shader_vector_math(GPUMaterial *mat, static void node_shader_update_vector_math(bNodeTree *UNUSED(ntree), bNode *node) { - bNodeSocket *sockB = BLI_findlink(&node->inputs, 1); - bNodeSocket *sockC = BLI_findlink(&node->inputs, 2); + bNodeSocket *sockB = (bNodeSocket *)BLI_findlink(&node->inputs, 1); + bNodeSocket *sockC = (bNodeSocket *)BLI_findlink(&node->inputs, 2); bNodeSocket *sockScale = nodeFindSocket(node, SOCK_IN, "Scale"); bNodeSocket *sockVector = nodeFindSocket(node, SOCK_OUT, "Vector"); @@ -130,6 +160,43 @@ static void node_shader_update_vector_math(bNodeTree *UNUSED(ntree), bNode *node } } +static void sh_node_vector_math_expand_in_mf_network(blender::bke::NodeMFNetworkBuilder &builder) +{ + using blender::float3; + + /* TODO: Implement other operations. */ + const int mode = builder.bnode().custom1; + switch (mode) { + case NODE_VECTOR_MATH_ADD: { + static blender::fn::CustomMF_SI_SI_SO<float3, float3, float3> fn{ + "Add", [](float3 a, float3 b) { return a + b; }}; + builder.set_matching_fn(fn); + break; + } + case NODE_VECTOR_MATH_SUBTRACT: { + static blender::fn::CustomMF_SI_SI_SO<float3, float3, float3> fn{ + "Subtract", [](float3 a, float3 b) { return a - b; }}; + builder.set_matching_fn(fn); + break; + } + case NODE_VECTOR_MATH_MULTIPLY: { + static blender::fn::CustomMF_SI_SI_SO<float3, float3, float3> fn{ + "Multiply", [](float3 a, float3 b) { return a * b; }}; + builder.set_matching_fn(fn); + break; + } + case NODE_VECTOR_MATH_DIVIDE: { + static blender::fn::CustomMF_SI_SI_SO<float3, float3, float3> fn{ + "Divide", [](float3 a, float3 b) { return float3::safe_divide(a, b); }}; + builder.set_matching_fn(fn); + break; + } + default: + BLI_assert(false); + break; + }; +} + void register_node_type_sh_vect_math(void) { static bNodeType ntype; @@ -139,6 +206,7 @@ void register_node_type_sh_vect_math(void) node_type_label(&ntype, node_vector_math_label); node_type_gpu(&ntype, gpu_shader_vector_math); node_type_update(&ntype, node_shader_update_vector_math); + ntype.expand_in_mf_network = sh_node_vector_math_expand_in_mf_network; nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_vertex_color.c b/source/blender/nodes/shader/nodes/node_shader_vertex_color.c index 70c924a7f85..40576b68dd5 100644 --- a/source/blender/nodes/shader/nodes/node_shader_vertex_color.c +++ b/source/blender/nodes/shader/nodes/node_shader_vertex_color.c @@ -39,6 +39,10 @@ static int node_shader_gpu_vertex_color(GPUMaterial *mat, GPUNodeStack *out) { NodeShaderVertexColor *vertexColor = (NodeShaderVertexColor *)node->storage; + if (U.experimental.use_sculpt_vertex_colors) { + GPUNodeLink *vertexColorLink = GPU_attribute(mat, CD_PROP_COLOR, vertexColor->layer_name); + return GPU_stack_link(mat, node, "node_vertex_color", in, out, vertexColorLink); + } GPUNodeLink *vertexColorLink = GPU_attribute(mat, CD_MCOL, vertexColor->layer_name); return GPU_stack_link(mat, node, "node_vertex_color", in, out, vertexColorLink); } |