1
1

Compare commits

...

4 Commits

Author SHA1 Message Date
6feb56e6da add cmake changes 2021-11-05 14:48:22 +01:00
f64859da9a fix 2021-11-05 14:46:42 +01:00
f8d2e14709 cleanup 2021-11-05 14:46:32 +01:00
371abaf66c prepare for unity builds 2021-11-05 13:11:26 +01:00
79 changed files with 902 additions and 1005 deletions

View File

@@ -14,6 +14,8 @@
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#pragma once
#include "BLI_span.hh"
#include "DNA_modifier_types.h"

View File

@@ -5703,52 +5703,52 @@ static void registerShaderNodes()
static void registerTextureNodes()
{
register_node_type_tex_group();
// register_node_type_tex_group();
register_node_type_tex_math();
register_node_type_tex_mix_rgb();
register_node_type_tex_valtorgb();
register_node_type_tex_rgbtobw();
register_node_type_tex_valtonor();
register_node_type_tex_curve_rgb();
register_node_type_tex_curve_time();
register_node_type_tex_invert();
register_node_type_tex_hue_sat();
register_node_type_tex_coord();
register_node_type_tex_distance();
register_node_type_tex_compose();
register_node_type_tex_decompose();
// register_node_type_tex_math();
// register_node_type_tex_mix_rgb();
// register_node_type_tex_valtorgb();
// register_node_type_tex_rgbtobw();
// register_node_type_tex_valtonor();
// register_node_type_tex_curve_rgb();
// register_node_type_tex_curve_time();
// register_node_type_tex_invert();
// register_node_type_tex_hue_sat();
// register_node_type_tex_coord();
// register_node_type_tex_distance();
// register_node_type_tex_compose();
// register_node_type_tex_decompose();
register_node_type_tex_output();
register_node_type_tex_viewer();
register_node_type_sh_script();
register_node_type_sh_tangent();
register_node_type_sh_normal_map();
register_node_type_sh_hair_info();
register_node_type_sh_volume_info();
// register_node_type_tex_output();
// register_node_type_tex_viewer();
// register_node_type_sh_script();
// register_node_type_sh_tangent();
// register_node_type_sh_normal_map();
// register_node_type_sh_hair_info();
// register_node_type_sh_volume_info();
register_node_type_tex_checker();
register_node_type_tex_texture();
register_node_type_tex_bricks();
register_node_type_tex_image();
register_node_type_sh_bsdf_refraction();
register_node_type_sh_ambient_occlusion();
// register_node_type_tex_checker();
// register_node_type_tex_texture();
// register_node_type_tex_bricks();
// register_node_type_tex_image();
// register_node_type_sh_bsdf_refraction();
// register_node_type_sh_ambient_occlusion();
register_node_type_tex_rotate();
register_node_type_tex_translate();
register_node_type_tex_scale();
register_node_type_tex_at();
// register_node_type_tex_rotate();
// register_node_type_tex_translate();
// register_node_type_tex_scale();
// register_node_type_tex_at();
register_node_type_tex_proc_voronoi();
register_node_type_tex_proc_blend();
register_node_type_tex_proc_magic();
register_node_type_tex_proc_marble();
register_node_type_tex_proc_clouds();
register_node_type_tex_proc_wood();
register_node_type_tex_proc_musgrave();
register_node_type_tex_proc_noise();
register_node_type_tex_proc_stucci();
register_node_type_tex_proc_distnoise();
// register_node_type_tex_proc_voronoi();
// register_node_type_tex_proc_blend();
// register_node_type_tex_proc_magic();
// register_node_type_tex_proc_marble();
// register_node_type_tex_proc_clouds();
// register_node_type_tex_proc_wood();
// register_node_type_tex_proc_musgrave();
// register_node_type_tex_proc_noise();
// register_node_type_tex_proc_stucci();
// register_node_type_tex_proc_distnoise();
}
static void registerGeometryNodes()

View File

@@ -389,29 +389,29 @@ set(SRC
shader/node_shader_tree.c
shader/node_shader_util.c
texture/nodes/node_texture_at.c
texture/nodes/node_texture_bricks.c
texture/nodes/node_texture_checker.c
texture/nodes/node_texture_common.c
texture/nodes/node_texture_compose.c
texture/nodes/node_texture_coord.c
texture/nodes/node_texture_curves.c
texture/nodes/node_texture_decompose.c
texture/nodes/node_texture_distance.c
texture/nodes/node_texture_hueSatVal.c
texture/nodes/node_texture_image.c
texture/nodes/node_texture_invert.c
texture/nodes/node_texture_math.c
texture/nodes/node_texture_mixRgb.c
texture/nodes/node_texture_output.c
texture/nodes/node_texture_proc.c
texture/nodes/node_texture_rotate.c
texture/nodes/node_texture_scale.c
texture/nodes/node_texture_texture.c
texture/nodes/node_texture_translate.c
texture/nodes/node_texture_valToNor.c
texture/nodes/node_texture_valToRgb.c
texture/nodes/node_texture_viewer.c
# texture/nodes/node_texture_at.c
# texture/nodes/node_texture_bricks.c
# texture/nodes/node_texture_checker.c
# texture/nodes/node_texture_common.c
# texture/nodes/node_texture_compose.c
# texture/nodes/node_texture_coord.c
# texture/nodes/node_texture_curves.c
# texture/nodes/node_texture_decompose.c
# texture/nodes/node_texture_distance.c
# texture/nodes/node_texture_hueSatVal.c
# texture/nodes/node_texture_image.c
# texture/nodes/node_texture_invert.c
# texture/nodes/node_texture_math.c
# texture/nodes/node_texture_mixRgb.c
# texture/nodes/node_texture_output.c
# texture/nodes/node_texture_proc.c
# texture/nodes/node_texture_rotate.c
# texture/nodes/node_texture_scale.c
# texture/nodes/node_texture_texture.c
# texture/nodes/node_texture_translate.c
# texture/nodes/node_texture_valToNor.c
# texture/nodes/node_texture_valToRgb.c
# texture/nodes/node_texture_viewer.c
texture/node_texture_tree.c
texture/node_texture_util.c
@@ -552,3 +552,20 @@ if(WITH_OPENVDB)
endif()
blender_add_lib(bf_nodes "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")
if (${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.16")
set_target_properties(bf_nodes PROPERTIES UNITY_BUILD ON)
set_target_properties(bf_nodes PROPERTIES UNITY_BUILD_BATCH_SIZE 10)
# target_precompile_headers(bf_nodes
# PRIVATE
# "$<$<COMPILE_LANGUAGE:CXX>:${CMAKE_CURRENT_SOURCE_DIR}/geometry/node_geometry_util.hh>"
# "$<$<COMPILE_LANGUAGE:CXX>:${CMAKE_CURRENT_SOURCE_DIR}/NOD_geometry_exec.hh>"
# "$<$<COMPILE_LANGUAGE:CXX>:${CMAKE_CURRENT_SOURCE_DIR}/NOD_geometry_nodes_eval_log.hh>"
# )
# if(WIN32)
# target_precompile_headers(bf_nodes
# PRIVATE
# "$<$<COMPILE_LANGUAGE:CXX>:bli_winstuff.h>"
# )
# endif()
endif()

View File

@@ -60,7 +60,9 @@ static void composite_get_from_context(const bContext *C,
*r_ntree = scene->nodetree;
}
static void foreach_nodeclass(Scene *UNUSED(scene), void *calldata, bNodeClassCallback func)
static void composite_foreach_nodeclass(Scene *UNUSED(scene),
void *calldata,
bNodeClassCallback func)
{
func(calldata, NODE_CLASS_INPUT, N_("Input"));
func(calldata, NODE_CLASS_OUTPUT, N_("Output"));
@@ -75,7 +77,7 @@ static void foreach_nodeclass(Scene *UNUSED(scene), void *calldata, bNodeClassCa
func(calldata, NODE_CLASS_LAYOUT, N_("Layout"));
}
static void free_node_cache(bNodeTree *UNUSED(ntree), bNode *node)
static void composite_free_node_cache(bNodeTree *UNUSED(ntree), bNode *node)
{
LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
if (sock->cache) {
@@ -84,15 +86,15 @@ static void free_node_cache(bNodeTree *UNUSED(ntree), bNode *node)
}
}
static void free_cache(bNodeTree *ntree)
static void composite_free_cache(bNodeTree *ntree)
{
LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
free_node_cache(ntree, node);
composite_free_node_cache(ntree, node);
}
}
/* local tree then owns all compbufs */
static void localize(bNodeTree *localtree, bNodeTree *ntree)
static void composite_localize(bNodeTree *localtree, bNodeTree *ntree)
{
bNode *node = (bNode *)ntree->nodes.first;
@@ -135,12 +137,12 @@ static void localize(bNodeTree *localtree, bNodeTree *ntree)
}
}
static void local_sync(bNodeTree *localtree, bNodeTree *ntree)
static void composite_local_sync(bNodeTree *localtree, bNodeTree *ntree)
{
BKE_node_preview_sync_tree(ntree, localtree);
}
static void local_merge(Main *bmain, bNodeTree *localtree, bNodeTree *ntree)
static void composite_local_merge(Main *bmain, bNodeTree *localtree, bNodeTree *ntree)
{
bNode *lnode;
bNodeSocket *lsock;
@@ -181,7 +183,7 @@ static void local_merge(Main *bmain, bNodeTree *localtree, bNodeTree *ntree)
}
}
static void update(bNodeTree *ntree)
static void composite_update(bNodeTree *ntree)
{
ntreeSetOutput(ntree);
@@ -223,13 +225,13 @@ void register_node_tree_type_cmp(void)
tt->ui_icon = 0; /* Defined in `drawnode.c`. */
strcpy(tt->ui_description, N_("Compositing nodes"));
tt->free_cache = free_cache;
tt->free_node_cache = free_node_cache;
tt->foreach_nodeclass = foreach_nodeclass;
tt->localize = localize;
tt->local_sync = local_sync;
tt->local_merge = local_merge;
tt->update = update;
tt->free_cache = composite_free_cache;
tt->free_node_cache = composite_free_node_cache;
tt->foreach_nodeclass = composite_foreach_nodeclass;
tt->localize = composite_localize;
tt->local_sync = composite_local_sync;
tt->local_merge = composite_local_merge;
tt->update = composite_update;
tt->get_from_context = composite_get_from_context;
tt->node_add_init = composite_node_add_init;
tt->valid_socket_type = composite_node_tree_socket_type_valid;

View File

@@ -40,7 +40,7 @@ static void cmp_node_movieclip_declare(NodeDeclarationBuilder &b)
} // namespace blender::nodes
static void init(const bContext *C, PointerRNA *ptr)
static void cmp_node_movieclip_init(const bContext *C, PointerRNA *ptr)
{
bNode *node = (bNode *)ptr->data;
Scene *scene = CTX_data_scene(C);
@@ -59,7 +59,7 @@ void register_node_type_cmp_movieclip(void)
cmp_node_type_base(&ntype, CMP_NODE_MOVIECLIP, "Movie Clip", NODE_CLASS_INPUT, NODE_PREVIEW);
ntype.declare = blender::nodes::cmp_node_movieclip_declare;
ntype.initfunc_api = init;
ntype.initfunc_api = cmp_node_movieclip_init;
node_type_storage(
&ntype, "MovieClipUser", node_free_standard_storage, node_copy_standard_storage);

View File

@@ -38,7 +38,10 @@ static bNodeSocketTemplate cmp_node_moviedistortion_out[] = {
{-1, ""},
};
static void label(bNodeTree *UNUSED(ntree), bNode *node, char *label, int maxlen)
static void cmp_node_moviedistortion_label(bNodeTree *UNUSED(ntree),
bNode *node,
char *label,
int maxlen)
{
if (node->custom1 == 0) {
BLI_strncpy(label, IFACE_("Undistortion"), maxlen);
@@ -48,7 +51,7 @@ static void label(bNodeTree *UNUSED(ntree), bNode *node, char *label, int maxlen
}
}
static void init(const bContext *C, PointerRNA *ptr)
static void cmp_node_moviedistortion_init(const bContext *C, PointerRNA *ptr)
{
bNode *node = (bNode *)ptr->data;
Scene *scene = CTX_data_scene(C);
@@ -57,7 +60,7 @@ static void init(const bContext *C, PointerRNA *ptr)
id_us_plus(node->id);
}
static void storage_free(bNode *node)
static void cmp_node_moviedistortion_storage_free(bNode *node)
{
if (node->storage) {
BKE_tracking_distortion_free((MovieDistortion *)node->storage);
@@ -66,7 +69,9 @@ static void storage_free(bNode *node)
node->storage = nullptr;
}
static void storage_copy(bNodeTree *UNUSED(dest_ntree), bNode *dest_node, const bNode *src_node)
static void cmp_node_moviedistortion_storage_copy(bNodeTree *UNUSED(dest_ntree),
bNode *dest_node,
const bNode *src_node)
{
if (src_node->storage) {
dest_node->storage = BKE_tracking_distortion_copy((MovieDistortion *)src_node->storage);
@@ -79,10 +84,13 @@ void register_node_type_cmp_moviedistortion(void)
cmp_node_type_base(&ntype, CMP_NODE_MOVIEDISTORTION, "Movie Distortion", NODE_CLASS_DISTORT, 0);
node_type_socket_templates(&ntype, cmp_node_moviedistortion_in, cmp_node_moviedistortion_out);
node_type_label(&ntype, label);
node_type_label(&ntype, cmp_node_moviedistortion_label);
ntype.initfunc_api = init;
node_type_storage(&ntype, nullptr, storage_free, storage_copy);
ntype.initfunc_api = cmp_node_moviedistortion_init;
node_type_storage(&ntype,
nullptr,
cmp_node_moviedistortion_storage_free,
cmp_node_moviedistortion_storage_copy);
nodeRegisterType(&ntype);
}

View File

@@ -32,7 +32,7 @@ static bNodeSocketTemplate cmp_node_planetrackdeform_out[] = {
{-1, ""},
};
static void init(bNodeTree *UNUSED(ntree), bNode *node)
static void node_cmp_planetrackdeform_init(bNodeTree *UNUSED(ntree), bNode *node)
{
NodePlaneTrackDeformData *data = (NodePlaneTrackDeformData *)MEM_callocN(
sizeof(NodePlaneTrackDeformData), "node plane track deform data");
@@ -48,7 +48,7 @@ void register_node_type_cmp_planetrackdeform(void)
cmp_node_type_base(
&ntype, CMP_NODE_PLANETRACKDEFORM, "Plane Track Deform", NODE_CLASS_DISTORT, 0);
node_type_socket_templates(&ntype, cmp_node_planetrackdeform_in, cmp_node_planetrackdeform_out);
node_type_init(&ntype, init);
node_type_init(&ntype, node_cmp_planetrackdeform_init);
node_type_storage(
&ntype, "NodePlaneTrackDeformData", node_free_standard_storage, node_copy_standard_storage);

View File

@@ -38,7 +38,7 @@ static bNodeSocketTemplate cmp_node_stabilize2d_out[] = {
{-1, ""},
};
static void init(const bContext *C, PointerRNA *ptr)
static void node_cmp_stabilize2d_init(const bContext *C, PointerRNA *ptr)
{
bNode *node = (bNode *)ptr->data;
Scene *scene = CTX_data_scene(C);
@@ -56,7 +56,7 @@ void register_node_type_cmp_stabilize2d(void)
cmp_node_type_base(&ntype, CMP_NODE_STABILIZE2D, "Stabilize 2D", NODE_CLASS_DISTORT, 0);
node_type_socket_templates(&ntype, cmp_node_stabilize2d_in, cmp_node_stabilize2d_out);
ntype.initfunc_api = init;
ntype.initfunc_api = node_cmp_stabilize2d_init;
nodeRegisterType(&ntype);
}

View File

@@ -23,16 +23,16 @@
#include "node_composite_util.hh"
static bNodeSocketTemplate inputs[] = {
static bNodeSocketTemplate node_cmp_sunbeams_inputs[] = {
{SOCK_RGBA, N_("Image"), 1.0f, 1.0f, 1.0f, 1.0f},
{-1, ""},
};
static bNodeSocketTemplate outputs[] = {
static bNodeSocketTemplate node_cmp_sunbeams_outputs[] = {
{SOCK_RGBA, N_("Image")},
{-1, ""},
};
static void init(bNodeTree *UNUSED(ntree), bNode *node)
static void node_cmp_sunbeams_init(bNodeTree *UNUSED(ntree), bNode *node)
{
NodeSunBeams *data = (NodeSunBeams *)MEM_callocN(sizeof(NodeSunBeams), "sun beams node");
@@ -46,8 +46,8 @@ void register_node_type_cmp_sunbeams(void)
static bNodeType ntype;
cmp_node_type_base(&ntype, CMP_NODE_SUNBEAMS, "Sun Beams", NODE_CLASS_OP_FILTER, 0);
node_type_socket_templates(&ntype, inputs, outputs);
node_type_init(&ntype, init);
node_type_socket_templates(&ntype, node_cmp_sunbeams_inputs, node_cmp_sunbeams_outputs);
node_type_init(&ntype, node_cmp_sunbeams_init);
node_type_storage(
&ntype, "NodeSunBeams", node_free_standard_storage, node_copy_standard_storage);

View File

@@ -34,7 +34,7 @@ static void cmp_node_trackpos_declare(NodeDeclarationBuilder &b)
} // namespace blender::nodes
static void init(bNodeTree *UNUSED(ntree), bNode *node)
static void cmp_node_trackpos_init(bNodeTree *UNUSED(ntree), bNode *node)
{
NodeTrackPosData *data = (NodeTrackPosData *)MEM_callocN(sizeof(NodeTrackPosData),
"node track position data");
@@ -48,7 +48,7 @@ void register_node_type_cmp_trackpos(void)
cmp_node_type_base(&ntype, CMP_NODE_TRACKPOS, "Track Position", NODE_CLASS_INPUT, 0);
ntype.declare = blender::nodes::cmp_node_trackpos_declare;
node_type_init(&ntype, init);
node_type_init(&ntype, cmp_node_trackpos_init);
node_type_storage(
&ntype, "NodeTrackPosData", node_free_standard_storage, node_copy_standard_storage);

View File

@@ -24,7 +24,7 @@
#include "node_function_util.hh"
namespace blender::nodes {
namespace blender::nodes::boolean_math_node {
static void fn_node_boolean_math_declare(NodeDeclarationBuilder &b)
{
@@ -84,17 +84,18 @@ static void fn_node_boolean_math_build_multi_function(NodeMultiFunctionBuilder &
builder.set_matching_fn(fn);
}
} // namespace blender::nodes
} // namespace blender::nodes::boolean_math_node
void register_node_type_fn_boolean_math()
{
static bNodeType ntype;
fn_node_type_base(&ntype, FN_NODE_BOOLEAN_MATH, "Boolean Math", NODE_CLASS_CONVERTER, 0);
ntype.declare = blender::nodes::fn_node_boolean_math_declare;
node_type_label(&ntype, blender::nodes::node_boolean_math_label);
node_type_update(&ntype, blender::nodes::node_boolean_math_update);
ntype.build_multi_function = blender::nodes::fn_node_boolean_math_build_multi_function;
ntype.draw_buttons = blender::nodes::fn_node_boolean_math_layout;
ntype.declare = blender::nodes::boolean_math_node::fn_node_boolean_math_declare;
node_type_label(&ntype, blender::nodes::boolean_math_node::node_boolean_math_label);
node_type_update(&ntype, blender::nodes::boolean_math_node::node_boolean_math_update);
ntype.build_multi_function =
blender::nodes::boolean_math_node::fn_node_boolean_math_build_multi_function;
ntype.draw_buttons = blender::nodes::boolean_math_node::fn_node_boolean_math_layout;
nodeRegisterType(&ntype);
}

View File

@@ -26,7 +26,7 @@
#include "node_function_util.hh"
namespace blender::nodes {
namespace blender::nodes::float_compare_node {
static void fn_node_float_compare_declare(NodeDeclarationBuilder &b)
{
@@ -103,17 +103,18 @@ static void fn_node_float_compare_build_multi_function(NodeMultiFunctionBuilder
builder.set_matching_fn(fn);
}
} // namespace blender::nodes
} // namespace blender::nodes::float_compare_node
void register_node_type_fn_float_compare()
{
static bNodeType ntype;
fn_node_type_base(&ntype, FN_NODE_COMPARE_FLOATS, "Compare Floats", NODE_CLASS_CONVERTER, 0);
ntype.declare = blender::nodes::fn_node_float_compare_declare;
node_type_label(&ntype, blender::nodes::node_float_compare_label);
node_type_update(&ntype, blender::nodes::node_float_compare_update);
ntype.build_multi_function = blender::nodes::fn_node_float_compare_build_multi_function;
ntype.draw_buttons = blender::nodes::geo_node_float_compare_layout;
ntype.declare = blender::nodes::float_compare_node::fn_node_float_compare_declare;
node_type_label(&ntype, blender::nodes::float_compare_node::node_float_compare_label);
node_type_update(&ntype, blender::nodes::float_compare_node::node_float_compare_update);
ntype.build_multi_function =
blender::nodes::float_compare_node::fn_node_float_compare_build_multi_function;
ntype.draw_buttons = blender::nodes::float_compare_node::geo_node_float_compare_layout;
nodeRegisterType(&ntype);
}

View File

@@ -25,7 +25,7 @@
#include "node_function_util.hh"
namespace blender::nodes {
namespace blender::nodes::float_to_int_node {
static void fn_node_float_to_int_declare(NodeDeclarationBuilder &b)
{
@@ -78,16 +78,17 @@ static void fn_node_float_to_int_build_multi_function(NodeMultiFunctionBuilder &
builder.set_matching_fn(fn);
}
} // namespace blender::nodes
} // namespace blender::nodes::float_to_int_node
void register_node_type_fn_float_to_int()
{
static bNodeType ntype;
fn_node_type_base(&ntype, FN_NODE_FLOAT_TO_INT, "Float to Integer", NODE_CLASS_CONVERTER, 0);
ntype.declare = blender::nodes::fn_node_float_to_int_declare;
node_type_label(&ntype, blender::nodes::node_float_to_int_label);
ntype.build_multi_function = blender::nodes::fn_node_float_to_int_build_multi_function;
ntype.draw_buttons = blender::nodes::fn_node_float_to_int_layout;
ntype.declare = blender::nodes::float_to_int_node::fn_node_float_to_int_declare;
node_type_label(&ntype, blender::nodes::float_to_int_node::node_float_to_int_label);
ntype.build_multi_function =
blender::nodes::float_to_int_node::fn_node_float_to_int_build_multi_function;
ntype.draw_buttons = blender::nodes::float_to_int_node::fn_node_float_to_int_layout;
nodeRegisterType(&ntype);
}

View File

@@ -24,7 +24,7 @@
#include "node_function_util.hh"
namespace blender::nodes {
namespace blender::nodes::rotate_euler_node {
static void fn_node_rotate_euler_declare(NodeDeclarationBuilder &b)
{
@@ -125,15 +125,16 @@ static void fn_node_rotate_euler_build_multi_function(NodeMultiFunctionBuilder &
builder.set_matching_fn(fn);
}
} // namespace blender::nodes
} // namespace blender::nodes::rotate_euler_node
void register_node_type_fn_rotate_euler()
{
static bNodeType ntype;
fn_node_type_base(&ntype, FN_NODE_ROTATE_EULER, "Rotate Euler", NODE_CLASS_CONVERTER, 0);
ntype.declare = blender::nodes::fn_node_rotate_euler_declare;
ntype.draw_buttons = blender::nodes::fn_node_rotate_euler_layout;
node_type_update(&ntype, blender::nodes::fn_node_rotate_euler_update);
ntype.build_multi_function = blender::nodes::fn_node_rotate_euler_build_multi_function;
ntype.declare = blender::nodes::rotate_euler_node::fn_node_rotate_euler_declare;
ntype.draw_buttons = blender::nodes::rotate_euler_node::fn_node_rotate_euler_layout;
node_type_update(&ntype, blender::nodes::rotate_euler_node::fn_node_rotate_euler_update);
ntype.build_multi_function =
blender::nodes::rotate_euler_node::fn_node_rotate_euler_build_multi_function;
nodeRegisterType(&ntype);
}

View File

@@ -20,7 +20,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::attribute_clamp_legacy_node {
static void geo_node_attribute_clamp_declare(NodeDeclarationBuilder &b)
{
@@ -262,7 +262,7 @@ static void geo_node_attribute_clamp_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::attribute_clamp_legacy_node
void register_node_type_geo_attribute_clamp()
{
@@ -270,11 +270,15 @@ void register_node_type_geo_attribute_clamp()
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_ATTRIBUTE_CLAMP, "Attribute Clamp", NODE_CLASS_ATTRIBUTE, 0);
node_type_init(&ntype, blender::nodes::geo_node_attribute_clamp_init);
node_type_update(&ntype, blender::nodes::geo_node_attribute_clamp_update);
ntype.declare = blender::nodes::geo_node_attribute_clamp_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_clamp_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_clamp_layout;
node_type_init(&ntype,
blender::nodes::attribute_clamp_legacy_node::geo_node_attribute_clamp_init);
node_type_update(&ntype,
blender::nodes::attribute_clamp_legacy_node::geo_node_attribute_clamp_update);
ntype.declare = blender::nodes::attribute_clamp_legacy_node::geo_node_attribute_clamp_declare;
ntype.geometry_node_execute =
blender::nodes::attribute_clamp_legacy_node::geo_node_attribute_clamp_exec;
ntype.draw_buttons =
blender::nodes::attribute_clamp_legacy_node::geo_node_attribute_clamp_layout;
node_type_storage(
&ntype, "NodeAttributeClamp", node_free_standard_storage, node_copy_standard_storage);
nodeRegisterType(&ntype);

View File

@@ -23,7 +23,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::attribute_color_ramp_legacy_node {
static void geo_node_attribute_color_ramp_declare(NodeDeclarationBuilder &b)
{
@@ -119,7 +119,7 @@ static void geo_node_attribute_color_ramp_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::attribute_color_ramp_legacy_node
void register_node_type_geo_attribute_color_ramp()
{
@@ -132,10 +132,15 @@ void register_node_type_geo_attribute_color_ramp()
0);
node_type_storage(
&ntype, "NodeAttributeColorRamp", node_free_standard_storage, node_copy_standard_storage);
node_type_init(&ntype, blender::nodes::geo_node_attribute_color_ramp_init);
node_type_init(
&ntype,
blender::nodes::attribute_color_ramp_legacy_node::geo_node_attribute_color_ramp_init);
node_type_size_preset(&ntype, NODE_SIZE_LARGE);
ntype.declare = blender::nodes::geo_node_attribute_color_ramp_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_color_ramp_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_color_ramp_layout;
ntype.declare =
blender::nodes::attribute_color_ramp_legacy_node::geo_node_attribute_color_ramp_declare;
ntype.geometry_node_execute =
blender::nodes::attribute_color_ramp_legacy_node::geo_node_attribute_color_ramp_exec;
ntype.draw_buttons =
blender::nodes::attribute_color_ramp_legacy_node::geo_node_attribute_color_ramp_layout;
nodeRegisterType(&ntype);
}

View File

@@ -19,7 +19,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::attribute_combine_xyz_legacy_node {
static void geo_node_attribute_combine_xyz_declare(NodeDeclarationBuilder &b)
{
@@ -130,7 +130,7 @@ static void geo_node_attribute_combine_xyz_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::attribute_combine_xyz_legacy_node
void register_node_type_geo_attribute_combine_xyz()
{
@@ -141,13 +141,20 @@ void register_node_type_geo_attribute_combine_xyz()
"Attribute Combine XYZ",
NODE_CLASS_ATTRIBUTE,
0);
node_type_init(&ntype, blender::nodes::geo_node_attribute_combine_xyz_init);
node_type_update(&ntype, blender::nodes::geo_node_attribute_combine_xyz_update);
node_type_init(
&ntype,
blender::nodes::attribute_combine_xyz_legacy_node::geo_node_attribute_combine_xyz_init);
node_type_update(
&ntype,
blender::nodes::attribute_combine_xyz_legacy_node::geo_node_attribute_combine_xyz_update);
node_type_storage(
&ntype, "NodeAttributeCombineXYZ", node_free_standard_storage, node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_attribute_combine_xyz_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_combine_xyz_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_combine_xyz_layout;
ntype.declare =
blender::nodes::attribute_combine_xyz_legacy_node::geo_node_attribute_combine_xyz_declare;
ntype.geometry_node_execute =
blender::nodes::attribute_combine_xyz_legacy_node::geo_node_attribute_combine_xyz_exec;
ntype.draw_buttons =
blender::nodes::attribute_combine_xyz_legacy_node::geo_node_attribute_combine_xyz_layout;
nodeRegisterType(&ntype);
}

View File

@@ -21,7 +21,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::attribute_compare_legacy_node {
static void geo_node_attribute_compare_declare(NodeDeclarationBuilder &b)
{
@@ -341,7 +341,7 @@ static void geo_node_attribute_compare_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::attribute_compare_legacy_node
void register_node_type_geo_attribute_compare()
{
@@ -349,12 +349,17 @@ void register_node_type_geo_attribute_compare()
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_ATTRIBUTE_COMPARE, "Attribute Compare", NODE_CLASS_ATTRIBUTE, 0);
ntype.declare = blender::nodes::geo_node_attribute_compare_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_compare_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_compare_layout;
node_type_update(&ntype, blender::nodes::geo_node_attribute_compare_update);
ntype.declare =
blender::nodes::attribute_compare_legacy_node::geo_node_attribute_compare_declare;
ntype.geometry_node_execute =
blender::nodes::attribute_compare_legacy_node::geo_node_attribute_compare_exec;
ntype.draw_buttons =
blender::nodes::attribute_compare_legacy_node::geo_node_attribute_compare_layout;
node_type_update(
&ntype, blender::nodes::attribute_compare_legacy_node::geo_node_attribute_compare_update);
node_type_storage(
&ntype, "NodeAttributeCompare", node_free_standard_storage, node_copy_standard_storage);
node_type_init(&ntype, blender::nodes::geo_node_attribute_compare_init);
node_type_init(&ntype,
blender::nodes::attribute_compare_legacy_node::geo_node_attribute_compare_init);
nodeRegisterType(&ntype);
}

View File

@@ -24,7 +24,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::attribute_curve_map_legacy_node {
static void geo_node_attribute_curve_map_declare(NodeDeclarationBuilder &b)
{
@@ -204,7 +204,7 @@ static void geo_node_attribute_curve_map_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::attribute_curve_map_legacy_node
void register_node_type_geo_attribute_curve_map()
{
@@ -212,15 +212,22 @@ void register_node_type_geo_attribute_curve_map()
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_ATTRIBUTE_CURVE_MAP, "Attribute Curve Map", NODE_CLASS_ATTRIBUTE, 0);
node_type_update(&ntype, blender::nodes::geo_node_attribute_curve_map_update);
node_type_init(&ntype, blender::nodes::geo_node_attribute_curve_map_init);
node_type_update(
&ntype,
blender::nodes::attribute_curve_map_legacy_node::geo_node_attribute_curve_map_update);
node_type_init(
&ntype, blender::nodes::attribute_curve_map_legacy_node::geo_node_attribute_curve_map_init);
node_type_size_preset(&ntype, NODE_SIZE_LARGE);
node_type_storage(&ntype,
"NodeAttributeCurveMap",
blender::nodes::geo_node_attribute_curve_map_free_storage,
blender::nodes::geo_node_attribute_curve_map_copy_storage);
ntype.declare = blender::nodes::geo_node_attribute_curve_map_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_curve_map_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_curve_map_layout;
node_type_storage(
&ntype,
"NodeAttributeCurveMap",
blender::nodes::attribute_curve_map_legacy_node::geo_node_attribute_curve_map_free_storage,
blender::nodes::attribute_curve_map_legacy_node::geo_node_attribute_curve_map_copy_storage);
ntype.declare =
blender::nodes::attribute_curve_map_legacy_node::geo_node_attribute_curve_map_declare;
ntype.geometry_node_execute =
blender::nodes::attribute_curve_map_legacy_node::geo_node_attribute_curve_map_exec;
ntype.draw_buttons =
blender::nodes::attribute_curve_map_legacy_node::geo_node_attribute_curve_map_layout;
nodeRegisterType(&ntype);
}

View File

@@ -19,7 +19,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::attribute_fill_legacy_node {
static void geo_node_attribute_fill_declare(NodeDeclarationBuilder &b)
{
@@ -146,7 +146,7 @@ static void geo_node_attribute_fill_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::attribute_fill_legacy_node
void register_node_type_geo_attribute_fill()
{
@@ -154,10 +154,12 @@ void register_node_type_geo_attribute_fill()
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_ATTRIBUTE_FILL, "Attribute Fill", NODE_CLASS_ATTRIBUTE, 0);
node_type_init(&ntype, blender::nodes::geo_node_attribute_fill_init);
node_type_update(&ntype, blender::nodes::geo_node_attribute_fill_update);
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_fill_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_fill_layout;
ntype.declare = blender::nodes::geo_node_attribute_fill_declare;
node_type_init(&ntype, blender::nodes::attribute_fill_legacy_node::geo_node_attribute_fill_init);
node_type_update(&ntype,
blender::nodes::attribute_fill_legacy_node::geo_node_attribute_fill_update);
ntype.geometry_node_execute =
blender::nodes::attribute_fill_legacy_node::geo_node_attribute_fill_exec;
ntype.draw_buttons = blender::nodes::attribute_fill_legacy_node::geo_node_attribute_fill_layout;
ntype.declare = blender::nodes::attribute_fill_legacy_node::geo_node_attribute_fill_declare;
nodeRegisterType(&ntype);
}

View File

@@ -22,7 +22,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::attribute_map_range_legacy_node {
static void geo_node_attribute_map_range_declare(NodeDeclarationBuilder &b)
{
@@ -413,7 +413,7 @@ static void geo_node_attribute_map_range_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::attribute_map_range_legacy_node
void register_node_type_geo_attribute_map_range()
{
@@ -421,12 +421,18 @@ void register_node_type_geo_attribute_map_range()
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_ATTRIBUTE_MAP_RANGE, "Attribute Map Range", NODE_CLASS_ATTRIBUTE, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_map_range_exec;
node_type_init(&ntype, blender::nodes::geo_node_attribute_map_range_init);
node_type_update(&ntype, blender::nodes::geo_node_attribute_map_range_update);
ntype.geometry_node_execute =
blender::nodes::attribute_map_range_legacy_node::geo_node_attribute_map_range_exec;
node_type_init(
&ntype, blender::nodes::attribute_map_range_legacy_node::geo_node_attribute_map_range_init);
node_type_update(
&ntype,
blender::nodes::attribute_map_range_legacy_node::geo_node_attribute_map_range_update);
node_type_storage(
&ntype, "NodeAttributeMapRange", node_free_standard_storage, node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_attribute_map_range_declare;
ntype.draw_buttons = blender::nodes::fn_attribute_map_range_layout;
ntype.declare =
blender::nodes::attribute_map_range_legacy_node::geo_node_attribute_map_range_declare;
ntype.draw_buttons =
blender::nodes::attribute_map_range_legacy_node::fn_attribute_map_range_layout;
nodeRegisterType(&ntype);
}

View File

@@ -25,7 +25,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::attribute_math_legacy_node {
static void geo_node_attribute_math_declare(NodeDeclarationBuilder &b)
{
@@ -295,7 +295,7 @@ static void geo_node_attribute_math_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::attribute_math_legacy_node
void register_node_type_geo_attribute_math()
{
@@ -303,12 +303,14 @@ void register_node_type_geo_attribute_math()
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_ATTRIBUTE_MATH, "Attribute Math", NODE_CLASS_ATTRIBUTE, 0);
ntype.declare = blender::nodes::geo_node_attribute_math_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_math_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_math_layout;
node_type_label(&ntype, blender::nodes::geo_node_math_label);
node_type_update(&ntype, blender::nodes::geo_node_attribute_math_update);
node_type_init(&ntype, blender::nodes::geo_node_attribute_math_init);
ntype.declare = blender::nodes::attribute_math_legacy_node::geo_node_attribute_math_declare;
ntype.geometry_node_execute =
blender::nodes::attribute_math_legacy_node::geo_node_attribute_math_exec;
ntype.draw_buttons = blender::nodes::attribute_math_legacy_node::geo_node_attribute_math_layout;
node_type_label(&ntype, blender::nodes::attribute_math_legacy_node::geo_node_math_label);
node_type_update(&ntype,
blender::nodes::attribute_math_legacy_node::geo_node_attribute_math_update);
node_type_init(&ntype, blender::nodes::attribute_math_legacy_node::geo_node_attribute_math_init);
node_type_storage(
&ntype, "NodeAttributeMath", node_free_standard_storage, node_copy_standard_storage);
nodeRegisterType(&ntype);

View File

@@ -25,7 +25,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::attribute_mix_legacy_node {
static void geo_node_mix_attribute_declare(NodeDeclarationBuilder &b)
{
@@ -238,19 +238,21 @@ static void geo_node_attribute_mix_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::attribute_mix_legacy_node
void register_node_type_geo_attribute_mix()
{
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_ATTRIBUTE_MIX, "Attribute Mix", NODE_CLASS_ATTRIBUTE, 0);
node_type_init(&ntype, blender::nodes::geo_node_attribute_mix_init);
node_type_update(&ntype, blender::nodes::geo_node_attribute_mix_update);
ntype.declare = blender::nodes::geo_node_mix_attribute_declare;
ntype.draw_buttons = blender::nodes::geo_node_attribute_mix_layout;
node_type_init(&ntype, blender::nodes::attribute_mix_legacy_node::geo_node_attribute_mix_init);
node_type_update(&ntype,
blender::nodes::attribute_mix_legacy_node::geo_node_attribute_mix_update);
ntype.declare = blender::nodes::attribute_mix_legacy_node::geo_node_mix_attribute_declare;
ntype.draw_buttons = blender::nodes::attribute_mix_legacy_node::geo_node_attribute_mix_layout;
node_type_storage(
&ntype, "NodeAttributeMix", node_free_standard_storage, node_copy_standard_storage);
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_mix_exec;
ntype.geometry_node_execute =
blender::nodes::attribute_mix_legacy_node::geo_node_attribute_mix_exec;
nodeRegisterType(&ntype);
}

View File

@@ -23,7 +23,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::attribute_randomize_node {
static void geo_node_legacy_attribute_randomize_declare(NodeDeclarationBuilder &b)
{
@@ -174,36 +174,6 @@ static void randomize_attribute_bool(MutableSpan<bool> span,
});
}
Array<uint32_t> get_geometry_element_ids_as_uints(const GeometryComponent &component,
const AttributeDomain domain)
{
const int domain_size = component.attribute_domain_size(domain);
/* Hash the reserved name attribute "id" as a (hopefully) stable seed for each point. */
GVArrayPtr hash_attribute = component.attribute_try_get_for_read("id", domain);
Array<uint32_t> hashes(domain_size);
if (hash_attribute) {
BLI_assert(hashes.size() == hash_attribute->size());
const CPPType &cpp_type = hash_attribute->type();
BLI_assert(cpp_type.is_hashable());
GVArray_GSpan items{*hash_attribute};
threading::parallel_for(hashes.index_range(), 512, [&](IndexRange range) {
for (const int i : range) {
hashes[i] = cpp_type.hash(items[i]);
}
});
}
else {
/* If there is no "id" attribute for per-point variation, just create it here. */
RandomNumberGenerator rng(0);
for (const int i : hashes.index_range()) {
hashes[i] = rng.get_uint32();
}
}
return hashes;
}
static AttributeDomain get_result_domain(const GeometryComponent &component,
const GeoNodeExecParams &params,
const StringRef name)
@@ -324,6 +294,40 @@ static void geo_node_legacy_random_attribute_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes::attribute_randomize_node
namespace blender::nodes {
Array<uint32_t> get_geometry_element_ids_as_uints(const GeometryComponent &component,
const AttributeDomain domain)
{
const int domain_size = component.attribute_domain_size(domain);
/* Hash the reserved name attribute "id" as a (hopefully) stable seed for each point. */
GVArrayPtr hash_attribute = component.attribute_try_get_for_read("id", domain);
Array<uint32_t> hashes(domain_size);
if (hash_attribute) {
BLI_assert(hashes.size() == hash_attribute->size());
const CPPType &cpp_type = hash_attribute->type();
BLI_assert(cpp_type.is_hashable());
GVArray_GSpan items{*hash_attribute};
threading::parallel_for(hashes.index_range(), 512, [&](IndexRange range) {
for (const int i : range) {
hashes[i] = cpp_type.hash(items[i]);
}
});
}
else {
/* If there is no "id" attribute for per-point variation, just create it here. */
RandomNumberGenerator rng(0);
for (const int i : hashes.index_range()) {
hashes[i] = rng.get_uint32();
}
}
return hashes;
}
} // namespace blender::nodes
void register_node_type_geo_legacy_attribute_randomize()
@@ -332,12 +336,18 @@ void register_node_type_geo_legacy_attribute_randomize()
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_ATTRIBUTE_RANDOMIZE, "Attribute Randomize", NODE_CLASS_ATTRIBUTE, 0);
node_type_init(&ntype, blender::nodes::geo_node_legacy_attribute_randomize_init);
node_type_update(&ntype, blender::nodes::geo_node_legacy_attribute_randomize_update);
node_type_init(
&ntype, blender::nodes::attribute_randomize_node::geo_node_legacy_attribute_randomize_init);
node_type_update(
&ntype,
blender::nodes::attribute_randomize_node::geo_node_legacy_attribute_randomize_update);
ntype.declare = blender::nodes::geo_node_legacy_attribute_randomize_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_legacy_random_attribute_exec;
ntype.draw_buttons = blender::nodes::geo_node_legacy_attribute_random_layout;
ntype.declare =
blender::nodes::attribute_randomize_node::geo_node_legacy_attribute_randomize_declare;
ntype.geometry_node_execute =
blender::nodes::attribute_randomize_node::geo_node_legacy_random_attribute_exec;
ntype.draw_buttons =
blender::nodes::attribute_randomize_node::geo_node_legacy_attribute_random_layout;
node_type_storage(
&ntype, "NodeAttributeRandomize", node_free_standard_storage, node_copy_standard_storage);
nodeRegisterType(&ntype);

View File

@@ -28,7 +28,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::attribute_sample_texture_legacy_node {
static void geo_node_attribute_sample_texture_declare(NodeDeclarationBuilder &b)
{
@@ -119,7 +119,7 @@ static void geo_node_attribute_sample_texture_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::attribute_sample_texture_legacy_node
void register_node_type_geo_sample_texture()
{
@@ -131,7 +131,9 @@ void register_node_type_geo_sample_texture()
NODE_CLASS_ATTRIBUTE,
0);
node_type_size_preset(&ntype, NODE_SIZE_LARGE);
ntype.declare = blender::nodes::geo_node_attribute_sample_texture_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_sample_texture_exec;
ntype.declare = blender::nodes::attribute_sample_texture_legacy_node::
geo_node_attribute_sample_texture_declare;
ntype.geometry_node_execute =
blender::nodes::attribute_sample_texture_legacy_node::geo_node_attribute_sample_texture_exec;
nodeRegisterType(&ntype);
}

View File

@@ -19,7 +19,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::attribute_separate_xyz_legacy_node {
static void geo_node_attribute_separate_xyz_declare(NodeDeclarationBuilder &b)
{
@@ -151,7 +151,7 @@ static void geo_node_attribute_separate_xyz_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::attribute_separate_xyz_legacy_node
void register_node_type_geo_attribute_separate_xyz()
{
@@ -162,12 +162,19 @@ void register_node_type_geo_attribute_separate_xyz()
"Attribute Separate XYZ",
NODE_CLASS_ATTRIBUTE,
0);
ntype.declare = blender::nodes::geo_node_attribute_separate_xyz_declare;
node_type_init(&ntype, blender::nodes::geo_node_attribute_separate_xyz_init);
node_type_update(&ntype, blender::nodes::geo_node_attribute_separate_xyz_update);
ntype.declare =
blender::nodes::attribute_separate_xyz_legacy_node::geo_node_attribute_separate_xyz_declare;
node_type_init(
&ntype,
blender::nodes::attribute_separate_xyz_legacy_node::geo_node_attribute_separate_xyz_init);
node_type_update(
&ntype,
blender::nodes::attribute_separate_xyz_legacy_node::geo_node_attribute_separate_xyz_update);
node_type_storage(
&ntype, "NodeAttributeSeparateXYZ", node_free_standard_storage, node_copy_standard_storage);
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_separate_xyz_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_separate_xyz_layout;
ntype.geometry_node_execute =
blender::nodes::attribute_separate_xyz_legacy_node::geo_node_attribute_separate_xyz_exec;
ntype.draw_buttons =
blender::nodes::attribute_separate_xyz_legacy_node::geo_node_attribute_separate_xyz_layout;
nodeRegisterType(&ntype);
}

View File

@@ -29,7 +29,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::attribute_transfer_legacy_node {
static void geo_node_attribute_transfer_declare(NodeDeclarationBuilder &b)
{
@@ -510,7 +510,7 @@ static void geo_node_attribute_transfer_exec(GeoNodeExecParams params)
params.set_output("Geometry", dst_geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::attribute_transfer_legacy_node
void register_node_type_geo_legacy_attribute_transfer()
{
@@ -518,13 +518,17 @@ void register_node_type_geo_legacy_attribute_transfer()
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_ATTRIBUTE_TRANSFER, "Attribute Transfer", NODE_CLASS_ATTRIBUTE, 0);
node_type_init(&ntype, blender::nodes::geo_node_attribute_transfer_init);
node_type_init(&ntype,
blender::nodes::attribute_transfer_legacy_node::geo_node_attribute_transfer_init);
node_type_storage(&ntype,
"NodeGeometryAttributeTransfer",
node_free_standard_storage,
node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_attribute_transfer_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_transfer_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_transfer_layout;
ntype.declare =
blender::nodes::attribute_transfer_legacy_node::geo_node_attribute_transfer_declare;
ntype.geometry_node_execute =
blender::nodes::attribute_transfer_legacy_node::geo_node_attribute_transfer_exec;
ntype.draw_buttons =
blender::nodes::attribute_transfer_legacy_node::geo_node_attribute_transfer_layout;
nodeRegisterType(&ntype);
}

View File

@@ -26,7 +26,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::attribute_vector_math_legacy_node {
static void geo_node_attribute_vector_math_declare(NodeDeclarationBuilder &b)
{
@@ -549,7 +549,7 @@ static void geo_node_attribute_vector_math_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::attribute_vector_math_legacy_node
void register_node_type_geo_attribute_vector_math()
{
@@ -560,12 +560,20 @@ void register_node_type_geo_attribute_vector_math()
"Attribute Vector Math",
NODE_CLASS_ATTRIBUTE,
0);
ntype.declare = blender::nodes::geo_node_attribute_vector_math_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_vector_math_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_vector_math_layout;
node_type_label(&ntype, blender::nodes::geo_node_vector_math_label);
node_type_update(&ntype, blender::nodes::geo_node_attribute_vector_math_update);
node_type_init(&ntype, blender::nodes::geo_node_attribute_vector_math_init);
ntype.declare =
blender::nodes::attribute_vector_math_legacy_node::geo_node_attribute_vector_math_declare;
ntype.geometry_node_execute =
blender::nodes::attribute_vector_math_legacy_node::geo_node_attribute_vector_math_exec;
ntype.draw_buttons =
blender::nodes::attribute_vector_math_legacy_node::geo_node_attribute_vector_math_layout;
node_type_label(&ntype,
blender::nodes::attribute_vector_math_legacy_node::geo_node_vector_math_label);
node_type_update(
&ntype,
blender::nodes::attribute_vector_math_legacy_node::geo_node_attribute_vector_math_update);
node_type_init(
&ntype,
blender::nodes::attribute_vector_math_legacy_node::geo_node_attribute_vector_math_init);
node_type_storage(
&ntype, "NodeAttributeVectorMath", node_free_standard_storage, node_copy_standard_storage);

View File

@@ -21,7 +21,7 @@
#include "UI_interface.h"
#include "UI_resources.h"
namespace blender::nodes {
namespace blender::nodes::attribute_vector_rotate_legacy_node {
static void geo_node_attribute_vector_rotate_declare(NodeDeclarationBuilder &b)
{
@@ -325,7 +325,7 @@ static void geo_node_attribute_vector_rotate_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::attribute_vector_rotate_legacy_node
void register_node_type_geo_attribute_vector_rotate()
{
@@ -336,13 +336,20 @@ void register_node_type_geo_attribute_vector_rotate()
"Attribute Vector Rotate",
NODE_CLASS_ATTRIBUTE,
0);
node_type_update(&ntype, blender::nodes::geo_node_attribute_vector_rotate_update);
node_type_init(&ntype, blender::nodes::geo_node_attribute_vector_rotate_init);
node_type_update(&ntype,
blender::nodes::attribute_vector_rotate_legacy_node::
geo_node_attribute_vector_rotate_update);
node_type_init(
&ntype,
blender::nodes::attribute_vector_rotate_legacy_node::geo_node_attribute_vector_rotate_init);
node_type_size(&ntype, 165, 100, 600);
node_type_storage(
&ntype, "NodeAttributeVectorRotate", node_free_standard_storage, node_copy_standard_storage);
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_vector_rotate_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_vector_rotate_layout;
ntype.declare = blender::nodes::geo_node_attribute_vector_rotate_declare;
ntype.geometry_node_execute =
blender::nodes::attribute_vector_rotate_legacy_node::geo_node_attribute_vector_rotate_exec;
ntype.draw_buttons =
blender::nodes::attribute_vector_rotate_legacy_node::geo_node_attribute_vector_rotate_layout;
ntype.declare = blender::nodes::attribute_vector_rotate_legacy_node::
geo_node_attribute_vector_rotate_declare;
nodeRegisterType(&ntype);
}

View File

@@ -25,7 +25,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::curve_endpoints_legacy_node {
static void geo_node_curve_endpoints_declare(NodeDeclarationBuilder &b)
{
@@ -206,7 +206,7 @@ static void geo_node_curve_endpoints_exec(GeoNodeExecParams params)
params.set_output("End Points", std::move(end_result));
}
} // namespace blender::nodes
} // namespace blender::nodes::curve_endpoints_legacy_node
void register_node_type_geo_legacy_curve_endpoints()
{
@@ -214,8 +214,9 @@ void register_node_type_geo_legacy_curve_endpoints()
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_CURVE_ENDPOINTS, "Curve Endpoints", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_endpoints_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_endpoints_exec;
ntype.declare = blender::nodes::curve_endpoints_legacy_node::geo_node_curve_endpoints_declare;
ntype.geometry_node_execute =
blender::nodes::curve_endpoints_legacy_node::geo_node_curve_endpoints_exec;
nodeRegisterType(&ntype);
}

View File

@@ -23,7 +23,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::select_by_handle_type_legacy_node {
static void geo_node_select_by_handle_type_declare(NodeDeclarationBuilder &b)
{
@@ -121,7 +121,7 @@ static void geo_node_select_by_handle_type_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::select_by_handle_type_legacy_node
void register_node_type_geo_legacy_select_by_handle_type()
{
@@ -132,14 +132,19 @@ void register_node_type_geo_legacy_select_by_handle_type()
"Select by Handle Type",
NODE_CLASS_GEOMETRY,
0);
ntype.declare = blender::nodes::geo_node_select_by_handle_type_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_select_by_handle_type_exec;
node_type_init(&ntype, blender::nodes::geo_node_curve_select_by_handle_type_init);
ntype.declare =
blender::nodes::select_by_handle_type_legacy_node::geo_node_select_by_handle_type_declare;
ntype.geometry_node_execute =
blender::nodes::select_by_handle_type_legacy_node::geo_node_select_by_handle_type_exec;
node_type_init(&ntype,
blender::nodes::select_by_handle_type_legacy_node::
geo_node_curve_select_by_handle_type_init);
node_type_storage(&ntype,
"NodeGeometryCurveSelectHandles",
node_free_standard_storage,
node_copy_standard_storage);
ntype.draw_buttons = blender::nodes::geo_node_curve_select_by_handle_type_layout;
ntype.draw_buttons = blender::nodes::select_by_handle_type_legacy_node::
geo_node_curve_select_by_handle_type_layout;
nodeRegisterType(&ntype);
}

View File

@@ -21,7 +21,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::set_curve_handles_legacy_node {
static void geo_node_curve_set_handles_decalre(NodeDeclarationBuilder &b)
{
@@ -124,21 +124,25 @@ static void geo_node_curve_set_handles_exec(GeoNodeExecParams params)
params.set_output("Curve", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::set_curve_handles_legacy_node
void register_node_type_geo_legacy_curve_set_handles()
{
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_CURVE_SET_HANDLES, "Set Handle Type", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_set_handles_decalre;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_set_handles_exec;
node_type_init(&ntype, blender::nodes::geo_node_curve_set_handles_init);
ntype.declare =
blender::nodes::set_curve_handles_legacy_node::geo_node_curve_set_handles_decalre;
ntype.geometry_node_execute =
blender::nodes::set_curve_handles_legacy_node::geo_node_curve_set_handles_exec;
node_type_init(&ntype,
blender::nodes::set_curve_handles_legacy_node::geo_node_curve_set_handles_init);
node_type_storage(&ntype,
"NodeGeometryCurveSetHandles",
node_free_standard_storage,
node_copy_standard_storage);
ntype.draw_buttons = blender::nodes::geo_node_curve_set_handles_layout;
ntype.draw_buttons =
blender::nodes::set_curve_handles_legacy_node::geo_node_curve_set_handles_layout;
nodeRegisterType(&ntype);
}

View File

@@ -23,7 +23,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::curve_spline_type_legacy_node {
static void geo_node_legacy_curve_spline_type_declare(NodeDeclarationBuilder &b)
{
@@ -282,21 +282,26 @@ static void geo_node_legacy_curve_spline_type_exec(GeoNodeExecParams params)
params.set_output("Curve", GeometrySet::create_with_curve(new_curve.release()));
}
} // namespace blender::nodes
} // namespace blender::nodes::curve_spline_type_legacy_node
void register_node_type_geo_legacy_curve_spline_type()
{
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_CURVE_SPLINE_TYPE, "Set Spline Type", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_legacy_curve_spline_type_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_legacy_curve_spline_type_exec;
node_type_init(&ntype, blender::nodes::geo_node_legacy_curve_spline_type_init);
ntype.declare =
blender::nodes::curve_spline_type_legacy_node::geo_node_legacy_curve_spline_type_declare;
ntype.geometry_node_execute =
blender::nodes::curve_spline_type_legacy_node::geo_node_legacy_curve_spline_type_exec;
node_type_init(
&ntype,
blender::nodes::curve_spline_type_legacy_node::geo_node_legacy_curve_spline_type_init);
node_type_storage(&ntype,
"NodeGeometryCurveSplineType",
node_free_standard_storage,
node_copy_standard_storage);
ntype.draw_buttons = blender::nodes::geo_node_legacy_curve_spline_type_layout;
ntype.draw_buttons =
blender::nodes::curve_spline_type_legacy_node::geo_node_legacy_curve_spline_type_layout;
nodeRegisterType(&ntype);
}

View File

@@ -26,7 +26,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::legacy_curve_to_points_node {
static void geo_node_curve_to_points_declare(NodeDeclarationBuilder &b)
{
@@ -133,35 +133,6 @@ static MutableSpan<T> create_attribute_and_retrieve_span(PointCloudComponent &po
return attribute.typed<T>();
}
CurveToPointsResults curve_to_points_create_result_attributes(PointCloudComponent &points,
const CurveEval &curve)
{
CurveToPointsResults attributes;
attributes.result_size = points.attribute_domain_size(ATTR_DOMAIN_POINT);
attributes.positions = create_attribute_and_retrieve_span<float3>(points, "position");
attributes.radii = create_attribute_and_retrieve_span<float>(points, "radius");
attributes.tilts = create_attribute_and_retrieve_span<float>(points, "tilt");
/* Because of the invariants of the curve component, we use the attributes of the
* first spline as a representative for the attribute meta data all splines. */
curve.splines().first()->attributes.foreach_attribute(
[&](const AttributeIDRef &attribute_id, const AttributeMetaData &meta_data) {
attributes.point_attributes.add_new(
attribute_id,
create_attribute_and_retrieve_span(points, attribute_id, meta_data.data_type));
return true;
},
ATTR_DOMAIN_POINT);
attributes.tangents = create_attribute_and_retrieve_span<float3>(points, "tangent");
attributes.normals = create_attribute_and_retrieve_span<float3>(points, "normal");
attributes.rotations = create_attribute_and_retrieve_span<float3>(points, "rotation");
return attributes;
}
/**
* TODO: For non-poly splines, this has double copies that could be avoided as part
* of a general look at optimizing uses of #Spline::interpolate_to_evaluated.
@@ -340,6 +311,39 @@ static void geo_node_curve_to_points_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(result));
}
} // namespace blender::nodes::legacy_curve_to_points_node
namespace blender::nodes {
CurveToPointsResults curve_to_points_create_result_attributes(PointCloudComponent &points,
const CurveEval &curve)
{
using namespace blender::nodes::legacy_curve_to_points_node;
CurveToPointsResults attributes;
attributes.result_size = points.attribute_domain_size(ATTR_DOMAIN_POINT);
attributes.positions = create_attribute_and_retrieve_span<float3>(points, "position");
attributes.radii = create_attribute_and_retrieve_span<float>(points, "radius");
attributes.tilts = create_attribute_and_retrieve_span<float>(points, "tilt");
/* Because of the invariants of the curve component, we use the attributes of the
* first spline as a representative for the attribute meta data all splines. */
curve.splines().first()->attributes.foreach_attribute(
[&](const AttributeIDRef &attribute_id, const AttributeMetaData &meta_data) {
attributes.point_attributes.add_new(
attribute_id,
create_attribute_and_retrieve_span(points, attribute_id, meta_data.data_type));
return true;
},
ATTR_DOMAIN_POINT);
attributes.tangents = create_attribute_and_retrieve_span<float3>(points, "tangent");
attributes.normals = create_attribute_and_retrieve_span<float3>(points, "normal");
attributes.rotations = create_attribute_and_retrieve_span<float3>(points, "rotation");
return attributes;
}
} // namespace blender::nodes
void register_node_type_geo_legacy_curve_to_points()
@@ -348,13 +352,17 @@ void register_node_type_geo_legacy_curve_to_points()
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_CURVE_TO_POINTS, "Curve to Points", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_to_points_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_to_points_exec;
ntype.draw_buttons = blender::nodes::geo_node_curve_to_points_layout;
ntype.declare = blender::nodes::legacy_curve_to_points_node::geo_node_curve_to_points_declare;
ntype.geometry_node_execute =
blender::nodes::legacy_curve_to_points_node::geo_node_curve_to_points_exec;
ntype.draw_buttons =
blender::nodes::legacy_curve_to_points_node::geo_node_curve_to_points_layout;
node_type_storage(
&ntype, "NodeGeometryCurveToPoints", node_free_standard_storage, node_copy_standard_storage);
node_type_init(&ntype, blender::nodes::geo_node_curve_to_points_init);
node_type_update(&ntype, blender::nodes::geo_node_curve_to_points_update);
node_type_init(&ntype,
blender::nodes::legacy_curve_to_points_node::geo_node_curve_to_points_init);
node_type_update(&ntype,
blender::nodes::legacy_curve_to_points_node::geo_node_curve_to_points_update);
nodeRegisterType(&ntype);
}

View File

@@ -29,21 +29,21 @@
using blender::bke::CustomDataAttributes;
/* Code from the mask modifier in MOD_mask.cc. */
extern void copy_masked_vertices_to_new_mesh(const Mesh &src_mesh,
Mesh &dst_mesh,
blender::Span<int> vertex_map);
extern void copy_masked_edges_to_new_mesh(const Mesh &src_mesh,
Mesh &dst_mesh,
blender::Span<int> vertex_map,
blender::Span<int> edge_map);
extern void copy_masked_polys_to_new_mesh(const Mesh &src_mesh,
Mesh &dst_mesh,
blender::Span<int> vertex_map,
blender::Span<int> edge_map,
blender::Span<int> masked_poly_indices,
blender::Span<int> new_loop_starts);
void copy_masked_vertices_to_new_mesh(const Mesh &src_mesh,
Mesh &dst_mesh,
blender::Span<int> vertex_map);
void copy_masked_edges_to_new_mesh(const Mesh &src_mesh,
Mesh &dst_mesh,
blender::Span<int> vertex_map,
blender::Span<int> edge_map);
void copy_masked_polys_to_new_mesh(const Mesh &src_mesh,
Mesh &dst_mesh,
blender::Span<int> vertex_map,
blender::Span<int> edge_map,
blender::Span<int> masked_poly_indices,
blender::Span<int> new_loop_starts);
namespace blender::nodes {
namespace blender::nodes::delete_geometry_legacy_node {
static void geo_node_delete_geometry_declare(NodeDeclarationBuilder &b)
{
@@ -662,7 +662,7 @@ static void geo_node_delete_geometry_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(out_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::delete_geometry_legacy_node
void register_node_type_geo_legacy_delete_geometry()
{
@@ -671,7 +671,8 @@ void register_node_type_geo_legacy_delete_geometry()
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_DELETE_GEOMETRY, "Delete Geometry", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_delete_geometry_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_delete_geometry_exec;
ntype.declare = blender::nodes::delete_geometry_legacy_node::geo_node_delete_geometry_declare;
ntype.geometry_node_execute =
blender::nodes::delete_geometry_legacy_node::geo_node_delete_geometry_exec;
nodeRegisterType(&ntype);
}

View File

@@ -22,7 +22,7 @@ extern "C" {
Mesh *doEdgeSplit(const Mesh *mesh, EdgeSplitModifierData *emd);
}
namespace blender::nodes {
namespace blender::nodes::edge_split_legacy_node {
static void geo_node_edge_split_declare(NodeDeclarationBuilder &b)
{
@@ -76,14 +76,14 @@ static void geo_node_edge_split_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::edge_split_legacy_node
void register_node_type_geo_legacy_edge_split()
{
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_LEGACY_EDGE_SPLIT, "Edge Split", NODE_CLASS_GEOMETRY, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_edge_split_exec;
ntype.declare = blender::nodes::geo_node_edge_split_declare;
ntype.geometry_node_execute = blender::nodes::edge_split_legacy_node::geo_node_edge_split_exec;
ntype.declare = blender::nodes::edge_split_legacy_node::geo_node_edge_split_declare;
nodeRegisterType(&ntype);
}

View File

@@ -38,7 +38,7 @@
using blender::bke::GeometryInstanceGroup;
namespace blender::nodes {
namespace blender::nodes::point_distribute_node {
static void geo_node_point_distribute_declare(NodeDeclarationBuilder &b)
{
@@ -654,7 +654,7 @@ static void geo_node_point_distribute_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set_out));
}
} // namespace blender::nodes
} // namespace blender::nodes::point_distribute_node
void register_node_type_geo_point_distribute()
{
@@ -662,9 +662,10 @@ void register_node_type_geo_point_distribute()
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_POINT_DISTRIBUTE, "Point Distribute", NODE_CLASS_GEOMETRY, 0);
node_type_update(&ntype, blender::nodes::node_point_distribute_update);
ntype.declare = blender::nodes::geo_node_point_distribute_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_point_distribute_exec;
ntype.draw_buttons = blender::nodes::geo_node_point_distribute_layout;
node_type_update(&ntype, blender::nodes::point_distribute_node::node_point_distribute_update);
ntype.declare = blender::nodes::point_distribute_node::geo_node_point_distribute_declare;
ntype.geometry_node_execute =
blender::nodes::point_distribute_node::geo_node_point_distribute_exec;
ntype.draw_buttons = blender::nodes::point_distribute_node::geo_node_point_distribute_layout;
nodeRegisterType(&ntype);
}

View File

@@ -21,7 +21,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::point_scale_node {
static void geo_node_point_scale_declare(NodeDeclarationBuilder &b)
{
@@ -120,7 +120,7 @@ static void geo_node_point_scale_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::point_scale_node
void register_node_type_geo_point_scale()
{
@@ -128,12 +128,12 @@ void register_node_type_geo_point_scale()
geo_node_type_base(&ntype, GEO_NODE_LEGACY_POINT_SCALE, "Point Scale", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_point_scale_declare;
node_type_init(&ntype, blender::nodes::geo_node_point_scale_init);
node_type_update(&ntype, blender::nodes::geo_node_point_scale_update);
ntype.declare = blender::nodes::point_scale_node::geo_node_point_scale_declare;
node_type_init(&ntype, blender::nodes::point_scale_node::geo_node_point_scale_init);
node_type_update(&ntype, blender::nodes::point_scale_node::geo_node_point_scale_update);
node_type_storage(
&ntype, "NodeGeometryPointScale", node_free_standard_storage, node_copy_standard_storage);
ntype.geometry_node_execute = blender::nodes::geo_node_point_scale_exec;
ntype.draw_buttons = blender::nodes::geo_node_point_scale_layout;
ntype.geometry_node_execute = blender::nodes::point_scale_node::geo_node_point_scale_exec;
ntype.draw_buttons = blender::nodes::point_scale_node::geo_node_point_scale_layout;
nodeRegisterType(&ntype);
}

View File

@@ -25,7 +25,7 @@
namespace blender::nodes {
static void geo_node_point_instance_declare(NodeDeclarationBuilder &b)
static void geo_node_point_separate_declare(NodeDeclarationBuilder &b)
{
b.add_input<decl::Geometry>(N_("Geometry"));
b.add_input<decl::String>(N_("Mask"));
@@ -166,7 +166,7 @@ void register_node_type_geo_point_separate()
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_POINT_SEPARATE, "Point Separate", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_point_instance_declare;
ntype.declare = blender::nodes::geo_node_point_separate_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_point_separate_exec;
ntype.geometry_node_execute_supports_laziness = true;
nodeRegisterType(&ntype);

View File

@@ -19,7 +19,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::point_translate_node {
static void geo_node_point_translate_declare(NodeDeclarationBuilder &b)
{
@@ -89,7 +89,7 @@ static void geo_node_point_translate_update(bNodeTree *UNUSED(ntree), bNode *nod
*node, "Translation", (GeometryNodeAttributeInputMode)node_storage.input_type);
}
} // namespace blender::nodes
} // namespace blender::nodes::point_translate_node
void register_node_type_geo_point_translate()
{
@@ -97,14 +97,15 @@ void register_node_type_geo_point_translate()
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_POINT_TRANSLATE, "Point Translate", NODE_CLASS_GEOMETRY, 0);
node_type_init(&ntype, blender::nodes::geo_node_point_translate_init);
node_type_update(&ntype, blender::nodes::geo_node_point_translate_update);
node_type_init(&ntype, blender::nodes::point_translate_node::geo_node_point_translate_init);
node_type_update(&ntype, blender::nodes::point_translate_node::geo_node_point_translate_update);
node_type_storage(&ntype,
"NodeGeometryPointTranslate",
node_free_standard_storage,
node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_point_translate_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_point_translate_exec;
ntype.draw_buttons = blender::nodes::geo_node_point_translate_layout;
ntype.declare = blender::nodes::point_translate_node::geo_node_point_translate_declare;
ntype.geometry_node_execute =
blender::nodes::point_translate_node::geo_node_point_translate_exec;
ntype.draw_buttons = blender::nodes::point_translate_node::geo_node_point_translate_layout;
nodeRegisterType(&ntype);
}

View File

@@ -23,7 +23,7 @@
#include "UI_resources.h"
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::subdivision_surface_legacy_node {
static void geo_node_subdivision_surface_declare(NodeDeclarationBuilder &b)
{
@@ -126,7 +126,7 @@ static void geo_node_subdivision_surface_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::subdivision_surface_legacy_node
void register_node_type_geo_legacy_subdivision_surface()
{
@@ -134,10 +134,14 @@ void register_node_type_geo_legacy_subdivision_surface()
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_SUBDIVISION_SURFACE, "Subdivision Surface", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_subdivision_surface_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_subdivision_surface_exec;
ntype.draw_buttons = blender::nodes::geo_node_subdivision_surface_layout;
node_type_init(&ntype, blender::nodes::geo_node_subdivision_surface_init);
ntype.declare =
blender::nodes::subdivision_surface_legacy_node::geo_node_subdivision_surface_declare;
ntype.geometry_node_execute =
blender::nodes::subdivision_surface_legacy_node::geo_node_subdivision_surface_exec;
ntype.draw_buttons =
blender::nodes::subdivision_surface_legacy_node::geo_node_subdivision_surface_layout;
node_type_init(
&ntype, blender::nodes::subdivision_surface_legacy_node::geo_node_subdivision_surface_init);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_storage(&ntype,
"NodeGeometrySubdivisionSurface",

View File

@@ -21,7 +21,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::handle_type_selection_node {
static void geo_node_curve_handle_type_selection_declare(NodeDeclarationBuilder &b)
{
@@ -152,7 +152,7 @@ static void geo_node_curve_handle_type_selection_exec(GeoNodeExecParams params)
params.set_output("Selection", std::move(selection_field));
}
} // namespace blender::nodes
} // namespace blender::nodes::handle_type_selection_node
void register_node_type_geo_curve_handle_type_selection()
{
@@ -163,14 +163,19 @@ void register_node_type_geo_curve_handle_type_selection()
"Handle Type Selection",
NODE_CLASS_GEOMETRY,
0);
ntype.declare = blender::nodes::geo_node_curve_handle_type_selection_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_handle_type_selection_exec;
node_type_init(&ntype, blender::nodes::geo_node_curve_handle_type_selection_init);
ntype.declare =
blender::nodes::handle_type_selection_node::geo_node_curve_handle_type_selection_declare;
ntype.geometry_node_execute =
blender::nodes::handle_type_selection_node::geo_node_curve_handle_type_selection_exec;
node_type_init(
&ntype,
blender::nodes::handle_type_selection_node::geo_node_curve_handle_type_selection_init);
node_type_storage(&ntype,
"NodeGeometryCurveSelectHandles",
node_free_standard_storage,
node_copy_standard_storage);
ntype.draw_buttons = blender::nodes::geo_node_curve_handle_type_selection_layout;
ntype.draw_buttons =
blender::nodes::handle_type_selection_node::geo_node_curve_handle_type_selection_layout;
nodeRegisterType(&ntype);
}

View File

@@ -20,7 +20,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::curve_reverse_node {
static void geo_node_curve_reverse_declare(NodeDeclarationBuilder &b)
{
@@ -60,13 +60,13 @@ static void geo_node_curve_reverse_exec(GeoNodeExecParams params)
params.set_output("Curve", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::curve_reverse_node
void register_node_type_geo_curve_reverse()
{
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_REVERSE_CURVE, "Reverse Curve", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_reverse_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_reverse_exec;
ntype.declare = blender::nodes::curve_reverse_node::geo_node_curve_reverse_declare;
ntype.geometry_node_execute = blender::nodes::curve_reverse_node::geo_node_curve_reverse_exec;
nodeRegisterType(&ntype);
}

View File

@@ -21,7 +21,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::set_curve_handles_node {
static void geo_node_curve_set_handles_declare(NodeDeclarationBuilder &b)
{
@@ -130,21 +130,22 @@ static void geo_node_curve_set_handles_exec(GeoNodeExecParams params)
}
params.set_output("Curve", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::set_curve_handles_node
void register_node_type_geo_curve_set_handles()
{
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_CURVE_SET_HANDLES, "Set Handle Type", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_set_handles_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_set_handles_exec;
node_type_init(&ntype, blender::nodes::geo_node_curve_set_handles_init);
ntype.declare = blender::nodes::set_curve_handles_node::geo_node_curve_set_handles_declare;
ntype.geometry_node_execute =
blender::nodes::set_curve_handles_node::geo_node_curve_set_handles_exec;
node_type_init(&ntype, blender::nodes::set_curve_handles_node::geo_node_curve_set_handles_init);
node_type_storage(&ntype,
"NodeGeometryCurveSetHandles",
node_free_standard_storage,
node_copy_standard_storage);
ntype.draw_buttons = blender::nodes::geo_node_curve_set_handles_layout;
ntype.draw_buttons = blender::nodes::set_curve_handles_node::geo_node_curve_set_handles_layout;
nodeRegisterType(&ntype);
}

View File

@@ -23,7 +23,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::curve_spline_type_node {
static void geo_node_curve_spline_type_declare(NodeDeclarationBuilder &b)
{
@@ -288,21 +288,22 @@ static void geo_node_curve_spline_type_exec(GeoNodeExecParams params)
params.set_output("Curve", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::curve_spline_type_node
void register_node_type_geo_curve_spline_type()
{
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_CURVE_SPLINE_TYPE, "Set Spline Type", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_spline_type_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_spline_type_exec;
node_type_init(&ntype, blender::nodes::geo_node_curve_spline_type_init);
ntype.declare = blender::nodes::curve_spline_type_node::geo_node_curve_spline_type_declare;
ntype.geometry_node_execute =
blender::nodes::curve_spline_type_node::geo_node_curve_spline_type_exec;
node_type_init(&ntype, blender::nodes::curve_spline_type_node::geo_node_curve_spline_type_init);
node_type_storage(&ntype,
"NodeGeometryCurveSplineType",
node_free_standard_storage,
node_copy_standard_storage);
ntype.draw_buttons = blender::nodes::geo_node_curve_spline_type_layout;
ntype.draw_buttons = blender::nodes::curve_spline_type_node::geo_node_curve_spline_type_layout;
nodeRegisterType(&ntype);
}

View File

@@ -29,7 +29,7 @@ using blender::fn::GVArray_For_GSpan;
using blender::fn::GVArray_For_Span;
using blender::fn::GVArray_Typed;
namespace blender::nodes {
namespace blender::nodes::curve_subdivide_node {
static void geo_node_curve_subdivide_declare(NodeDeclarationBuilder &b)
{
@@ -355,14 +355,14 @@ static void geo_node_subdivide_exec(GeoNodeExecParams params)
params.set_output("Curve", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::curve_subdivide_node
void register_node_type_geo_curve_subdivide()
{
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_SUBDIVIDE_CURVE, "Subdivide Curve", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_subdivide_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_subdivide_exec;
ntype.declare = blender::nodes::curve_subdivide_node::geo_node_curve_subdivide_declare;
ntype.geometry_node_execute = blender::nodes::curve_subdivide_node::geo_node_subdivide_exec;
nodeRegisterType(&ntype);
}

View File

@@ -26,7 +26,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::curve_to_points_node {
static void geo_node_curve_to_points_declare(NodeDeclarationBuilder &b)
{
@@ -289,18 +289,6 @@ static void copy_spline_domain_attributes(const CurveEval &curve,
ATTR_DOMAIN_CURVE);
}
void curve_create_default_rotation_attribute(Span<float3> tangents,
Span<float3> normals,
MutableSpan<float3> rotations)
{
threading::parallel_for(IndexRange(rotations.size()), 512, [&](IndexRange range) {
for (const int i : range) {
rotations[i] =
float4x4::from_normalized_axis_data({0, 0, 0}, normals[i], tangents[i]).to_euler();
}
});
}
static void geo_node_curve_to_points_exec(GeoNodeExecParams params)
{
NodeGeometryCurveToPoints &node_storage = *(NodeGeometryCurveToPoints *)params.node().storage;
@@ -374,6 +362,20 @@ static void geo_node_curve_to_points_exec(GeoNodeExecParams params)
}
}
} // namespace blender::nodes::curve_to_points_node
namespace blender::nodes {
void curve_create_default_rotation_attribute(Span<float3> tangents,
Span<float3> normals,
MutableSpan<float3> rotations)
{
threading::parallel_for(IndexRange(rotations.size()), 512, [&](IndexRange range) {
for (const int i : range) {
rotations[i] =
float4x4::from_normalized_axis_data({0, 0, 0}, normals[i], tangents[i]).to_euler();
}
});
}
} // namespace blender::nodes
void register_node_type_geo_curve_to_points()
@@ -381,13 +383,14 @@ void register_node_type_geo_curve_to_points()
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_CURVE_TO_POINTS, "Curve to Points", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_to_points_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_to_points_exec;
ntype.draw_buttons = blender::nodes::geo_node_curve_to_points_layout;
ntype.declare = blender::nodes::curve_to_points_node::geo_node_curve_to_points_declare;
ntype.geometry_node_execute =
blender::nodes::curve_to_points_node::geo_node_curve_to_points_exec;
ntype.draw_buttons = blender::nodes::curve_to_points_node::geo_node_curve_to_points_layout;
node_type_storage(
&ntype, "NodeGeometryCurveToPoints", node_free_standard_storage, node_copy_standard_storage);
node_type_init(&ntype, blender::nodes::geo_node_curve_to_points_init);
node_type_update(&ntype, blender::nodes::geo_node_curve_to_points_update);
node_type_init(&ntype, blender::nodes::curve_to_points_node::geo_node_curve_to_points_init);
node_type_update(&ntype, blender::nodes::curve_to_points_node::geo_node_curve_to_points_update);
nodeRegisterType(&ntype);
}

View File

@@ -32,21 +32,21 @@
using blender::bke::CustomDataAttributes;
/* Code from the mask modifier in MOD_mask.cc. */
extern void copy_masked_vertices_to_new_mesh(const Mesh &src_mesh,
Mesh &dst_mesh,
blender::Span<int> vertex_map);
extern void copy_masked_edges_to_new_mesh(const Mesh &src_mesh,
Mesh &dst_mesh,
blender::Span<int> vertex_map,
blender::Span<int> edge_map);
extern void copy_masked_polys_to_new_mesh(const Mesh &src_mesh,
Mesh &dst_mesh,
blender::Span<int> vertex_map,
blender::Span<int> edge_map,
blender::Span<int> masked_poly_indices,
blender::Span<int> new_loop_starts);
void copy_masked_vertices_to_new_mesh(const Mesh &src_mesh,
Mesh &dst_mesh,
blender::Span<int> vertex_map);
void copy_masked_edges_to_new_mesh(const Mesh &src_mesh,
Mesh &dst_mesh,
blender::Span<int> vertex_map,
blender::Span<int> edge_map);
void copy_masked_polys_to_new_mesh(const Mesh &src_mesh,
Mesh &dst_mesh,
blender::Span<int> vertex_map,
blender::Span<int> edge_map,
blender::Span<int> masked_poly_indices,
blender::Span<int> new_loop_starts);
namespace blender::nodes {
namespace blender::nodes::delete_geometry_node {
static void geo_node_delete_geometry_declare(NodeDeclarationBuilder &b)
{
@@ -1148,35 +1148,6 @@ static void separate_mesh_selection(GeometrySet &geometry_set,
do_mesh_separation(geometry_set, src_component, selection, invert, selection_domain, mode);
}
void separate_geometry(GeometrySet &geometry_set,
const AttributeDomain domain,
const GeometryNodeDeleteGeometryMode mode,
const Field<bool> &selection_field,
const bool invert,
bool &r_is_error)
{
bool some_valid_domain = false;
if (geometry_set.has_pointcloud()) {
if (domain == ATTR_DOMAIN_POINT) {
separate_point_cloud_selection(geometry_set, selection_field, invert);
some_valid_domain = true;
}
}
if (geometry_set.has_mesh()) {
if (domain != ATTR_DOMAIN_CURVE) {
separate_mesh_selection(geometry_set, selection_field, domain, mode, invert);
some_valid_domain = true;
}
}
if (geometry_set.has_curve()) {
if (ELEM(domain, ATTR_DOMAIN_POINT, ATTR_DOMAIN_CURVE)) {
separate_curve_selection(geometry_set, selection_field, domain, invert);
some_valid_domain = true;
}
}
r_is_error = !some_valid_domain && geometry_set.has_realized_data();
}
static void geo_node_delete_geometry_exec(GeoNodeExecParams params)
{
GeometrySet geometry_set = params.extract_input<GeometrySet>("Geometry");
@@ -1204,6 +1175,38 @@ static void geo_node_delete_geometry_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set));
}
} // namespace blender::nodes::delete_geometry_node
namespace blender::nodes {
void separate_geometry(GeometrySet &geometry_set,
const AttributeDomain domain,
const GeometryNodeDeleteGeometryMode mode,
const Field<bool> &selection_field,
const bool invert,
bool &r_is_error)
{
using namespace blender::nodes::delete_geometry_node;
bool some_valid_domain = false;
if (geometry_set.has_pointcloud()) {
if (domain == ATTR_DOMAIN_POINT) {
separate_point_cloud_selection(geometry_set, selection_field, invert);
some_valid_domain = true;
}
}
if (geometry_set.has_mesh()) {
if (domain != ATTR_DOMAIN_CURVE) {
separate_mesh_selection(geometry_set, selection_field, domain, mode, invert);
some_valid_domain = true;
}
}
if (geometry_set.has_curve()) {
if (ELEM(domain, ATTR_DOMAIN_POINT, ATTR_DOMAIN_CURVE)) {
separate_curve_selection(geometry_set, selection_field, domain, invert);
some_valid_domain = true;
}
}
r_is_error = !some_valid_domain && geometry_set.has_realized_data();
}
} // namespace blender::nodes
void register_node_type_geo_delete_geometry()
@@ -1217,10 +1220,11 @@ void register_node_type_geo_delete_geometry()
node_free_standard_storage,
node_copy_standard_storage);
node_type_init(&ntype, blender::nodes::geo_node_delete_geometry_init);
node_type_init(&ntype, blender::nodes::delete_geometry_node::geo_node_delete_geometry_init);
ntype.declare = blender::nodes::geo_node_delete_geometry_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_delete_geometry_exec;
ntype.draw_buttons = blender::nodes::geo_node_delete_geometry_layout;
ntype.declare = blender::nodes::delete_geometry_node::geo_node_delete_geometry_declare;
ntype.geometry_node_execute =
blender::nodes::delete_geometry_node::geo_node_delete_geometry_exec;
ntype.draw_buttons = blender::nodes::delete_geometry_node::geo_node_delete_geometry_layout;
nodeRegisterType(&ntype);
}

View File

@@ -38,7 +38,7 @@
using blender::bke::GeometryInstanceGroup;
namespace blender::nodes {
namespace blender::nodes::distribute_points_on_faces_node {
static void geo_node_point_distribute_points_on_faces_declare(NodeDeclarationBuilder &b)
{
@@ -573,7 +573,7 @@ static void geo_node_point_distribute_points_on_faces_exec(GeoNodeExecParams par
}
}
} // namespace blender::nodes
} // namespace blender::nodes::distribute_points_on_faces_node
void register_node_type_geo_distribute_points_on_faces()
{
@@ -584,10 +584,15 @@ void register_node_type_geo_distribute_points_on_faces()
"Distribute Points on Faces",
NODE_CLASS_GEOMETRY,
0);
node_type_update(&ntype, blender::nodes::node_point_distribute_points_on_faces_update);
node_type_update(&ntype,
blender::nodes::distribute_points_on_faces_node::
node_point_distribute_points_on_faces_update);
node_type_size(&ntype, 170, 100, 320);
ntype.declare = blender::nodes::geo_node_point_distribute_points_on_faces_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_point_distribute_points_on_faces_exec;
ntype.draw_buttons = blender::nodes::geo_node_point_distribute_points_on_faces_layout;
ntype.declare = blender::nodes::distribute_points_on_faces_node::
geo_node_point_distribute_points_on_faces_declare;
ntype.geometry_node_execute = blender::nodes::distribute_points_on_faces_node::
geo_node_point_distribute_points_on_faces_exec;
ntype.draw_buttons = blender::nodes::distribute_points_on_faces_node::
geo_node_point_distribute_points_on_faces_layout;
nodeRegisterType(&ntype);
}

View File

@@ -22,7 +22,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::edge_split_node {
static void geo_node_edge_split_declare(NodeDeclarationBuilder &b)
{
@@ -81,14 +81,14 @@ static void geo_node_edge_split_exec(GeoNodeExecParams params)
params.set_output("Mesh", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::edge_split_node
void register_node_type_geo_edge_split()
{
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_SPLIT_EDGES, "Split Edges", NODE_CLASS_GEOMETRY, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_edge_split_exec;
ntype.declare = blender::nodes::geo_node_edge_split_declare;
ntype.geometry_node_execute = blender::nodes::edge_split_node::geo_node_edge_split_exec;
ntype.declare = blender::nodes::edge_split_node::geo_node_edge_split_declare;
nodeRegisterType(&ntype);
}

View File

@@ -18,7 +18,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::mesh_to_curve_node {
static void geo_node_legacy_mesh_to_curve_declare(NodeDeclarationBuilder &b)
{
@@ -56,14 +56,15 @@ static void geo_node_legacy_mesh_to_curve_exec(GeoNodeExecParams params)
params.set_output("Curve", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::mesh_to_curve_node
void register_node_type_geo_mesh_to_curve()
{
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_MESH_TO_CURVE, "Mesh to Curve", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_legacy_mesh_to_curve_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_legacy_mesh_to_curve_exec;
ntype.declare = blender::nodes::mesh_to_curve_node::geo_node_legacy_mesh_to_curve_declare;
ntype.geometry_node_execute =
blender::nodes::mesh_to_curve_node::geo_node_legacy_mesh_to_curve_exec;
nodeRegisterType(&ntype);
}

View File

@@ -26,7 +26,7 @@
using blender::Array;
namespace blender::nodes {
namespace blender::nodes::mesh_to_points_node {
static void geo_node_mesh_to_points_declare(NodeDeclarationBuilder &b)
{
@@ -172,17 +172,17 @@ static void geo_node_mesh_to_points_exec(GeoNodeExecParams params)
params.set_output("Points", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::mesh_to_points_node
void register_node_type_geo_mesh_to_points()
{
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_MESH_TO_POINTS, "Mesh to Points", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_mesh_to_points_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_mesh_to_points_exec;
node_type_init(&ntype, blender::nodes::geo_node_mesh_to_points_init);
ntype.draw_buttons = blender::nodes::geo_node_mesh_to_points_layout;
ntype.declare = blender::nodes::mesh_to_points_node::geo_node_mesh_to_points_declare;
ntype.geometry_node_execute = blender::nodes::mesh_to_points_node::geo_node_mesh_to_points_exec;
node_type_init(&ntype, blender::nodes::mesh_to_points_node::geo_node_mesh_to_points_init);
ntype.draw_buttons = blender::nodes::mesh_to_points_node::geo_node_mesh_to_points_layout;
node_type_storage(
&ntype, "NodeGeometryMeshToPoints", node_free_standard_storage, node_copy_standard_storage);
nodeRegisterType(&ntype);

View File

@@ -28,7 +28,7 @@
#include "UI_interface.h"
#include "UI_resources.h"
namespace blender::nodes {
namespace blender::nodes::points_to_volume_node {
static void geo_node_points_to_volume_declare(NodeDeclarationBuilder &b)
{
@@ -253,7 +253,7 @@ static void geo_node_points_to_volume_exec(GeoNodeExecParams params)
#endif
}
} // namespace blender::nodes
} // namespace blender::nodes::points_to_volume_node
void register_node_type_geo_points_to_volume()
{
@@ -266,10 +266,12 @@ void register_node_type_geo_points_to_volume()
node_free_standard_storage,
node_copy_standard_storage);
node_type_size(&ntype, 170, 120, 700);
node_type_init(&ntype, blender::nodes::geo_node_points_to_volume_init);
node_type_update(&ntype, blender::nodes::geo_node_points_to_volume_update);
ntype.declare = blender::nodes::geo_node_points_to_volume_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_points_to_volume_exec;
ntype.draw_buttons = blender::nodes::geo_node_points_to_volume_layout;
node_type_init(&ntype, blender::nodes::points_to_volume_node::geo_node_points_to_volume_init);
node_type_update(&ntype,
blender::nodes::points_to_volume_node::geo_node_points_to_volume_update);
ntype.declare = blender::nodes::points_to_volume_node::geo_node_points_to_volume_declare;
ntype.geometry_node_execute =
blender::nodes::points_to_volume_node::geo_node_points_to_volume_exec;
ntype.draw_buttons = blender::nodes::points_to_volume_node::geo_node_points_to_volume_layout;
nodeRegisterType(&ntype);
}

View File

@@ -27,7 +27,7 @@
using namespace blender::bke::mesh_surface_sample;
namespace blender::nodes {
namespace blender::nodes::raycast_node {
static void geo_node_raycast_declare(NodeDeclarationBuilder &b)
{
@@ -426,7 +426,7 @@ static void geo_node_raycast_exec(GeoNodeExecParams params)
}
}
} // namespace blender::nodes
} // namespace blender::nodes::raycast_node
void register_node_type_geo_raycast()
{
@@ -434,12 +434,12 @@ void register_node_type_geo_raycast()
geo_node_type_base(&ntype, GEO_NODE_RAYCAST, "Raycast", NODE_CLASS_GEOMETRY, 0);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_init(&ntype, blender::nodes::geo_node_raycast_init);
node_type_update(&ntype, blender::nodes::geo_node_raycast_update);
node_type_init(&ntype, blender::nodes::raycast_node::geo_node_raycast_init);
node_type_update(&ntype, blender::nodes::raycast_node::geo_node_raycast_update);
node_type_storage(
&ntype, "NodeGeometryRaycast", node_free_standard_storage, node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_raycast_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_raycast_exec;
ntype.draw_buttons = blender::nodes::geo_node_raycast_layout;
ntype.declare = blender::nodes::raycast_node::geo_node_raycast_declare;
ntype.geometry_node_execute = blender::nodes::raycast_node::geo_node_raycast_exec;
ntype.draw_buttons = blender::nodes::raycast_node::geo_node_raycast_layout;
nodeRegisterType(&ntype);
}

View File

@@ -16,9 +16,9 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::separate_components_node {
static void geo_node_join_geometry_declare(NodeDeclarationBuilder &b)
static void geo_node_separate_components_declare(NodeDeclarationBuilder &b)
{
b.add_input<decl::Geometry>(N_("Geometry"));
b.add_output<decl::Geometry>(N_("Mesh"));
@@ -61,7 +61,7 @@ static void geo_node_separate_components_exec(GeoNodeExecParams params)
params.set_output("Instances", instances);
}
} // namespace blender::nodes
} // namespace blender::nodes::separate_components_node
void register_node_type_geo_separate_components()
{
@@ -69,7 +69,8 @@ void register_node_type_geo_separate_components()
geo_node_type_base(
&ntype, GEO_NODE_SEPARATE_COMPONENTS, "Separate Components", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_join_geometry_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_separate_components_exec;
ntype.declare = blender::nodes::separate_components_node::geo_node_separate_components_declare;
ntype.geometry_node_execute =
blender::nodes::separate_components_node::geo_node_separate_components_exec;
nodeRegisterType(&ntype);
}

View File

@@ -19,7 +19,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::separate_geometry_node {
static void geo_node_separate_geometry_declare(NodeDeclarationBuilder &b)
{
@@ -95,7 +95,7 @@ static void geo_node_separate_geometry_exec(GeoNodeExecParams params)
}
}
} // namespace blender::nodes
} // namespace blender::nodes::separate_geometry_node
void register_node_type_geo_separate_geometry()
{
@@ -109,10 +109,11 @@ void register_node_type_geo_separate_geometry()
node_free_standard_storage,
node_copy_standard_storage);
node_type_init(&ntype, blender::nodes::geo_node_separate_geometry_init);
node_type_init(&ntype, blender::nodes::separate_geometry_node::geo_node_separate_geometry_init);
ntype.declare = blender::nodes::geo_node_separate_geometry_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_separate_geometry_exec;
ntype.draw_buttons = blender::nodes::geo_node_separate_geometry_layout;
ntype.declare = blender::nodes::separate_geometry_node::geo_node_separate_geometry_declare;
ntype.geometry_node_execute =
blender::nodes::separate_geometry_node::geo_node_separate_geometry_exec;
ntype.draw_buttons = blender::nodes::separate_geometry_node::geo_node_separate_geometry_layout;
nodeRegisterType(&ntype);
}

View File

@@ -16,7 +16,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::set_curve_radius_node {
static void geo_node_set_curve_radius_declare(NodeDeclarationBuilder &b)
{
@@ -69,7 +69,7 @@ static void geo_node_set_curve_radius_exec(GeoNodeExecParams params)
params.set_output("Curve", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::set_curve_radius_node
void register_node_type_geo_set_curve_radius()
{
@@ -77,7 +77,8 @@ void register_node_type_geo_set_curve_radius()
geo_node_type_base(
&ntype, GEO_NODE_SET_CURVE_RADIUS, "Set Curve Radius", NODE_CLASS_GEOMETRY, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_set_curve_radius_exec;
ntype.declare = blender::nodes::geo_node_set_curve_radius_declare;
ntype.geometry_node_execute =
blender::nodes::set_curve_radius_node::geo_node_set_curve_radius_exec;
ntype.declare = blender::nodes::set_curve_radius_node::geo_node_set_curve_radius_declare;
nodeRegisterType(&ntype);
}

View File

@@ -16,7 +16,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::set_point_radius_node {
static void geo_node_set_point_radius_declare(NodeDeclarationBuilder &b)
{
@@ -70,7 +70,7 @@ static void geo_node_set_point_radius_exec(GeoNodeExecParams params)
params.set_output("Points", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::set_point_radius_node
void register_node_type_geo_set_point_radius()
{
@@ -78,7 +78,8 @@ void register_node_type_geo_set_point_radius()
geo_node_type_base(
&ntype, GEO_NODE_SET_POINT_RADIUS, "Set Point Radius", NODE_CLASS_GEOMETRY, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_set_point_radius_exec;
ntype.declare = blender::nodes::geo_node_set_point_radius_declare;
ntype.geometry_node_execute =
blender::nodes::set_point_radius_node::geo_node_set_point_radius_exec;
ntype.declare = blender::nodes::set_point_radius_node::geo_node_set_point_radius_declare;
nodeRegisterType(&ntype);
}

View File

@@ -27,7 +27,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::subdivision_surface_node {
static void geo_node_subdivision_surface_declare(NodeDeclarationBuilder &b)
{
@@ -145,7 +145,7 @@ static void geo_node_subdivision_surface_exec(GeoNodeExecParams params)
params.set_output("Mesh", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::subdivision_surface_node
void register_node_type_geo_subdivision_surface()
{
@@ -153,10 +153,13 @@ void register_node_type_geo_subdivision_surface()
geo_node_type_base(
&ntype, GEO_NODE_SUBDIVISION_SURFACE, "Subdivision Surface", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_subdivision_surface_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_subdivision_surface_exec;
ntype.draw_buttons = blender::nodes::geo_node_subdivision_surface_layout;
node_type_init(&ntype, blender::nodes::geo_node_subdivision_surface_init);
ntype.declare = blender::nodes::subdivision_surface_node::geo_node_subdivision_surface_declare;
ntype.geometry_node_execute =
blender::nodes::subdivision_surface_node::geo_node_subdivision_surface_exec;
ntype.draw_buttons =
blender::nodes::subdivision_surface_node::geo_node_subdivision_surface_layout;
node_type_init(&ntype,
blender::nodes::subdivision_surface_node::geo_node_subdivision_surface_init);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_storage(&ntype,
"NodeGeometrySubdivisionSurface",

View File

@@ -36,7 +36,7 @@
using namespace blender::bke::mesh_surface_sample;
using blender::fn::GArray;
namespace blender::nodes {
namespace blender::nodes::attribute_transfer_node {
static void geo_node_transfer_attribute_declare(NodeDeclarationBuilder &b)
{
@@ -802,7 +802,7 @@ static void geo_node_transfer_attribute_exec(GeoNodeExecParams params)
output_attribute_field(params, std::move(output_field));
}
} // namespace blender::nodes
} // namespace blender::nodes::attribute_transfer_node
void register_node_type_geo_transfer_attribute()
{
@@ -810,14 +810,17 @@ void register_node_type_geo_transfer_attribute()
geo_node_type_base(
&ntype, GEO_NODE_TRANSFER_ATTRIBUTE, "Transfer Attribute", NODE_CLASS_ATTRIBUTE, 0);
node_type_init(&ntype, blender::nodes::geo_node_transfer_attribute_init);
node_type_update(&ntype, blender::nodes::geo_node_transfer_attribute_update);
node_type_init(&ntype,
blender::nodes::attribute_transfer_node::geo_node_transfer_attribute_init);
node_type_update(&ntype,
blender::nodes::attribute_transfer_node::geo_node_transfer_attribute_update);
node_type_storage(&ntype,
"NodeGeometryTransferAttribute",
node_free_standard_storage,
node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_transfer_attribute_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_transfer_attribute_exec;
ntype.draw_buttons = blender::nodes::geo_node_transfer_attribute_layout;
ntype.declare = blender::nodes::attribute_transfer_node::geo_node_transfer_attribute_declare;
ntype.geometry_node_execute =
blender::nodes::attribute_transfer_node::geo_node_transfer_attribute_exec;
ntype.draw_buttons = blender::nodes::attribute_transfer_node::geo_node_transfer_attribute_layout;
nodeRegisterType(&ntype);
}

View File

@@ -35,7 +35,7 @@
#include "UI_interface.h"
#include "UI_resources.h"
namespace blender::nodes {
namespace blender::nodes::volume_to_mesh_node {
static void geo_node_volume_to_mesh_declare(NodeDeclarationBuilder &b)
{
@@ -192,20 +192,20 @@ static void geo_node_volume_to_mesh_exec(GeoNodeExecParams params)
params.set_output("Mesh", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::volume_to_mesh_node
void register_node_type_geo_volume_to_mesh()
{
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_VOLUME_TO_MESH, "Volume to Mesh", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_volume_to_mesh_declare;
ntype.declare = blender::nodes::volume_to_mesh_node::geo_node_volume_to_mesh_declare;
node_type_storage(
&ntype, "NodeGeometryVolumeToMesh", node_free_standard_storage, node_copy_standard_storage);
node_type_size(&ntype, 170, 120, 700);
node_type_init(&ntype, blender::nodes::geo_node_volume_to_mesh_init);
node_type_update(&ntype, blender::nodes::geo_node_volume_to_mesh_update);
ntype.geometry_node_execute = blender::nodes::geo_node_volume_to_mesh_exec;
ntype.draw_buttons = blender::nodes::geo_node_volume_to_mesh_layout;
node_type_init(&ntype, blender::nodes::volume_to_mesh_node::geo_node_volume_to_mesh_init);
node_type_update(&ntype, blender::nodes::volume_to_mesh_node::geo_node_volume_to_mesh_update);
ntype.geometry_node_execute = blender::nodes::volume_to_mesh_node::geo_node_volume_to_mesh_exec;
ntype.draw_buttons = blender::nodes::volume_to_mesh_node::geo_node_volume_to_mesh_layout;
nodeRegisterType(&ntype);
}

View File

@@ -19,7 +19,7 @@
#include "../node_shader_util.h"
static bNodeSocketTemplate outputs[] = {
static bNodeSocketTemplate node_shader_hair_info_outputs[] = {
{SOCK_FLOAT, N_("Is Strand"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{SOCK_FLOAT, N_("Intercept"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{SOCK_FLOAT, N_("Length"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@@ -49,7 +49,7 @@ void register_node_type_sh_hair_info(void)
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_HAIR_INFO, "Hair Info", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, NULL, outputs);
node_type_socket_templates(&ntype, NULL, node_shader_hair_info_outputs);
node_type_init(&ntype, NULL);
node_type_storage(&ntype, "", NULL, NULL);
node_type_gpu(&ntype, node_shader_gpu_hair_info);

View File

@@ -30,11 +30,11 @@ static bNodeSocketTemplate sh_node_holdout_out[] = {
{-1, ""},
};
static int gpu_shader_rgb(GPUMaterial *mat,
bNode *node,
bNodeExecData *UNUSED(execdata),
GPUNodeStack *in,
GPUNodeStack *out)
static int sh_node_holdout_gpu_shader_rgb(GPUMaterial *mat,
bNode *node,
bNodeExecData *UNUSED(execdata),
GPUNodeStack *in,
GPUNodeStack *out)
{
return GPU_stack_link(mat, node, "node_holdout", in, out);
}
@@ -48,7 +48,7 @@ void register_node_type_sh_holdout(void)
node_type_socket_templates(&ntype, sh_node_holdout_in, sh_node_holdout_out);
node_type_init(&ntype, NULL);
node_type_storage(&ntype, "", NULL, NULL);
node_type_gpu(&ntype, gpu_shader_rgb);
node_type_gpu(&ntype, sh_node_holdout_gpu_shader_rgb);
nodeRegisterType(&ntype);
}

View File

@@ -53,7 +53,7 @@ static void node_shader_init_map_range(bNodeTree *UNUSED(ntree), bNode *node)
node->custom2 = NODE_MAP_RANGE_LINEAR; /* interpolation */
}
static const char *gpu_shader_get_name(int mode)
static const char *gpu_shader_map_range_gpu_shader_get_name(int mode)
{
switch (mode) {
case NODE_MAP_RANGE_LINEAR:
@@ -75,7 +75,7 @@ static int gpu_shader_map_range(GPUMaterial *mat,
GPUNodeStack *in,
GPUNodeStack *out)
{
const char *name = gpu_shader_get_name(node->custom2);
const char *name = gpu_shader_map_range_gpu_shader_get_name(node->custom2);
int ret = 0;
if (name != nullptr) {

View File

@@ -46,7 +46,7 @@ static void sh_node_math_declare(NodeDeclarationBuilder &b)
} // namespace blender::nodes
static const char *gpu_shader_get_name(int mode)
static const char *sh_node_math_gpu_shader_get_name(int mode)
{
const blender::nodes::FloatMathOperationInfo *info =
blender::nodes::get_float_math_operation_info(mode);
@@ -65,7 +65,7 @@ static int gpu_shader_math(GPUMaterial *mat,
GPUNodeStack *in,
GPUNodeStack *out)
{
const char *name = gpu_shader_get_name(node->custom1);
const char *name = sh_node_math_gpu_shader_get_name(node->custom1);
if (name != nullptr) {
int ret = GPU_stack_link(mat, node, name, in, out);

View File

@@ -62,7 +62,7 @@ static void node_shader_exec_mix_rgb(void *UNUSED(data),
copy_v3_v3(out[0]->vec, col);
}
static const char *gpu_shader_get_name(int mode)
static const char *gpu_shader_mix_rgb_gpu_shader_get_name(int mode)
{
switch (mode) {
case MA_RAMP_BLEND:
@@ -112,7 +112,7 @@ static int gpu_shader_mix_rgb(GPUMaterial *mat,
GPUNodeStack *in,
GPUNodeStack *out)
{
const char *name = gpu_shader_get_name(node->custom1);
const char *name = gpu_shader_mix_rgb_gpu_shader_get_name(node->custom1);
if (name != nullptr) {
int ret = GPU_stack_link(mat, node, name, in, out);

View File

@@ -20,7 +20,7 @@
#include "../node_shader_util.h"
#include "RE_texture.h"
static bNodeSocketTemplate outputs[] = {
static bNodeSocketTemplate node_shader_particle_info_outputs[] = {
{SOCK_FLOAT, "Index"},
{SOCK_FLOAT, "Random"},
{SOCK_FLOAT, "Age"},
@@ -67,7 +67,7 @@ void register_node_type_sh_particle_info(void)
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_PARTICLE_INFO, "Particle Info", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, NULL, outputs);
node_type_socket_templates(&ntype, NULL, node_shader_particle_info_outputs);
node_type_exec(&ntype, NULL, NULL, node_shader_exec_particle_info);
node_type_gpu(&ntype, gpu_shader_particle_info);

View File

@@ -29,11 +29,11 @@ static bNodeSocketTemplate sh_node_rgb_out[] = {
{-1, ""},
};
static int gpu_shader_rgb(GPUMaterial *mat,
bNode *node,
bNodeExecData *UNUSED(execdata),
GPUNodeStack *in,
GPUNodeStack *out)
static int sh_node_rgb_gpu_shader_rgb(GPUMaterial *mat,
bNode *node,
bNodeExecData *UNUSED(execdata),
GPUNodeStack *in,
GPUNodeStack *out)
{
GPUNodeLink *link = GPU_uniformbuf_link_out(mat, node, out, 0);
return GPU_stack_link(mat, node, "set_rgba", in, out, link);
@@ -45,7 +45,7 @@ void register_node_type_sh_rgb(void)
sh_node_type_base(&ntype, SH_NODE_RGB, "RGB", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, NULL, sh_node_rgb_out);
node_type_gpu(&ntype, gpu_shader_rgb);
node_type_gpu(&ntype, sh_node_rgb_gpu_shader_rgb);
nodeRegisterType(&ntype);
}

View File

@@ -25,7 +25,7 @@
/* **************** Script ******************** */
static void init(bNodeTree *UNUSED(ntree), bNode *node)
static void node_shader_script_init(bNodeTree *UNUSED(ntree), bNode *node)
{
NodeShaderScript *nss = MEM_callocN(sizeof(NodeShaderScript), "shader script node");
node->storage = nss;
@@ -63,7 +63,7 @@ void register_node_type_sh_script(void)
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_SCRIPT, "Script", NODE_CLASS_SCRIPT, 0);
node_type_init(&ntype, init);
node_type_init(&ntype, node_shader_script_init);
node_type_storage(&ntype, "NodeShaderScript", node_free_script, node_copy_script);
nodeRegisterType(&ntype);

View File

@@ -52,7 +52,7 @@ static void node_shader_init_tex_noise(bNodeTree *UNUSED(ntree), bNode *node)
node->storage = tex;
}
static const char *gpu_shader_get_name(const int dimensions)
static const char *node_shader_tex_noise_gpu_shader_get_name(const int dimensions)
{
BLI_assert(dimensions >= 1 && dimensions <= 4);
return std::array{"node_noise_texture_1d",
@@ -72,7 +72,7 @@ static int node_shader_gpu_tex_noise(GPUMaterial *mat,
node_shader_gpu_tex_mapping(mat, node, in, out);
NodeTexNoise *tex = (NodeTexNoise *)node->storage;
const char *name = gpu_shader_get_name(tex->dimensions);
const char *name = node_shader_tex_noise_gpu_shader_get_name(tex->dimensions);
return GPU_stack_link(mat, node, name, in, out);
}

View File

@@ -61,7 +61,8 @@ static void node_shader_init_tex_voronoi(bNodeTree *UNUSED(ntree), bNode *node)
node->storage = tex;
}
static const char *gpu_shader_get_name(const int feature, const int dimensions)
static const char *node_shader_tex_voronoi_gpu_shader_get_name(const int feature,
const int dimensions)
{
BLI_assert(feature >= 0 && feature < 5);
BLI_assert(dimensions > 0 && dimensions < 5);
@@ -118,7 +119,7 @@ static int node_shader_gpu_tex_voronoi(GPUMaterial *mat,
NodeTexVoronoi *tex = (NodeTexVoronoi *)node->storage;
float metric = tex->distance;
const char *name = gpu_shader_get_name(tex->feature, tex->dimensions);
const char *name = node_shader_tex_voronoi_gpu_shader_get_name(tex->feature, tex->dimensions);
return GPU_stack_link(mat, node, name, in, out, GPU_constant(&metric));
}

View File

@@ -39,7 +39,7 @@ static void node_shader_init_tex_white_noise(bNodeTree *UNUSED(ntree), bNode *no
node->custom1 = 3;
}
static const char *gpu_shader_get_name(const int dimensions)
static const char *node_shader_tex_white_noise_gpu_shader_get_name(const int dimensions)
{
BLI_assert(dimensions >= 1 && dimensions <= 4);
return std::array{"node_white_noise_1d",
@@ -54,7 +54,7 @@ static int gpu_shader_tex_white_noise(GPUMaterial *mat,
GPUNodeStack *in,
GPUNodeStack *out)
{
const char *name = gpu_shader_get_name(node->custom1);
const char *name = node_shader_tex_white_noise_gpu_shader_get_name(node->custom1);
return GPU_stack_link(mat, node, name, in, out);
}
@@ -183,7 +183,8 @@ class WhiteNoiseFunction : public fn::MultiFunction {
}
};
static void sh_node_noise_build_multi_function(blender::nodes::NodeMultiFunctionBuilder &builder)
static void sh_node_white_noise_build_multi_function(
blender::nodes::NodeMultiFunctionBuilder &builder)
{
bNode &node = builder.node();
builder.construct_and_set_matching_fn<WhiteNoiseFunction>((int)node.custom1);
@@ -201,7 +202,7 @@ void register_node_type_sh_tex_white_noise(void)
node_type_init(&ntype, node_shader_init_tex_white_noise);
node_type_gpu(&ntype, gpu_shader_tex_white_noise);
node_type_update(&ntype, node_shader_update_tex_white_noise);
ntype.build_multi_function = blender::nodes::sh_node_noise_build_multi_function;
ntype.build_multi_function = blender::nodes::sh_node_white_noise_build_multi_function;
nodeRegisterType(&ntype);
}

View File

@@ -40,7 +40,7 @@ static void sh_node_vector_math_declare(NodeDeclarationBuilder &b)
} // namespace blender::nodes
static const char *gpu_shader_get_name(int mode)
static const char *sh_node_vector_math_gpu_shader_get_name(int mode)
{
switch (mode) {
case NODE_VECTOR_MATH_ADD:
@@ -111,7 +111,7 @@ static int gpu_shader_vector_math(GPUMaterial *mat,
GPUNodeStack *in,
GPUNodeStack *out)
{
const char *name = gpu_shader_get_name(node->custom1);
const char *name = sh_node_vector_math_gpu_shader_get_name(node->custom1);
if (name != nullptr) {
return GPU_stack_link(mat, node, name, in, out);
}
@@ -187,7 +187,7 @@ static void node_shader_update_vector_math(bNodeTree *UNUSED(ntree), bNode *node
}
}
static const blender::fn::MultiFunction *get_multi_function(bNode &node)
static const blender::fn::MultiFunction *sh_node_vector_math_get_multi_function(bNode &node)
{
using blender::float3;
@@ -269,7 +269,7 @@ static const blender::fn::MultiFunction *get_multi_function(bNode &node)
static void sh_node_vector_math_build_multi_function(
blender::nodes::NodeMultiFunctionBuilder &builder)
{
const blender::fn::MultiFunction *fn = get_multi_function(builder.node());
const blender::fn::MultiFunction *fn = sh_node_vector_math_get_multi_function(builder.node());
builder.set_matching_fn(fn);
}

View File

@@ -38,7 +38,7 @@ static void sh_node_vector_rotate_declare(NodeDeclarationBuilder &b)
} // namespace blender::nodes
static const char *gpu_shader_get_name(int mode)
static const char *shader_nose_vector_rotate_gpu_shader_get_name(int mode)
{
switch (mode) {
case NODE_VECTOR_ROTATE_TYPE_AXIS:
@@ -62,7 +62,7 @@ static int gpu_shader_vector_rotate(GPUMaterial *mat,
GPUNodeStack *in,
GPUNodeStack *out)
{
const char *name = gpu_shader_get_name(node->custom1);
const char *name = shader_nose_vector_rotate_gpu_shader_get_name(node->custom1);
if (name != nullptr) {
float invert = (node->custom2) ? -1.0 : 1.0;
@@ -101,7 +101,8 @@ static float3 sh_node_vector_rotate_euler(const float3 vector,
return result + center;
}
static const blender::fn::MultiFunction *get_multi_function(bNode &node)
static const blender::fn::MultiFunction *sh_node_vector_rotate_euler_get_multi_function(
bNode &node)
{
bool invert = node.custom2;
const int mode = node.custom1;
@@ -189,7 +190,8 @@ static const blender::fn::MultiFunction *get_multi_function(bNode &node)
static void sh_node_vector_rotate_build_multi_function(
blender::nodes::NodeMultiFunctionBuilder &builder)
{
const blender::fn::MultiFunction *fn = get_multi_function(builder.node());
const blender::fn::MultiFunction *fn = sh_node_vector_rotate_euler_get_multi_function(
builder.node());
builder.set_matching_fn(fn);
}

View File

@@ -50,114 +50,114 @@
#include "RE_texture.h"
static void texture_get_from_context(const bContext *C,
bNodeTreeType *UNUSED(treetype),
bNodeTree **r_ntree,
ID **r_id,
ID **r_from)
{
SpaceNode *snode = CTX_wm_space_node(C);
Scene *scene = CTX_data_scene(C);
ViewLayer *view_layer = CTX_data_view_layer(C);
Object *ob = OBACT(view_layer);
Tex *tx = NULL;
// static void texture_get_from_context(const bContext *C,
// bNodeTreeType *UNUSED(treetype),
// bNodeTree **r_ntree,
// ID **r_id,
// ID **r_from)
// {
// SpaceNode *snode = CTX_wm_space_node(C);
// Scene *scene = CTX_data_scene(C);
// ViewLayer *view_layer = CTX_data_view_layer(C);
// Object *ob = OBACT(view_layer);
// Tex *tx = NULL;
if (snode->texfrom == SNODE_TEX_BRUSH) {
struct Brush *brush = NULL;
// if (snode->texfrom == SNODE_TEX_BRUSH) {
// struct Brush *brush = NULL;
if (ob && (ob->mode & OB_MODE_SCULPT)) {
brush = BKE_paint_brush(&scene->toolsettings->sculpt->paint);
}
else {
brush = BKE_paint_brush(&scene->toolsettings->imapaint.paint);
}
// if (ob && (ob->mode & OB_MODE_SCULPT)) {
// brush = BKE_paint_brush(&scene->toolsettings->sculpt->paint);
// }
// else {
// brush = BKE_paint_brush(&scene->toolsettings->imapaint.paint);
// }
if (brush) {
*r_from = (ID *)brush;
tx = give_current_brush_texture(brush);
if (tx) {
*r_id = &tx->id;
*r_ntree = tx->nodetree;
}
}
}
else if (snode->texfrom == SNODE_TEX_LINESTYLE) {
FreestyleLineStyle *linestyle = BKE_linestyle_active_from_view_layer(view_layer);
if (linestyle) {
*r_from = (ID *)linestyle;
tx = give_current_linestyle_texture(linestyle);
if (tx) {
*r_id = &tx->id;
*r_ntree = tx->nodetree;
}
}
}
}
// if (brush) {
// *r_from = (ID *)brush;
// tx = give_current_brush_texture(brush);
// if (tx) {
// *r_id = &tx->id;
// *r_ntree = tx->nodetree;
// }
// }
// }
// else if (snode->texfrom == SNODE_TEX_LINESTYLE) {
// FreestyleLineStyle *linestyle = BKE_linestyle_active_from_view_layer(view_layer);
// if (linestyle) {
// *r_from = (ID *)linestyle;
// tx = give_current_linestyle_texture(linestyle);
// if (tx) {
// *r_id = &tx->id;
// *r_ntree = tx->nodetree;
// }
// }
// }
// }
static void foreach_nodeclass(Scene *UNUSED(scene), void *calldata, bNodeClassCallback func)
{
func(calldata, NODE_CLASS_INPUT, N_("Input"));
func(calldata, NODE_CLASS_OUTPUT, N_("Output"));
func(calldata, NODE_CLASS_OP_COLOR, N_("Color"));
func(calldata, NODE_CLASS_PATTERN, N_("Patterns"));
func(calldata, NODE_CLASS_TEXTURE, N_("Textures"));
func(calldata, NODE_CLASS_CONVERTER, N_("Converter"));
func(calldata, NODE_CLASS_DISTORT, N_("Distort"));
func(calldata, NODE_CLASS_GROUP, N_("Group"));
func(calldata, NODE_CLASS_INTERFACE, N_("Interface"));
func(calldata, NODE_CLASS_LAYOUT, N_("Layout"));
}
// static void foreach_nodeclass(Scene *UNUSED(scene), void *calldata, bNodeClassCallback func)
// {
// func(calldata, NODE_CLASS_INPUT, N_("Input"));
// func(calldata, NODE_CLASS_OUTPUT, N_("Output"));
// func(calldata, NODE_CLASS_OP_COLOR, N_("Color"));
// func(calldata, NODE_CLASS_PATTERN, N_("Patterns"));
// func(calldata, NODE_CLASS_TEXTURE, N_("Textures"));
// func(calldata, NODE_CLASS_CONVERTER, N_("Converter"));
// func(calldata, NODE_CLASS_DISTORT, N_("Distort"));
// func(calldata, NODE_CLASS_GROUP, N_("Group"));
// func(calldata, NODE_CLASS_INTERFACE, N_("Interface"));
// func(calldata, NODE_CLASS_LAYOUT, N_("Layout"));
// }
/* XXX muting disabled in previews because of threading issues with the main execution
* it works here, but disabled for consistency
*/
#if 1
static void localize(bNodeTree *localtree, bNodeTree *UNUSED(ntree))
{
bNode *node, *node_next;
// /* XXX muting disabled in previews because of threading issues with the main execution
// * it works here, but disabled for consistency
// */
// #if 1
// static void localize(bNodeTree *localtree, bNodeTree *UNUSED(ntree))
// {
// bNode *node, *node_next;
/* replace muted nodes and reroute nodes by internal links */
for (node = localtree->nodes.first; node; node = node_next) {
node_next = node->next;
// /* replace muted nodes and reroute nodes by internal links */
// for (node = localtree->nodes.first; node; node = node_next) {
// node_next = node->next;
if (node->flag & NODE_MUTED || node->type == NODE_REROUTE) {
nodeInternalRelink(localtree, node);
ntreeFreeLocalNode(localtree, node);
}
}
}
#else
static void localize(bNodeTree *UNUSED(localtree), bNodeTree *UNUSED(ntree))
{
}
#endif
// if (node->flag & NODE_MUTED || node->type == NODE_REROUTE) {
// nodeInternalRelink(localtree, node);
// ntreeFreeLocalNode(localtree, node);
// }
// }
// }
// #else
// static void localize(bNodeTree *UNUSED(localtree), bNodeTree *UNUSED(ntree))
// {
// }
// #endif
static void local_sync(bNodeTree *localtree, bNodeTree *ntree)
{
BKE_node_preview_sync_tree(ntree, localtree);
}
// static void local_sync(bNodeTree *localtree, bNodeTree *ntree)
// {
// BKE_node_preview_sync_tree(ntree, localtree);
// }
static void local_merge(Main *UNUSED(bmain), bNodeTree *localtree, bNodeTree *ntree)
{
BKE_node_preview_merge_tree(ntree, localtree, true);
}
// static void local_merge(Main *UNUSED(bmain), bNodeTree *localtree, bNodeTree *ntree)
// {
// BKE_node_preview_merge_tree(ntree, localtree, true);
// }
static void update(bNodeTree *ntree)
{
ntree_update_reroute_nodes(ntree);
// static void update(bNodeTree *ntree)
// {
// ntree_update_reroute_nodes(ntree);
if (ntree->update & NTREE_UPDATE_NODES) {
/* clean up preview cache, in case nodes have been removed */
BKE_node_preview_remove_unused(ntree);
}
}
// if (ntree->update & NTREE_UPDATE_NODES) {
// /* clean up preview cache, in case nodes have been removed */
// BKE_node_preview_remove_unused(ntree);
// }
// }
static bool texture_node_tree_socket_type_valid(bNodeTreeType *UNUSED(ntreetype),
bNodeSocketType *socket_type)
{
return nodeIsStaticSocketType(socket_type) &&
ELEM(socket_type->type, SOCK_FLOAT, SOCK_VECTOR, SOCK_RGBA);
}
// static bool texture_node_tree_socket_type_valid(bNodeTreeType *UNUSED(ntreetype),
// bNodeSocketType *socket_type)
// {
// return nodeIsStaticSocketType(socket_type) &&
// ELEM(socket_type->type, SOCK_FLOAT, SOCK_VECTOR, SOCK_RGBA);
// }
bNodeTreeType *ntreeType_Texture;
@@ -172,13 +172,13 @@ void register_node_tree_type_tex(void)
tt->ui_icon = 0; /* Defined in `drawnode.c`. */
strcpy(tt->ui_description, N_("Texture nodes"));
tt->foreach_nodeclass = foreach_nodeclass;
tt->update = update;
tt->localize = localize;
tt->local_sync = local_sync;
tt->local_merge = local_merge;
tt->get_from_context = texture_get_from_context;
tt->valid_socket_type = texture_node_tree_socket_type_valid;
// tt->foreach_nodeclass = foreach_nodeclass;
// tt->update = update;
// tt->localize = localize;
// tt->local_sync = local_sync;
// tt->local_merge = local_merge;
// tt->get_from_context = texture_get_from_context;
// tt->valid_socket_type = texture_node_tree_socket_type_valid;
tt->rna_ext.srna = &RNA_TextureNodeTree;

View File

@@ -26,7 +26,7 @@
#include <math.h>
static bNodeSocketTemplate inputs[] = {
static bNodeSocketTemplate node_sh_texture_brick_inputs[] = {
{SOCK_RGBA, N_("Bricks 1"), 0.596f, 0.282f, 0.0f, 1.0f},
{SOCK_RGBA, N_("Bricks 2"), 0.632f, 0.504f, 0.05f, 1.0f},
{SOCK_RGBA, N_("Mortar"), 0.0f, 0.0f, 0.0f, 1.0f},
@@ -36,18 +36,18 @@ static bNodeSocketTemplate inputs[] = {
{SOCK_FLOAT, N_("Row Height"), 0.25f, 0.0f, 0.0f, 0.0f, 0.001f, 99.0f, PROP_UNSIGNED},
{-1, ""},
};
static bNodeSocketTemplate outputs[] = {
static bNodeSocketTemplate node_sh_texture_brick_outputs[] = {
{SOCK_RGBA, N_("Color")},
{-1, ""},
};
static void init(bNodeTree *UNUSED(ntree), bNode *node)
static void node_sh_texture_brick_init(bNodeTree *UNUSED(ntree), bNode *node)
{
node->custom3 = 0.5; /* offset */
node->custom4 = 1.0; /* squash */
}
static float noise(int n) /* fast integer noise */
static float node_sh_texture_brick_noise(int n) /* fast integer noise */
{
int nn;
n = (n >> 13) ^ n;
@@ -55,7 +55,8 @@ static float noise(int n) /* fast integer noise */
return 0.5f * ((float)nn / 1073741824.0f);
}
static void colorfn(float *out, TexParams *p, bNode *node, bNodeStack **in, short thread)
static void node_sh_texture_brick_colorfn(
float *out, TexParams *p, bNode *node, bNodeStack **in, short thread)
{
const float *co = p->co;
@@ -92,7 +93,7 @@ static void colorfn(float *out, TexParams *p, bNode *node, bNodeStack **in, shor
ins_x = (x + offset) - brick_width * bricknum;
ins_y = y - row_height * rownum;
tint = noise((rownum << 16) + (bricknum & 0xFFFF)) + bias;
tint = node_sh_texture_brick_noise((rownum << 16) + (bricknum & 0xFFFF)) + bias;
CLAMP(tint, 0.0f, 1.0f);
if (ins_x < mortar_thickness || ins_y < mortar_thickness ||
@@ -105,14 +106,14 @@ static void colorfn(float *out, TexParams *p, bNode *node, bNodeStack **in, shor
}
}
static void exec(void *data,
int UNUSED(thread),
bNode *node,
bNodeExecData *execdata,
bNodeStack **in,
bNodeStack **out)
static void node_sh_texture_brick_exec(void *data,
int UNUSED(thread),
bNode *node,
bNodeExecData *execdata,
bNodeStack **in,
bNodeStack **out)
{
tex_output(node, execdata, in, out[0], &colorfn, data);
tex_output(node, execdata, in, out[0], &node_sh_texture_brick_colorfn, data);
}
void register_node_type_tex_bricks(void)
@@ -120,10 +121,10 @@ void register_node_type_tex_bricks(void)
static bNodeType ntype;
tex_node_type_base(&ntype, TEX_NODE_BRICKS, "Bricks", NODE_CLASS_PATTERN, NODE_PREVIEW);
node_type_socket_templates(&ntype, inputs, outputs);
node_type_socket_templates(&ntype, node_sh_texture_brick_inputs, node_sh_texture_brick_outputs);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_init(&ntype, init);
node_type_exec(&ntype, NULL, NULL, exec);
node_type_init(&ntype, node_sh_texture_brick_init);
node_type_exec(&ntype, NULL, NULL, node_sh_texture_brick_exec);
nodeRegisterType(&ntype);
}

View File

@@ -24,12 +24,12 @@
#include "NOD_texture.h"
#include "node_texture_util.h"
static bNodeSocketTemplate outputs[] = {
static bNodeSocketTemplate node_sh_texture_image_outputs[] = {
{SOCK_RGBA, N_("Image")},
{-1, ""},
};
static void colorfn(
static void node_sh_texture_image_colorfn(
float *out, TexParams *p, bNode *node, bNodeStack **UNUSED(in), short UNUSED(thread))
{
float x = p->co[0];
@@ -86,17 +86,17 @@ static void colorfn(
}
}
static void exec(void *data,
int UNUSED(thread),
bNode *node,
bNodeExecData *execdata,
bNodeStack **in,
bNodeStack **out)
static void node_sh_texture_image_exec(void *data,
int UNUSED(thread),
bNode *node,
bNodeExecData *execdata,
bNodeStack **in,
bNodeStack **out)
{
tex_output(node, execdata, in, out[0], &colorfn, data);
tex_output(node, execdata, in, out[0], &node_sh_texture_image_colorfn, data);
}
static void init(bNodeTree *UNUSED(ntree), bNode *node)
static void node_sh_texture_image_init(bNodeTree *UNUSED(ntree), bNode *node)
{
ImageUser *iuser = MEM_callocN(sizeof(ImageUser), "node image user");
node->storage = iuser;
@@ -109,10 +109,10 @@ void register_node_type_tex_image(void)
static bNodeType ntype;
tex_node_type_base(&ntype, TEX_NODE_IMAGE, "Image", NODE_CLASS_INPUT, NODE_PREVIEW);
node_type_socket_templates(&ntype, NULL, outputs);
node_type_init(&ntype, init);
node_type_socket_templates(&ntype, NULL, node_sh_texture_image_outputs);
node_type_init(&ntype, node_sh_texture_image_init);
node_type_storage(&ntype, "ImageUser", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, NULL, NULL, exec);
node_type_exec(&ntype, NULL, NULL, node_sh_texture_image_exec);
node_type_label(&ntype, node_image_label);
nodeRegisterType(&ntype);

View File

@@ -25,19 +25,19 @@
#include "node_texture_util.h"
/* **************** COMPOSITE ******************** */
static bNodeSocketTemplate inputs[] = {
static bNodeSocketTemplate node_cmp_texture_out_inputs[] = {
{SOCK_RGBA, N_("Color"), 0.0f, 0.0f, 0.0f, 1.0f},
{SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, PROP_DIRECTION},
{-1, ""},
};
/* applies to render pipeline */
static void exec(void *data,
int UNUSED(thread),
bNode *node,
bNodeExecData *execdata,
bNodeStack **in,
bNodeStack **UNUSED(out))
static void node_cmp_texture_out_exec(void *data,
int UNUSED(thread),
bNode *node,
bNodeExecData *execdata,
bNodeStack **in,
bNodeStack **UNUSED(out))
{
TexCallData *cdata = (TexCallData *)data;
TexResult *target = cdata->target;
@@ -77,7 +77,7 @@ static void exec(void *data,
}
}
static void unique_name(bNode *node)
static void node_cmp_texture_out_unique_name(bNode *node)
{
TexNodeOutput *tno = (TexNodeOutput *)node->storage;
char new_name[sizeof(tno->name)];
@@ -121,7 +121,7 @@ static void unique_name(bNode *node)
}
}
static void assign_index(struct bNode *node)
static void node_cmp_texture_out_assign_index(struct bNode *node)
{
bNode *tnode;
int index = 1;
@@ -144,21 +144,23 @@ check_index:
node->custom1 = index;
}
static void init(bNodeTree *UNUSED(ntree), bNode *node)
static void node_cmp_texture_out_init(bNodeTree *UNUSED(ntree), bNode *node)
{
TexNodeOutput *tno = MEM_callocN(sizeof(TexNodeOutput), "TEX_output");
node->storage = tno;
strcpy(tno->name, "Default");
unique_name(node);
assign_index(node);
node_cmp_texture_out_unique_name(node);
node_cmp_texture_out_assign_index(node);
}
static void copy(bNodeTree *dest_ntree, bNode *dest_node, const bNode *src_node)
static void node_cmp_texture_out_copy(bNodeTree *dest_ntree,
bNode *dest_node,
const bNode *src_node)
{
node_copy_standard_storage(dest_ntree, dest_node, src_node);
unique_name(dest_node);
assign_index(dest_node);
node_cmp_texture_out_unique_name(dest_node);
node_cmp_texture_out_assign_index(dest_node);
}
void register_node_type_tex_output(void)
@@ -166,11 +168,12 @@ void register_node_type_tex_output(void)
static bNodeType ntype;
tex_node_type_base(&ntype, TEX_NODE_OUTPUT, "Output", NODE_CLASS_OUTPUT, NODE_PREVIEW);
node_type_socket_templates(&ntype, inputs, NULL);
node_type_socket_templates(&ntype, node_cmp_texture_out_inputs, NULL);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_init(&ntype, init);
node_type_storage(&ntype, "TexNodeOutput", node_free_standard_storage, copy);
node_type_exec(&ntype, NULL, NULL, exec);
node_type_init(&ntype, node_cmp_texture_out_init);
node_type_storage(
&ntype, "TexNodeOutput", node_free_standard_storage, node_cmp_texture_out_copy);
node_type_exec(&ntype, NULL, NULL, node_cmp_texture_out_exec);
/* Do not allow muting output. */
node_type_internal_links(&ntype, NULL);

View File

@@ -29,287 +29,3 @@
/*
* In this file: wrappers to use procedural textures as nodes
*/
static bNodeSocketTemplate outputs_both[] = {
{SOCK_RGBA, N_("Color"), 1.0f, 0.0f, 0.0f, 1.0f},
{SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, PROP_DIRECTION},
{-1, ""}};
static bNodeSocketTemplate outputs_color_only[] = {{SOCK_RGBA, N_("Color")}, {-1, ""}};
/* Inputs common to all, #defined because nodes will need their own inputs too */
#define I 2 /* count */
#define COMMON_INPUTS \
{SOCK_RGBA, "Color 1", 0.0f, 0.0f, 0.0f, 1.0f}, \
{ \
SOCK_RGBA, "Color 2", 1.0f, 1.0f, 1.0f, 1.0f \
}
/* Calls multitex and copies the result to the outputs.
* Called by xxx_exec, which handles inputs. */
static void do_proc(float *result,
TexParams *p,
const float col1[4],
const float col2[4],
char is_normal,
Tex *tex,
const short thread)
{
TexResult texres;
int textype;
if (is_normal) {
texres.nor = result;
}
else {
texres.nor = NULL;
}
textype = multitex_nodes(
tex, p->co, p->dxt, p->dyt, p->osatex, &texres, thread, 0, p->mtex, NULL);
if (is_normal) {
return;
}
if (textype & TEX_RGB) {
copy_v4_v4(result, &texres.tr);
}
else {
copy_v4_v4(result, col1);
ramp_blend(MA_RAMP_BLEND, result, texres.tin, col2);
}
}
typedef void (*MapFn)(Tex *tex, bNodeStack **in, TexParams *p, const short thread);
static void texfn(float *result,
TexParams *p,
bNode *node,
bNodeStack **in,
char is_normal,
MapFn map_inputs,
short thread)
{
Tex tex = *((Tex *)(node->storage));
float col1[4], col2[4];
tex_input_rgba(col1, in[0], p, thread);
tex_input_rgba(col2, in[1], p, thread);
map_inputs(&tex, in, p, thread);
do_proc(result, p, col1, col2, is_normal, &tex, thread);
}
static int count_outputs(bNode *node)
{
bNodeSocket *sock;
int num = 0;
for (sock = node->outputs.first; sock; sock = sock->next) {
num++;
}
return num;
}
/* Boilerplate generators */
#define ProcNoInputs(name) \
static void name##_map_inputs( \
Tex *UNUSED(tex), bNodeStack **UNUSED(in), TexParams *UNUSED(p), short UNUSED(thread)) \
{ \
}
#define ProcDef(name) \
static void name##_colorfn( \
float *result, TexParams *p, bNode *node, bNodeStack **in, short thread) \
{ \
texfn(result, p, node, in, 0, &name##_map_inputs, thread); \
} \
static void name##_normalfn( \
float *result, TexParams *p, bNode *node, bNodeStack **in, short thread) \
{ \
texfn(result, p, node, in, 1, &name##_map_inputs, thread); \
} \
static void name##_exec(void *data, \
int UNUSED(thread), \
bNode *node, \
bNodeExecData *execdata, \
bNodeStack **in, \
bNodeStack **out) \
{ \
int outs = count_outputs(node); \
if (outs >= 1) { \
tex_output(node, execdata, in, out[0], &name##_colorfn, data); \
} \
if (outs >= 2) { \
tex_output(node, execdata, in, out[1], &name##_normalfn, data); \
} \
}
/* --- VORONOI -- */
static bNodeSocketTemplate voronoi_inputs[] = {
COMMON_INPUTS,
{SOCK_FLOAT, N_("W1"), 1.0f, 0.0f, 0.0f, 0.0f, -2.0f, 2.0f, PROP_NONE},
{SOCK_FLOAT, N_("W2"), 0.0f, 0.0f, 0.0f, 0.0f, -2.0f, 2.0f, PROP_NONE},
{SOCK_FLOAT, N_("W3"), 0.0f, 0.0f, 0.0f, 0.0f, -2.0f, 2.0f, PROP_NONE},
{SOCK_FLOAT, N_("W4"), 0.0f, 0.0f, 0.0f, 0.0f, -2.0f, 2.0f, PROP_NONE},
{SOCK_FLOAT, N_("iScale"), 1.0f, 0.0f, 0.0f, 0.0f, 0.01f, 10.0f, PROP_UNSIGNED},
{SOCK_FLOAT, N_("Size"), 0.25f, 0.0f, 0.0f, 0.0f, 0.0001f, 4.0f, PROP_UNSIGNED},
{-1, ""}};
static void voronoi_map_inputs(Tex *tex, bNodeStack **in, TexParams *p, short thread)
{
tex->vn_w1 = tex_input_value(in[I + 0], p, thread);
tex->vn_w2 = tex_input_value(in[I + 1], p, thread);
tex->vn_w3 = tex_input_value(in[I + 2], p, thread);
tex->vn_w4 = tex_input_value(in[I + 3], p, thread);
tex->ns_outscale = tex_input_value(in[I + 4], p, thread);
tex->noisesize = tex_input_value(in[I + 5], p, thread);
}
ProcDef(voronoi);
/* --- BLEND -- */
static bNodeSocketTemplate blend_inputs[] = {COMMON_INPUTS, {-1, ""}};
ProcNoInputs(blend);
ProcDef(blend);
/* -- MAGIC -- */
static bNodeSocketTemplate magic_inputs[] = {
COMMON_INPUTS,
{SOCK_FLOAT, N_("Turbulence"), 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 200.0f, PROP_UNSIGNED},
{-1, ""}};
static void magic_map_inputs(Tex *tex, bNodeStack **in, TexParams *p, short thread)
{
tex->turbul = tex_input_value(in[I + 0], p, thread);
}
ProcDef(magic);
/* --- MARBLE --- */
static bNodeSocketTemplate marble_inputs[] = {
COMMON_INPUTS,
{SOCK_FLOAT, N_("Size"), 0.25f, 0.0f, 0.0f, 0.0f, 0.0001f, 2.0f, PROP_UNSIGNED},
{SOCK_FLOAT, N_("Turbulence"), 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 200.0f, PROP_UNSIGNED},
{-1, ""}};
static void marble_map_inputs(Tex *tex, bNodeStack **in, TexParams *p, short thread)
{
tex->noisesize = tex_input_value(in[I + 0], p, thread);
tex->turbul = tex_input_value(in[I + 1], p, thread);
}
ProcDef(marble);
/* --- CLOUDS --- */
static bNodeSocketTemplate clouds_inputs[] = {
COMMON_INPUTS,
{SOCK_FLOAT, N_("Size"), 0.25f, 0.0f, 0.0f, 0.0f, 0.0001f, 2.0f, PROP_UNSIGNED},
{-1, ""}};
static void clouds_map_inputs(Tex *tex, bNodeStack **in, TexParams *p, short thread)
{
tex->noisesize = tex_input_value(in[I + 0], p, thread);
}
ProcDef(clouds);
/* --- DISTORTED NOISE --- */
static bNodeSocketTemplate distnoise_inputs[] = {
COMMON_INPUTS,
{SOCK_FLOAT, N_("Size"), 0.25f, 0.0f, 0.0f, 0.0f, 0.0001f, 2.0f, PROP_UNSIGNED},
{SOCK_FLOAT, N_("Distortion"), 1.00f, 0.0f, 0.0f, 0.0f, 0.0000f, 10.0f, PROP_UNSIGNED},
{-1, ""}};
static void distnoise_map_inputs(Tex *tex, bNodeStack **in, TexParams *p, short thread)
{
tex->noisesize = tex_input_value(in[I + 0], p, thread);
tex->dist_amount = tex_input_value(in[I + 1], p, thread);
}
ProcDef(distnoise);
/* --- WOOD --- */
static bNodeSocketTemplate wood_inputs[] = {
COMMON_INPUTS,
{SOCK_FLOAT, N_("Size"), 0.25f, 0.0f, 0.0f, 0.0f, 0.0001f, 2.0f, PROP_UNSIGNED},
{SOCK_FLOAT, N_("Turbulence"), 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 200.0f, PROP_UNSIGNED},
{-1, ""}};
static void wood_map_inputs(Tex *tex, bNodeStack **in, TexParams *p, short thread)
{
tex->noisesize = tex_input_value(in[I + 0], p, thread);
tex->turbul = tex_input_value(in[I + 1], p, thread);
}
ProcDef(wood);
/* --- MUSGRAVE --- */
static bNodeSocketTemplate musgrave_inputs[] = {
COMMON_INPUTS,
{SOCK_FLOAT, N_("H"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0001f, 2.0f, PROP_UNSIGNED},
{SOCK_FLOAT, N_("Lacunarity"), 2.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, PROP_UNSIGNED},
{SOCK_FLOAT, N_("Octaves"), 2.0f, 0.0f, 0.0f, 0.0f, 0.0f, 8.0f, PROP_UNSIGNED},
{SOCK_FLOAT, N_("iScale"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 10.0f, PROP_UNSIGNED},
{SOCK_FLOAT, N_("Size"), 0.25f, 0.0f, 0.0f, 0.0f, 0.0001f, 2.0f, PROP_UNSIGNED},
{-1, ""}};
static void musgrave_map_inputs(Tex *tex, bNodeStack **in, TexParams *p, short thread)
{
tex->mg_H = tex_input_value(in[I + 0], p, thread);
tex->mg_lacunarity = tex_input_value(in[I + 1], p, thread);
tex->mg_octaves = tex_input_value(in[I + 2], p, thread);
tex->ns_outscale = tex_input_value(in[I + 3], p, thread);
tex->noisesize = tex_input_value(in[I + 4], p, thread);
}
ProcDef(musgrave);
/* --- NOISE --- */
static bNodeSocketTemplate noise_inputs[] = {COMMON_INPUTS, {-1, ""}};
ProcNoInputs(noise);
ProcDef(noise);
/* --- STUCCI --- */
static bNodeSocketTemplate stucci_inputs[] = {
COMMON_INPUTS,
{SOCK_FLOAT, N_("Size"), 0.25f, 0.0f, 0.0f, 0.0f, 0.0001f, 2.0f, PROP_UNSIGNED},
{SOCK_FLOAT, N_("Turbulence"), 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 200.0f, PROP_UNSIGNED},
{-1, ""}};
static void stucci_map_inputs(Tex *tex, bNodeStack **in, TexParams *p, short thread)
{
tex->noisesize = tex_input_value(in[I + 0], p, thread);
tex->turbul = tex_input_value(in[I + 1], p, thread);
}
ProcDef(stucci);
/* --- */
static void init(bNodeTree *UNUSED(ntree), bNode *node)
{
Tex *tex = MEM_callocN(sizeof(Tex), "Tex");
node->storage = tex;
BKE_texture_default(tex);
tex->type = node->type - TEX_NODE_PROC;
if (tex->type == TEX_WOOD) {
tex->stype = TEX_BANDNOISE;
}
}
/* Node type definitions */
#define TexDef(TEXTYPE, outputs, name, Name) \
void register_node_type_tex_proc_##name(void) \
{ \
static bNodeType ntype; \
\
tex_node_type_base(&ntype, TEX_NODE_PROC + TEXTYPE, Name, NODE_CLASS_TEXTURE, NODE_PREVIEW); \
node_type_socket_templates(&ntype, name##_inputs, outputs); \
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE); \
node_type_init(&ntype, init); \
node_type_storage(&ntype, "Tex", node_free_standard_storage, node_copy_standard_storage); \
node_type_exec(&ntype, NULL, NULL, name##_exec); \
\
nodeRegisterType(&ntype); \
}
#define C outputs_color_only
#define CV outputs_both
TexDef(TEX_VORONOI, CV, voronoi, "Voronoi") TexDef(TEX_BLEND, C, blend, "Blend");
TexDef(TEX_MAGIC, C, magic, "Magic") TexDef(TEX_MARBLE, CV, marble, "Marble");
TexDef(TEX_CLOUDS, CV, clouds, "Clouds") TexDef(TEX_WOOD, CV, wood, "Wood");
TexDef(TEX_MUSGRAVE, CV, musgrave, "Musgrave") TexDef(TEX_NOISE, C, noise, "Noise");
TexDef(TEX_STUCCI, CV, stucci, "Stucci");
TexDef(TEX_DISTNOISE, CV, distnoise, "Distorted Noise");