diff options
| author | Lukas Toenne <lukas.toenne@googlemail.com> | 2013-03-18 20:34:57 +0400 |
|---|---|---|
| committer | Lukas Toenne <lukas.toenne@googlemail.com> | 2013-03-18 20:34:57 +0400 |
| commit | 4638e5f99a9ba59ad0b8a1fd52b12e876480b9e8 (patch) | |
| tree | 2444f12b4612440f44cf02835cdf5951b6564e92 /source/blender/nodes | |
| parent | 7bfef29f2f2a1b262d28abdc6e30fcd9c1f1caad (diff) | |
Merge of the PyNodes branch (aka "custom nodes") into trunk.
PyNodes opens up the node system in Blender to scripters and adds a number of UI-level improvements.
=== Dynamic node type registration ===
Node types can now be added at runtime, using the RNA registration mechanism from python. This enables addons such as render engines to create a complete user interface with nodes.
Examples of how such nodes can be defined can be found in my personal wiki docs atm [1] and as a script template in release/scripts/templates_py/custom_nodes.py [2].
=== Node group improvements ===
Each node editor now has a tree history of edited node groups, which allows opening and editing nested node groups. The node editor also supports pinning now, so that different spaces can be used to edit different node groups simultaneously. For more ramblings and rationale see (really old) blog post on code.blender.org [3].
The interface of node groups has been overhauled. Sockets of a node group are no longer displayed in columns on either side, but instead special input/output nodes are used to mirror group sockets inside a node tree. This solves the problem of long node lines in groups and allows more adaptable node layout. Internal sockets can be exposed from a group by either connecting to the extension sockets in input/output nodes (shown as empty circle) or by adding sockets from the node property bar in the "Interface" panel. Further details such as the socket name can also be changed there.
[1] http://wiki.blender.org/index.php/User:Phonybone/Python_Nodes
[2] http://projects.blender.org/scm/viewvc.php/trunk/blender/release/scripts/templates_py/custom_nodes.py?view=markup&root=bf-blender
[3] http://code.blender.org/index.php/2012/01/improving-node-group-interface-editing/
Diffstat (limited to 'source/blender/nodes')
186 files changed, 2506 insertions, 2493 deletions
diff --git a/source/blender/nodes/CMakeLists.txt b/source/blender/nodes/CMakeLists.txt index 12842085189..f3b3d6b1f53 100644 --- a/source/blender/nodes/CMakeLists.txt +++ b/source/blender/nodes/CMakeLists.txt @@ -123,7 +123,7 @@ set(SRC composite/nodes/node_composite_pixelate.c composite/node_composite_tree.c - composite/node_composite_util.h + composite/node_composite_util.c shader/nodes/node_shader_camera.c shader/nodes/node_shader_common.c @@ -224,13 +224,16 @@ set(SRC intern/node_common.c intern/node_socket.c + composite/node_composite_util.h shader/node_shader_util.h texture/node_texture_util.h + NOD_common.h NOD_composite.h NOD_shader.h NOD_texture.h NOD_socket.h + NOD_static_types.h intern/node_util.h intern/node_exec.h intern/node_common.h diff --git a/source/blender/nodes/NOD_common.h b/source/blender/nodes/NOD_common.h new file mode 100644 index 00000000000..ac0ceab36d4 --- /dev/null +++ b/source/blender/nodes/NOD_common.h @@ -0,0 +1,54 @@ +/* + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * The Original Code is Copyright (C) 2005 Blender Foundation. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): Lukas Toenne. + * + * ***** END GPL LICENSE BLOCK ***** + */ + +/** \file NOD_common.h + * \ingroup nodes + */ + +#ifndef NOD_COMMON_H +#define NOD_COMMON_H + +#include "BKE_node.h" + +void register_node_type_frame(void); +void register_node_type_reroute(void); + +void register_node_type_group_input(void); +void register_node_type_group_output(void); + + +/* internal functions for editor */ +struct bNodeSocket *node_group_find_input_socket(struct bNode *groupnode, const char *identifier); +struct bNodeSocket *node_group_find_output_socket(struct bNode *groupnode, const char *identifier); +void node_group_verify(struct bNodeTree *ntree, struct bNode *node, struct ID *id); + +struct bNodeSocket *node_group_input_find_socket(struct bNode *node, const char *identifier); +struct bNodeSocket *node_group_output_find_socket(struct bNode *node, const char *identifier); +void node_group_input_verify(struct bNodeTree *ntree, struct bNode *node, struct ID *id); +void node_group_output_verify(struct bNodeTree *ntree, struct bNode *node, struct ID *id); + +#endif diff --git a/source/blender/nodes/NOD_composite.h b/source/blender/nodes/NOD_composite.h index 6d60ac0bb58..f272ec670e7 100644 --- a/source/blender/nodes/NOD_composite.h +++ b/source/blender/nodes/NOD_composite.h @@ -34,105 +34,109 @@ #include "BKE_node.h" -extern bNodeTreeType ntreeType_Composite; +extern struct bNodeTreeType *ntreeType_Composite; /* ****************** types array for all composite nodes ****************** */ -void register_node_type_cmp_group(struct bNodeTreeType *ttype); +void register_node_tree_type_cmp(void); -void register_node_type_cmp_rlayers(struct bNodeTreeType *ttype); -void register_node_type_cmp_image(struct bNodeTreeType *ttype); -void register_node_type_cmp_texture(struct bNodeTreeType *ttype); -void register_node_type_cmp_value(struct bNodeTreeType *ttype); -void register_node_type_cmp_rgb(struct bNodeTreeType *ttype); -void register_node_type_cmp_curve_time(struct bNodeTreeType *ttype); -void register_node_type_cmp_movieclip(struct bNodeTreeType *ttype); +void register_node_type_cmp_group(void); +void register_node_type_cmp_forloop(void); +void register_node_type_cmp_whileloop(void); + +void register_node_type_cmp_rlayers(void); +void register_node_type_cmp_image(void); +void register_node_type_cmp_texture(void); +void register_node_type_cmp_value(void); +void register_node_type_cmp_rgb(void); +void register_node_type_cmp_curve_time(void); +void register_node_type_cmp_movieclip(void); void register_node_type_cmp_usermask(struct bNodeTreeType *ttype); -void register_node_type_cmp_composite(struct bNodeTreeType *ttype); -void register_node_type_cmp_viewer(struct bNodeTreeType *ttype); -void register_node_type_cmp_splitviewer(struct bNodeTreeType *ttype); -void register_node_type_cmp_output_file(struct bNodeTreeType *ttype); -void register_node_type_cmp_view_levels(struct bNodeTreeType *ttype); - -void register_node_type_cmp_curve_rgb(struct bNodeTreeType *ttype); -void register_node_type_cmp_mix_rgb(struct bNodeTreeType *ttype); -void register_node_type_cmp_hue_sat(struct bNodeTreeType *ttype); -void register_node_type_cmp_brightcontrast(struct bNodeTreeType *ttype); -void register_node_type_cmp_gamma(struct bNodeTreeType *ttype); -void register_node_type_cmp_invert(struct bNodeTreeType *ttype); -void register_node_type_cmp_alphaover(struct bNodeTreeType *ttype); -void register_node_type_cmp_zcombine(struct bNodeTreeType *ttype); -void register_node_type_cmp_colorbalance(struct bNodeTreeType *ttype); -void register_node_type_cmp_huecorrect(struct bNodeTreeType *ttype); - -void register_node_type_cmp_normal(struct bNodeTreeType *ttype); -void register_node_type_cmp_curve_vec(struct bNodeTreeType *ttype); -void register_node_type_cmp_map_value(struct bNodeTreeType *ttype); -void register_node_type_cmp_map_range(struct bNodeTreeType *ttype); -void register_node_type_cmp_normalize(struct bNodeTreeType *ttype); - -void register_node_type_cmp_filter(struct bNodeTreeType *ttype); -void register_node_type_cmp_blur(struct bNodeTreeType *ttype); -void register_node_type_cmp_dblur(struct bNodeTreeType *ttype); -void register_node_type_cmp_bilateralblur(struct bNodeTreeType *ttype); -void register_node_type_cmp_vecblur(struct bNodeTreeType *ttype); -void register_node_type_cmp_dilateerode(struct bNodeTreeType *ttype); -void register_node_type_cmp_inpaint(struct bNodeTreeType *ttype); -void register_node_type_cmp_despeckle(struct bNodeTreeType *ttype); -void register_node_type_cmp_defocus(struct bNodeTreeType *ttype); - -void register_node_type_cmp_valtorgb(struct bNodeTreeType *ttype); -void register_node_type_cmp_rgbtobw(struct bNodeTreeType *ttype); -void register_node_type_cmp_setalpha(struct bNodeTreeType *ttype); -void register_node_type_cmp_idmask(struct bNodeTreeType *ttype); -void register_node_type_cmp_math(struct bNodeTreeType *ttype); -void register_node_type_cmp_seprgba(struct bNodeTreeType *ttype); -void register_node_type_cmp_combrgba(struct bNodeTreeType *ttype); -void register_node_type_cmp_sephsva(struct bNodeTreeType *ttype); -void register_node_type_cmp_combhsva(struct bNodeTreeType *ttype); -void register_node_type_cmp_sepyuva(struct bNodeTreeType *ttype); -void register_node_type_cmp_combyuva(struct bNodeTreeType *ttype); -void register_node_type_cmp_sepycca(struct bNodeTreeType *ttype); -void register_node_type_cmp_combycca(struct bNodeTreeType *ttype); -void register_node_type_cmp_premulkey(struct bNodeTreeType *ttype); - -void register_node_type_cmp_diff_matte(struct bNodeTreeType *ttype); -void register_node_type_cmp_distance_matte(struct bNodeTreeType *ttype); -void register_node_type_cmp_chroma_matte(struct bNodeTreeType *ttype); -void register_node_type_cmp_color_matte(struct bNodeTreeType *ttype); -void register_node_type_cmp_channel_matte(struct bNodeTreeType *ttype); -void register_node_type_cmp_color_spill(struct bNodeTreeType *ttype); -void register_node_type_cmp_luma_matte(struct bNodeTreeType *ttype); -void register_node_type_cmp_doubleedgemask(struct bNodeTreeType *ttype); -void register_node_type_cmp_keyingscreen(struct bNodeTreeType *ttype); -void register_node_type_cmp_keying(struct bNodeTreeType *ttype); - -void register_node_type_cmp_translate(struct bNodeTreeType *ttype); -void register_node_type_cmp_rotate(struct bNodeTreeType *ttype); -void register_node_type_cmp_scale(struct bNodeTreeType *ttype); -void register_node_type_cmp_flip(struct bNodeTreeType *ttype); -void register_node_type_cmp_crop(struct bNodeTreeType *ttype); -void register_node_type_cmp_displace(struct bNodeTreeType *ttype); -void register_node_type_cmp_mapuv(struct bNodeTreeType *ttype); -void register_node_type_cmp_transform(struct bNodeTreeType *ttype); -void register_node_type_cmp_stabilize2d(struct bNodeTreeType *ttype); -void register_node_type_cmp_moviedistortion(struct bNodeTreeType *ttype); -void register_node_type_cmp_mask(struct bNodeTreeType *ttype); - -void register_node_type_cmp_glare(struct bNodeTreeType *ttype); -void register_node_type_cmp_tonemap(struct bNodeTreeType *ttype); -void register_node_type_cmp_lensdist(struct bNodeTreeType *ttype); - - -void register_node_type_cmp_colorcorrection(struct bNodeTreeType *ttype); -void register_node_type_cmp_boxmask(struct bNodeTreeType *ttype); -void register_node_type_cmp_ellipsemask(struct bNodeTreeType *ttype); -void register_node_type_cmp_bokehimage(struct bNodeTreeType *ttype); -void register_node_type_cmp_bokehblur(struct bNodeTreeType *ttype); -void register_node_type_cmp_switch(struct bNodeTreeType *ttype); -void register_node_type_cmp_pixelate(struct bNodeTreeType *ttype); -void register_node_type_cmp_trackpos(struct bNodeTreeType *ttype); +void register_node_type_cmp_composite(void); +void register_node_type_cmp_viewer(void); +void register_node_type_cmp_splitviewer(void); +void register_node_type_cmp_output_file(void); +void register_node_type_cmp_view_levels(void); + +void register_node_type_cmp_curve_rgb(void); +void register_node_type_cmp_mix_rgb(void); +void register_node_type_cmp_hue_sat(void); +void register_node_type_cmp_brightcontrast(void); +void register_node_type_cmp_gamma(void); +void register_node_type_cmp_invert(void); +void register_node_type_cmp_alphaover(void); +void register_node_type_cmp_zcombine(void); +void register_node_type_cmp_colorbalance(void); +void register_node_type_cmp_huecorrect(void); + +void register_node_type_cmp_normal(void); +void register_node_type_cmp_curve_vec(void); +void register_node_type_cmp_map_value(void); +void register_node_type_cmp_map_range(void); +void register_node_type_cmp_normalize(void); + +void register_node_type_cmp_filter(void); +void register_node_type_cmp_blur(void); +void register_node_type_cmp_dblur(void); +void register_node_type_cmp_bilateralblur(void); +void register_node_type_cmp_vecblur(void); +void register_node_type_cmp_dilateerode(void); +void register_node_type_cmp_inpaint(void); +void register_node_type_cmp_despeckle(void); +void register_node_type_cmp_defocus(void); + +void register_node_type_cmp_valtorgb(void); +void register_node_type_cmp_rgbtobw(void); +void register_node_type_cmp_setalpha(void); +void register_node_type_cmp_idmask(void); +void register_node_type_cmp_math(void); +void register_node_type_cmp_seprgba(void); +void register_node_type_cmp_combrgba(void); +void register_node_type_cmp_sephsva(void); +void register_node_type_cmp_combhsva(void); +void register_node_type_cmp_sepyuva(void); +void register_node_type_cmp_combyuva(void); +void register_node_type_cmp_sepycca(void); +void register_node_type_cmp_combycca(void); +void register_node_type_cmp_premulkey(void); + +void register_node_type_cmp_diff_matte(void); +void register_node_type_cmp_distance_matte(void); +void register_node_type_cmp_chroma_matte(void); +void register_node_type_cmp_color_matte(void); +void register_node_type_cmp_channel_matte(void); +void register_node_type_cmp_color_spill(void); +void register_node_type_cmp_luma_matte(void); +void register_node_type_cmp_doubleedgemask(void); +void register_node_type_cmp_keyingscreen(void); +void register_node_type_cmp_keying(void); + +void register_node_type_cmp_translate(void); +void register_node_type_cmp_rotate(void); +void register_node_type_cmp_scale(void); +void register_node_type_cmp_flip(void); +void register_node_type_cmp_crop(void); +void register_node_type_cmp_displace(void); +void register_node_type_cmp_mapuv(void); +void register_node_type_cmp_transform(void); +void register_node_type_cmp_stabilize2d(void); +void register_node_type_cmp_moviedistortion(void); +void register_node_type_cmp_mask(void); + +void register_node_type_cmp_glare(void); +void register_node_type_cmp_tonemap(void); +void register_node_type_cmp_lensdist(void); + + +void register_node_type_cmp_colorcorrection(void); +void register_node_type_cmp_boxmask(void); +void register_node_type_cmp_ellipsemask(void); +void register_node_type_cmp_bokehimage(void); +void register_node_type_cmp_bokehblur(void); +void register_node_type_cmp_switch(void); +void register_node_type_cmp_pixelate(void); +void register_node_type_cmp_trackpos(void); #endif diff --git a/source/blender/nodes/NOD_shader.h b/source/blender/nodes/NOD_shader.h index 0a7a11e4506..9561fe00409 100644 --- a/source/blender/nodes/NOD_shader.h +++ b/source/blender/nodes/NOD_shader.h @@ -34,87 +34,91 @@ #include "BKE_node.h" -extern struct bNodeTreeType ntreeType_Shader; +extern struct bNodeTreeType *ntreeType_Shader; /* the type definitions array */ /* ****************** types array for all shaders ****************** */ -void register_node_type_sh_group(struct bNodeTreeType *ttype); - -void register_node_type_sh_output(struct bNodeTreeType *ttype); -void register_node_type_sh_material(struct bNodeTreeType *ttype); -void register_node_type_sh_camera(struct bNodeTreeType *ttype); -void register_node_type_sh_value(struct bNodeTreeType *ttype); -void register_node_type_sh_rgb(struct bNodeTreeType *ttype); -void register_node_type_sh_mix_rgb(struct bNodeTreeType *ttype); -void register_node_type_sh_valtorgb(struct bNodeTreeType *ttype); -void register_node_type_sh_rgbtobw(struct bNodeTreeType *ttype); -void register_node_type_sh_texture(struct bNodeTreeType *ttype); -void register_node_type_sh_normal(struct bNodeTreeType *ttype); -void register_node_type_sh_gamma(struct bNodeTreeType *ttype); -void register_node_type_sh_brightcontrast(struct bNodeTreeType *ttype); -void register_node_type_sh_geom(struct bNodeTreeType *ttype); -void register_node_type_sh_mapping(struct bNodeTreeType *ttype); -void register_node_type_sh_curve_vec(struct bNodeTreeType *ttype); -void register_node_type_sh_curve_rgb(struct bNodeTreeType *ttype); -void register_node_type_sh_math(struct bNodeTreeType *ttype); -void register_node_type_sh_vect_math(struct bNodeTreeType *ttype); -void register_node_type_sh_squeeze(struct bNodeTreeType *ttype); -void register_node_type_sh_dynamic(struct bNodeTreeType *ttype); -void register_node_type_sh_material_ext(struct bNodeTreeType *ttype); -void register_node_type_sh_invert(struct bNodeTreeType *ttype); -void register_node_type_sh_seprgb(struct bNodeTreeType *ttype); -void register_node_type_sh_combrgb(struct bNodeTreeType *ttype); -void register_node_type_sh_hue_sat(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_brick(struct bNodeTreeType *ttype); - -void register_node_type_sh_attribute(struct bNodeTreeType *ttype); -void register_node_type_sh_geometry(struct bNodeTreeType *ttype); -void register_node_type_sh_light_path(struct bNodeTreeType *ttype); -void register_node_type_sh_light_falloff(struct bNodeTreeType *ttype); -void register_node_type_sh_object_info(struct bNodeTreeType *ttype); -void register_node_type_sh_fresnel(struct bNodeTreeType *ttype); -void register_node_type_sh_layer_weight(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_coord(struct bNodeTreeType *ttype); -void register_node_type_sh_particle_info(struct bNodeTreeType *ttype); -void register_node_type_sh_hair_info(struct bNodeTreeType *ttype); -void register_node_type_sh_script(struct bNodeTreeType *ttype); -void register_node_type_sh_normal_map(struct bNodeTreeType *ttype); -void register_node_type_sh_tangent(struct bNodeTreeType *ttype); - -void register_node_type_sh_ambient_occlusion(struct bNodeTreeType *ttype); -void register_node_type_sh_background(struct bNodeTreeType *ttype); -void register_node_type_sh_bsdf_diffuse(struct bNodeTreeType *ttype); -void register_node_type_sh_bsdf_glossy(struct bNodeTreeType *ttype); -void register_node_type_sh_bsdf_glass(struct bNodeTreeType *ttype); -void register_node_type_sh_bsdf_refraction(struct bNodeTreeType *ttype); -void register_node_type_sh_bsdf_translucent(struct bNodeTreeType *ttype); -void register_node_type_sh_bsdf_transparent(struct bNodeTreeType *ttype); -void register_node_type_sh_bsdf_velvet(struct bNodeTreeType *ttype); -void register_node_type_sh_bsdf_anisotropic(struct bNodeTreeType *ttype); -void register_node_type_sh_emission(struct bNodeTreeType *ttype); -void register_node_type_sh_holdout(struct bNodeTreeType *ttype); -void register_node_type_sh_volume_transparent(struct bNodeTreeType *ttype); -void register_node_type_sh_volume_isotropic(struct bNodeTreeType *ttype); -void register_node_type_sh_mix_shader(struct bNodeTreeType *ttype); -void register_node_type_sh_add_shader(struct bNodeTreeType *ttype); - -void register_node_type_sh_output_lamp(struct bNodeTreeType *ttype); -void register_node_type_sh_output_material(struct bNodeTreeType *ttype); -void register_node_type_sh_output_world(struct bNodeTreeType *ttype); - -void register_node_type_sh_tex_image(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_environment(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_sky(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_voronoi(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_gradient(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_magic(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_wave(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_musgrave(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_noise(struct bNodeTreeType *ttype); -void register_node_type_sh_tex_checker(struct bNodeTreeType *ttype); -void register_node_type_sh_bump(struct bNodeTreeType *ttype); +void register_node_tree_type_sh(void); + +void register_node_type_sh_group(void); +void register_node_type_sh_forloop(void); +void register_node_type_sh_whileloop(void); + +void register_node_type_sh_output(void); +void register_node_type_sh_material(void); +void register_node_type_sh_camera(void); +void register_node_type_sh_value(void); +void register_node_type_sh_rgb(void); +void register_node_type_sh_mix_rgb(void); +void register_node_type_sh_valtorgb(void); +void register_node_type_sh_rgbtobw(void); +void register_node_type_sh_texture(void); +void register_node_type_sh_normal(void); +void register_node_type_sh_gamma(void); +void register_node_type_sh_brightcontrast(void); +void register_node_type_sh_geom(void); +void register_node_type_sh_mapping(void); +void register_node_type_sh_curve_vec(void); +void register_node_type_sh_curve_rgb(void); +void register_node_type_sh_math(void); +void register_node_type_sh_vect_math(void); +void register_node_type_sh_squeeze(void); +void register_node_type_sh_dynamic(void); +void register_node_type_sh_material_ext(void); +void register_node_type_sh_invert(void); +void register_node_type_sh_seprgb(void); +void register_node_type_sh_combrgb(void); +void register_node_type_sh_hue_sat(void); +void register_node_type_sh_tex_brick(void); + +void register_node_type_sh_attribute(void); +void register_node_type_sh_geometry(void); +void register_node_type_sh_light_path(void); +void register_node_type_sh_light_falloff(void); +void register_node_type_sh_object_info(void); +void register_node_type_sh_fresnel(void); +void register_node_type_sh_layer_weight(void); +void register_node_type_sh_tex_coord(void); +void register_node_type_sh_particle_info(void); +void register_node_type_sh_hair_info(void); +void register_node_type_sh_script(void); +void register_node_type_sh_normal_map(void); +void register_node_type_sh_tangent(void); + +void register_node_type_sh_ambient_occlusion(void); +void register_node_type_sh_background(void); +void register_node_type_sh_bsdf_diffuse(void); +void register_node_type_sh_bsdf_glossy(void); +void register_node_type_sh_bsdf_glass(void); +void register_node_type_sh_bsdf_refraction(void); +void register_node_type_sh_bsdf_translucent(void); +void register_node_type_sh_bsdf_transparent(void); +void register_node_type_sh_bsdf_velvet(void); +void register_node_type_sh_bsdf_anisotropic(void); +void register_node_type_sh_emission(void); +void register_node_type_sh_holdout(void); +void register_node_type_sh_volume_transparent(void); +void register_node_type_sh_volume_isotropic(void); +void register_node_type_sh_mix_shader(void); +void register_node_type_sh_add_shader(void); + +void register_node_type_sh_output_lamp(void); +void register_node_type_sh_output_material(void); +void register_node_type_sh_output_world(void); + +void register_node_type_sh_tex_image(void); +void register_node_type_sh_tex_environment(void); +void register_node_type_sh_tex_sky(void); +void register_node_type_sh_tex_voronoi(void); +void register_node_type_sh_tex_gradient(void); +void register_node_type_sh_tex_magic(void); +void register_node_type_sh_tex_wave(void); +void register_node_type_sh_tex_musgrave(void); +void register_node_type_sh_tex_noise(void); +void register_node_type_sh_tex_checker(void); +void register_node_type_sh_bump(void); #endif diff --git a/source/blender/nodes/NOD_socket.h b/source/blender/nodes/NOD_socket.h index b14f7c4e884..5f7da1c3f4d 100644 --- a/source/blender/nodes/NOD_socket.h +++ b/source/blender/nodes/NOD_socket.h @@ -45,41 +45,11 @@ struct bNodeTree; struct bNode; struct bNodeStack; -void node_socket_type_init(struct bNodeSocketType *types[]); - -void *node_socket_make_default_value(int type); -void node_socket_free_default_value(int type, void *default_value); -void node_socket_init_default_value(int type, void *default_value); -void node_socket_copy_default_value(int type, void *to_default_value, void *from_default_value); -void node_socket_convert_default_value(int to_type, void *to_default_value, int from_type, void *from_default_value); - -void node_socket_set_default_value_int(void *default_value, PropertySubType subtype, int value, int min, int max); -void node_socket_set_default_value_float(void *default_value, PropertySubType subtype, float value, float min, float max); -void node_socket_set_default_value_boolean(void *default_value, char value); -void node_socket_set_default_value_vector(void *default_value, PropertySubType subtype, float x, float y, float z, float min, float max); -void node_socket_set_default_value_rgba(void *default_value, float r, float g, float b, float a); -void node_socket_set_default_value_shader(void *default_value); -void node_socket_set_default_value_mesh(void *default_value); -void node_socket_set_default_value_string(void *default_value, PropertySubType subtype, const char *value); - -struct bNodeSocket *node_add_input_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp); -struct bNodeSocket *node_add_output_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp); +struct bNodeSocket *node_add_socket_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp, int in_out); void node_verify_socket_templates(struct bNodeTree *ntree, struct bNode *node); - -/* Socket Converters */ - -#define SOCK_VECTOR_X 1 -#define SOCK_VECTOR_Y 2 -#define SOCK_VECTOR_Z 3 - -#define SOCK_RGBA_R 1 -#define SOCK_RGBA_G 2 -#define SOCK_RGBA_B 3 -#define SOCK_RGBA_A 4 - -#define SOCK_MESH_VERT_CO 1 -#define SOCK_MESH_VERT_NO 2 +void node_socket_init_default_value(struct bNodeSocket *sock); +void register_standard_node_socket_types(void); #endif diff --git a/source/blender/nodes/NOD_static_types.h b/source/blender/nodes/NOD_static_types.h new file mode 100644 index 00000000000..9d044772274 --- /dev/null +++ b/source/blender/nodes/NOD_static_types.h @@ -0,0 +1,233 @@ +/* + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributor(s): Robin Allen + * + * ***** END GPL LICENSE BLOCK ***** + */ + +/** \file blender/makesrna/intern/NOD_static_types.h + * \ingroup nodes + */ + +/* intentionally no include guard */ + +/* Empty definitions for undefined macros to avoid warnings */ +#ifndef DefNode +#define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) +#endif + +/* WARNING! If you edit those strings, please do the same in relevant nodes files (under blender/nodes/...)! */ + +/* Tree type Node ID RNA def function Enum name Struct name UI Name UI Description */ +DefNode( Node, NODE_FRAME, def_frame, "FRAME", Frame, "Frame", "" ) +DefNode( Node, NODE_GROUP, def_group, "GROUP", Group, "Group", "" ) +DefNode( Node, NODE_GROUP_INPUT, def_group_input, "GROUP_INPUT", GroupInput, "Group Input", "" ) +DefNode( Node, NODE_GROUP_OUTPUT, def_group_output, "GROUP_OUTPUT", GroupOutput, "Group Output", "" ) +DefNode( Node, NODE_REROUTE, 0, "REROUTE", Reroute, "Reroute", "" ) + +DefNode( ShaderNode, SH_NODE_OUTPUT, 0, "OUTPUT", Output, "Output", "" ) +DefNode( ShaderNode, SH_NODE_MATERIAL, def_sh_material, "MATERIAL", Material, "Material", "" ) +DefNode( ShaderNode, SH_NODE_RGB, 0, "RGB", RGB, "RGB", "" ) +DefNode( ShaderNode, SH_NODE_VALUE, 0, "VALUE", Value, "Value", "" ) +DefNode( ShaderNode, SH_NODE_MIX_RGB, def_mix_rgb, "MIX_RGB", MixRGB, "MixRGB", "" ) +DefNode( ShaderNode, SH_NODE_VALTORGB, def_colorramp, "VALTORGB", ValToRGB, "ColorRamp", "" ) +DefNode( ShaderNode, SH_NODE_RGBTOBW, 0, "RGBTOBW", RGBToBW, "RGB to BW", "" ) +DefNode( ShaderNode, SH_NODE_TEXTURE, def_texture, "TEXTURE", Texture, "Texture", "" ) +DefNode( ShaderNode, SH_NODE_NORMAL, 0, "NORMAL", Normal, "Normal", "" ) +DefNode( ShaderNode, SH_NODE_GAMMA, 0, "GAMMA", Gamma, "Gamma", "" ) +DefNode( ShaderNode, SH_NODE_BRIGHTCONTRAST, 0, "BRIGHTCONTRAST", BrightContrast, "Bright Contrast", "" ) +DefNode( ShaderNode, SH_NODE_GEOMETRY, def_sh_geometry, "GEOMETRY", Geometry, "Geometry", "" ) +DefNode( ShaderNode, SH_NODE_MAPPING, def_sh_mapping, "MAPPING", Mapping, "Mapping", "" ) +DefNode( ShaderNode, SH_NODE_CURVE_VEC, def_vector_curve, "CURVE_VEC", VectorCurve, "Vector Curves", "" ) +DefNode( ShaderNode, SH_NODE_CURVE_RGB, def_rgb_curve, "CURVE_RGB", RGBCurve, "RGB Curves", "" ) +DefNode( ShaderNode, SH_NODE_CAMERA, 0, "CAMERA", CameraData, "Camera Data", "" ) +DefNode( ShaderNode, SH_NODE_MATH, def_math, "MATH", Math, "Math", "" ) +DefNode( ShaderNode, SH_NODE_VECT_MATH, def_vector_math, "VECT_MATH", VectorMath, "Vector Math", "" ) +DefNode( ShaderNode, SH_NODE_SQUEEZE, 0, "SQUEEZE", Squeeze, "Squeeze Value", "" ) +DefNode( ShaderNode, SH_NODE_MATERIAL_EXT, def_sh_material, "MATERIAL_EXT", ExtendedMaterial, "Extended Material", "" ) +DefNode( ShaderNode, SH_NODE_INVERT, 0, "INVERT", Invert, "Invert", "" ) +DefNode( ShaderNode, SH_NODE_SEPRGB, 0, "SEPRGB", SeparateRGB, "Separate RGB", "" ) +DefNode( ShaderNode, SH_NODE_COMBRGB, 0, "COMBRGB", CombineRGB, "Combine RGB", "" ) +DefNode( ShaderNode, SH_NODE_HUE_SAT, 0, "HUE_SAT", HueSaturation, "Hue/Saturation", "" ) + +DefNode( ShaderNode, SH_NODE_OUTPUT_MATERIAL, 0, "OUTPUT_MATERIAL", OutputMaterial, "Material Output", "" ) +DefNode( ShaderNode, SH_NODE_OUTPUT_LAMP, 0, "OUTPUT_LAMP", OutputLamp, "Lamp Output", "" ) +DefNode( ShaderNode, SH_NODE_OUTPUT_WORLD, 0, "OUTPUT_WORLD", OutputWorld, "World Output", "" ) +DefNode( ShaderNode, SH_NODE_FRESNEL, 0, "FRESNEL", Fresnel, "Fresnel", "" ) +DefNode( ShaderNode, SH_NODE_LAYER_WEIGHT, 0, "LAYER_WEIGHT", LayerWeight, "LayerWeight", "" ) +DefNode( ShaderNode, SH_NODE_MIX_SHADER, 0, "MIX_SHADER", MixShader, "Mix Shader", "" ) +DefNode( ShaderNode, SH_NODE_ADD_SHADER, 0, "ADD_SHADER", AddShader, "Add Shader", "" ) +DefNode( ShaderNode, SH_NODE_ATTRIBUTE, def_sh_attribute, "ATTRIBUTE", Attribute, "Attribute", "" ) +DefNode( ShaderNode, SH_NODE_AMBIENT_OCCLUSION, 0, "AMBIENT_OCCLUSION", AmbientOcclusion, "Ambient Occlusion", "" ) +DefNode( ShaderNode, SH_NODE_BACKGROUND, 0, "BACKGROUND", Background, "Background", "" ) +DefNode( ShaderNode, SH_NODE_HOLDOUT, 0, "HOLDOUT", Holdout, "Holdout", "" ) +DefNode( ShaderNode, SH_NODE_BSDF_ANISOTROPIC, 0, "BSDF_ANISOTROPIC", BsdfAnisotropic, "Anisotropic BSDF", "" ) +DefNode( ShaderNode, SH_NODE_BSDF_DIFFUSE, 0, "BSDF_DIFFUSE", BsdfDiffuse, "Diffuse BSDF", "" ) +DefNode( ShaderNode, SH_NODE_BSDF_GLOSSY, def_glossy, "BSDF_GLOSSY", BsdfGlossy, "Glossy BSDF", "" ) +DefNode( ShaderNode, SH_NODE_BSDF_GLASS, def_glossy, "BSDF_GLASS", BsdfGlass, "Glass BSDF", "" ) +DefNode( ShaderNode, SH_NODE_BSDF_REFRACTION, def_glossy, "BSDF_REFRACTION", BsdfRefraction, "Refraction BSDF", "" ) +DefNode( ShaderNode, SH_NODE_BSDF_TRANSLUCENT, 0, "BSDF_TRANSLUCENT", BsdfTranslucent, "Translucent BSDF", "" ) +DefNode( ShaderNode, SH_NODE_BSDF_TRANSPARENT, 0, "BSDF_TRANSPARENT", BsdfTransparent, "Transparent BSDF", "" ) +DefNode( ShaderNode, SH_NODE_BSDF_VELVET, 0, "BSDF_VELVET", BsdfVelvet, "Velvet BSDF", "" ) +DefNode( ShaderNode, SH_NODE_VOLUME_TRANSPARENT, 0, "VOLUME_TRANSPARENT", VolumeTransparent,"Transparent Volume","" ) +DefNode( ShaderNode, SH_NODE_VOLUME_ISOTROPIC, 0, "VOLUME_ISOTROPIC", VolumeIsotropic, "Isotropic Volume", "" ) +DefNode( ShaderNode, SH_NODE_EMISSION, 0, "EMISSION", Emission, "Emission", "" ) +DefNode( ShaderNode, SH_NODE_NEW_GEOMETRY, 0, "NEW_GEOMETRY", NewGeometry, "Geometry", "" ) +DefNode( ShaderNode, SH_NODE_LIGHT_PATH, 0, "LIGHT_PATH", LightPath, "Light Path", "" ) +DefNode( ShaderNode, SH_NODE_LIGHT_FALLOFF, 0, "LIGHT_FALLOFF", LightFalloff, "Light Falloff", "" ) +DefNode( ShaderNode, SH_NODE_OBJECT_INFO, 0, "OBJECT_INFO", ObjectInfo, "Object Info", "" ) +DefNode( ShaderNode, SH_NODE_PARTICLE_INFO, 0, "PARTICLE_INFO", ParticleInfo, "Particle Info", "" ) +DefNode( ShaderNode, SH_NODE_HAIR_INFO, 0, "HAIR_INFO", HairInfo, "Hair Info", "" ) +DefNode( ShaderNode, SH_NODE_BUMP, 0, "BUMP", Bump, "Bump", "" ) +DefNode( ShaderNode, SH_NODE_NORMAL_MAP, def_sh_normal_map, "NORMAL_MAP", NormalMap, "Normal Map", "" ) +DefNode( ShaderNode, SH_NODE_TANGENT, def_sh_tangent, "TANGENT", Tangent, "Tangent", "" ) +DefNode( ShaderNode, SH_NODE_SCRIPT, def_sh_script, "SCRIPT", Script, "Script", "" ) +DefNode( ShaderNode, SH_NODE_TEX_IMAGE, def_sh_tex_image, "TEX_IMAGE", TexImage, "Image Texture", "" ) +DefNode( ShaderNode, SH_NODE_TEX_ENVIRONMENT, def_sh_tex_environment, "TEX_ENVIRONMENT", TexEnvironment, "Environment Texture","" ) +DefNode( ShaderNode, SH_NODE_TEX_SKY, def_sh_tex_sky, "TEX_SKY", TexSky, "Sky Texture", "" ) +DefNode( ShaderNode, SH_NODE_TEX_GRADIENT, def_sh_tex_gradient, "TEX_GRADIENT", TexGradient, "Gradient Texture", "" ) +DefNode( ShaderNode, SH_NODE_TEX_NOISE, def_sh_tex_noise, "TEX_NOISE", TexNoise, "Noise Texture", "" ) +DefNode( ShaderNode, SH_NODE_TEX_MAGIC, def_sh_tex_magic, "TEX_MAGIC", TexMagic, "Magic Texture", "" ) +DefNode( ShaderNode, SH_NODE_TEX_WAVE, def_sh_tex_wave, "TEX_WAVE", TexWave, "Wave Texture", "" ) +DefNode( ShaderNode, SH_NODE_TEX_MUSGRAVE, def_sh_tex_musgrave, "TEX_MUSGRAVE", TexMusgrave, "Musgrave Texture", "" ) +DefNode( ShaderNode, SH_NODE_TEX_VORONOI, def_sh_tex_voronoi, "TEX_VORONOI", TexVoronoi, "Voronoi Texture", "" ) +DefNode( ShaderNode, SH_NODE_TEX_CHECKER, def_sh_tex_checker, "TEX_CHECKER", TexChecker, "Checker Texture", "" ) +DefNode( ShaderNode, SH_NODE_TEX_BRICK, def_sh_tex_brick, "TEX_BRICK", TexBrick, "Brick Texture", "" ) +DefNode( ShaderNode, SH_NODE_TEX_COORD, def_sh_tex_coord, "TEX_COORD", TexCoord, "Texture Coordinate","" ) + +DefNode( CompositorNode, CMP_NODE_VIEWER, def_cmp_viewer, "VIEWER", Viewer, "Viewer", "" ) +DefNode( CompositorNode, CMP_NODE_RGB, 0, "RGB", RGB, "RGB", "" ) +DefNode( CompositorNode, CMP_NODE_VALUE, 0, "VALUE", Value, "Value", "" ) +DefNode( CompositorNode, CMP_NODE_MIX_RGB, def_mix_rgb, "MIX_RGB", MixRGB, "Mix", "" ) +DefNode( CompositorNode, CMP_NODE_VALTORGB, def_colorramp, "VALTORGB", ValToRGB, "ColorRamp", "" ) +DefNode( CompositorNode, CMP_NODE_RGBTOBW, 0, "RGBTOBW", RGBToBW, "RGB to BW", "" ) +DefNode( CompositorNode, CMP_NODE_NORMAL, 0, "NORMAL", Normal, "Normal", "" ) +DefNode( CompositorNode, CMP_NODE_CURVE_VEC, def_vector_curve, "CURVE_VEC", CurveVec, "Vector Curves", "" ) +DefNode( CompositorNode, CMP_NODE_CURVE_RGB, def_rgb_curve, "CURVE_RGB", CurveRGB, "RGB Curves", "" ) +DefNode( CompositorNode, CMP_NODE_ALPHAOVER, def_cmp_alpha_over, "ALPHAOVER", AlphaOver, "Alpha Over", "" ) +DefNode( CompositorNode, CMP_NODE_BLUR, def_cmp_blur, "BLUR", Blur, "Blur", "" ) +DefNode( CompositorNode, CMP_NODE_FILTER, def_cmp_filter, "FILTER", Filter, "Filter", "" ) +DefNode( CompositorNode, CMP_NODE_MAP_VALUE, def_cmp_map_value, "MAP_VALUE", MapValue, "Map Value", "" ) +DefNode( CompositorNode, CMP_NODE_MAP_RANGE, def_cmp_map_range, "MAP_RANGE", MapRange, "Map Range", "" ) +DefNode( CompositorNode, CMP_NODE_TIME, def_time, "TIME", Time, "Time", "" ) +DefNode( CompositorNode, CMP_NODE_VECBLUR, def_cmp_vector_blur, "VECBLUR", VecBlur, "Vector Blur", "" ) +DefNode( CompositorNode, CMP_NODE_SEPRGBA, 0, "SEPRGBA", SepRGBA, "Separate RGBA", "" ) +DefNode( CompositorNode, CMP_NODE_SEPHSVA, 0, "SEPHSVA", SepHSVA, "Separate HSVA", "" ) +DefNode( CompositorNode, CMP_NODE_SETALPHA, 0, "SETALPHA", SetAlpha, "Set Alpha", "" ) +DefNode( CompositorNode, CMP_NODE_HUE_SAT, def_cmp_hue_saturation, "HUE_SAT", HueSat, "Hue Saturation Value","" ) +DefNode( CompositorNode, CMP_NODE_IMAGE, def_cmp_image, "IMAGE", Image, "Image", "" ) +DefNode( CompositorNode, CMP_NODE_R_LAYERS, def_cmp_render_layers, "R_LAYERS", RLayers, "Render Layers", "" ) +DefNode( CompositorNode, CMP_NODE_COMPOSITE, def_cmp_composite, "COMPOSITE", Composite, "Composite", "" ) +DefNode( CompositorNode, CMP_NODE_OUTPUT_FILE, def_cmp_output_file, "OUTPUT_FILE", OutputFile, "File Output", "" ) +DefNode( CompositorNode, CMP_NODE_TEXTURE, def_texture, "TEXTURE", Texture, "Texture", "" ) +DefNode( CompositorNode, CMP_NODE_TRANSLATE, def_cmp_translate, "TRANSLATE", Translate, "Translate", "" ) +DefNode( CompositorNode, CMP_NODE_ZCOMBINE, def_cmp_zcombine, "ZCOMBINE", Zcombine, "Z Combine", "" ) +DefNode( CompositorNode, CMP_NODE_COMBRGBA, 0, "COMBRGBA", CombRGBA, "Combine RGBA", "" ) +DefNode( CompositorNode, CMP_NODE_DILATEERODE, def_cmp_dilate_erode, "DILATEERODE", DilateErode, "Dilate/Erode", "" ) +DefNode( CompositorNode, CMP_NODE_INPAINT, def_cmp_inpaint, "INPAINT", Inpaint, "Inpaint", "" ) +DefNode( CompositorNode, CMP_NODE_DESPECKLE, def_cmp_despeckle, "DESPECKLE", Despeckle, "Despeckle", "" ) +DefNode( CompositorNode, CMP_NODE_ROTATE, def_cmp_rotate, "ROTATE", Rotate, "Rotate", "" ) +DefNode( CompositorNode, CMP_NODE_SCALE, def_cmp_scale, "SCALE", Scale, "Scale", "" ) +DefNode( CompositorNode, CMP_NODE_SEPYCCA, def_cmp_ycc, "SEPYCCA", SepYCCA, "Separate YCbCrA", "" ) +DefNode( CompositorNode, CMP_NODE_COMBYCCA, def_cmp_ycc, "COMBYCCA", CombYCCA, "Combine YCbCrA", "" ) +DefNode( CompositorNode, CMP_NODE_SEPYUVA, 0, "SEPYUVA", SepYUVA, "Separate YUVA", "" ) +DefNode( CompositorNode, CMP_NODE_COMBYUVA, 0, "COMBYUVA", CombYUVA, "Combine YUVA", "" ) +DefNode( CompositorNode, CMP_NODE_DIFF_MATTE, def_cmp_diff_matte, "DIFF_MATTE", DiffMatte, "Difference Key", "" ) +DefNode( CompositorNode, CMP_NODE_COLOR_SPILL, def_cmp_color_spill, "COLOR_SPILL", ColorSpill, "Color Spill", "" ) +DefNode( CompositorNode, CMP_NODE_CHROMA_MATTE, def_cmp_chroma_matte, "CHROMA_MATTE", ChromaMatte, "Chroma Key", "" ) +DefNode( CompositorNode, CMP_NODE_CHANNEL_MATTE, def_cmp_channel_matte, "CHANNEL_MATTE", ChannelMatte, "Channel Key", "" ) +DefNode( CompositorNode, CMP_NODE_FLIP, def_cmp_flip, "FLIP", Flip, "Flip", "" ) +DefNode( CompositorNode, CMP_NODE_SPLITVIEWER, def_cmp_splitviewer, "SPLITVIEWER", SplitViewer, "Split Viewer", "" ) +DefNode( CompositorNode, CMP_NODE_MAP_UV, def_cmp_map_uv, "MAP_UV", MapUV, "Map UV", "" ) +DefNode( CompositorNode, CMP_NODE_ID_MASK, def_cmp_id_mask, "ID_MASK", IDMask, "ID Mask", "" ) +DefNode( CompositorNode, CMP_NODE_DOUBLEEDGEMASK, def_cmp_double_edge_mask,"DOUBLEEDGEMASK", DoubleEdgeMask, "Double Edge Mask", "" ) +DefNode( CompositorNode, CMP_NODE_DEFOCUS, def_cmp_defocus, "DEFOCUS", Defocus, "Defocus", "" ) +DefNode( CompositorNode, CMP_NODE_DISPLACE, 0, "DISPLACE", Displace, "Displace", "" ) +DefNode( CompositorNode, CMP_NODE_COMBHSVA, 0, "COMBHSVA", CombHSVA, "Combine HSVA", "" ) +DefNode( CompositorNode, CMP_NODE_MATH, def_math, "MATH", Math, "Math", "" ) +DefNode( CompositorNode, CMP_NODE_LUMA_MATTE, def_cmp_luma_matte, "LUMA_MATTE", LumaMatte, "Luminance Key", "" ) +DefNode( CompositorNode, CMP_NODE_BRIGHTCONTRAST, 0, "BRIGHTCONTRAST", BrightContrast, "Bright/Contrast", "" ) +DefNode( CompositorNode, CMP_NODE_GAMMA, 0, "GAMMA", Gamma, "Gamma", "" ) +DefNode( CompositorNode, CMP_NODE_INVERT, def_cmp_invert, "INVERT", Invert, "Invert", "" ) +DefNode( CompositorNode, CMP_NODE_NORMALIZE, 0, "NORMALIZE", Normalize, "Normalize", "" ) +DefNode( CompositorNode, CMP_NODE_CROP, def_cmp_crop, "CROP", Crop, "Crop", "" ) +DefNode( CompositorNode, CMP_NODE_DBLUR, def_cmp_dblur, "DBLUR", DBlur, "Directional Blur", "" ) +DefNode( CompositorNode, CMP_NODE_BILATERALBLUR, def_cmp_bilateral_blur, "BILATERALBLUR", Bilateralblur, "Bilateral Blur", "" ) +DefNode( CompositorNode, CMP_NODE_PREMULKEY, def_cmp_premul_key, "PREMULKEY", PremulKey, "Alpha Convert", "" ) +DefNode( CompositorNode, CMP_NODE_GLARE, def_cmp_glare, "GLARE", Glare, "Glare", "" ) +DefNode( CompositorNode, CMP_NODE_TONEMAP, def_cmp_tonemap, "TONEMAP", Tonemap, "Tonemap", "" ) +DefNode( CompositorNode, CMP_NODE_LENSDIST, def_cmp_lensdist, "LENSDIST", Lensdist, "Lens Distortion", "" ) +DefNode( CompositorNode, CMP_NODE_VIEW_LEVELS, def_cmp_levels, "LEVELS", Levels, "Levels", "" ) +DefNode( CompositorNode, CMP_NODE_COLOR_MATTE, def_cmp_color_matte, "COLOR_MATTE", ColorMatte, "Color Key", "" ) +DefNode( CompositorNode, CMP_NODE_DIST_MATTE, def_cmp_distance_matte, "DISTANCE_MATTE", DistanceMatte, "Distance Key", "" ) +DefNode( CompositorNode, CMP_NODE_COLORBALANCE, def_cmp_colorbalance, "COLORBALANCE", ColorBalance, "Color Balance", "" ) +DefNode( CompositorNode, CMP_NODE_HUECORRECT, def_cmp_huecorrect, "HUECORRECT", HueCorrect, "Hue Correct", "" ) +DefNode( CompositorNode, CMP_NODE_MOVIECLIP, def_cmp_movieclip, "MOVIECLIP", MovieClip, "Movie Clip", "" ) +DefNode( CompositorNode, CMP_NODE_TRANSFORM, dev_cmd_transform, "TRANSFORM", Transform, "Transform", "" ) +DefNode( CompositorNode, CMP_NODE_STABILIZE2D, def_cmp_stabilize2d, "STABILIZE2D", Stabilize, "Stabilize 2D", "" ) +DefNode( CompositorNode, CMP_NODE_MOVIEDISTORTION,def_cmp_moviedistortion,"MOVIEDISTORTION",MovieDistortion, "Movie Distortion", "" ) +DefNode( CompositorNode, CMP_NODE_MASK_BOX, def_cmp_boxmask, "BOXMASK", BoxMask, "Box Mask", "" ) +DefNode( CompositorNode, CMP_NODE_MASK_ELLIPSE, def_cmp_ellipsemask, "ELLIPSEMASK", EllipseMask, "Ellipse Mask", "" ) +DefNode( CompositorNode, CMP_NODE_BOKEHIMAGE, def_cmp_bokehimage, "BOKEHIMAGE", BokehImage, "Bokeh Image", "" ) +DefNode( CompositorNode, CMP_NODE_BOKEHBLUR, def_cmp_bokehblur, "BOKEHBLUR", BokehBlur, "Bokeh Blur", "" ) +DefNode( CompositorNode, CMP_NODE_SWITCH, def_cmp_switch, "SWITCH", Switch, "Switch", "" ) +DefNode( CompositorNode, CMP_NODE_COLORCORRECTION,def_cmp_colorcorrection,"COLORCORRECTION",ColorCorrection, "Color Correction", "" ) +DefNode( CompositorNode, CMP_NODE_MASK, def_cmp_mask, "MASK", Mask, "Mask", "" ) +DefNode( CompositorNode, CMP_NODE_KEYINGSCREEN, def_cmp_keyingscreen, "KEYINGSCREEN", KeyingScreen, "Keying Screen", "" ) +DefNode( CompositorNode, CMP_NODE_KEYING, def_cmp_keying, "KEYING", Keying, "Keying", "" ) +DefNode( CompositorNode, CMP_NODE_TRACKPOS, def_cmp_trackpos, "TRACKPOS", TrackPos, "Track Position", "" ) +DefNode( CompositorNode, CMP_NODE_PIXELATE, 0, "PIXELATE", Pixelate, "Pixelate", "" ) + +DefNode( TextureNode, TEX_NODE_OUTPUT, def_tex_output, "OUTPUT", Output, "Output", "" ) +DefNode( TextureNode, TEX_NODE_CHECKER, 0, "CHECKER", Checker, "Checker", "" ) +DefNode( TextureNode, TEX_NODE_TEXTURE, def_texture, "TEXTURE", Texture, "Texture", "" ) +DefNode( TextureNode, TEX_NODE_BRICKS, def_tex_bricks, "BRICKS", Bricks, "Bricks", "" ) +DefNode( TextureNode, TEX_NODE_MATH, def_math, "MATH", Math, "Math", "" ) +DefNode( TextureNode, TEX_NODE_MIX_RGB, def_mix_rgb, "MIX_RGB", MixRGB, "Mix RGB", "" ) +DefNode( TextureNode, TEX_NODE_RGBTOBW, 0, "RGBTOBW", RGBToBW, "RGB to BW", "" ) +DefNode( TextureNode, TEX_NODE_VALTORGB, def_colorramp, "VALTORGB", ValToRGB, "ColorRamp", "" ) +DefNode( TextureNode, TEX_NODE_IMAGE, def_tex_image, "IMAGE", Image, "Image", "" ) +DefNode( TextureNode, TEX_NODE_CURVE_RGB, def_rgb_curve, "CURVE_RGB", CurveRGB, "RGB Curves", "" ) +DefNode( TextureNode, TEX_NODE_INVERT, 0, "INVERT", Invert, "Invert", "" ) +DefNode( TextureNode, TEX_NODE_HUE_SAT, 0, "HUE_SAT", HueSaturation, "Hue/Saturation", "" ) +DefNode( TextureNode, TEX_NODE_CURVE_TIME, def_time, "CURVE_TIME", CurveTime, "Curve Time", "" ) +DefNode( TextureNode, TEX_NODE_ROTATE, 0, "ROTATE", Rotate, "Rotate", "" ) +DefNode( TextureNode, TEX_NODE_VIEWER, 0, "VIEWER", Viewer, "Viewer", "" ) +DefNode( TextureNode, TEX_NODE_TRANSLATE, 0, "TRANSLATE", Translate, "Translate", "" ) +DefNode( TextureNode, TEX_NODE_COORD, 0, "COORD", Coordinates, "Coordinates", "" ) +DefNode( TextureNode, TEX_NODE_DISTANCE, 0, "DISTANCE", Distance, "Distance", "" ) +DefNode( TextureNode, TEX_NODE_COMPOSE, 0, "COMPOSE", Compose, "Combine RGBA", "" ) +DefNode( TextureNode, TEX_NODE_DECOMPOSE, 0, "DECOMPOSE", Decompose, "Separate RGBA", "" ) +DefNode( TextureNode, TEX_NODE_VALTONOR, 0, "VALTONOR", ValToNor, "Value to Normal", "" ) +DefNode( TextureNode, TEX_NODE_SCALE, 0, "SCALE", Scale, "Scale", "" ) +DefNode( TextureNode, TEX_NODE_AT, 0, "AT", At, "At", "" ) +/* procedural textures */ +DefNode( TextureNode, TEX_NODE_PROC+TEX_VORONOI, 0, "TEX_VORONOI", TexVoronoi, "Voronoi", "" ) +DefNode( TextureNode, TEX_NODE_PROC+TEX_BLEND, 0, "TEX_BLEND", TexBlend, "Blend", "" ) +DefNode( TextureNode, TEX_NODE_PROC+TEX_MAGIC, 0, "TEX_MAGIC", TexMagic, "Magic", "" ) +DefNode( TextureNode, TEX_NODE_PROC+TEX_MARBLE, 0, "TEX_MARBLE", TexMarble, "Marble", "" ) +DefNode( TextureNode, TEX_NODE_PROC+TEX_CLOUDS, 0, "TEX_CLOUDS", TexClouds, "Clouds", "" ) +DefNode( TextureNode, TEX_NODE_PROC+TEX_WOOD, 0, "TEX_WOOD", TexWood, "Wood", "" ) +DefNode( TextureNode, TEX_NODE_PROC+TEX_MUSGRAVE, 0, "TEX_MUSGRAVE", TexMusgrave, "Musgrave", "" ) +DefNode( TextureNode, TEX_NODE_PROC+TEX_NOISE, 0, "TEX_NOISE", TexNoise, "Noise", "" ) +DefNode( TextureNode, TEX_NODE_PROC+TEX_STUCCI, 0, "TEX_STUCCI", TexStucci, "Stucci", "" ) +DefNode( TextureNode, TEX_NODE_PROC+TEX_DISTNOISE, 0, "TEX_DISTNOISE", TexDistNoise, "Distorted Noise", "" ) + + +/* undefine macros */ +#undef DefNode diff --git a/source/blender/nodes/NOD_texture.h b/source/blender/nodes/NOD_texture.h index a1be9963b8a..ea003f23960 100644 --- a/source/blender/nodes/NOD_texture.h +++ b/source/blender/nodes/NOD_texture.h @@ -34,48 +34,52 @@ #include "BKE_node.h" -extern bNodeTreeType ntreeType_Texture; +extern struct bNodeTreeType *ntreeType_Texture; /* ****************** types array for all texture nodes ****************** */ -void register_node_type_tex_group(struct bNodeTreeType *ttype); +void register_node_tree_type_tex(void); -void register_node_type_tex_math(struct bNodeTreeType *ttype); -void register_node_type_tex_mix_rgb(struct bNodeTreeType *ttype); -void register_node_type_tex_valtorgb(struct bNodeTreeType *ttype); -void register_node_type_tex_valtonor(struct bNodeTreeType *ttype); -void register_node_type_tex_rgbtobw(struct bNodeTreeType *ttype); -void register_node_type_tex_output(struct bNodeTreeType *ttype); -void register_node_type_tex_viewer(struct bNodeTreeType *ttype); -void register_node_type_tex_checker(struct bNodeTreeType *ttype); -void register_node_type_tex_texture(struct bNodeTreeType *ttype); -void register_node_type_tex_bricks(struct bNodeTreeType *ttype); -void register_node_type_tex_image(struct bNodeTreeType *ttype); -void register_node_type_tex_curve_rgb(struct bNodeTreeType *ttype); -void register_node_type_tex_curve_time(struct bNodeTreeType *ttype); -void register_node_type_tex_invert(struct bNodeTreeType *ttype); -void register_node_type_tex_hue_sat(struct bNodeTreeType *ttype); -void register_node_type_tex_coord(struct bNodeTreeType *ttype); -void register_node_type_tex_distance(struct bNodeTreeType *ttype); +void register_node_type_tex_group(void); +void register_node_type_tex_forloop(void); +void register_node_type_tex_whileloop(void); -void register_node_type_tex_rotate(struct bNodeTreeType *ttype); -void register_node_type_tex_translate(struct bNodeTreeType *ttype); -void register_node_type_tex_scale(struct bNodeTreeType *ttype); -void register_node_type_tex_at(struct bNodeTreeType *ttype); +void register_node_type_tex_math(void); +void register_node_type_tex_mix_rgb(void); +void register_node_type_tex_valtorgb(void); +void register_node_type_tex_valtonor(void); +void register_node_type_tex_rgbtobw(void); +void register_node_type_tex_output(void); +void register_node_type_tex_viewer(void); +void register_node_type_tex_checker(void); +void register_node_type_tex_texture(void); +void register_node_type_tex_bricks(void); +void register_node_type_tex_image(void); +void register_node_type_tex_curve_rgb(void); +void register_node_type_tex_curve_time(void); +void register_node_type_tex_invert(void); +void register_node_type_tex_hue_sat(void); +void register_node_type_tex_coord(void); +void register_node_type_tex_distance(void); -void register_node_type_tex_compose(struct bNodeTreeType *ttype); -void register_node_type_tex_decompose(struct bNodeTreeType *ttype); +void register_node_type_tex_rotate(void); +void register_node_type_tex_translate(void); +void register_node_type_tex_scale(void); +void register_node_type_tex_at(void); -void register_node_type_tex_proc_voronoi(struct bNodeTreeType *ttype); -void register_node_type_tex_proc_blend(struct bNodeTreeType *ttype); -void register_node_type_tex_proc_magic(struct bNodeTreeType *ttype); -void register_node_type_tex_proc_marble(struct bNodeTreeType *ttype); -void register_node_type_tex_proc_clouds(struct bNodeTreeType *ttype); -void register_node_type_tex_proc_wood(struct bNodeTreeType *ttype); -void register_node_type_tex_proc_musgrave(struct bNodeTreeType *ttype); -void register_node_type_tex_proc_noise(struct bNodeTreeType *ttype); -void register_node_type_tex_proc_stucci(struct bNodeTreeType *ttype); -void register_node_type_tex_proc_distnoise(struct bNodeTreeType *ttype); +void register_node_type_tex_compose(void); +void register_node_type_tex_decompose(void); + +void register_node_type_tex_proc_voronoi(void); +void register_node_type_tex_proc_blend(void); +void register_node_type_tex_proc_magic(void); +void register_node_type_tex_proc_marble(void); +void register_node_type_tex_proc_clouds(void); +void register_node_type_tex_proc_wood(void); +void register_node_type_tex_proc_musgrave(void); +void register_node_type_tex_proc_noise(void); +void register_node_type_tex_proc_stucci(void); +void register_node_type_tex_proc_distnoise(void); #endif diff --git a/source/blender/nodes/composite/node_composite_tree.c b/source/blender/nodes/composite/node_composite_tree.c index 999bcb9bba5..d10ab9d8d49 100644 --- a/source/blender/nodes/composite/node_composite_tree.c +++ b/source/blender/nodes/composite/node_composite_tree.c @@ -44,6 +44,7 @@ #include "BKE_animsys.h" #include "BKE_colortools.h" +#include "BKE_context.h" #include "BKE_fcurve.h" #include "BKE_global.h" #include "BKE_main.h" @@ -64,14 +65,17 @@ #include "COM_compositor.h" #endif -static void foreach_nodetree(Main *main, void *calldata, bNodeTreeCallback func) +static void composite_get_from_context(const bContext *C, bNodeTreeType *UNUSED(treetype), bNodeTree **r_ntree, ID **r_id, ID **r_from) { - Scene *sce; - for (sce= main->scene.first; sce; sce= sce->id.next) { - if (sce->nodetree) { - func(calldata, &sce->id, sce->nodetree); - } - } + Scene *scene = CTX_data_scene(C); + + *r_from = NULL; + *r_id = &scene->id; + *r_ntree = scene->nodetree; + + /* update output sockets based on available layers */ + ntreeCompositForceHidden(scene->nodetree, scene); + } static void foreach_nodeclass(Scene *UNUSED(scene), void *calldata, bNodeClassCallback func) @@ -85,6 +89,7 @@ static void foreach_nodeclass(Scene *UNUSED(scene), void *calldata, bNodeClassCa func(calldata, NODE_CLASS_MATTE, N_("Matte")); 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")); } @@ -106,22 +111,6 @@ static void free_cache(bNodeTree *ntree) free_node_cache(ntree, node); } -static void update_node(bNodeTree *ntree, bNode *node) -{ - bNodeSocket *sock; - - for (sock= node->outputs.first; sock; sock= sock->next) { - if (sock->cache) { - //free_compbuf(sock->cache); - //sock->cache= NULL; - } - } - node->need_exec= 1; - /* individual node update call */ - if (node->typeinfo->updatefunc) - node->typeinfo->updatefunc(ntree, node); -} - /* local tree then owns all compbufs */ static void localize(bNodeTree *localtree, bNodeTree *ntree) { @@ -145,16 +134,6 @@ static void localize(bNodeTree *localtree, bNodeTree *ntree) } } - /* copy over the preview buffers to update graduatly */ - if (node->preview) { - bNodePreview *preview = MEM_callocN(sizeof(bNodePreview), "Preview"); - preview->pad = node->preview->pad; - preview->xsize = node->preview->xsize; - preview->ysize = node->preview->ysize; - preview->rect = MEM_dupallocN(node->preview->rect); - node->new_node->preview = preview; - } - for (sock= node->outputs.first; sock; sock= sock->next) { sock->new_sock->cache= sock->cache; sock->cache= NULL; @@ -183,24 +162,8 @@ static void localize(bNodeTree *localtree, bNodeTree *ntree) } } -static void local_sync(bNodeTree *localtree, bNodeTree *ntree) +static void local_sync(bNodeTree *UNUSED(localtree), bNodeTree *UNUSED(ntree)) { - bNode *lnode; - - /* move over the compbufs and previews */ - for (lnode= localtree->nodes.first; lnode; lnode= lnode->next) { - if ( (lnode->exec & NODE_READY) && !(lnode->exec & NODE_SKIPPED) ) { - if (ntreeNodeExists(ntree, lnode->new_node)) { - - if (lnode->preview && lnode->preview->rect) { - nodeFreePreview(lnode->new_node); - lnode->new_node->preview= lnode->preview; - lnode->preview= NULL; - } - - } - } - } } static void local_merge(bNodeTree *localtree, bNodeTree *ntree) @@ -245,27 +208,38 @@ static void update(bNodeTree *ntree) ntreeSetOutput(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); + } } -bNodeTreeType ntreeType_Composite = { - /* type */ NTREE_COMPOSIT, - /* idname */ "NTCompositing Nodetree", +bNodeTreeType *ntreeType_Composite; + +void register_node_tree_type_cmp() +{ + bNodeTreeType *tt = ntreeType_Composite = MEM_callocN(sizeof(bNodeTreeType), "compositor node tree type"); - /* node_types */ { NULL, NULL }, + tt->type = NTREE_COMPOSIT; + strcpy(tt->idname, "CompositorNodeTree"); + strcpy(tt->ui_name, "Compositing"); + tt->ui_icon = 0; /* defined in drawnode.c */ + strcpy(tt->ui_description, ""); - /* free_cache */ free_cache, - /* free_node_cache */ free_node_cache, - /* foreach_nodetree */ foreach_nodetree, - /* foreach_nodeclass */ foreach_nodeclass, - /* localize */ localize, - /* local_sync */ local_sync, - /* local_merge */ local_merge, - /* update */ update, - /* update_node */ update_node, - /* validate_link */ NULL, - /* update_internal_links */ node_update_internal_links_default -}; - + 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->get_from_context = composite_get_from_context; + + tt->ext.srna = &RNA_CompositorNodeTree; + + ntreeTypeAdd(tt); +} void *COM_linker_hack = NULL; diff --git a/source/blender/nodes/composite/node_composite_util.c b/source/blender/nodes/composite/node_composite_util.c new file mode 100644 index 00000000000..b125473d5fa --- /dev/null +++ b/source/blender/nodes/composite/node_composite_util.c @@ -0,0 +1,59 @@ +/* + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * The Original Code is Copyright (C) 2006 Blender Foundation. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL LICENSE BLOCK ***** + */ + +/** \file blender/nodes/composite/node_composite_util.c + * \ingroup nodes + */ + +#include "node_composite_util.h" + + +int cmp_node_poll_default(bNodeType *UNUSED(ntype), bNodeTree *ntree) +{ + return (strcmp(ntree->idname, "CompositorNodeTree")==0); +} + +void cmp_node_update_default(bNodeTree *UNUSED(ntree), bNode *node) +{ + bNodeSocket *sock; + for(sock= node->outputs.first; sock; sock= sock->next) { + if(sock->cache) { + //free_compbuf(sock->cache); + //sock->cache= NULL; + } + } + node->need_exec= 1; +} + +void cmp_node_type_base(bNodeType *ntype, int type, const char *name, short nclass, short flag) +{ + node_type_base(ntype, type, name, nclass, flag); + + ntype->poll = cmp_node_poll_default; + ntype->updatefunc = cmp_node_update_default; + ntype->update_internal_links = node_update_internal_links_default; +} diff --git a/source/blender/nodes/composite/node_composite_util.h b/source/blender/nodes/composite/node_composite_util.h index a3c4bffe018..3f9cfc03089 100644 --- a/source/blender/nodes/composite/node_composite_util.h +++ b/source/blender/nodes/composite/node_composite_util.h @@ -59,4 +59,9 @@ #define CMP_SCALE_MAX 12000 +int cmp_node_poll_default(struct bNodeType *ntype, struct bNodeTree *ntree); +void cmp_node_update_default(struct bNodeTree *UNUSED(ntree), struct bNode *node); +void cmp_node_type_base(struct bNodeType *ntype, int type, const char *name, short nclass, short flag); + #endif /* __NODE_COMPOSITE_UTIL_H__ */ + diff --git a/source/blender/nodes/composite/nodes/node_composite_alphaOver.c b/source/blender/nodes/composite/nodes/node_composite_alphaOver.c index 217670621a8..d7c452e406e 100644 --- a/source/blender/nodes/composite/nodes/node_composite_alphaOver.c +++ b/source/blender/nodes/composite/nodes/node_composite_alphaOver.c @@ -43,19 +43,19 @@ static bNodeSocketTemplate cmp_node_alphaover_out[] = { { -1, 0, "" } }; -static void node_alphaover_init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_alphaover_init(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= MEM_callocN(sizeof(NodeTwoFloats), "NodeTwoFloats"); } -void register_node_type_cmp_alphaover(bNodeTreeType *ttype) +void register_node_type_cmp_alphaover() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_ALPHAOVER, "Alpha Over", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_ALPHAOVER, "Alpha Over", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_alphaover_in, cmp_node_alphaover_out); node_type_init(&ntype, node_alphaover_init); node_type_storage(&ntype, "NodeTwoFloats", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_bilateralblur.c b/source/blender/nodes/composite/nodes/node_composite_bilateralblur.c index b8bf379b14b..bb2f9023866 100644 --- a/source/blender/nodes/composite/nodes/node_composite_bilateralblur.c +++ b/source/blender/nodes/composite/nodes/node_composite_bilateralblur.c @@ -43,7 +43,7 @@ static bNodeSocketTemplate cmp_node_bilateralblur_out[] = { { -1, 0, "" } }; -static void node_composit_init_bilateralblur(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_bilateralblur(bNodeTree *UNUSED(ntree), bNode *node) { NodeBilateralBlurData *nbbd = MEM_callocN(sizeof(NodeBilateralBlurData), "node bilateral blur data"); node->storage = nbbd; @@ -51,14 +51,14 @@ static void node_composit_init_bilateralblur(bNodeTree *UNUSED(ntree), bNode *no nbbd->sigma_space = 5.0; } -void register_node_type_cmp_bilateralblur(bNodeTreeType *ttype) +void register_node_type_cmp_bilateralblur() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_BILATERALBLUR, "Bilateral Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_BILATERALBLUR, "Bilateral Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_bilateralblur_in, cmp_node_bilateralblur_out); node_type_init(&ntype, node_composit_init_bilateralblur); node_type_storage(&ntype, "NodeBilateralBlurData", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_blur.c b/source/blender/nodes/composite/nodes/node_composite_blur.c index 20fce05a40e..e531f1080cd 100644 --- a/source/blender/nodes/composite/nodes/node_composite_blur.c +++ b/source/blender/nodes/composite/nodes/node_composite_blur.c @@ -44,21 +44,21 @@ static bNodeSocketTemplate cmp_node_blur_out[] = { { -1, 0, "" } }; -static void node_composit_init_blur(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_blur(bNodeTree *UNUSED(ntree), bNode *node) { NodeBlurData *data = MEM_callocN(sizeof(NodeBlurData), "node blur data"); data->filtertype = R_FILTER_GAUSS; node->storage = data; } -void register_node_type_cmp_blur(bNodeTreeType *ttype) +void register_node_type_cmp_blur() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_BLUR, "Blur", NODE_CLASS_OP_FILTER, NODE_PREVIEW | NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_BLUR, "Blur", NODE_CLASS_OP_FILTER, NODE_PREVIEW | NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_blur_in, cmp_node_blur_out); node_type_init(&ntype, node_composit_init_blur); node_type_storage(&ntype, "NodeBlurData", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_bokehblur.c b/source/blender/nodes/composite/nodes/node_composite_bokehblur.c index ea3162a9e55..a2d9e6e1473 100644 --- a/source/blender/nodes/composite/nodes/node_composite_bokehblur.c +++ b/source/blender/nodes/composite/nodes/node_composite_bokehblur.c @@ -49,19 +49,19 @@ static bNodeSocketTemplate cmp_node_bokehblur_out[] = { { -1, 0, "" } }; -static void node_composit_init_bokehblur(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_bokehblur(bNodeTree *UNUSED(ntree), bNode *node) { node->custom3 = 4.0f; node->custom4 = 16.0f; } -void register_node_type_cmp_bokehblur(bNodeTreeType *ttype) +void register_node_type_cmp_bokehblur(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_BOKEHBLUR, "Bokeh Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_BOKEHBLUR, "Bokeh Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_bokehblur_in, cmp_node_bokehblur_out); node_type_init(&ntype, node_composit_init_bokehblur); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_bokehimage.c b/source/blender/nodes/composite/nodes/node_composite_bokehimage.c index b006280ca8a..c04682c42a6 100644 --- a/source/blender/nodes/composite/nodes/node_composite_bokehimage.c +++ b/source/blender/nodes/composite/nodes/node_composite_bokehimage.c @@ -41,7 +41,8 @@ static bNodeSocketTemplate cmp_node_bokehimage_out[] = { { SOCK_RGBA, 0, N_("Image"), 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f}, { -1, 0, "" } }; -static void node_composit_init_bokehimage(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) + +static void node_composit_init_bokehimage(bNodeTree *UNUSED(ntree), bNode *node) { NodeBokehImage * data = MEM_callocN(sizeof(NodeBokehImage), "NodeBokehImage"); data->angle = 0.0f; @@ -52,14 +53,14 @@ static void node_composit_init_bokehimage(bNodeTree *UNUSED(ntree), bNode *node, node->storage = data; } -void register_node_type_cmp_bokehimage(bNodeTreeType *ttype) +void register_node_type_cmp_bokehimage(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_BOKEHIMAGE, "Bokeh Image", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_BOKEHIMAGE, "Bokeh Image", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, cmp_node_bokehimage_out); node_type_init(&ntype, node_composit_init_bokehimage); node_type_storage(&ntype, "NodeBokehImage", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_boxmask.c b/source/blender/nodes/composite/nodes/node_composite_boxmask.c index eb2c58894f3..41820457b4b 100644 --- a/source/blender/nodes/composite/nodes/node_composite_boxmask.c +++ b/source/blender/nodes/composite/nodes/node_composite_boxmask.c @@ -44,7 +44,7 @@ static bNodeSocketTemplate cmp_node_boxmask_out[] = { { -1, 0, "" } }; -static void node_composit_init_boxmask(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_boxmask(bNodeTree *UNUSED(ntree), bNode *node) { NodeBoxMask *data = MEM_callocN(sizeof(NodeBoxMask), "NodeBoxMask"); data->x = 0.5; @@ -55,16 +55,16 @@ static void node_composit_init_boxmask(bNodeTree *UNUSED(ntree), bNode *node, bN node->storage = data; } -void register_node_type_cmp_boxmask(bNodeTreeType *ttype) +void register_node_type_cmp_boxmask(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_MASK_BOX, "Box Mask", NODE_CLASS_MATTE, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_MASK_BOX, "Box Mask", NODE_CLASS_MATTE, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_boxmask_in, cmp_node_boxmask_out); node_type_init(&ntype, node_composit_init_boxmask); node_type_storage(&ntype, "NodeBoxMask", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_brightness.c b/source/blender/nodes/composite/nodes/node_composite_brightness.c index 025f5c03c7c..babb753a98b 100644 --- a/source/blender/nodes/composite/nodes/node_composite_brightness.c +++ b/source/blender/nodes/composite/nodes/node_composite_brightness.c @@ -48,12 +48,12 @@ static bNodeSocketTemplate cmp_node_brightcontrast_out[] = { }; -void register_node_type_cmp_brightcontrast(bNodeTreeType *ttype) +void register_node_type_cmp_brightcontrast() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_BRIGHTCONTRAST, "Bright/Contrast", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_BRIGHTCONTRAST, "Bright/Contrast", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_brightcontrast_in, cmp_node_brightcontrast_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_channelMatte.c b/source/blender/nodes/composite/nodes/node_composite_channelMatte.c index acb0566be7c..b68bc066b12 100644 --- a/source/blender/nodes/composite/nodes/node_composite_channelMatte.c +++ b/source/blender/nodes/composite/nodes/node_composite_channelMatte.c @@ -45,7 +45,7 @@ static bNodeSocketTemplate cmp_node_channel_matte_out[] = { {-1, 0, ""} }; -static void node_composit_init_channel_matte(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_channel_matte(bNodeTree *UNUSED(ntree), bNode *node) { NodeChroma *c= MEM_callocN(sizeof(NodeChroma), "node chroma"); node->storage=c; @@ -60,14 +60,14 @@ static void node_composit_init_channel_matte(bNodeTree *UNUSED(ntree), bNode *no node->custom2= 2; /* Green Channel */ } -void register_node_type_cmp_channel_matte(bNodeTreeType *ttype) +void register_node_type_cmp_channel_matte() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_CHANNEL_MATTE, "Channel Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_CHANNEL_MATTE, "Channel Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_channel_matte_in, cmp_node_channel_matte_out); node_type_init(&ntype, node_composit_init_channel_matte); node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_chromaMatte.c b/source/blender/nodes/composite/nodes/node_composite_chromaMatte.c index 29782c3bc51..f119c5ae04f 100644 --- a/source/blender/nodes/composite/nodes/node_composite_chromaMatte.c +++ b/source/blender/nodes/composite/nodes/node_composite_chromaMatte.c @@ -45,7 +45,7 @@ static bNodeSocketTemplate cmp_node_chroma_out[] = { {-1, 0, ""} }; -static void node_composit_init_chroma_matte(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_chroma_matte(bNodeTree *UNUSED(ntree), bNode *node) { NodeChroma *c= MEM_callocN(sizeof(NodeChroma), "node chroma"); node->storage= c; @@ -56,14 +56,14 @@ static void node_composit_init_chroma_matte(bNodeTree *UNUSED(ntree), bNode *nod c->fstrength= 1.0f; } -void register_node_type_cmp_chroma_matte(bNodeTreeType *ttype) +void register_node_type_cmp_chroma_matte() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_CHROMA_MATTE, "Chroma Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_CHROMA_MATTE, "Chroma Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_chroma_in, cmp_node_chroma_out); node_type_init(&ntype, node_composit_init_chroma_matte); node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_colorMatte.c b/source/blender/nodes/composite/nodes/node_composite_colorMatte.c index 9905a2446b8..c1ed315adcb 100644 --- a/source/blender/nodes/composite/nodes/node_composite_colorMatte.c +++ b/source/blender/nodes/composite/nodes/node_composite_colorMatte.c @@ -45,7 +45,7 @@ static bNodeSocketTemplate cmp_node_color_out[] = { {-1, 0, ""} }; -static void node_composit_init_color_matte(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_color_matte(bNodeTree *UNUSED(ntree), bNode *node) { NodeChroma *c= MEM_callocN(sizeof(NodeChroma), "node color"); node->storage= c; @@ -56,14 +56,14 @@ static void node_composit_init_color_matte(bNodeTree *UNUSED(ntree), bNode *node c->fstrength= 1.0f; } -void register_node_type_cmp_color_matte(bNodeTreeType *ttype) +void register_node_type_cmp_color_matte() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_COLOR_MATTE, "Color Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_COLOR_MATTE, "Color Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_color_in, cmp_node_color_out); node_type_init(&ntype, node_composit_init_color_matte); node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_colorSpill.c b/source/blender/nodes/composite/nodes/node_composite_colorSpill.c index 32fa446790e..848a5280992 100644 --- a/source/blender/nodes/composite/nodes/node_composite_colorSpill.c +++ b/source/blender/nodes/composite/nodes/node_composite_colorSpill.c @@ -43,7 +43,7 @@ static bNodeSocketTemplate cmp_node_color_spill_out[] = { {-1, 0, ""} }; -static void node_composit_init_color_spill(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_color_spill(bNodeTree *UNUSED(ntree), bNode *node) { NodeColorspill *ncs= MEM_callocN(sizeof(NodeColorspill), "node colorspill"); node->storage=ncs; @@ -54,14 +54,14 @@ static void node_composit_init_color_spill(bNodeTree *UNUSED(ntree), bNode *node ncs->unspill=0; /* do not use unspill */ } -void register_node_type_cmp_color_spill(bNodeTreeType *ttype) +void register_node_type_cmp_color_spill() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_COLOR_SPILL, "Color Spill", NODE_CLASS_MATTE, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_COLOR_SPILL, "Color Spill", NODE_CLASS_MATTE, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_color_spill_in, cmp_node_color_spill_out); node_type_init(&ntype, node_composit_init_color_spill); node_type_storage(&ntype, "NodeColorspill", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_colorbalance.c b/source/blender/nodes/composite/nodes/node_composite_colorbalance.c index da9ce64d994..ebd41441b31 100644 --- a/source/blender/nodes/composite/nodes/node_composite_colorbalance.c +++ b/source/blender/nodes/composite/nodes/node_composite_colorbalance.c @@ -46,7 +46,7 @@ static bNodeSocketTemplate cmp_node_colorbalance_out[] = { {-1, 0, ""} }; -static void node_composit_init_colorbalance(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_colorbalance(bNodeTree *UNUSED(ntree), bNode *node) { NodeColorBalance *n= node->storage= MEM_callocN(sizeof(NodeColorBalance), "node colorbalance"); @@ -55,15 +55,15 @@ static void node_composit_init_colorbalance(bNodeTree *UNUSED(ntree), bNode *nod n->gain[0] = n->gain[1] = n->gain[2] = 1.0f; } -void register_node_type_cmp_colorbalance(bNodeTreeType *ttype) +void register_node_type_cmp_colorbalance() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_COLORBALANCE, "Color Balance", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_COLORBALANCE, "Color Balance", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_colorbalance_in, cmp_node_colorbalance_out); node_type_size(&ntype, 400, 200, 400); node_type_init(&ntype, node_composit_init_colorbalance); node_type_storage(&ntype, "NodeColorBalance", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_colorcorrection.c b/source/blender/nodes/composite/nodes/node_composite_colorcorrection.c index 19f2fad2e42..9b09462ed0f 100644 --- a/source/blender/nodes/composite/nodes/node_composite_colorcorrection.c +++ b/source/blender/nodes/composite/nodes/node_composite_colorcorrection.c @@ -47,7 +47,7 @@ static bNodeSocketTemplate cmp_node_colorcorrection_out[] = { { -1,0,""} }; -static void node_composit_init_colorcorrection(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_colorcorrection(bNodeTree *UNUSED(ntree), bNode *node) { NodeColorCorrection *n= node->storage= MEM_callocN(sizeof(NodeColorCorrection), "node colorcorrection"); n->startmidtones = 0.2f; @@ -75,15 +75,15 @@ static void node_composit_init_colorcorrection(bNodeTree *UNUSED(ntree), bNode * node->custom1 = 7; // red + green + blue enabled } -void register_node_type_cmp_colorcorrection(bNodeTreeType *ttype) +void register_node_type_cmp_colorcorrection(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_COLORCORRECTION, "Color Correction", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_COLORCORRECTION, "Color Correction", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_colorcorrection_in, cmp_node_colorcorrection_out); node_type_size(&ntype, 400, 200, 600); node_type_init(&ntype, node_composit_init_colorcorrection); node_type_storage(&ntype, "NodeColorCorrection", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_common.c b/source/blender/nodes/composite/nodes/node_composite_common.c index 7198798a152..384653e7b41 100644 --- a/source/blender/nodes/composite/nodes/node_composite_common.c +++ b/source/blender/nodes/composite/nodes/node_composite_common.c @@ -33,25 +33,35 @@ #include "DNA_node_types.h" #include "node_composite_util.h" +#include "NOD_common.h" #include "node_common.h" #include "node_exec.h" #include "BKE_node.h" -void register_node_type_cmp_group(bNodeTreeType *ttype) +#include "RNA_access.h" + +void register_node_type_cmp_group() { static bNodeType ntype; - - node_type_base(ttype, &ntype, NODE_GROUP, "Group", NODE_CLASS_GROUP, NODE_OPTIONS | NODE_CONST_OUTPUT); + + /* NB: cannot use sh_node_type_base for node group, because it would map the node type + * to the shared NODE_GROUP integer type id. + */ + node_type_base_custom(&ntype, "CompositorNodeGroup", "Group", NODE_CLASS_GROUP, NODE_OPTIONS | NODE_CONST_OUTPUT); + ntype.type = NODE_GROUP; + ntype.poll = cmp_node_poll_default; + ntype.update_internal_links = node_update_internal_links_default; + ntype.ext.srna = RNA_struct_find("CompositorNodeGroup"); + BLI_assert(ntype.ext.srna != NULL); + RNA_struct_blender_type_set(ntype.ext.srna, &ntype); + node_type_socket_templates(&ntype, NULL, NULL); node_type_size(&ntype, 120, 60, 200); node_type_label(&ntype, node_group_label); - node_type_init(&ntype, node_group_init); - node_type_valid(&ntype, node_group_valid); - node_type_template(&ntype, node_group_template); node_type_update(&ntype, NULL, node_group_verify); - node_type_group_edit(&ntype, node_group_edit_get, node_group_edit_set, node_group_edit_clear); + strcpy(ntype.group_tree_idname, "CompositorNodeTree"); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_composite.c b/source/blender/nodes/composite/nodes/node_composite_composite.c index ea281a3f556..42e284e0c52 100644 --- a/source/blender/nodes/composite/nodes/node_composite_composite.c +++ b/source/blender/nodes/composite/nodes/node_composite_composite.c @@ -39,15 +39,15 @@ static bNodeSocketTemplate cmp_node_composite_in[] = { { -1, 0, "" } }; -void register_node_type_cmp_composite(bNodeTreeType *ttype) +void register_node_type_cmp_composite() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_COMPOSITE, "Composite", NODE_CLASS_OUTPUT, NODE_OPTIONS | NODE_PREVIEW); + cmp_node_type_base(&ntype, CMP_NODE_COMPOSITE, "Composite", NODE_CLASS_OUTPUT, NODE_OPTIONS | NODE_PREVIEW); node_type_socket_templates(&ntype, cmp_node_composite_in, NULL); /* Do not allow muting for this node. */ node_type_internal_links(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_crop.c b/source/blender/nodes/composite/nodes/node_composite_crop.c index 10af55480cd..bae36024b88 100644 --- a/source/blender/nodes/composite/nodes/node_composite_crop.c +++ b/source/blender/nodes/composite/nodes/node_composite_crop.c @@ -43,7 +43,7 @@ static bNodeSocketTemplate cmp_node_crop_out[] = { { -1, 0, "" } }; -static void node_composit_init_crop(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_crop(bNodeTree *UNUSED(ntree), bNode *node) { NodeTwoXYs *nxy= MEM_callocN(sizeof(NodeTwoXYs), "node xy data"); node->storage= nxy; @@ -53,14 +53,14 @@ static void node_composit_init_crop(bNodeTree *UNUSED(ntree), bNode *node, bNode nxy->y2= 0; } -void register_node_type_cmp_crop(bNodeTreeType *ttype) +void register_node_type_cmp_crop() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_CROP, "Crop", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_CROP, "Crop", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_crop_in, cmp_node_crop_out); node_type_init(&ntype, node_composit_init_crop); node_type_storage(&ntype, "NodeTwoXYs", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_curves.c b/source/blender/nodes/composite/nodes/node_composite_curves.c index 9f40159baf3..18999cdc985 100644 --- a/source/blender/nodes/composite/nodes/node_composite_curves.c +++ b/source/blender/nodes/composite/nodes/node_composite_curves.c @@ -41,24 +41,24 @@ static bNodeSocketTemplate cmp_node_time_out[] = { { -1, 0, "" } }; -static void node_composit_init_curves_time(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_curves_time(bNodeTree *UNUSED(ntree), bNode *node) { node->custom1= 1; node->custom2= 250; node->storage= curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f); } -void register_node_type_cmp_curve_time(bNodeTreeType *ttype) +void register_node_type_cmp_curve_time() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_TIME, "Time", NODE_CLASS_INPUT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_TIME, "Time", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, cmp_node_time_out); node_type_size(&ntype, 140, 100, 320); node_type_init(&ntype, node_composit_init_curves_time); node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } @@ -74,22 +74,22 @@ static bNodeSocketTemplate cmp_node_curve_vec_out[] = { { -1, 0, "" } }; -static void node_composit_init_curve_vec(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_curve_vec(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= curvemapping_add(3, -1.0f, -1.0f, 1.0f, 1.0f); } -void register_node_type_cmp_curve_vec(bNodeTreeType *ttype) +void register_node_type_cmp_curve_vec() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_CURVE_VEC, "Vector Curves", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_CURVE_VEC, "Vector Curves", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_curve_vec_in, cmp_node_curve_vec_out); node_type_size(&ntype, 200, 140, 320); node_type_init(&ntype, node_composit_init_curve_vec); node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } @@ -107,20 +107,20 @@ static bNodeSocketTemplate cmp_node_curve_rgb_out[] = { { -1, 0, "" } }; -static void node_composit_init_curve_rgb(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_curve_rgb(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= curvemapping_add(4, 0.0f, 0.0f, 1.0f, 1.0f); } -void register_node_type_cmp_curve_rgb(bNodeTreeType *ttype) +void register_node_type_cmp_curve_rgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_curve_rgb_in, cmp_node_curve_rgb_out); node_type_size(&ntype, 200, 140, 320); node_type_init(&ntype, node_composit_init_curve_rgb); node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_defocus.c b/source/blender/nodes/composite/nodes/node_composite_defocus.c index c05f1d6fcff..95d9e611584 100644 --- a/source/blender/nodes/composite/nodes/node_composite_defocus.c +++ b/source/blender/nodes/composite/nodes/node_composite_defocus.c @@ -44,7 +44,7 @@ static bNodeSocketTemplate cmp_node_defocus_out[] = { { -1, 0, "" } }; -static void node_composit_init_defocus(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_defocus(bNodeTree *UNUSED(ntree), bNode *node) { /* qdn: defocus node */ NodeDefocus *nbd = MEM_callocN(sizeof(NodeDefocus), "node defocus data"); @@ -61,14 +61,14 @@ static void node_composit_init_defocus(bNodeTree *UNUSED(ntree), bNode *node, bN node->storage = nbd; } -void register_node_type_cmp_defocus(bNodeTreeType *ttype) +void register_node_type_cmp_defocus() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_DEFOCUS, "Defocus", NODE_CLASS_OP_FILTER, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_DEFOCUS, "Defocus", NODE_CLASS_OP_FILTER, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_defocus_in, cmp_node_defocus_out); node_type_init(&ntype, node_composit_init_defocus); node_type_storage(&ntype, "NodeDefocus", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_despeckle.c b/source/blender/nodes/composite/nodes/node_composite_despeckle.c index 816a1803e47..9811e2762df 100644 --- a/source/blender/nodes/composite/nodes/node_composite_despeckle.c +++ b/source/blender/nodes/composite/nodes/node_composite_despeckle.c @@ -42,19 +42,19 @@ static bNodeSocketTemplate cmp_node_despeckle_out[] = { { -1, 0, "" } }; -static void node_composit_init_despeckle(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_despeckle(bNodeTree *UNUSED(ntree), bNode *node) { node->custom3 = 0.5f; node->custom4 = 0.5f; } -void register_node_type_cmp_despeckle(bNodeTreeType *ttype) +void register_node_type_cmp_despeckle() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_DESPECKLE, "Despeckle", NODE_CLASS_OP_FILTER, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_DESPECKLE, "Despeckle", NODE_CLASS_OP_FILTER, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_despeckle_in, cmp_node_despeckle_out); node_type_init(&ntype, node_composit_init_despeckle); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_diffMatte.c b/source/blender/nodes/composite/nodes/node_composite_diffMatte.c index 29712d54e32..1faf1d1e82c 100644 --- a/source/blender/nodes/composite/nodes/node_composite_diffMatte.c +++ b/source/blender/nodes/composite/nodes/node_composite_diffMatte.c @@ -45,7 +45,7 @@ static bNodeSocketTemplate cmp_node_diff_matte_out[] = { {-1, 0, ""} }; -static void node_composit_init_diff_matte(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_diff_matte(bNodeTree *UNUSED(ntree), bNode *node) { NodeChroma *c= MEM_callocN(sizeof(NodeChroma), "node chroma"); node->storage= c; @@ -53,14 +53,14 @@ static void node_composit_init_diff_matte(bNodeTree *UNUSED(ntree), bNode *node, c->t2= 0.1f; } -void register_node_type_cmp_diff_matte(bNodeTreeType *ttype) +void register_node_type_cmp_diff_matte() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_DIFF_MATTE, "Difference Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_DIFF_MATTE, "Difference Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_diff_matte_in, cmp_node_diff_matte_out); node_type_init(&ntype, node_composit_init_diff_matte); node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_dilate.c b/source/blender/nodes/composite/nodes/node_composite_dilate.c index fabc54f61b3..d68a8c340d7 100644 --- a/source/blender/nodes/composite/nodes/node_composite_dilate.c +++ b/source/blender/nodes/composite/nodes/node_composite_dilate.c @@ -44,22 +44,21 @@ static bNodeSocketTemplate cmp_node_dilateerode_out[] = { { -1, 0, "" } }; -static void node_composit_init_dilateerode(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_dilateerode(bNodeTree *UNUSED(ntree), bNode *node) { NodeDilateErode *data = MEM_callocN(sizeof(NodeDilateErode), "NodeDilateErode"); data->falloff = PROP_SMOOTH; node->storage = data; } -void register_node_type_cmp_dilateerode(bNodeTreeType *ttype) +void register_node_type_cmp_dilateerode() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_DILATEERODE, "Dilate/Erode", NODE_CLASS_OP_FILTER, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_DILATEERODE, "Dilate/Erode", NODE_CLASS_OP_FILTER, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_dilateerode_in, cmp_node_dilateerode_out); node_type_init(&ntype, node_composit_init_dilateerode); - node_type_storage(&ntype, "NodeDilateErode", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_directionalblur.c b/source/blender/nodes/composite/nodes/node_composite_directionalblur.c index 6197d78563c..3a9c4928175 100644 --- a/source/blender/nodes/composite/nodes/node_composite_directionalblur.c +++ b/source/blender/nodes/composite/nodes/node_composite_directionalblur.c @@ -42,7 +42,7 @@ static bNodeSocketTemplate cmp_node_dblur_out[] = { { -1, 0, "" } }; -static void node_composit_init_dblur(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_dblur(bNodeTree *UNUSED(ntree), bNode *node) { NodeDBlurData *ndbd = MEM_callocN(sizeof(NodeDBlurData), "node dblur data"); node->storage = ndbd; @@ -50,14 +50,14 @@ static void node_composit_init_dblur(bNodeTree *UNUSED(ntree), bNode *node, bNod ndbd->center_y = 0.5; } -void register_node_type_cmp_dblur(bNodeTreeType *ttype) +void register_node_type_cmp_dblur() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_DBLUR, "Directional Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_DBLUR, "Directional Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_dblur_in, cmp_node_dblur_out); node_type_init(&ntype, node_composit_init_dblur); node_type_storage(&ntype, "NodeDBlurData", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_displace.c b/source/blender/nodes/composite/nodes/node_composite_displace.c index 251345d8a28..2ae7423b31b 100644 --- a/source/blender/nodes/composite/nodes/node_composite_displace.c +++ b/source/blender/nodes/composite/nodes/node_composite_displace.c @@ -47,12 +47,12 @@ static bNodeSocketTemplate cmp_node_displace_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_displace(bNodeTreeType *ttype) +void register_node_type_cmp_displace() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_DISPLACE, "Displace", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_DISPLACE, "Displace", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_displace_in, cmp_node_displace_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_distanceMatte.c b/source/blender/nodes/composite/nodes/node_composite_distanceMatte.c index 26f8055e7f2..1bbe71810c3 100644 --- a/source/blender/nodes/composite/nodes/node_composite_distanceMatte.c +++ b/source/blender/nodes/composite/nodes/node_composite_distanceMatte.c @@ -45,7 +45,7 @@ static bNodeSocketTemplate cmp_node_distance_matte_out[] = { {-1, 0, ""} }; -static void node_composit_init_distance_matte(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_distance_matte(bNodeTree *UNUSED(ntree), bNode *node) { NodeChroma *c= MEM_callocN(sizeof(NodeChroma), "node chroma"); node->storage= c; @@ -54,14 +54,14 @@ static void node_composit_init_distance_matte(bNodeTree *UNUSED(ntree), bNode *n c->t2= 0.1f; } -void register_node_type_cmp_distance_matte(bNodeTreeType *ttype) +void register_node_type_cmp_distance_matte() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_DIST_MATTE, "Distance Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_DIST_MATTE, "Distance Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_distance_matte_in, cmp_node_distance_matte_out); node_type_init(&ntype, node_composit_init_distance_matte); node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_doubleEdgeMask.c b/source/blender/nodes/composite/nodes/node_composite_doubleEdgeMask.c index d5dd63a4042..767dfce4d59 100644 --- a/source/blender/nodes/composite/nodes/node_composite_doubleEdgeMask.c +++ b/source/blender/nodes/composite/nodes/node_composite_doubleEdgeMask.c @@ -42,12 +42,13 @@ static bNodeSocketTemplate cmp_node_doubleedgemask_out[] = { { -1, 0, "" } // output socket array terminator }; -void register_node_type_cmp_doubleedgemask(bNodeTreeType *ttype) +void register_node_type_cmp_doubleedgemask() { static bNodeType ntype; // allocate a node type data structure - node_type_base(ttype, &ntype, CMP_NODE_DOUBLEEDGEMASK, "Double Edge Mask", NODE_CLASS_MATTE, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_DOUBLEEDGEMASK, "Double Edge Mask", NODE_CLASS_MATTE, NODE_OPTIONS); + node_type_socket_templates(&ntype, cmp_node_doubleedgemask_in, cmp_node_doubleedgemask_out); node_type_socket_templates(&ntype, cmp_node_doubleedgemask_in, cmp_node_doubleedgemask_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_ellipsemask.c b/source/blender/nodes/composite/nodes/node_composite_ellipsemask.c index c2e34dc07a0..c4a01abc6d1 100644 --- a/source/blender/nodes/composite/nodes/node_composite_ellipsemask.c +++ b/source/blender/nodes/composite/nodes/node_composite_ellipsemask.c @@ -44,7 +44,7 @@ static bNodeSocketTemplate cmp_node_ellipsemask_out[] = { { -1, 0, "" } }; -static void node_composit_init_ellipsemask(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_ellipsemask(bNodeTree *UNUSED(ntree), bNode *node) { NodeEllipseMask *data = MEM_callocN(sizeof(NodeEllipseMask), "NodeEllipseMask"); data->x = 0.5; @@ -55,17 +55,17 @@ static void node_composit_init_ellipsemask(bNodeTree *UNUSED(ntree), bNode *node node->storage = data; } -void register_node_type_cmp_ellipsemask(bNodeTreeType *ttype) +void register_node_type_cmp_ellipsemask(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_MASK_ELLIPSE, "Ellipse Mask", NODE_CLASS_MATTE, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_MASK_ELLIPSE, "Ellipse Mask", NODE_CLASS_MATTE, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_ellipsemask_in, cmp_node_ellipsemask_out); node_type_size(&ntype, 260, 110, 320); node_type_init(&ntype, node_composit_init_ellipsemask); node_type_storage(&ntype, "NodeEllipseMask", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_filter.c b/source/blender/nodes/composite/nodes/node_composite_filter.c index 3ecc7282632..cdd3e136874 100644 --- a/source/blender/nodes/composite/nodes/node_composite_filter.c +++ b/source/blender/nodes/composite/nodes/node_composite_filter.c @@ -43,13 +43,13 @@ static bNodeSocketTemplate cmp_node_filter_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_filter(bNodeTreeType *ttype) +void register_node_type_cmp_filter() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_FILTER, "Filter", NODE_CLASS_OP_FILTER, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_FILTER, "Filter", NODE_CLASS_OP_FILTER, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_filter_in, cmp_node_filter_out); node_type_label(&ntype, node_filter_label); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_flip.c b/source/blender/nodes/composite/nodes/node_composite_flip.c index f56805809c5..0041cdfd44e 100644 --- a/source/blender/nodes/composite/nodes/node_composite_flip.c +++ b/source/blender/nodes/composite/nodes/node_composite_flip.c @@ -43,12 +43,12 @@ static bNodeSocketTemplate cmp_node_flip_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_flip(bNodeTreeType *ttype) +void register_node_type_cmp_flip() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_FLIP, "Flip", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_FLIP, "Flip", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_flip_in, cmp_node_flip_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_gamma.c b/source/blender/nodes/composite/nodes/node_composite_gamma.c index 6da56165979..43eaa26c863 100644 --- a/source/blender/nodes/composite/nodes/node_composite_gamma.c +++ b/source/blender/nodes/composite/nodes/node_composite_gamma.c @@ -45,12 +45,12 @@ static bNodeSocketTemplate cmp_node_gamma_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_gamma(bNodeTreeType *ttype) +void register_node_type_cmp_gamma() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_GAMMA, "Gamma", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_GAMMA, "Gamma", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_gamma_in, cmp_node_gamma_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_glare.c b/source/blender/nodes/composite/nodes/node_composite_glare.c index dde056de807..c2f889a7bf5 100644 --- a/source/blender/nodes/composite/nodes/node_composite_glare.c +++ b/source/blender/nodes/composite/nodes/node_composite_glare.c @@ -41,7 +41,7 @@ static bNodeSocketTemplate cmp_node_glare_out[] = { { -1, 0, "" } }; -static void node_composit_init_glare(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_glare(bNodeTree *UNUSED(ntree), bNode *node) { NodeGlare *ndg = MEM_callocN(sizeof(NodeGlare), "node glare data"); ndg->quality = 1; @@ -57,14 +57,14 @@ static void node_composit_init_glare(bNodeTree *UNUSED(ntree), bNode *node, bNod node->storage = ndg; } -void register_node_type_cmp_glare(bNodeTreeType *ttype) +void register_node_type_cmp_glare() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_GLARE, "Glare", NODE_CLASS_OP_FILTER, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_GLARE, "Glare", NODE_CLASS_OP_FILTER, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_glare_in, cmp_node_glare_out); node_type_init(&ntype, node_composit_init_glare); node_type_storage(&ntype, "NodeGlare", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_hueSatVal.c b/source/blender/nodes/composite/nodes/node_composite_hueSatVal.c index 64ba24e082d..06ba1ba4851 100644 --- a/source/blender/nodes/composite/nodes/node_composite_hueSatVal.c +++ b/source/blender/nodes/composite/nodes/node_composite_hueSatVal.c @@ -44,7 +44,7 @@ static bNodeSocketTemplate cmp_node_hue_sat_out[] = { { -1, 0, "" } }; -static void node_composit_init_hue_sat(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_hue_sat(bNodeTree *UNUSED(ntree), bNode *node) { NodeHueSat *nhs= MEM_callocN(sizeof(NodeHueSat), "node hue sat"); node->storage= nhs; @@ -53,14 +53,14 @@ static void node_composit_init_hue_sat(bNodeTree *UNUSED(ntree), bNode *node, bN nhs->val= 1.0f; } -void register_node_type_cmp_hue_sat(bNodeTreeType *ttype) +void register_node_type_cmp_hue_sat() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_hue_sat_in, cmp_node_hue_sat_out); node_type_init(&ntype, node_composit_init_hue_sat); node_type_storage(&ntype, "NodeHueSat", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_huecorrect.c b/source/blender/nodes/composite/nodes/node_composite_huecorrect.c index 738f2f511f7..3ec4a9c9a4a 100644 --- a/source/blender/nodes/composite/nodes/node_composite_huecorrect.c +++ b/source/blender/nodes/composite/nodes/node_composite_huecorrect.c @@ -43,7 +43,7 @@ static bNodeSocketTemplate cmp_node_huecorrect_out[] = { { -1, 0, "" } }; -static void node_composit_init_huecorrect(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_huecorrect(bNodeTree *UNUSED(ntree), bNode *node) { CurveMapping *cumapping = node->storage= curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f); int c; @@ -59,15 +59,15 @@ static void node_composit_init_huecorrect(bNodeTree *UNUSED(ntree), bNode *node, cumapping->cur = 1; } -void register_node_type_cmp_huecorrect(bNodeTreeType *ttype) +void register_node_type_cmp_huecorrect() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_HUECORRECT, "Hue Correct", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_HUECORRECT, "Hue Correct", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_huecorrect_in, cmp_node_huecorrect_out); node_type_size(&ntype, 320, 140, 500); node_type_init(&ntype, node_composit_init_huecorrect); node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_idMask.c b/source/blender/nodes/composite/nodes/node_composite_idMask.c index 89ef4ad3d01..2d4fcc76462 100644 --- a/source/blender/nodes/composite/nodes/node_composite_idMask.c +++ b/source/blender/nodes/composite/nodes/node_composite_idMask.c @@ -44,12 +44,12 @@ static bNodeSocketTemplate cmp_node_idmask_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_idmask(bNodeTreeType *ttype) +void register_node_type_cmp_idmask() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_ID_MASK, "ID Mask", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_ID_MASK, "ID Mask", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_idmask_in, cmp_node_idmask_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_image.c b/source/blender/nodes/composite/nodes/node_composite_image.c index 563ad2b74b2..f9f289297d7 100644 --- a/source/blender/nodes/composite/nodes/node_composite_image.c +++ b/source/blender/nodes/composite/nodes/node_composite_image.c @@ -70,7 +70,7 @@ static bNodeSocket *cmp_node_image_add_render_pass_output(bNodeTree *ntree, bNod bNodeSocket *sock; NodeImageLayer *sockdata; - sock = node_add_output_from_template(ntree, node, &cmp_node_rlayers_out[rres_index]); + sock = node_add_socket_from_template(ntree, node, &cmp_node_rlayers_out[rres_index], SOCK_OUT); /* extra socket info */ sockdata = MEM_callocN(sizeof(NodeImageLayer), "node image layer"); sock->storage = sockdata; @@ -157,7 +157,7 @@ static void cmp_node_image_add_multilayer_outputs(bNodeTree *ntree, bNode *node, else type = SOCK_RGBA; - sock = nodeAddSocket(ntree, node, SOCK_OUT, rpass->name, type); + sock = nodeAddStaticSocket(ntree, node, SOCK_OUT, type, PROP_NONE, rpass->name, rpass->name); /* extra socket info */ sockdata = MEM_callocN(sizeof(NodeImageLayer), "node image layer"); sock->storage = sockdata; @@ -240,9 +240,6 @@ static void cmp_node_image_verify_outputs(bNodeTree *ntree, bNode *node) /* XXX make callback */ cmp_node_image_create_outputs(ntree, node); - /* flag all new sockets as dynamic, to prevent removal by socket verification function */ - for (newsock=node->outputs.first; newsock; newsock=newsock->next) - newsock->flag |= SOCK_DYNAMIC; for (newsock=node->outputs.first; newsock; newsock=newsock->next) { /* XXX make callback */ @@ -284,7 +281,7 @@ static void cmp_node_image_update(bNodeTree *ntree, bNode *node) cmp_node_image_verify_outputs(ntree, node); } -static void node_composit_init_image(bNodeTree *ntree, bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_image(bNodeTree *ntree, bNode *node) { ImageUser *iuser= MEM_callocN(sizeof(ImageUser), "node image user"); node->storage= iuser; @@ -308,38 +305,48 @@ static void node_composit_free_image(bNode *node) MEM_freeN(node->storage); } -static void node_composit_copy_image(bNode *orig_node, bNode *new_node) +static void node_composit_copy_image(bNodeTree *UNUSED(dest_ntree), bNode *dest_node, bNode *src_node) { bNodeSocket *sock; - new_node->storage= MEM_dupallocN(orig_node->storage); + dest_node->storage= MEM_dupallocN(src_node->storage); /* copy extra socket info */ - for (sock=orig_node->outputs.first; sock; sock=sock->next) + for (sock=src_node->outputs.first; sock; sock=sock->next) sock->new_sock->storage = MEM_dupallocN(sock->storage); } -void register_node_type_cmp_image(bNodeTreeType *ttype) +void register_node_type_cmp_image() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_IMAGE, "Image", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_IMAGE, "Image", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); node_type_init(&ntype, node_composit_init_image); node_type_storage(&ntype, "ImageUser", node_composit_free_image, node_composit_copy_image); node_type_update(&ntype, cmp_node_image_update, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } /* **************** RENDER RESULT ******************** */ -void register_node_type_cmp_rlayers(bNodeTreeType *ttype) +static int node_composit_poll_rlayers(bNodeType *UNUSED(ntype), bNodeTree *ntree) +{ + PointerRNA ptr; + + /* render layers node can only be used in local scene->nodetree, since it directly links to the scene */ + RNA_id_pointer_create((ID *)ntree, &ptr); + return (strcmp(ntree->idname, "CompositorNodeTree")==0 && RNA_boolean_get(&ptr, "is_local_tree")); +} + +void register_node_type_cmp_rlayers() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_R_LAYERS, "Render Layers", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_R_LAYERS, "Render Layers", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, cmp_node_rlayers_out); + ntype.poll = node_composit_poll_rlayers; - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_inpaint.c b/source/blender/nodes/composite/nodes/node_composite_inpaint.c index 4844b35fb62..83517d07b69 100644 --- a/source/blender/nodes/composite/nodes/node_composite_inpaint.c +++ b/source/blender/nodes/composite/nodes/node_composite_inpaint.c @@ -44,12 +44,12 @@ static bNodeSocketTemplate cmp_node_inpaint_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_inpaint(bNodeTreeType *ttype) +void register_node_type_cmp_inpaint(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_INPAINT, "Inpaint", NODE_CLASS_OP_FILTER, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_INPAINT, "Inpaint", NODE_CLASS_OP_FILTER, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_inpaint_in, cmp_node_inpaint_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_invert.c b/source/blender/nodes/composite/nodes/node_composite_invert.c index 0bfbe42868b..9765c3c8764 100644 --- a/source/blender/nodes/composite/nodes/node_composite_invert.c +++ b/source/blender/nodes/composite/nodes/node_composite_invert.c @@ -43,19 +43,19 @@ static bNodeSocketTemplate cmp_node_invert_out[] = { { -1, 0, "" } }; -static void node_composit_init_invert(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_invert(bNodeTree *UNUSED(ntree), bNode *node) { node->custom1 |= CMP_CHAN_RGB; } /* custom1 = mix type */ -void register_node_type_cmp_invert(bNodeTreeType *ttype) +void register_node_type_cmp_invert() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_invert_in, cmp_node_invert_out); node_type_init(&ntype, node_composit_init_invert); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_keying.c b/source/blender/nodes/composite/nodes/node_composite_keying.c index 51e0e9a8e39..464df4d72ab 100644 --- a/source/blender/nodes/composite/nodes/node_composite_keying.c +++ b/source/blender/nodes/composite/nodes/node_composite_keying.c @@ -60,7 +60,7 @@ static bNodeSocketTemplate cmp_node_keying_out[] = { { -1, 0, "" } }; -static void node_composit_init_keying(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_keying(bNodeTree *UNUSED(ntree), bNode *node) { NodeKeyingData *data; @@ -78,14 +78,14 @@ static void node_composit_init_keying(bNodeTree *UNUSED(ntree), bNode *node, bNo node->storage = data; } -void register_node_type_cmp_keying(bNodeTreeType *ttype) +void register_node_type_cmp_keying(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_KEYING, "Keying", NODE_CLASS_MATTE, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_KEYING, "Keying", NODE_CLASS_MATTE, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_keying_in, cmp_node_keying_out); node_type_init(&ntype, node_composit_init_keying); node_type_storage(&ntype, "NodeKeyingData", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_keyingscreen.c b/source/blender/nodes/composite/nodes/node_composite_keyingscreen.c index 1974087e8e7..b593196d815 100644 --- a/source/blender/nodes/composite/nodes/node_composite_keyingscreen.c +++ b/source/blender/nodes/composite/nodes/node_composite_keyingscreen.c @@ -50,7 +50,7 @@ static bNodeSocketTemplate cmp_node_keyingscreen_out[] = { { -1, 0, "" } }; -static void node_composit_init_keyingscreen(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_keyingscreen(bNodeTree *UNUSED(ntree), bNode *node) { NodeKeyingScreenData *data; @@ -59,14 +59,14 @@ static void node_composit_init_keyingscreen(bNodeTree *UNUSED(ntree), bNode *nod node->storage = data; } -void register_node_type_cmp_keyingscreen(bNodeTreeType *ttype) +void register_node_type_cmp_keyingscreen(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_KEYINGSCREEN, "Keying Screen", NODE_CLASS_MATTE, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_KEYINGSCREEN, "Keying Screen", NODE_CLASS_MATTE, NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, cmp_node_keyingscreen_out); node_type_init(&ntype, node_composit_init_keyingscreen); node_type_storage(&ntype, "NodeKeyingScreenData", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_lensdist.c b/source/blender/nodes/composite/nodes/node_composite_lensdist.c index 15d10e07946..78eeccbe4b1 100644 --- a/source/blender/nodes/composite/nodes/node_composite_lensdist.c +++ b/source/blender/nodes/composite/nodes/node_composite_lensdist.c @@ -43,7 +43,7 @@ static bNodeSocketTemplate cmp_node_lensdist_out[] = { { -1, 0, "" } }; -static void node_composit_init_lensdist(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_lensdist(bNodeTree *UNUSED(ntree), bNode *node) { NodeLensDist *nld = MEM_callocN(sizeof(NodeLensDist), "node lensdist data"); nld->jit = nld->proj = nld->fit = 0; @@ -51,14 +51,14 @@ static void node_composit_init_lensdist(bNodeTree *UNUSED(ntree), bNode *node, b } -void register_node_type_cmp_lensdist(bNodeTreeType *ttype) +void register_node_type_cmp_lensdist() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_LENSDIST, "Lens Distortion", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_LENSDIST, "Lens Distortion", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_lensdist_in, cmp_node_lensdist_out); node_type_init(&ntype, node_composit_init_lensdist); node_type_storage(&ntype, "NodeLensDist", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_levels.c b/source/blender/nodes/composite/nodes/node_composite_levels.c index f50a8838d74..2d24dfadbd3 100644 --- a/source/blender/nodes/composite/nodes/node_composite_levels.c +++ b/source/blender/nodes/composite/nodes/node_composite_levels.c @@ -45,19 +45,19 @@ static bNodeSocketTemplate cmp_node_view_levels_out[] = { {-1, 0, ""} }; -static void node_composit_init_view_levels(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_view_levels(bNodeTree *UNUSED(ntree), bNode *node) { node->custom1=1; /*All channels*/ } -void register_node_type_cmp_view_levels(bNodeTreeType *ttype) +void register_node_type_cmp_view_levels() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_VIEW_LEVELS, "Levels", NODE_CLASS_OUTPUT, NODE_OPTIONS|NODE_PREVIEW); + cmp_node_type_base(&ntype, CMP_NODE_VIEW_LEVELS, "Levels", NODE_CLASS_OUTPUT, NODE_OPTIONS|NODE_PREVIEW); node_type_socket_templates(&ntype, cmp_node_view_levels_in, cmp_node_view_levels_out); node_type_init(&ntype, node_composit_init_view_levels); node_type_storage(&ntype, "ImageUser", NULL, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_lummaMatte.c b/source/blender/nodes/composite/nodes/node_composite_lummaMatte.c index 60a7f3014de..2155db9ae20 100644 --- a/source/blender/nodes/composite/nodes/node_composite_lummaMatte.c +++ b/source/blender/nodes/composite/nodes/node_composite_lummaMatte.c @@ -45,7 +45,7 @@ static bNodeSocketTemplate cmp_node_luma_matte_out[] = { {-1, 0, ""} }; -static void node_composit_init_luma_matte(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_luma_matte(bNodeTree *UNUSED(ntree), bNode *node) { NodeChroma *c= MEM_callocN(sizeof(NodeChroma), "node chroma"); node->storage=c; @@ -53,14 +53,14 @@ static void node_composit_init_luma_matte(bNodeTree *UNUSED(ntree), bNode *node, c->t2= 0.0f; } -void register_node_type_cmp_luma_matte(bNodeTreeType *ttype) +void register_node_type_cmp_luma_matte() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_LUMA_MATTE, "Luminance Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_LUMA_MATTE, "Luminance Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_luma_matte_in, cmp_node_luma_matte_out); node_type_init(&ntype, node_composit_init_luma_matte); node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_mapRange.c b/source/blender/nodes/composite/nodes/node_composite_mapRange.c index 07f34e79bd1..43d359db0a5 100644 --- a/source/blender/nodes/composite/nodes/node_composite_mapRange.c +++ b/source/blender/nodes/composite/nodes/node_composite_mapRange.c @@ -46,12 +46,12 @@ static bNodeSocketTemplate cmp_node_map_range_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_map_range(bNodeTreeType *ttype) +void register_node_type_cmp_map_range() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_MAP_RANGE, "Map Range", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_MAP_RANGE, "Map Range", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_map_range_in, cmp_node_map_range_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_mapUV.c b/source/blender/nodes/composite/nodes/node_composite_mapUV.c index fa4c8d7022c..eca8dea0470 100644 --- a/source/blender/nodes/composite/nodes/node_composite_mapUV.c +++ b/source/blender/nodes/composite/nodes/node_composite_mapUV.c @@ -44,12 +44,12 @@ static bNodeSocketTemplate cmp_node_mapuv_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_mapuv(bNodeTreeType *ttype) +void register_node_type_cmp_mapuv() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_MAP_UV, "Map UV", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_MAP_UV, "Map UV", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_mapuv_in, cmp_node_mapuv_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_mapValue.c b/source/blender/nodes/composite/nodes/node_composite_mapValue.c index 046eeaf4fc8..e12c7e2d2c7 100644 --- a/source/blender/nodes/composite/nodes/node_composite_mapValue.c +++ b/source/blender/nodes/composite/nodes/node_composite_mapValue.c @@ -42,19 +42,19 @@ static bNodeSocketTemplate cmp_node_map_value_out[] = { { -1, 0, "" } }; -static void node_composit_init_map_value(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_map_value(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= add_tex_mapping(); } -void register_node_type_cmp_map_value(bNodeTreeType *ttype) +void register_node_type_cmp_map_value() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_MAP_VALUE, "Map Value", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_MAP_VALUE, "Map Value", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_map_value_in, cmp_node_map_value_out); node_type_init(&ntype, node_composit_init_map_value); node_type_storage(&ntype, "TexMapping", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_mask.c b/source/blender/nodes/composite/nodes/node_composite_mask.c index 27534698422..f97e83f177a 100644 --- a/source/blender/nodes/composite/nodes/node_composite_mask.c +++ b/source/blender/nodes/composite/nodes/node_composite_mask.c @@ -45,7 +45,7 @@ static bNodeSocketTemplate cmp_node_mask_out[] = { { -1, 0, "" } }; -static void node_composit_init_mask(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_mask(bNodeTree *UNUSED(ntree), bNode *node) { NodeMask *data = MEM_callocN(sizeof(NodeMask), "NodeMask"); data->size_x = data->size_y = 256; @@ -55,15 +55,15 @@ static void node_composit_init_mask(bNodeTree *UNUSED(ntree), bNode *node, bNode node->custom3 = 0.5f; /* shutter */ } -void register_node_type_cmp_mask(bNodeTreeType *ttype) +void register_node_type_cmp_mask(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_MASK, "Mask", NODE_CLASS_INPUT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_MASK, "Mask", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, cmp_node_mask_out); node_type_init(&ntype, node_composit_init_mask); node_type_storage(&ntype, "NodeMask", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_math.c b/source/blender/nodes/composite/nodes/node_composite_math.c index 5f5369ce03a..90c0d6ce30a 100644 --- a/source/blender/nodes/composite/nodes/node_composite_math.c +++ b/source/blender/nodes/composite/nodes/node_composite_math.c @@ -45,13 +45,13 @@ static bNodeSocketTemplate cmp_node_math_out[] = { }; -void register_node_type_cmp_math(bNodeTreeType *ttype) +void register_node_type_cmp_math() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_math_in, cmp_node_math_out); node_type_label(&ntype, node_math_label); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_mixrgb.c b/source/blender/nodes/composite/nodes/node_composite_mixrgb.c index 23e4fc90457..0a6559d4f2f 100644 --- a/source/blender/nodes/composite/nodes/node_composite_mixrgb.c +++ b/source/blender/nodes/composite/nodes/node_composite_mixrgb.c @@ -44,13 +44,13 @@ static bNodeSocketTemplate cmp_node_mix_rgb_out[] = { }; /* custom1 = mix type */ -void register_node_type_cmp_mix_rgb(bNodeTreeType *ttype) +void register_node_type_cmp_mix_rgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_mix_rgb_in, cmp_node_mix_rgb_out); node_type_label(&ntype, node_blend_label); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_movieclip.c b/source/blender/nodes/composite/nodes/node_composite_movieclip.c index 39d46e053bf..ae6f02452b4 100644 --- a/source/blender/nodes/composite/nodes/node_composite_movieclip.c +++ b/source/blender/nodes/composite/nodes/node_composite_movieclip.c @@ -42,7 +42,7 @@ static bNodeSocketTemplate cmp_node_movieclip_out[] = { { -1, 0, "" } }; -static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void init(bNodeTree *UNUSED(ntree), bNode *node) { MovieClipUser *user = MEM_callocN(sizeof(MovieClipUser), "node movie clip user"); @@ -50,14 +50,14 @@ static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(nt user->framenr = 1; } -void register_node_type_cmp_movieclip(bNodeTreeType *ttype) +void register_node_type_cmp_movieclip() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_MOVIECLIP, "Movie Clip", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_MOVIECLIP, "Movie Clip", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, cmp_node_movieclip_out); node_type_init(&ntype, init); node_type_storage(&ntype, "MovieClipUser", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_moviedistortion.c b/source/blender/nodes/composite/nodes/node_composite_moviedistortion.c index 198ffbb2857..b8770d1670e 100644 --- a/source/blender/nodes/composite/nodes/node_composite_moviedistortion.c +++ b/source/blender/nodes/composite/nodes/node_composite_moviedistortion.c @@ -60,21 +60,21 @@ static void storage_free(bNode *node) node->storage = NULL; } -static void storage_copy(bNode *orig_node, bNode *new_node) +static void storage_copy(bNodeTree *UNUSED(dest_ntree), bNode *dest_node, bNode *src_node) { - if (orig_node->storage) - new_node->storage = BKE_tracking_distortion_copy(orig_node->storage); + if (src_node->storage) + dest_node->storage = BKE_tracking_distortion_copy(src_node->storage); } -void register_node_type_cmp_moviedistortion(bNodeTreeType *ttype) +void register_node_type_cmp_moviedistortion() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_MOVIEDISTORTION, "Movie Distortion", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_MOVIEDISTORTION, "Movie Distortion", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_moviedistortion_in, cmp_node_moviedistortion_out); node_type_label(&ntype, label); node_type_storage(&ntype, NULL, storage_free, storage_copy); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_normal.c b/source/blender/nodes/composite/nodes/node_composite_normal.c index 88db5d36810..7a6d2fcd8e8 100644 --- a/source/blender/nodes/composite/nodes/node_composite_normal.c +++ b/source/blender/nodes/composite/nodes/node_composite_normal.c @@ -32,7 +32,6 @@ #include "node_composite_util.h" - /* **************** NORMAL ******************** */ static bNodeSocketTemplate cmp_node_normal_in[] = { { SOCK_VECTOR, 1, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_DIRECTION}, @@ -40,28 +39,17 @@ static bNodeSocketTemplate cmp_node_normal_in[] = { }; static bNodeSocketTemplate cmp_node_normal_out[] = { - { SOCK_VECTOR, 0, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_DIRECTION}, + { SOCK_VECTOR, 0, N_("Normal"), 0.0f, 0.0f, 1.0f, 0.0f, -1.0f, 1.0f, PROP_DIRECTION}, { SOCK_FLOAT, 0, N_("Dot")}, { -1, 0, "" } }; -static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) -{ - bNodeSocket *sock= node->outputs.first; - float *nor= ((bNodeSocketValueVector*)sock->default_value)->value; - - nor[0] = 0.0f; - nor[1] = 0.0f; - nor[2] = 1.0f; -} - -void register_node_type_cmp_normal(bNodeTreeType *ttype) +void register_node_type_cmp_normal() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_NORMAL, "Normal", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_NORMAL, "Normal", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_normal_in, cmp_node_normal_out); - node_type_init(&ntype, init); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_normalize.c b/source/blender/nodes/composite/nodes/node_composite_normalize.c index db811666900..2f19c6bc523 100644 --- a/source/blender/nodes/composite/nodes/node_composite_normalize.c +++ b/source/blender/nodes/composite/nodes/node_composite_normalize.c @@ -43,12 +43,12 @@ static bNodeSocketTemplate cmp_node_normalize_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_normalize(bNodeTreeType *ttype) +void register_node_type_cmp_normalize() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_NORMALIZE, "Normalize", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_NORMALIZE, "Normalize", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_normalize_in, cmp_node_normalize_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_outputFile.c b/source/blender/nodes/composite/nodes/node_composite_outputFile.c index d9a146ddaad..e008e17cbb0 100644 --- a/source/blender/nodes/composite/nodes/node_composite_outputFile.c +++ b/source/blender/nodes/composite/nodes/node_composite_outputFile.c @@ -34,6 +34,10 @@ #include "BLI_utildefines.h" #include "BLI_path_util.h" +#include "BKE_context.h" + +#include "RNA_access.h" + #include "node_composite_util.h" #include "IMB_imbuf.h" @@ -105,7 +109,7 @@ void ntreeCompositOutputFileUniqueLayer(ListBase *list, bNodeSocket *sock, const bNodeSocket *ntreeCompositOutputFileAddSocket(bNodeTree *ntree, bNode *node, const char *name, ImageFormatData *im_format) { NodeImageMultiFile *nimf = node->storage; - bNodeSocket *sock = nodeAddSocket(ntree, node, SOCK_IN, "", SOCK_RGBA); + bNodeSocket *sock = nodeAddStaticSocket(ntree, node, SOCK_IN, SOCK_RGBA, PROP_NONE, NULL, name); /* create format data for the input socket */ NodeImageMultiFileSocket *sockdata = MEM_callocN(sizeof(NodeImageMultiFileSocket), "socket image format"); @@ -165,14 +169,19 @@ void ntreeCompositOutputFileSetLayer(bNode *node, bNodeSocket *sock, const char ntreeCompositOutputFileUniqueLayer(&node->inputs, sock, name, '_'); } -static void init_output_file(bNodeTree *ntree, bNode *node, bNodeTemplate *ntemp) +/* XXX uses initfunc_api callback, regular initfunc does not support context yet */ +static void init_output_file(const bContext *C, PointerRNA *ptr) { + Scene *scene = CTX_data_scene(C); + bNodeTree *ntree = ptr->id.data; + bNode *node = ptr->data; NodeImageMultiFile *nimf= MEM_callocN(sizeof(NodeImageMultiFile), "node image multi file"); ImageFormatData *format = NULL; node->storage= nimf; + + if (scene) { + RenderData *rd = &scene->r; - if (ntemp->scene) { - RenderData *rd = &ntemp->scene->r; BLI_strncpy(nimf->base_path, rd->pic, sizeof(nimf->base_path)); nimf->format = rd->im_format; if (BKE_imtype_is_movie(nimf->format.imtype)) { @@ -200,41 +209,43 @@ static void free_output_file(bNode *node) MEM_freeN(node->storage); } -static void copy_output_file(struct bNode *node, struct bNode *target) +static void copy_output_file(bNodeTree *UNUSED(dest_ntree), bNode *dest_node, bNode *src_node) { - bNodeSocket *sock, *newsock; + bNodeSocket *src_sock, *dest_sock; - target->storage = MEM_dupallocN(node->storage); + dest_node->storage = MEM_dupallocN(src_node->storage); /* duplicate storage data in sockets */ - for (sock=node->inputs.first, newsock=target->inputs.first; sock && newsock; sock=sock->next, newsock=newsock->next) { - newsock->storage = MEM_dupallocN(sock->storage); + for (src_sock=src_node->inputs.first, dest_sock=dest_node->inputs.first; src_sock && dest_sock; src_sock=src_sock->next, dest_sock=dest_sock->next) { + dest_sock->storage = MEM_dupallocN(src_sock->storage); } } -static void update_output_file(bNodeTree *UNUSED(ntree), bNode *node) +static void update_output_file(bNodeTree *ntree, bNode *node) { bNodeSocket *sock; + PointerRNA ptr; + + cmp_node_update_default(ntree, node); /* automatically update the socket type based on linked input */ for (sock=node->inputs.first; sock; sock=sock->next) { if (sock->link) { - int linktype = sock->link->fromsock->type; - if (linktype != sock->type) - nodeSocketSetType(sock, linktype); + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr); + RNA_enum_set(&ptr, "type", sock->link->fromsock->type); } } } -void register_node_type_cmp_output_file(bNodeTreeType *ttype) +void register_node_type_cmp_output_file() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_OUTPUT_FILE, "File Output", NODE_CLASS_OUTPUT, NODE_OPTIONS|NODE_PREVIEW); + cmp_node_type_base(&ntype, CMP_NODE_OUTPUT_FILE, "File Output", NODE_CLASS_OUTPUT, NODE_OPTIONS|NODE_PREVIEW); node_type_socket_templates(&ntype, NULL, NULL); - node_type_init(&ntype, init_output_file); + ntype.initfunc_api = init_output_file; node_type_storage(&ntype, "NodeImageMultiFile", free_output_file, copy_output_file); node_type_update(&ntype, update_output_file, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_pixelate.c b/source/blender/nodes/composite/nodes/node_composite_pixelate.c index 3b65a2cdbd5..bb8df65ee23 100644 --- a/source/blender/nodes/composite/nodes/node_composite_pixelate.c +++ b/source/blender/nodes/composite/nodes/node_composite_pixelate.c @@ -45,12 +45,12 @@ static bNodeSocketTemplate cmp_node_pixelate_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_pixelate(bNodeTreeType *ttype) +void register_node_type_cmp_pixelate() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_PIXELATE, "Pixelate", NODE_CLASS_OP_FILTER, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_PIXELATE, "Pixelate", NODE_CLASS_OP_FILTER, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_pixelate_in, cmp_node_pixelate_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_premulkey.c b/source/blender/nodes/composite/nodes/node_composite_premulkey.c index 01eb3607760..75e34335c3a 100644 --- a/source/blender/nodes/composite/nodes/node_composite_premulkey.c +++ b/source/blender/nodes/composite/nodes/node_composite_premulkey.c @@ -44,12 +44,12 @@ static bNodeSocketTemplate cmp_node_premulkey_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_premulkey(bNodeTreeType *ttype) +void register_node_type_cmp_premulkey() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_PREMULKEY, "Alpha Convert", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_PREMULKEY, "Alpha Convert", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_premulkey_in, cmp_node_premulkey_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_rgb.c b/source/blender/nodes/composite/nodes/node_composite_rgb.c index 30b23a4c146..d2ebd84487d 100644 --- a/source/blender/nodes/composite/nodes/node_composite_rgb.c +++ b/source/blender/nodes/composite/nodes/node_composite_rgb.c @@ -32,32 +32,19 @@ #include "node_composite_util.h" - /* **************** RGB ******************** */ static bNodeSocketTemplate cmp_node_rgb_out[] = { - { SOCK_RGBA, 0, N_("RGBA"), 0.5f, 0.5f, 0.5f, 1.0f}, + { SOCK_RGBA, 0, N_("RGBA"), 0.5f, 0.5f, 0.5f, 1.0f}, { -1, 0, "" } }; -static void node_composit_init_rgb(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) -{ - bNodeSocket *sock= node->outputs.first; - float *col= ((bNodeSocketValueRGBA*)sock->default_value)->value; - /* uses the default value of the output socket, must be initialized here */ - col[0] = 0.5f; - col[1] = 0.5f; - col[2] = 0.5f; - col[3] = 1.0f; -} - -void register_node_type_cmp_rgb(bNodeTreeType *ttype) +void register_node_type_cmp_rgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_RGB, "RGB", NODE_CLASS_INPUT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_RGB, "RGB", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, cmp_node_rgb_out); - node_type_init(&ntype, node_composit_init_rgb); node_type_size_preset(&ntype, NODE_SIZE_SMALL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_rotate.c b/source/blender/nodes/composite/nodes/node_composite_rotate.c index 6b5521ea4d2..f52d54b9c64 100644 --- a/source/blender/nodes/composite/nodes/node_composite_rotate.c +++ b/source/blender/nodes/composite/nodes/node_composite_rotate.c @@ -44,18 +44,18 @@ static bNodeSocketTemplate cmp_node_rotate_out[] = { { -1, 0, "" } }; -static void node_composit_init_rotate(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_rotate(bNodeTree *UNUSED(ntree), bNode *node) { node->custom1= 1; /* Bilinear Filter*/ } -void register_node_type_cmp_rotate(bNodeTreeType *ttype) +void register_node_type_cmp_rotate() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_ROTATE, "Rotate", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_ROTATE, "Rotate", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_rotate_in, cmp_node_rotate_out); node_type_init(&ntype, node_composit_init_rotate); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_scale.c b/source/blender/nodes/composite/nodes/node_composite_scale.c index 6c2c6c37cb7..284b6dca72d 100644 --- a/source/blender/nodes/composite/nodes/node_composite_scale.c +++ b/source/blender/nodes/composite/nodes/node_composite_scale.c @@ -45,12 +45,12 @@ static bNodeSocketTemplate cmp_node_scale_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_scale(bNodeTreeType *ttype) +void register_node_type_cmp_scale() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_SCALE, "Scale", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_SCALE, "Scale", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_scale_in, cmp_node_scale_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_sepcombHSVA.c b/source/blender/nodes/composite/nodes/node_composite_sepcombHSVA.c index d463f35a07a..2043812c6eb 100644 --- a/source/blender/nodes/composite/nodes/node_composite_sepcombHSVA.c +++ b/source/blender/nodes/composite/nodes/node_composite_sepcombHSVA.c @@ -46,14 +46,14 @@ static bNodeSocketTemplate cmp_node_sephsva_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_sephsva(bNodeTreeType *ttype) +void register_node_type_cmp_sephsva() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_SEPHSVA, "Separate HSVA", NODE_CLASS_CONVERTOR, 0); + cmp_node_type_base(&ntype, CMP_NODE_SEPHSVA, "Separate HSVA", NODE_CLASS_CONVERTOR, 0); node_type_socket_templates(&ntype, cmp_node_sephsva_in, cmp_node_sephsva_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } @@ -70,12 +70,12 @@ static bNodeSocketTemplate cmp_node_combhsva_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_combhsva(bNodeTreeType *ttype) +void register_node_type_cmp_combhsva() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_COMBHSVA, "Combine HSVA", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_COMBHSVA, "Combine HSVA", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_combhsva_in, cmp_node_combhsva_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_sepcombRGBA.c b/source/blender/nodes/composite/nodes/node_composite_sepcombRGBA.c index 03b43f5073f..6b522184fe7 100644 --- a/source/blender/nodes/composite/nodes/node_composite_sepcombRGBA.c +++ b/source/blender/nodes/composite/nodes/node_composite_sepcombRGBA.c @@ -45,14 +45,14 @@ static bNodeSocketTemplate cmp_node_seprgba_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_seprgba(bNodeTreeType *ttype) +void register_node_type_cmp_seprgba() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_SEPRGBA, "Separate RGBA", NODE_CLASS_CONVERTOR, 0); + cmp_node_type_base(&ntype, CMP_NODE_SEPRGBA, "Separate RGBA", NODE_CLASS_CONVERTOR, 0); node_type_socket_templates(&ntype, cmp_node_seprgba_in, cmp_node_seprgba_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } @@ -70,12 +70,12 @@ static bNodeSocketTemplate cmp_node_combrgba_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_combrgba(bNodeTreeType *ttype) +void register_node_type_cmp_combrgba() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_COMBRGBA, "Combine RGBA", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_COMBRGBA, "Combine RGBA", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_combrgba_in, cmp_node_combrgba_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_sepcombYCCA.c b/source/blender/nodes/composite/nodes/node_composite_sepcombYCCA.c index 16aba1ba408..5940cf18c8a 100644 --- a/source/blender/nodes/composite/nodes/node_composite_sepcombYCCA.c +++ b/source/blender/nodes/composite/nodes/node_composite_sepcombYCCA.c @@ -47,14 +47,14 @@ static bNodeSocketTemplate cmp_node_sepycca_out[] = { }; -void register_node_type_cmp_sepycca(bNodeTreeType *ttype) +void register_node_type_cmp_sepycca() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_SEPYCCA, "Separate YCbCrA", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_SEPYCCA, "Separate YCbCrA", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_sepycca_in, cmp_node_sepycca_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } @@ -72,12 +72,12 @@ static bNodeSocketTemplate cmp_node_combycca_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_combycca(bNodeTreeType *ttype) +void register_node_type_cmp_combycca() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_COMBYCCA, "Combine YCbCrA", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_COMBYCCA, "Combine YCbCrA", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_combycca_in, cmp_node_combycca_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_sepcombYUVA.c b/source/blender/nodes/composite/nodes/node_composite_sepcombYUVA.c index 7d7ec166fd4..01dfd3b1abd 100644 --- a/source/blender/nodes/composite/nodes/node_composite_sepcombYUVA.c +++ b/source/blender/nodes/composite/nodes/node_composite_sepcombYUVA.c @@ -46,15 +46,14 @@ static bNodeSocketTemplate cmp_node_sepyuva_out[] = { { -1, 0, "" } }; - -void register_node_type_cmp_sepyuva(bNodeTreeType *ttype) +void register_node_type_cmp_sepyuva() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_SEPYUVA, "Separate YUVA", NODE_CLASS_CONVERTOR, 0); + cmp_node_type_base(&ntype, CMP_NODE_SEPYUVA, "Separate YUVA", NODE_CLASS_CONVERTOR, 0); node_type_socket_templates(&ntype, cmp_node_sepyuva_in, cmp_node_sepyuva_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } @@ -72,12 +71,12 @@ static bNodeSocketTemplate cmp_node_combyuva_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_combyuva(bNodeTreeType *ttype) +void register_node_type_cmp_combyuva() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_COMBYUVA, "Combine YUVA", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_COMBYUVA, "Combine YUVA", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_combyuva_in, cmp_node_combyuva_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_setalpha.c b/source/blender/nodes/composite/nodes/node_composite_setalpha.c index d36acc6c054..30e408dcccb 100644 --- a/source/blender/nodes/composite/nodes/node_composite_setalpha.c +++ b/source/blender/nodes/composite/nodes/node_composite_setalpha.c @@ -43,12 +43,12 @@ static bNodeSocketTemplate cmp_node_setalpha_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_setalpha(bNodeTreeType *ttype) +void register_node_type_cmp_setalpha() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_SETALPHA, "Set Alpha", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_SETALPHA, "Set Alpha", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_setalpha_in, cmp_node_setalpha_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_splitViewer.c b/source/blender/nodes/composite/nodes/node_composite_splitViewer.c index 38a6981613a..9fd61eca668 100644 --- a/source/blender/nodes/composite/nodes/node_composite_splitViewer.c +++ b/source/blender/nodes/composite/nodes/node_composite_splitViewer.c @@ -39,7 +39,7 @@ static bNodeSocketTemplate cmp_node_splitviewer_in[] = { { -1, 0, "" } }; -static void node_composit_init_splitviewer(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_splitviewer(bNodeTree *UNUSED(ntree), bNode *node) { ImageUser *iuser= MEM_callocN(sizeof(ImageUser), "node image user"); node->storage= iuser; @@ -49,11 +49,11 @@ static void node_composit_init_splitviewer(bNodeTree *UNUSED(ntree), bNode *node node->custom1= 50; /* default 50% split */ } -void register_node_type_cmp_splitviewer(bNodeTreeType *ttype) +void register_node_type_cmp_splitviewer() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_SPLITVIEWER, "Split Viewer", NODE_CLASS_OUTPUT, NODE_PREVIEW|NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_SPLITVIEWER, "Split Viewer", NODE_CLASS_OUTPUT, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_splitviewer_in, NULL); node_type_init(&ntype, node_composit_init_splitviewer); node_type_storage(&ntype, "ImageUser", node_free_standard_storage, node_copy_standard_storage); @@ -61,5 +61,5 @@ void register_node_type_cmp_splitviewer(bNodeTreeType *ttype) /* Do not allow muting for this node. */ node_type_internal_links(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_stabilize2d.c b/source/blender/nodes/composite/nodes/node_composite_stabilize2d.c index 6b345b4c15c..2aa2906d67a 100644 --- a/source/blender/nodes/composite/nodes/node_composite_stabilize2d.c +++ b/source/blender/nodes/composite/nodes/node_composite_stabilize2d.c @@ -45,12 +45,12 @@ static bNodeSocketTemplate cmp_node_stabilize2d_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_stabilize2d(bNodeTreeType *ttype) +void register_node_type_cmp_stabilize2d() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_STABILIZE2D, "Stabilize 2D", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_STABILIZE2D, "Stabilize 2D", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_stabilize2d_in, cmp_node_stabilize2d_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_switch.c b/source/blender/nodes/composite/nodes/node_composite_switch.c index 49fa61a8397..a6254de62d5 100644 --- a/source/blender/nodes/composite/nodes/node_composite_switch.c +++ b/source/blender/nodes/composite/nodes/node_composite_switch.c @@ -46,13 +46,13 @@ static bNodeSocketTemplate cmp_node_switch_out[] = { }; /* custom1 = mix type */ -void register_node_type_cmp_switch(bNodeTreeType *ttype) +void register_node_type_cmp_switch(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_SWITCH, "Switch", NODE_CLASS_LAYOUT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_SWITCH, "Switch", NODE_CLASS_LAYOUT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_switch_in, cmp_node_switch_out); node_type_size_preset(&ntype, NODE_SIZE_SMALL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_texture.c b/source/blender/nodes/composite/nodes/node_composite_texture.c index 515093fc3e1..3793dd4669a 100644 --- a/source/blender/nodes/composite/nodes/node_composite_texture.c +++ b/source/blender/nodes/composite/nodes/node_composite_texture.c @@ -44,12 +44,12 @@ static bNodeSocketTemplate cmp_node_texture_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_texture(bNodeTreeType *ttype) +void register_node_type_cmp_texture() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW); + cmp_node_type_base(&ntype, CMP_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW); node_type_socket_templates(&ntype, cmp_node_texture_in, cmp_node_texture_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_tonemap.c b/source/blender/nodes/composite/nodes/node_composite_tonemap.c index fd3a217b150..4f43297a182 100644 --- a/source/blender/nodes/composite/nodes/node_composite_tonemap.c +++ b/source/blender/nodes/composite/nodes/node_composite_tonemap.c @@ -41,7 +41,7 @@ static bNodeSocketTemplate cmp_node_tonemap_out[] = { { -1, 0, "" } }; -static void node_composit_init_tonemap(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_tonemap(bNodeTree *UNUSED(ntree), bNode *node) { NodeTonemap *ntm = MEM_callocN(sizeof(NodeTonemap), "node tonemap data"); ntm->type = 1; @@ -57,14 +57,14 @@ static void node_composit_init_tonemap(bNodeTree *UNUSED(ntree), bNode *node, bN node->storage = ntm; } -void register_node_type_cmp_tonemap(bNodeTreeType *ttype) +void register_node_type_cmp_tonemap() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_TONEMAP, "Tonemap", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_TONEMAP, "Tonemap", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_tonemap_in, cmp_node_tonemap_out); node_type_init(&ntype, node_composit_init_tonemap); node_type_storage(&ntype, "NodeTonemap", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_trackpos.c b/source/blender/nodes/composite/nodes/node_composite_trackpos.c index 1583680720a..bc3c54702ac 100644 --- a/source/blender/nodes/composite/nodes/node_composite_trackpos.c +++ b/source/blender/nodes/composite/nodes/node_composite_trackpos.c @@ -39,21 +39,21 @@ static bNodeSocketTemplate cmp_node_trackpos_out[] = { { -1, 0, "" } }; -static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void init(bNodeTree *UNUSED(ntree), bNode *node) { NodeTrackPosData *data = MEM_callocN(sizeof(NodeTrackPosData), "node track position data"); node->storage = data; } -void register_node_type_cmp_trackpos(bNodeTreeType *ttype) +void register_node_type_cmp_trackpos(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_TRACKPOS, "Track Position", NODE_CLASS_INPUT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_TRACKPOS, "Track Position", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, cmp_node_trackpos_out); node_type_init(&ntype, init); node_type_storage(&ntype, "NodeTrackPosData", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_transform.c b/source/blender/nodes/composite/nodes/node_composite_transform.c index 3ed8bdb9995..9618cc85811 100644 --- a/source/blender/nodes/composite/nodes/node_composite_transform.c +++ b/source/blender/nodes/composite/nodes/node_composite_transform.c @@ -48,12 +48,12 @@ static bNodeSocketTemplate cmp_node_transform_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_transform(bNodeTreeType *ttype) +void register_node_type_cmp_transform() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_TRANSFORM, "Transform", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_TRANSFORM, "Transform", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_transform_in, cmp_node_transform_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_translate.c b/source/blender/nodes/composite/nodes/node_composite_translate.c index 5d555cdcda9..2449f614fe0 100644 --- a/source/blender/nodes/composite/nodes/node_composite_translate.c +++ b/source/blender/nodes/composite/nodes/node_composite_translate.c @@ -46,20 +46,20 @@ static bNodeSocketTemplate cmp_node_translate_out[] = { { -1, 0, "" } }; -static void node_composit_init_translate(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_translate(bNodeTree *UNUSED(ntree), bNode *node) { NodeTranslateData *data = MEM_callocN(sizeof(NodeTranslateData), "node translate data"); node->storage = data; } -void register_node_type_cmp_translate(bNodeTreeType *ttype) +void register_node_type_cmp_translate() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_TRANSLATE, "Translate", NODE_CLASS_DISTORT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_TRANSLATE, "Translate", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_translate_in, cmp_node_translate_out); node_type_init(&ntype, node_composit_init_translate); node_type_storage(&ntype, "NodeTranslateData", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_valToRgb.c b/source/blender/nodes/composite/nodes/node_composite_valToRgb.c index 5a23507bcc7..db02c51c95f 100644 --- a/source/blender/nodes/composite/nodes/node_composite_valToRgb.c +++ b/source/blender/nodes/composite/nodes/node_composite_valToRgb.c @@ -44,22 +44,22 @@ static bNodeSocketTemplate cmp_node_valtorgb_out[] = { { -1, 0, "" } }; -static void node_composit_init_valtorgb(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_valtorgb(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= add_colorband(1); } -void register_node_type_cmp_valtorgb(bNodeTreeType *ttype) +void register_node_type_cmp_valtorgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_valtorgb_in, cmp_node_valtorgb_out); node_type_size(&ntype, 240, 200, 320); node_type_init(&ntype, node_composit_init_valtorgb); node_type_storage(&ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } @@ -74,13 +74,13 @@ static bNodeSocketTemplate cmp_node_rgbtobw_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_rgbtobw(bNodeTreeType *ttype) +void register_node_type_cmp_rgbtobw() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTOR, 0); + cmp_node_type_base(&ntype, CMP_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTOR, 0); node_type_socket_templates(&ntype, cmp_node_rgbtobw_in, cmp_node_rgbtobw_out); node_type_size_preset(&ntype, NODE_SIZE_SMALL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_value.c b/source/blender/nodes/composite/nodes/node_composite_value.c index 306170baf93..491c01c465a 100644 --- a/source/blender/nodes/composite/nodes/node_composite_value.c +++ b/source/blender/nodes/composite/nodes/node_composite_value.c @@ -34,29 +34,17 @@ /* **************** VALUE ******************** */ static bNodeSocketTemplate cmp_node_value_out[] = { - /* XXX value nodes use the output sockets for buttons, so we need explicit limits here! */ - { SOCK_FLOAT, 0, N_("Value"), 0.0f, 0.0f, 0.0f, 0.0f, -FLT_MAX, FLT_MAX}, + { SOCK_FLOAT, 0, N_("Value"), 0.5f, 0, 0, 0, -FLT_MAX, FLT_MAX, PROP_NONE}, { -1, 0, "" } }; -static void node_composit_init_value(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) -{ - bNodeSocket *sock= node->outputs.first; - bNodeSocketValueFloat *dval= (bNodeSocketValueFloat*)sock->default_value; - /* uses the default value of the output socket, must be initialized here */ - dval->value = 0.5f; - dval->min = -FLT_MAX; - dval->max = FLT_MAX; -} - -void register_node_type_cmp_value(bNodeTreeType *ttype) +void register_node_type_cmp_value() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_VALUE, "Value", NODE_CLASS_INPUT, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_VALUE, "Value", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, cmp_node_value_out); - node_type_init(&ntype, node_composit_init_value); node_type_size_preset(&ntype, NODE_SIZE_SMALL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_vecBlur.c b/source/blender/nodes/composite/nodes/node_composite_vecBlur.c index 35fb4a944db..02a5fdcc0e5 100644 --- a/source/blender/nodes/composite/nodes/node_composite_vecBlur.c +++ b/source/blender/nodes/composite/nodes/node_composite_vecBlur.c @@ -45,7 +45,7 @@ static bNodeSocketTemplate cmp_node_vecblur_out[] = { { -1, 0, "" } }; -static void node_composit_init_vecblur(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_vecblur(bNodeTree *UNUSED(ntree), bNode *node) { NodeBlurData *nbd = MEM_callocN(sizeof(NodeBlurData), "node blur data"); node->storage = nbd; @@ -54,14 +54,14 @@ static void node_composit_init_vecblur(bNodeTree *UNUSED(ntree), bNode *node, bN } /* custom1: itterations, custom2: maxspeed (0 = nolimit) */ -void register_node_type_cmp_vecblur(bNodeTreeType *ttype) +void register_node_type_cmp_vecblur() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_VECBLUR, "Vector Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_VECBLUR, "Vector Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_vecblur_in, cmp_node_vecblur_out); node_type_init(&ntype, node_composit_init_vecblur); node_type_storage(&ntype, "NodeBlurData", node_free_standard_storage, node_copy_standard_storage); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_viewer.c b/source/blender/nodes/composite/nodes/node_composite_viewer.c index 211ebe54eb0..a1e6640dcb6 100644 --- a/source/blender/nodes/composite/nodes/node_composite_viewer.c +++ b/source/blender/nodes/composite/nodes/node_composite_viewer.c @@ -41,7 +41,7 @@ static bNodeSocketTemplate cmp_node_viewer_in[] = { { -1, 0, "" } }; -static void node_composit_init_viewer(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_composit_init_viewer(bNodeTree *UNUSED(ntree), bNode *node) { ImageUser *iuser = MEM_callocN(sizeof(ImageUser), "node image user"); node->storage = iuser; @@ -52,16 +52,16 @@ static void node_composit_init_viewer(bNodeTree *UNUSED(ntree), bNode *node, bNo node->custom4 = 0.5f; } -void register_node_type_cmp_viewer(bNodeTreeType *ttype) +void register_node_type_cmp_viewer() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_VIEWER, "Viewer", NODE_CLASS_OUTPUT, NODE_OPTIONS | NODE_PREVIEW); + cmp_node_type_base(&ntype, CMP_NODE_VIEWER, "Viewer", NODE_CLASS_OUTPUT, NODE_OPTIONS | NODE_PREVIEW); node_type_socket_templates(&ntype, cmp_node_viewer_in, NULL); node_type_init(&ntype, node_composit_init_viewer); node_type_storage(&ntype, "ImageUser", node_free_standard_storage, node_copy_standard_storage); node_type_internal_links(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/composite/nodes/node_composite_zcombine.c b/source/blender/nodes/composite/nodes/node_composite_zcombine.c index ba81174e103..ca7258c5b97 100644 --- a/source/blender/nodes/composite/nodes/node_composite_zcombine.c +++ b/source/blender/nodes/composite/nodes/node_composite_zcombine.c @@ -48,12 +48,12 @@ static bNodeSocketTemplate cmp_node_zcombine_out[] = { { -1, 0, "" } }; -void register_node_type_cmp_zcombine(bNodeTreeType *ttype) +void register_node_type_cmp_zcombine() { static bNodeType ntype; - node_type_base(ttype, &ntype, CMP_NODE_ZCOMBINE, "Z Combine", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + cmp_node_type_base(&ntype, CMP_NODE_ZCOMBINE, "Z Combine", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, cmp_node_zcombine_in, cmp_node_zcombine_out); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/intern/node_common.c b/source/blender/nodes/intern/node_common.c index d59061dfc0a..85e2f775ad9 100644 --- a/source/blender/nodes/intern/node_common.c +++ b/source/blender/nodes/intern/node_common.c @@ -31,19 +31,22 @@ #include <string.h> +#include <stddef.h> #include "DNA_node_types.h" #include "BLI_listbase.h" +#include "BLI_math.h" +#include "BLI_path_util.h" #include "BLI_string.h" #include "BLI_utildefines.h" #include "BLF_translation.h" #include "BKE_global.h" +#include "BKE_idprop.h" #include "BKE_library.h" #include "BKE_main.h" -#include "BLI_math.h" #include "BKE_node.h" #include "RNA_access.h" @@ -55,247 +58,110 @@ #include "node_util.h" #include "node_exec.h" #include "NOD_socket.h" +#include "NOD_common.h" + /**** Group ****/ -bNodeSocket *node_group_find_input(bNode *gnode, bNodeSocket *gsock) +bNodeSocket *node_group_find_input_socket(bNode *groupnode, const char *identifier) { bNodeSocket *sock; - for (sock=gnode->inputs.first; sock; sock=sock->next) - if (sock->groupsock == gsock) + for (sock=groupnode->inputs.first; sock; sock=sock->next) + if (strcmp(sock->identifier, identifier)==0) return sock; return NULL; } -bNodeSocket *node_group_find_output(bNode *gnode, bNodeSocket *gsock) +bNodeSocket *node_group_find_output_socket(bNode *groupnode, const char *identifier) { bNodeSocket *sock; - for (sock=gnode->outputs.first; sock; sock=sock->next) - if (sock->groupsock == gsock) + for (sock=groupnode->outputs.first; sock; sock=sock->next) + if (strcmp(sock->identifier, identifier)==0) return sock; return NULL; } -bNodeSocket *node_group_add_extern_socket(bNodeTree *UNUSED(ntree), ListBase *lb, int in_out, bNodeSocket *gsock) -{ - bNodeSocket *sock; - - if (gsock->flag & SOCK_INTERNAL) - return NULL; - - sock= MEM_callocN(sizeof(bNodeSocket), "sock"); - - /* make a copy of the group socket */ - *sock = *gsock; - sock->link = NULL; - sock->next = sock->prev = NULL; - sock->new_sock = NULL; - - /* group sockets are dynamically added */ - sock->flag |= SOCK_DYNAMIC|SOCK_COLLAPSED; - - sock->own_index = gsock->own_index; - sock->groupsock = gsock; - sock->limit = (in_out==SOCK_IN ? 1 : 0xFFF); - - sock->default_value = node_socket_make_default_value(sock->type); - node_socket_copy_default_value(sock->type, sock->default_value, gsock->default_value); - - if (lb) - BLI_addtail(lb, sock); - - return sock; -} - -bNodeSocket *node_group_add_socket(bNodeTree *ngroup, const char *name, int type, int in_out) -{ - bNodeSocketType *stype = ntreeGetSocketType(type); - bNodeSocket *gsock = MEM_callocN(sizeof(bNodeSocket), "bNodeSocket"); - - BLI_strncpy(gsock->name, name, sizeof(gsock->name)); - gsock->type = type; - /* group sockets are dynamically added */ - gsock->flag |= SOCK_DYNAMIC|SOCK_COLLAPSED; - - gsock->next = gsock->prev = NULL; - gsock->new_sock = NULL; - gsock->link = NULL; - /* assign new unique index */ - gsock->own_index = ngroup->cur_index++; - gsock->limit = (in_out==SOCK_IN ? 0xFFF : 1); - - if (stype->value_structsize > 0) - gsock->default_value = MEM_callocN(stype->value_structsize, "default socket value"); - - BLI_addtail(in_out==SOCK_IN ? &ngroup->inputs : &ngroup->outputs, gsock); - - ngroup->update |= (in_out==SOCK_IN ? NTREE_UPDATE_GROUP_IN : NTREE_UPDATE_GROUP_OUT); - - return gsock; -} - -bNodeSocket *node_group_expose_socket(bNodeTree *ngroup, bNodeSocket *sock, int in_out) -{ - bNodeSocket *gsock= node_group_add_socket(ngroup, sock->name, sock->type, in_out); - - /* initialize the default value. */ - node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value); - - return gsock; -} - -void node_group_expose_all_sockets(bNodeTree *ngroup) -{ - bNode *node; - bNodeSocket *sock, *gsock; - - for (node=ngroup->nodes.first; node; node=node->next) { - for (sock=node->inputs.first; sock; sock=sock->next) { - if (!sock->link && !nodeSocketIsHidden(sock)) { - gsock = node_group_add_socket(ngroup, sock->name, sock->type, SOCK_IN); - - /* initialize the default value. */ - node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value); - - sock->link = nodeAddLink(ngroup, NULL, gsock, node, sock); - } - } - for (sock=node->outputs.first; sock; sock=sock->next) { - if (nodeCountSocketLinks(ngroup, sock)==0 && !nodeSocketIsHidden(sock)) { - gsock = node_group_add_socket(ngroup, sock->name, sock->type, SOCK_OUT); - - /* initialize the default value. */ - node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value); - - gsock->link = nodeAddLink(ngroup, node, sock, NULL, gsock); - } - } - } -} - -void node_group_remove_socket(bNodeTree *ngroup, bNodeSocket *gsock, int in_out) -{ - nodeRemSocketLinks(ngroup, gsock); - - switch (in_out) { - case SOCK_IN: - BLI_remlink(&ngroup->inputs, gsock); - ngroup->update |= NTREE_UPDATE_GROUP_IN; - break; - case SOCK_OUT: - BLI_remlink(&ngroup->outputs, gsock); - ngroup->update |= NTREE_UPDATE_GROUP_OUT; - break; - } - - if (gsock->default_value) - MEM_freeN(gsock->default_value); - - MEM_freeN(gsock); -} - /* groups display their internal tree name as label */ const char *node_group_label(bNode *node) { return (node->id)? node->id->name + 2: IFACE_("Missing Datablock"); } -int node_group_valid(bNodeTree *ntree, bNodeTemplate *ntemp) +int node_group_poll_instance(bNode *node, bNodeTree *nodetree) { - bNodeTemplate childtemp; - bNode *node; - - /* regular groups cannot be recursive */ - if (ntree == ntemp->ngroup) - return 0; - - /* make sure all children are valid */ - for (node=ntemp->ngroup->nodes.first; node; node=node->next) { - childtemp = nodeMakeTemplate(node); - if (!nodeValid(ntree, &childtemp)) - return 0; - } - - return 1; -} - -bNodeTemplate node_group_template(bNode *node) -{ - bNodeTemplate ntemp; - ntemp.type = NODE_GROUP; - ntemp.ngroup = (bNodeTree *)node->id; - return ntemp; + bNodeTree *grouptree = (bNodeTree*)node->id; + if (grouptree) + return nodeGroupPoll(nodetree, grouptree); + else + return 1; } -void node_group_init(bNodeTree *ntree, bNode *node, bNodeTemplate *ntemp) +int nodeGroupPoll(bNodeTree *nodetree, bNodeTree *grouptree) { - node->id = (ID *)ntemp->ngroup; + bNode *node; + int valid = 1; - /* NB: group socket input/output roles are inverted internally! - * Group "inputs" work as outputs in links and vice versa. - */ - if (ntemp->ngroup) { - bNodeSocket *gsock; - for (gsock=ntemp->ngroup->inputs.first; gsock; gsock=gsock->next) - node_group_add_extern_socket(ntree, &node->inputs, SOCK_IN, gsock); - for (gsock=ntemp->ngroup->outputs.first; gsock; gsock=gsock->next) - node_group_add_extern_socket(ntree, &node->outputs, SOCK_OUT, gsock); + if (nodetree == grouptree) + return 0; + + for (node=grouptree->nodes.first; node; node=node->next) { + if (!node->typeinfo->poll_instance(node, nodetree)) { + valid = 0; + break; + } } + return valid; } -static bNodeSocket *group_verify_socket(bNodeTree *ntree, ListBase *lb, int in_out, bNodeSocket *gsock) +/* used for both group nodes and interface nodes */ +static bNodeSocket *group_verify_socket(bNodeTree *ntree, bNode *gnode, bNodeSocket *iosock, ListBase *verify_lb, int in_out) { bNodeSocket *sock; - /* group sockets tagged as internal are not exposed ever */ - if (gsock->flag & SOCK_INTERNAL) - return NULL; - - for (sock= lb->first; sock; sock= sock->next) { - if (sock->own_index==gsock->own_index) + for (sock= verify_lb->first; sock; sock= sock->next) { + if (strcmp(sock->identifier, iosock->identifier)==0) break; } if (sock) { - sock->groupsock = gsock; - - BLI_strncpy(sock->name, gsock->name, sizeof(sock->name)); - if (gsock->type != sock->type) - nodeSocketSetType(sock, gsock->type); - - /* XXX hack: group socket input/output roles are inverted internally, - * need to change the limit value when making actual node sockets from them. - */ - sock->limit = (in_out==SOCK_IN ? 1 : 0xFFF); - - BLI_remlink(lb, sock); - - return sock; + strcpy(sock->name, iosock->name); } else { - return node_group_add_extern_socket(ntree, NULL, in_out, gsock); + sock = nodeAddSocket(ntree, gnode, in_out, iosock->idname, iosock->identifier, iosock->name); + + if (iosock->typeinfo->interface_init_socket) + iosock->typeinfo->interface_init_socket(ntree, iosock, gnode, sock, "interface"); } + + /* remove from list temporarily, to distinguish from orphaned sockets */ + BLI_remlink(verify_lb, sock); + + return sock; } -static void group_verify_socket_list(bNodeTree *ntree, bNode *node, ListBase *lb, int in_out, ListBase *glb) +/* used for both group nodes and interface nodes */ +static void group_verify_socket_list(bNodeTree *ntree, bNode *gnode, + ListBase *iosock_lb, ListBase *verify_lb, int in_out) { - bNodeSocket *sock, *nextsock, *gsock; + bNodeSocket *iosock, *sock, *nextsock; /* step by step compare */ - for (gsock= glb->first; gsock; gsock=gsock->next) { + + iosock = iosock_lb->first; + for (; iosock; iosock = iosock->next) { /* abusing new_sock pointer for verification here! only used inside this function */ - gsock->new_sock= group_verify_socket(ntree, lb, in_out, gsock); + iosock->new_sock = group_verify_socket(ntree, gnode, iosock, verify_lb, in_out); } /* leftovers are removed */ - for (sock=lb->first; sock; sock=nextsock) { - nextsock=sock->next; - if (sock->flag & SOCK_DYNAMIC) - nodeRemoveSocket(ntree, node, sock); + for (sock = verify_lb->first; sock; sock = nextsock) { + nextsock = sock->next; + nodeRemoveSocket(ntree, gnode, sock); } /* and we put back the verified sockets */ - for (gsock= glb->first; gsock; gsock=gsock->next) { - if (gsock->new_sock) { - BLI_addtail(lb, gsock->new_sock); - gsock->new_sock = NULL; + iosock = iosock_lb->first; + for (; iosock; iosock = iosock->next) { + if (iosock->new_sock) { + BLI_addtail(verify_lb, iosock->new_sock); + iosock->new_sock = NULL; } } } @@ -304,59 +170,16 @@ static void group_verify_socket_list(bNodeTree *ntree, bNode *node, ListBase *lb void node_group_verify(struct bNodeTree *ntree, struct bNode *node, struct ID *id) { /* check inputs and outputs, and remove or insert them */ - if (node->id==id) { + if (id == node->id) { bNodeTree *ngroup= (bNodeTree *)node->id; - group_verify_socket_list(ntree, node, &node->inputs, SOCK_IN, &ngroup->inputs); - group_verify_socket_list(ntree, node, &node->outputs, SOCK_OUT, &ngroup->outputs); + group_verify_socket_list(ntree, node, &ngroup->inputs, &node->inputs, SOCK_IN); + group_verify_socket_list(ntree, node, &ngroup->outputs, &node->outputs, SOCK_OUT); } } -struct bNodeTree *node_group_edit_get(bNode *node) -{ - if (node->flag & NODE_GROUP_EDIT) - return (bNodeTree *)node->id; - else - return NULL; -} - -struct bNodeTree *node_group_edit_set(bNode *node, int edit) -{ - if (edit) { - bNodeTree *ngroup= (bNodeTree *)node->id; - if (ngroup) { - if (ngroup->id.lib) - ntreeMakeLocal(ngroup); - - node->flag |= NODE_GROUP_EDIT; - } - return ngroup; - } - else { - node->flag &= ~NODE_GROUP_EDIT; - return NULL; - } -} - -void node_group_edit_clear(bNode *node) -{ - bNodeTree *ngroup= (bNodeTree *)node->id; - bNode *inode; - - node->flag &= ~NODE_GROUP_EDIT; - - if (ngroup) - for (inode=ngroup->nodes.first; inode; inode=inode->next) - nodeGroupEditClear(inode); -} - -static void UNUSED_FUNCTION(node_group_link)(bNodeTree *ntree, bNodeSocket *sock, int in_out) -{ - node_group_expose_socket(ntree, sock, in_out); -} - /**** FRAME ****/ -static void node_frame_init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_frame_init(bNodeTree *UNUSED(ntree), bNode *node) { NodeFrame *data = (NodeFrame *)MEM_callocN(sizeof(NodeFrame), "frame node storage"); node->storage = data; @@ -366,19 +189,19 @@ static void node_frame_init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate data->label_size = 20; } -void register_node_type_frame(bNodeTreeType *ttype) +void register_node_type_frame(void) { /* frame type is used for all tree types, needs dynamic allocation */ bNodeType *ntype= MEM_callocN(sizeof(bNodeType), "frame node type"); - node_type_base(ttype, ntype, NODE_FRAME, "Frame", NODE_CLASS_LAYOUT, NODE_BACKGROUND|NODE_OPTIONS); + node_type_base(ntype, NODE_FRAME, "Frame", NODE_CLASS_LAYOUT, NODE_BACKGROUND|NODE_OPTIONS); node_type_init(ntype, node_frame_init); node_type_storage(ntype, "NodeFrame", node_free_standard_storage, node_copy_standard_storage); node_type_size(ntype, 150, 100, 0); node_type_compatibility(ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); ntype->needs_free = 1; - nodeRegisterType(ttype, ntype); + nodeRegisterType(ntype); } @@ -403,34 +226,34 @@ static void node_reroute_update_internal_links(bNodeTree *ntree, bNode *node) BLI_addtail(&node->internal_links, link); } -static void node_reroute_init(bNodeTree *ntree, bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_reroute_init(bNodeTree *ntree, bNode *node) { /* Note: Cannot use socket templates for this, since it would reset the socket type * on each file read via the template verification procedure. */ - nodeAddSocket(ntree, node, SOCK_IN, "Input", SOCK_RGBA); - nodeAddSocket(ntree, node, SOCK_OUT, "Output", SOCK_RGBA); + nodeAddStaticSocket(ntree, node, SOCK_IN, SOCK_RGBA, PROP_NONE, "Input", "Input"); + nodeAddStaticSocket(ntree, node, SOCK_OUT, SOCK_RGBA, PROP_NONE, "Output", "Output"); } -void register_node_type_reroute(bNodeTreeType *ttype) +void register_node_type_reroute(void) { /* frame type is used for all tree types, needs dynamic allocation */ bNodeType *ntype= MEM_callocN(sizeof(bNodeType), "frame node type"); - node_type_base(ttype, ntype, NODE_REROUTE, "Reroute", NODE_CLASS_LAYOUT, 0); + node_type_base(ntype, NODE_REROUTE, "Reroute", NODE_CLASS_LAYOUT, 0); node_type_init(ntype, node_reroute_init); node_type_internal_links(ntype, node_reroute_update_internal_links); ntype->needs_free = 1; - nodeRegisterType(ttype, ntype); + nodeRegisterType(ntype); } static void node_reroute_inherit_type_recursive(bNodeTree *ntree, bNode *node) { bNodeSocket *input = node->inputs.first; bNodeSocket *output = node->outputs.first; - int type = SOCK_FLOAT; bNodeLink *link; + int type = SOCK_FLOAT; /* XXX it would be a little bit more efficient to restrict actual updates * to rerout nodes connected to an updated node, but there's no reliable flag @@ -446,6 +269,8 @@ static void node_reroute_inherit_type_recursive(bNodeTree *ntree, bNode *node) bNode *tonode = link->tonode; if (!tonode || !fromnode) continue; + if (nodeLinkIsHidden(link)) + continue; if (tonode == node && fromnode->type == NODE_REROUTE && !fromnode->done) node_reroute_inherit_type_recursive(ntree, fromnode); @@ -462,9 +287,13 @@ static void node_reroute_inherit_type_recursive(bNodeTree *ntree, bNode *node) /* arbitrary, could also test output->type, both are the same */ if (input->type != type) { + PointerRNA input_ptr, output_ptr; /* same type for input/output */ - nodeSocketSetType(input, type); - nodeSocketSetType(output, type); + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, input, &input_ptr); + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, output, &output_ptr); + + RNA_enum_set(&input_ptr, "type", type); + RNA_enum_set(&output_ptr, "type", type); } } @@ -484,9 +313,8 @@ void ntree_update_reroute_nodes(bNodeTree *ntree) node_reroute_inherit_type_recursive(ntree, node); } -void BKE_node_tree_unlink_id_cb(void *calldata, struct ID *UNUSED(owner_id), struct bNodeTree *ntree) +void BKE_node_tree_unlink_id(ID *id, struct bNodeTree *ntree) { - ID *id = (ID *)calldata; bNode *node; for (node = ntree->nodes.first; node; node = node->next) { @@ -495,3 +323,179 @@ void BKE_node_tree_unlink_id_cb(void *calldata, struct ID *UNUSED(owner_id), str } } } + +/**** GROUP_INPUT / GROUP_OUTPUT ****/ + +static void node_group_input_init(bNodeTree *ntree, bNode *node) +{ + node_group_input_verify(ntree, node, (ID *)ntree); +} + +bNodeSocket *node_group_input_find_socket(bNode *node, const char *identifier) +{ + bNodeSocket *sock; + for (sock=node->outputs.first; sock; sock=sock->next) + if (strcmp(sock->identifier, identifier)==0) + return sock; + return NULL; +} + +void node_group_input_verify(bNodeTree *ntree, bNode *node, ID *id) +{ + /* check inputs and outputs, and remove or insert them */ + if (id == (ID *)ntree) { + /* value_in_out inverted for interface nodes to get correct socket value_property */ + group_verify_socket_list(ntree, node, &ntree->inputs, &node->outputs, SOCK_OUT); + + /* add virtual extension socket */ + nodeAddSocket(ntree, node, SOCK_OUT, "NodeSocketVirtual", "__extend__", ""); + } +} + +static void node_group_input_update(bNodeTree *ntree, bNode *node) +{ + bNodeSocket *extsock = node->outputs.last; + bNodeLink *link; + /* Adding a tree socket and verifying will remove the extension socket! + * This list caches the existing links from the extension socket + * so they can be recreated after verification. + */ + ListBase tmplinks; + + /* find links from the extension socket and store them */ + tmplinks.first = tmplinks.last = NULL; + for (link = ntree->links.first; link; link = link->next) { + if (nodeLinkIsHidden(link)) + continue; + if (link->fromsock == extsock) { + bNodeLink *tlink = MEM_callocN(sizeof(bNodeLink), "temporary link"); + *tlink = *link; + BLI_addtail(&tmplinks, tlink); + } + } + + if (tmplinks.first) { + bNodeSocket *gsock, *newsock; + /* XXX Multiple sockets can be connected to the extension socket at once, + * in that case the arbitrary first link determines name and type. + * This could be improved by choosing the "best" type among all links, + * whatever that means. + */ + bNodeLink *exposelink = tmplinks.first; + + /* XXX what if connecting virtual to virtual socket?? */ + gsock = ntreeAddSocketInterfaceFromSocket(ntree, exposelink->tonode, exposelink->tosock); + + node_group_input_verify(ntree, node, (ID *)ntree); + newsock = node_group_input_find_socket(node, gsock->identifier); + + /* redirect links from the extension socket */ + for (link = tmplinks.first; link; link = link->next) { + nodeAddLink(ntree, node, newsock, link->tonode, link->tosock); + } + + BLI_freelistN(&tmplinks); + } +} + +void register_node_type_group_input(void) +{ + /* used for all tree types, needs dynamic allocation */ + bNodeType *ntype= MEM_callocN(sizeof(bNodeType), "node type"); + + node_type_base(ntype, NODE_GROUP_INPUT, "Group Input", NODE_CLASS_INTERFACE, NODE_OPTIONS); + node_type_size(ntype, 140, 80, 200); + node_type_init(ntype, node_group_input_init); + node_type_update(ntype, node_group_input_update, node_group_input_verify); + node_type_compatibility(ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); + + ntype->needs_free = 1; + nodeRegisterType(ntype); +} + +static void node_group_output_init(bNodeTree *ntree, bNode *node) +{ + node_group_output_verify(ntree, node, (ID *)ntree); +} + +bNodeSocket *node_group_output_find_socket(bNode *node, const char *identifier) +{ + bNodeSocket *sock; + for (sock=node->inputs.first; sock; sock=sock->next) + if (strcmp(sock->identifier, identifier)==0) + return sock; + return NULL; +} + +void node_group_output_verify(bNodeTree *ntree, bNode *node, ID *id) +{ + /* check inputs and outputs, and remove or insert them */ + if (id == (ID *)ntree) { + /* value_in_out inverted for interface nodes to get correct socket value_property */ + group_verify_socket_list(ntree, node, &ntree->outputs, &node->inputs, SOCK_IN); + + /* add virtual extension socket */ + nodeAddSocket(ntree, node, SOCK_IN, "NodeSocketVirtual", "__extend__", ""); + } +} + +static void node_group_output_update(bNodeTree *ntree, bNode *node) +{ + bNodeSocket *extsock = node->inputs.last; + bNodeLink *link; + /* Adding a tree socket and verifying will remove the extension socket! + * This list caches the existing links to the extension socket + * so they can be recreated after verification. + */ + ListBase tmplinks; + + /* find links to the extension socket and store them */ + tmplinks.first = tmplinks.last = NULL; + for (link = ntree->links.first; link; link = link->next) { + if (nodeLinkIsHidden(link)) + continue; + if (link->tosock == extsock) { + bNodeLink *tlink = MEM_callocN(sizeof(bNodeLink), "temporary link"); + *tlink = *link; + BLI_addtail(&tmplinks, tlink); + } + } + + if (tmplinks.first) { + bNodeSocket *gsock, *newsock; + /* XXX Multiple sockets can be connected to the extension socket at once, + * in that case the arbitrary first link determines name and type. + * This could be improved by choosing the "best" type among all links, + * whatever that means. + */ + bNodeLink *exposelink = tmplinks.first; + + /* XXX what if connecting virtual to virtual socket?? */ + gsock = ntreeAddSocketInterfaceFromSocket(ntree, exposelink->fromnode, exposelink->fromsock); + + node_group_output_verify(ntree, node, (ID *)ntree); + newsock = node_group_output_find_socket(node, gsock->identifier); + + /* redirect links to the extension socket */ + for (link = tmplinks.first; link; link = link->next) { + nodeAddLink(ntree, link->fromnode, link->fromsock, node, newsock); + } + + BLI_freelistN(&tmplinks); + } +} + +void register_node_type_group_output(void) +{ + /* used for all tree types, needs dynamic allocation */ + bNodeType *ntype= MEM_callocN(sizeof(bNodeType), "node type"); + + node_type_base(ntype, NODE_GROUP_OUTPUT, "Group Output", NODE_CLASS_INTERFACE, NODE_OPTIONS); + node_type_size(ntype, 140, 80, 200); + node_type_init(ntype, node_group_output_init); + node_type_update(ntype, node_group_output_update, node_group_output_verify); + node_type_compatibility(ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); + + ntype->needs_free = 1; + nodeRegisterType(ntype); +} diff --git a/source/blender/nodes/intern/node_common.h b/source/blender/nodes/intern/node_common.h index 9e04a9e05f8..498da607b91 100644 --- a/source/blender/nodes/intern/node_common.h +++ b/source/blender/nodes/intern/node_common.h @@ -37,15 +37,8 @@ struct bNodeTree; -void node_group_init(struct bNodeTree *ntree, struct bNode *node, struct bNodeTemplate *ntemp); const char *node_group_label(struct bNode *node); -struct bNodeTemplate node_group_template(struct bNode *node); -int node_group_valid(struct bNodeTree *ntree, struct bNodeTemplate *ntemp); -void node_group_verify(struct bNodeTree *ntree, struct bNode *node, struct ID *id); - -struct bNodeTree *node_group_edit_get(struct bNode *node); -struct bNodeTree *node_group_edit_set(struct bNode *node, int edit); -void node_group_edit_clear(bNode *node); +int node_group_poll_instance(struct bNode *node, struct bNodeTree *nodetree); void ntree_update_reroute_nodes(struct bNodeTree *ntree); diff --git a/source/blender/nodes/intern/node_exec.c b/source/blender/nodes/intern/node_exec.c index 8cf7cc7a1ea..8fb23064bf0 100644 --- a/source/blender/nodes/intern/node_exec.c +++ b/source/blender/nodes/intern/node_exec.c @@ -41,12 +41,19 @@ #include "MEM_guardedalloc.h" #include "node_exec.h" +#include "node_util.h" +/* supported socket types in old nodes */ +int node_exec_socket_use_stack(bNodeSocket *sock) +{ + return ELEM3(sock->type, SOCK_FLOAT, SOCK_VECTOR, SOCK_RGBA); +} + /* for a given socket, find the actual stack entry */ bNodeStack *node_get_socket_stack(bNodeStack *stack, bNodeSocket *sock) { - if (stack && sock) + if (stack && sock && sock->stack_index >= 0) return stack + sock->stack_index; return NULL; } @@ -75,7 +82,10 @@ static void node_init_input_index(bNodeSocket *sock, int *index) sock->stack_index = sock->link->fromsock->stack_index; } else { - sock->stack_index = (*index)++; + if (node_exec_socket_use_stack(sock)) + sock->stack_index = (*index)++; + else + sock->stack_index = -1; } } @@ -91,19 +101,27 @@ static void node_init_output_index(bNodeSocket *sock, int *index, ListBase *inte } } /* if not internally connected, assign a new stack index anyway to avoid bad stack access */ - if (!link) - sock->stack_index = (*index)++; + if (!link) { + if (node_exec_socket_use_stack(sock)) + sock->stack_index = (*index)++; + else + sock->stack_index = -1; + } } else { - sock->stack_index = (*index)++; + if (node_exec_socket_use_stack(sock)) + sock->stack_index = (*index)++; + else + sock->stack_index = -1; } } /* basic preparation of socket stacks */ -static struct bNodeStack *setup_stack(bNodeStack *stack, bNodeSocket *sock) +static struct bNodeStack *setup_stack(bNodeStack *stack, bNodeTree *ntree, bNode *node, bNodeSocket *sock) { bNodeStack *ns = node_get_socket_stack(stack, sock); - float null_value[4] = {0.0f, 0.0f, 0.0f, 0.0f}; + if (!ns) + return NULL; /* don't mess with remote socket stacks, these are initialized by other nodes! */ if (sock->link) @@ -111,49 +129,37 @@ static struct bNodeStack *setup_stack(bNodeStack *stack, bNodeSocket *sock) ns->sockettype = sock->type; - if (sock->default_value) { - switch (sock->type) { + switch (sock->type) { case SOCK_FLOAT: - ns->vec[0] = ((bNodeSocketValueFloat *)sock->default_value)->value; + ns->vec[0] = node_socket_get_float(ntree, node, sock); break; case SOCK_VECTOR: - copy_v3_v3(ns->vec, ((bNodeSocketValueVector *)sock->default_value)->value); + node_socket_get_vector(ntree, node, sock, ns->vec); break; case SOCK_RGBA: - copy_v4_v4(ns->vec, ((bNodeSocketValueRGBA *)sock->default_value)->value); + node_socket_get_color(ntree, node, sock, ns->vec); break; - } - } - else { - switch (sock->type) { - case SOCK_FLOAT: - ns->vec[0] = 0.0f; - break; - case SOCK_VECTOR: - copy_v3_v3(ns->vec, null_value); - break; - case SOCK_RGBA: - copy_v4_v4(ns->vec, null_value); - break; - } } return ns; } -bNodeTreeExec *ntree_exec_begin(bNodeTree *ntree) +bNodeTreeExec *ntree_exec_begin(bNodeExecContext *context, bNodeTree *ntree, bNodeInstanceKey parent_key) { bNodeTreeExec *exec; bNode *node; bNodeExec *nodeexec; - bNodeSocket *sock, *gsock; + bNodeInstanceKey nodekey; + bNodeSocket *sock; bNodeStack *ns; int index; bNode **nodelist; int totnodes, n; - if ((ntree->init & NTREE_TYPE_INIT)==0) - ntreeInitTypes(ntree); + BLI_assert(ntreeIsValid(ntree)); + + /* ensure all sock->link pointers and node levels are correct */ + ntreeUpdateTree(ntree); /* get a dependency-sorted list of nodes */ ntreeGetDependencyList(ntree, &nodelist, &totnodes); @@ -165,9 +171,6 @@ bNodeTreeExec *ntree_exec_begin(bNodeTree *ntree) /* set stack indices */ index = 0; - /* group inputs essentially work as outputs */ - for (gsock=ntree->inputs.first; gsock; gsock = gsock->next) - node_init_output_index(gsock, &index, NULL); for (n=0; n < totnodes; ++n) { node = nodelist[n]; @@ -186,9 +189,6 @@ bNodeTreeExec *ntree_exec_begin(bNodeTree *ntree) node_init_output_index(sock, &index, NULL); } } - /* group outputs essentially work as inputs */ - for (gsock=ntree->outputs.first; gsock; gsock = gsock->next) - node_init_input_index(gsock, &index); /* allocated exec data pointers for nodes */ exec->totnodes = totnodes; @@ -201,11 +201,7 @@ bNodeTreeExec *ntree_exec_begin(bNodeTree *ntree) for (n=0; n < exec->stacksize; ++n) exec->stack[n].hasinput = 1; - /* prepare group tree inputs */ - for (sock=ntree->inputs.first; sock; sock=sock->next) { - /* ns = */ setup_stack(exec->stack, sock); - } - /* prepare all internal nodes for execution */ + /* prepare all nodes for execution */ for (n=0, nodeexec= exec->nodeexec; n < totnodes; ++n, ++nodeexec) { node = nodeexec->node = nodelist[n]; @@ -215,22 +211,20 @@ bNodeTreeExec *ntree_exec_begin(bNodeTree *ntree) if (sock->link && !(sock->link->flag & NODE_LINK_VALID)) node->need_exec= 0; - ns = setup_stack(exec->stack, sock); - ns->hasoutput = 1; + ns = setup_stack(exec->stack, ntree, node, sock); + if (ns) + ns->hasoutput = 1; } /* tag all outputs */ for (sock=node->outputs.first; sock; sock=sock->next) { - /* ns = */ setup_stack(exec->stack, sock); + /* ns = */ setup_stack(exec->stack, ntree, node, sock); } + nodekey = BKE_node_instance_key(parent_key, ntree, node); + nodeexec->data.preview = context->previews ? BKE_node_instance_hash_lookup(context->previews, nodekey) : NULL; if (node->typeinfo->initexecfunc) - nodeexec->data = node->typeinfo->initexecfunc(node); - } - /* prepare group tree outputs */ - for (sock=ntree->outputs.first; sock; sock=sock->next) { - ns = setup_stack(exec->stack, sock); - ns->hasoutput = 1; + nodeexec->data.data = node->typeinfo->initexecfunc(context, node, nodekey); } if (nodelist) @@ -250,7 +244,7 @@ void ntree_exec_end(bNodeTreeExec *exec) for (n=0, nodeexec= exec->nodeexec; n < exec->totnodes; ++n, ++nodeexec) { if (nodeexec->node->typeinfo) if (nodeexec->node->typeinfo->freeexecfunc) - nodeexec->node->typeinfo->freeexecfunc(nodeexec->node, nodeexec->data); + nodeexec->node->typeinfo->freeexecfunc(nodeexec->node, nodeexec->data.data); } if (exec->nodeexec) @@ -309,9 +303,7 @@ bool ntreeExecThreadNodes(bNodeTreeExec *exec, bNodeThreadStack *nts, void *call // if (node->typeinfo->compatibility == NODE_NEW_SHADING) // return false; if (node->typeinfo->execfunc) - node->typeinfo->execfunc(callerdata, node, nsin, nsout); - else if (node->typeinfo->newexecfunc) - node->typeinfo->newexecfunc(callerdata, thread, node, nodeexec->data, nsin, nsout); + node->typeinfo->execfunc(callerdata, thread, node, &nodeexec->data, nsin, nsout); } } diff --git a/source/blender/nodes/intern/node_exec.h b/source/blender/nodes/intern/node_exec.h index 5febda036e0..7d76ef34934 100644 --- a/source/blender/nodes/intern/node_exec.h +++ b/source/blender/nodes/intern/node_exec.h @@ -39,6 +39,8 @@ #include "BKE_node.h" +#include "node_util.h" + #include "RNA_types.h" struct bNodeTree; @@ -48,20 +50,20 @@ struct bNodeStack; /* Node execution data */ typedef struct bNodeExec { struct bNode *node; /* backpointer to node */ - void *data; /* custom data storage */ + bNodeExecData data; } bNodeExec; /* Execution Data for each instance of node tree execution */ typedef struct bNodeTreeExec { struct bNodeTree *nodetree; /* backpointer to node tree */ - int totnodes; /* total node count */ + int totnodes; /* total node count */ struct bNodeExec *nodeexec; /* per-node execution data */ int stacksize; struct bNodeStack *stack; /* socket data stack */ /* only used by material and texture trees to keep one stack for each thread */ - ListBase *threadstack; /* one instance of the stack for each thread */ + ListBase *threadstack; /* one instance of the stack for each thread */ } bNodeTreeExec; /* stores one stack copy for each thread (material and texture trees) */ @@ -71,14 +73,22 @@ typedef struct bNodeThreadStack { int used; } bNodeThreadStack; +int node_exec_socket_use_stack(struct bNodeSocket *sock); + struct bNodeStack *node_get_socket_stack(struct bNodeStack *stack, struct bNodeSocket *sock); void node_get_stack(struct bNode *node, struct bNodeStack *stack, struct bNodeStack **in, struct bNodeStack **out); -struct bNodeTreeExec *ntree_exec_begin(struct bNodeTree *ntree); +struct bNodeTreeExec *ntree_exec_begin(struct bNodeExecContext *context, struct bNodeTree *ntree, bNodeInstanceKey parent_key); void ntree_exec_end(struct bNodeTreeExec *exec); struct bNodeThreadStack *ntreeGetThreadStack(struct bNodeTreeExec *exec, int thread); void ntreeReleaseThreadStack(struct bNodeThreadStack *nts); bool ntreeExecThreadNodes(struct bNodeTreeExec *exec, struct bNodeThreadStack *nts, void *callerdata, int thread); +struct bNodeTreeExec *ntreeShaderBeginExecTree_internal(struct bNodeExecContext *context, struct bNodeTree *ntree, bNodeInstanceKey parent_key); +void ntreeShaderEndExecTree_internal(struct bNodeTreeExec *exec); + +struct bNodeTreeExec *ntreeTexBeginExecTree_internal(struct bNodeExecContext *context, struct bNodeTree *ntree, bNodeInstanceKey parent_key); +void ntreeTexEndExecTree_internal(struct bNodeTreeExec *exec); + #endif diff --git a/source/blender/nodes/intern/node_socket.c b/source/blender/nodes/intern/node_socket.c index 69256fafc3d..68ae8fa87b3 100644 --- a/source/blender/nodes/intern/node_socket.c +++ b/source/blender/nodes/intern/node_socket.c @@ -33,547 +33,95 @@ #include "DNA_node_types.h" -#include "DNA_mesh_types.h" -#include "DNA_meshdata_types.h" -#include "DNA_object_types.h" -#include "DNA_scene_types.h" - #include "BLI_listbase.h" #include "BLI_math.h" +#include "BLI_string.h" #include "BLI_utildefines.h" #include "BLI_string.h" -#include "BKE_DerivedMesh.h" #include "BKE_node.h" +#include "BKE_idprop.h" #include "RNA_access.h" +#include "RNA_define.h" #include "RNA_types.h" #include "MEM_guardedalloc.h" #include "NOD_socket.h" -/****************** FLOAT ******************/ - -static bNodeSocketType node_socket_type_float = { - /* type */ SOCK_FLOAT, - /* ui_name */ "Float", - /* ui_description */ "Floating Point", - /* ui_icon */ 0, - /* ui_color */ {160, 160, 160, 255}, - - /* value_structname */ "bNodeSocketValueFloat", - /* value_structsize */ sizeof(bNodeSocketValueFloat), - - /* buttonfunc */ NULL, -}; - -/****************** VECTOR ******************/ - -static bNodeSocketType node_socket_type_vector = { - /* type */ SOCK_VECTOR, - /* ui_name */ "Vector", - /* ui_description */ "3-dimensional floating point vector", - /* ui_icon */ 0, - /* ui_color */ {100, 100, 200, 255}, - - /* value_structname */ "bNodeSocketValueVector", - /* value_structsize */ sizeof(bNodeSocketValueVector), - - /* buttonfunc */ NULL, -}; - -/****************** RGBA ******************/ - -static bNodeSocketType node_socket_type_rgba = { - /* type */ SOCK_RGBA, - /* ui_name */ "RGBA", - /* ui_description */ "RGBA color", - /* ui_icon */ 0, - /* ui_color */ {200, 200, 40, 255}, - - /* value_structname */ "bNodeSocketValueRGBA", - /* value_structsize */ sizeof(bNodeSocketValueRGBA), - - /* buttonfunc */ NULL, -}; - -/****************** INT ******************/ - -static bNodeSocketType node_socket_type_int = { - /* type */ SOCK_INT, - /* ui_name */ "Int", - /* ui_description */ "Integer", - /* ui_icon */ 0, - /* ui_color */ {17, 133, 37, 255}, - - /* value_structname */ "bNodeSocketValueInt", - /* value_structsize */ sizeof(bNodeSocketValueInt), - - /* buttonfunc */ NULL, -}; - -/****************** BOOLEAN ******************/ - -static bNodeSocketType node_socket_type_boolean = { - /* type */ SOCK_BOOLEAN, - /* ui_name */ "Boolean", - /* ui_description */ "Boolean", - /* ui_icon */ 0, - /* ui_color */ {158, 139, 63, 255}, - - /* value_structname */ "bNodeSocketValueBoolean", - /* value_structsize */ sizeof(bNodeSocketValueBoolean), - - /* buttonfunc */ NULL, -}; - -/****************** SHADER ******************/ - -static bNodeSocketType node_socket_type_shader = { - /* type */ SOCK_SHADER, - /* ui_name */ "Shader", - /* ui_description */ "Shader", - /* ui_icon */ 0, - /* ui_color */ {100, 200, 100, 255}, - - /* value_structname */ NULL, - /* value_structsize */ 0, - - /* buttonfunc */ NULL, -}; - -/****************** MESH ******************/ - -static bNodeSocketType node_socket_type_mesh = { - /* type */ SOCK_MESH, - /* ui_name */ "Mesh", - /* ui_description */ "Mesh geometry data", - /* ui_icon */ 0, - /* ui_color */ {255, 133, 7, 255}, - - /* value_structname */ NULL, - /* value_structsize */ 0, - - /* buttonfunc */ NULL, -}; +struct Main; -/****************** STRING ******************/ - -static bNodeSocketType node_socket_type_string = { - /* type */ SOCK_STRING, - /* ui_name */ "String", - /* ui_description */ "String", - /* ui_icon */ 0, - /* ui_color */ {255, 255, 255, 255}, - - /* value_structname */ "bNodeSocketValueString", - /* value_structsize */ sizeof(bNodeSocketValueString), - - /* buttonfunc */ NULL, -}; - -void node_socket_type_init(bNodeSocketType *types[]) +struct bNodeSocket *node_add_socket_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp, int in_out) { - #define INIT_TYPE(name) types[node_socket_type_##name.type] = &node_socket_type_##name + bNodeSocket *sock = nodeAddStaticSocket(ntree, node, in_out, stemp->type, stemp->subtype, stemp->identifier, stemp->name); - INIT_TYPE(float); - INIT_TYPE(vector); - INIT_TYPE(rgba); - INIT_TYPE(int); - INIT_TYPE(boolean); - INIT_TYPE(shader); - INIT_TYPE(mesh); - INIT_TYPE(string); + sock->flag |= stemp->flag; - #undef INIT_TYPE -} - -void *node_socket_make_default_value(int type) -{ - /* XXX currently just allocates from stype->structsize. - * it might become necessary to do more complex allocations for later types. - */ - bNodeSocketType *stype = ntreeGetSocketType(type); - if (stype->value_structsize > 0) { - void *default_value = MEM_callocN(stype->value_structsize, "default socket value"); - return default_value; - } - else - return NULL; -} - -void node_socket_free_default_value(int UNUSED(type), void *default_value) -{ - /* XXX can just free the pointee for all current socket types. */ - if (default_value) - MEM_freeN(default_value); -} - -void node_socket_init_default_value(int type, void *default_value) -{ - switch (type) { - case SOCK_FLOAT: - node_socket_set_default_value_float(default_value, PROP_NONE, 0.0f, -FLT_MAX, FLT_MAX); - break; - case SOCK_INT: - node_socket_set_default_value_int(default_value, PROP_NONE, 0, INT_MIN, INT_MAX); - break; - case SOCK_BOOLEAN: - node_socket_set_default_value_boolean(default_value, FALSE); - break; - case SOCK_VECTOR: - node_socket_set_default_value_vector(default_value, PROP_NONE, 0.0f, 0.0f, 0.0f, -FLT_MAX, FLT_MAX); - break; - case SOCK_RGBA: - node_socket_set_default_value_rgba(default_value, 0.0f, 0.0f, 0.0f, 1.0f); - break; - case SOCK_SHADER: - node_socket_set_default_value_shader(default_value); - break; - case SOCK_MESH: - node_socket_set_default_value_mesh(default_value); - break; - case SOCK_STRING: - node_socket_set_default_value_string(default_value, PROP_NONE, (char *)""); - break; - } -} - -void node_socket_set_default_value_int(void *default_value, PropertySubType subtype, int value, int min, int max) -{ - bNodeSocketValueInt *val = default_value; - val->subtype = subtype; - val->value = value; - val->min = min; - val->max = max; -} - -void node_socket_set_default_value_float(void *default_value, PropertySubType subtype, float value, float min, float max) -{ - bNodeSocketValueFloat *val = default_value; - val->subtype = subtype; - val->value = value; - val->min = min; - val->max = max; -} - -void node_socket_set_default_value_boolean(void *default_value, char value) -{ - bNodeSocketValueBoolean *val = default_value; - val->value = value; -} - -void node_socket_set_default_value_vector(void *default_value, PropertySubType subtype, float x, float y, float z, float min, float max) -{ - bNodeSocketValueVector *val = default_value; - val->subtype = subtype; - val->value[0] = x; - val->value[1] = y; - val->value[2] = z; - val->min = min; - val->max = max; -} - -void node_socket_set_default_value_rgba(void *default_value, float r, float g, float b, float a) -{ - bNodeSocketValueRGBA *val = default_value; - val->value[0] = r; - val->value[1] = g; - val->value[2] = b; - val->value[3] = a; -} - -void node_socket_set_default_value_string(void *default_value, PropertySubType subtype, const char *value) -{ - bNodeSocketValueString *val = default_value; - val->subtype = subtype; - BLI_strncpy(val->value, value, 1024);//FILE_MAX -} - -void node_socket_set_default_value_shader(void *UNUSED(default_value)) -{ -} - -void node_socket_set_default_value_mesh(void *UNUSED(default_value)) -{ -} - - -void node_socket_copy_default_value(int type, void *to_default_value, void *from_default_value) -{ - /* XXX only one of these pointers is valid! just putting them here for convenience */ - bNodeSocketValueFloat *fromfloat= (bNodeSocketValueFloat*)from_default_value; - bNodeSocketValueInt *fromint= (bNodeSocketValueInt*)from_default_value; - bNodeSocketValueBoolean *frombool= (bNodeSocketValueBoolean*)from_default_value; - bNodeSocketValueVector *fromvector= (bNodeSocketValueVector*)from_default_value; - bNodeSocketValueRGBA *fromrgba= (bNodeSocketValueRGBA*)from_default_value; - bNodeSocketValueString *fromstring= (bNodeSocketValueString*)from_default_value; - - bNodeSocketValueFloat *tofloat= (bNodeSocketValueFloat*)to_default_value; - bNodeSocketValueInt *toint= (bNodeSocketValueInt*)to_default_value; - bNodeSocketValueBoolean *tobool= (bNodeSocketValueBoolean*)to_default_value; - bNodeSocketValueVector *tovector= (bNodeSocketValueVector*)to_default_value; - bNodeSocketValueRGBA *torgba= (bNodeSocketValueRGBA*)to_default_value; - bNodeSocketValueString *tostring= (bNodeSocketValueString*)to_default_value; - - switch (type) { - case SOCK_FLOAT: - *tofloat = *fromfloat; - break; - case SOCK_INT: - *toint = *fromint; - break; - case SOCK_BOOLEAN: - *tobool = *frombool; - break; - case SOCK_VECTOR: - *tovector = *fromvector; - break; - case SOCK_RGBA: - *torgba = *fromrgba; - break; - case SOCK_STRING: - *tostring = *fromstring; - break; - } -} - -/* XXX This is a makeshift function to have useful initial group socket values. - * In the end this should be implemented by a flexible socket data conversion system, - * which is yet to be implemented. The idea is that beside default standard conversions, - * such as int-to-float, it should be possible to quickly select a conversion method or - * a chain of conversions for each input, whenever there is more than one option. - * E.g. a vector-to-float conversion could use either of the x/y/z components or - * the vector length. - * - * In the interface this could be implemented by a pseudo-script textbox on linked inputs, - * with quick selection from a predefined list of conversion options. Some Examples: - * - vector component 'z' (vector->float): "z" - * - grayscale color (float->color): "gray" - * - color luminance (color->float): "lum" - * - matrix column 2 length (matrix->vector->float): "col[1].len" - * - mesh vertex coordinate 'y' (mesh->vertex->vector->float): "vertex.co.y" - * - * The actual conversion is then done by a series of conversion functions, - * which are defined in the socket type structs. - */ -void node_socket_convert_default_value(int to_type, void *to_default_value, int from_type, void *from_default_value) -{ - /* XXX only one of these pointers is valid! just putting them here for convenience */ - bNodeSocketValueFloat *fromfloat= (bNodeSocketValueFloat*)from_default_value; - bNodeSocketValueInt *fromint= (bNodeSocketValueInt*)from_default_value; - bNodeSocketValueBoolean *frombool= (bNodeSocketValueBoolean*)from_default_value; - bNodeSocketValueVector *fromvector= (bNodeSocketValueVector*)from_default_value; - bNodeSocketValueRGBA *fromrgba= (bNodeSocketValueRGBA*)from_default_value; - - bNodeSocketValueFloat *tofloat= (bNodeSocketValueFloat*)to_default_value; - bNodeSocketValueInt *toint= (bNodeSocketValueInt*)to_default_value; - bNodeSocketValueBoolean *tobool= (bNodeSocketValueBoolean*)to_default_value; - bNodeSocketValueVector *tovector= (bNodeSocketValueVector*)to_default_value; - bNodeSocketValueRGBA *torgba= (bNodeSocketValueRGBA*)to_default_value; - - switch (from_type) { - case SOCK_FLOAT: - switch (to_type) { - case SOCK_FLOAT: - tofloat->value = fromfloat->value; - break; - case SOCK_INT: - toint->value = (int)fromfloat->value; - break; - case SOCK_BOOLEAN: - tobool->value = (fromfloat->value > 0.0f); - break; - case SOCK_VECTOR: - tovector->value[0] = tovector->value[1] = tovector->value[2] = fromfloat->value; - break; - case SOCK_RGBA: - torgba->value[0] = torgba->value[1] = torgba->value[2] = torgba->value[3] = fromfloat->value; - break; - } - break; - case SOCK_INT: - switch (to_type) { - case SOCK_FLOAT: - tofloat->value = (float)fromint->value; - break; - case SOCK_INT: - toint->value = fromint->value; - break; - case SOCK_BOOLEAN: - tobool->value = (fromint->value > 0); - break; - case SOCK_VECTOR: - tovector->value[0] = tovector->value[1] = tovector->value[2] = (float)fromint->value; - break; - case SOCK_RGBA: - torgba->value[0] = torgba->value[1] = torgba->value[2] = torgba->value[3] = (float)fromint->value; - break; - } - break; - case SOCK_BOOLEAN: - switch (to_type) { - case SOCK_FLOAT: - tofloat->value = (float)frombool->value; - break; - case SOCK_INT: - toint->value = (int)frombool->value; - break; - case SOCK_BOOLEAN: - tobool->value = frombool->value; - break; - case SOCK_VECTOR: - tovector->value[0] = tovector->value[1] = tovector->value[2] = (float)frombool->value; - break; - case SOCK_RGBA: - torgba->value[0] = torgba->value[1] = torgba->value[2] = torgba->value[3] = (float)frombool->value; - break; - } - break; - case SOCK_VECTOR: - switch (to_type) { - case SOCK_FLOAT: - tofloat->value = fromvector->value[0]; - break; - case SOCK_INT: - toint->value = (int)fromvector->value[0]; - break; - case SOCK_BOOLEAN: - tobool->value = (fromvector->value[0] > 0.0f); - break; - case SOCK_VECTOR: - copy_v3_v3(tovector->value, fromvector->value); - break; - case SOCK_RGBA: - copy_v3_v3(torgba->value, fromvector->value); - torgba->value[3] = 1.0f; + /* initialize default_value */ + switch (stemp->type) { + case SOCK_FLOAT: { + bNodeSocketValueFloat *dval = sock->default_value; + dval->value = stemp->val1; + dval->min = stemp->min; + dval->max = stemp->max; break; } - break; - case SOCK_RGBA: - switch (to_type) { - case SOCK_FLOAT: - tofloat->value = fromrgba->value[0]; - break; - case SOCK_INT: - toint->value = (int)fromrgba->value[0]; - break; - case SOCK_BOOLEAN: - tobool->value = (fromrgba->value[0] > 0.0f); - break; - case SOCK_VECTOR: - copy_v3_v3(tovector->value, fromrgba->value); - break; - case SOCK_RGBA: - copy_v4_v4(torgba->value, fromrgba->value); + case SOCK_INT: { + bNodeSocketValueInt *dval = sock->default_value; + dval->value = (int)stemp->val1; + dval->min = (int)stemp->min; + dval->max = (int)stemp->max; break; } - break; - } -} - -static void node_socket_set_minmax_subtype(bNodeSocket *sock, struct bNodeSocketTemplate *stemp) -{ - switch (sock->type) { - case SOCK_FLOAT: - { - bNodeSocketValueFloat *dval= sock->default_value; - dval->min = stemp->min; - dval->max = stemp->max; - dval->subtype = stemp->subtype; + case SOCK_BOOLEAN: { + bNodeSocketValueBoolean *dval = sock->default_value; + dval->value = (int)stemp->val1; break; } - case SOCK_INT: - { - bNodeSocketValueInt *dval= sock->default_value; + case SOCK_VECTOR: { + bNodeSocketValueVector *dval = sock->default_value; + dval->value[0] = stemp->val1; + dval->value[1] = stemp->val2; + dval->value[2] = stemp->val3; dval->min = stemp->min; dval->max = stemp->max; - dval->subtype = stemp->subtype; break; } - case SOCK_VECTOR: - { - bNodeSocketValueVector *dval= sock->default_value; - dval->min = stemp->min; - dval->max = stemp->max; - dval->subtype = stemp->subtype; + case SOCK_RGBA: { + bNodeSocketValueRGBA *dval = sock->default_value; + dval->value[0] = stemp->val1; + dval->value[1] = stemp->val2; + dval->value[2] = stemp->val3; + dval->value[3] = stemp->val4; break; } } -} - -struct bNodeSocket *node_add_input_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp) -{ - bNodeSocket *sock = nodeAddSocket(ntree, node, SOCK_IN, stemp->name, stemp->type); - sock->flag |= stemp->flag; - - switch (stemp->type) { - case SOCK_INT: - node_socket_set_default_value_int(sock->default_value, stemp->subtype, (int)stemp->val1, (int)stemp->min, (int)stemp->max); - break; - case SOCK_FLOAT: - node_socket_set_default_value_float(sock->default_value, stemp->subtype, stemp->val1, stemp->min, stemp->max); - break; - case SOCK_BOOLEAN: - node_socket_set_default_value_boolean(sock->default_value, (char)stemp->val1); - break; - case SOCK_VECTOR: - node_socket_set_default_value_vector(sock->default_value, stemp->subtype, stemp->val1, stemp->val2, stemp->val3, stemp->min, stemp->max); - break; - case SOCK_RGBA: - node_socket_set_default_value_rgba(sock->default_value, stemp->val1, stemp->val2, stemp->val3, stemp->val4); - break; - case SOCK_SHADER: - node_socket_set_default_value_shader(sock->default_value); - break; - case SOCK_MESH: - node_socket_set_default_value_mesh(sock->default_value); - break; - case SOCK_STRING: - node_socket_set_default_value_string(sock->default_value, stemp->subtype, (char *)""); - break; - } return sock; } -struct bNodeSocket *node_add_output_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp) -{ - bNodeSocket *sock = nodeAddSocket(ntree, node, SOCK_OUT, stemp->name, stemp->type); - node_socket_set_minmax_subtype(sock, stemp); - return sock; -} - static bNodeSocket *verify_socket_template(bNodeTree *ntree, bNode *node, int in_out, ListBase *socklist, bNodeSocketTemplate *stemp) { bNodeSocket *sock; for (sock= socklist->first; sock; sock= sock->next) { - if (!(sock->flag & SOCK_DYNAMIC) && strncmp(sock->name, stemp->name, NODE_MAXSTR)==0) + if (strncmp(sock->name, stemp->name, NODE_MAXSTR)==0) break; } if (sock) { - sock->type = stemp->type; /* in future, read this from tydefs! */ + sock->type = stemp->type; if (stemp->limit == 0) sock->limit= 0xFFF; else sock->limit = stemp->limit; sock->flag |= stemp->flag; - /* Copy the property range and subtype parameters in case the template changed. - * NOT copying the actual value here, only button behavior changes! - */ - node_socket_set_minmax_subtype(sock, stemp); - BLI_remlink(socklist, sock); return sock; } else { /* no socket for this template found, make a new one */ - if (in_out==SOCK_IN) - sock = node_add_input_from_template(ntree, node, stemp); - else - sock = node_add_output_from_template(ntree, node, stemp); + sock = node_add_socket_from_template(ntree, node, stemp, in_out); /* remove the new socket from the node socket list first, * will be added back after verification. */ @@ -592,8 +140,7 @@ static void verify_socket_template_list(bNodeTree *ntree, bNode *node, int in_ou if (stemp_first==NULL) { for (sock = (bNodeSocket*)socklist->first; sock; sock=nextsock) { nextsock = sock->next; - if (!(sock->flag & SOCK_DYNAMIC)) - nodeRemoveSocket(ntree, node, sock); + nodeRemoveSocket(ntree, node, sock); } } else { @@ -606,8 +153,7 @@ static void verify_socket_template_list(bNodeTree *ntree, bNode *node, int in_ou /* leftovers are removed */ for (sock = (bNodeSocket*)socklist->first; sock; sock=nextsock) { nextsock = sock->next; - if (!(sock->flag & SOCK_DYNAMIC)) - nodeRemoveSocket(ntree, node, sock); + nodeRemoveSocket(ntree, node, sock); } /* and we put back the verified sockets */ @@ -635,14 +181,182 @@ static void verify_socket_template_list(bNodeTree *ntree, bNode *node, int in_ou void node_verify_socket_templates(bNodeTree *ntree, bNode *node) { bNodeType *ntype= node->typeinfo; - /* XXX Small trick: don't try to match socket lists when there are no templates. - * This also prevents group node sockets from being removed, without the need to explicitly + /* Don't try to match socket lists when there are no templates. + * This prevents group node sockets from being removed, without the need to explicitly * check the node type here. */ - if (ntype && ((ntype->inputs && ntype->inputs[0].type >= 0) || - (ntype->outputs && ntype->outputs[0].type >= 0))) - { - verify_socket_template_list(ntree, node, SOCK_IN, &node->inputs, ntype->inputs); - verify_socket_template_list(ntree, node, SOCK_OUT, &node->outputs, ntype->outputs); + if (ntype) { + if (ntype->inputs && ntype->inputs[0].type >= 0) + verify_socket_template_list(ntree, node, SOCK_IN, &node->inputs, ntype->inputs); + if (ntype->outputs && ntype->outputs[0].type >= 0) + verify_socket_template_list(ntree, node, SOCK_OUT, &node->outputs, ntype->outputs); + } +} + + +void node_socket_init_default_value(bNodeSocket *sock) +{ + int type = sock->typeinfo->type; + int subtype = sock->typeinfo->subtype; + + if (sock->default_value) + return; /* already initialized */ + + switch (type) { + case SOCK_FLOAT: { + bNodeSocketValueFloat *dval = MEM_callocN(sizeof(bNodeSocketValueFloat), "node socket value float"); + dval->subtype = subtype; + dval->value = 0.0f; + dval->min = -FLT_MAX; + dval->max = FLT_MAX; + + sock->default_value = dval; + break; + } + case SOCK_INT: { + bNodeSocketValueInt *dval = MEM_callocN(sizeof(bNodeSocketValueInt), "node socket value int"); + dval->subtype = subtype; + dval->value = 0; + dval->min = INT_MIN; + dval->max = INT_MAX; + + sock->default_value = dval; + break; + } + case SOCK_BOOLEAN: { + bNodeSocketValueBoolean *dval = MEM_callocN(sizeof(bNodeSocketValueBoolean), "node socket value bool"); + dval->value = false; + + sock->default_value = dval; + break; + } + case SOCK_VECTOR: { + bNodeSocketValueVector *dval = MEM_callocN(sizeof(bNodeSocketValueVector), "node socket value vector"); + dval->subtype = subtype; + copy_v3_v3(dval->value, (float[]){0.0f, 0.0f, 0.0f}); + dval->min = -FLT_MAX; + dval->max = FLT_MAX; + + sock->default_value = dval; + break; } + case SOCK_RGBA: { + bNodeSocketValueRGBA *dval = MEM_callocN(sizeof(bNodeSocketValueRGBA), "node socket value color"); + copy_v4_v4(dval->value, (float[]){0.0f, 0.0f, 0.0f, 1.0f}); + + sock->default_value = dval; + break; + } + case SOCK_STRING: { + bNodeSocketValueString *dval = MEM_callocN(sizeof(bNodeSocketValueString), "node socket value string"); + dval->subtype = subtype; + dval->value[0] = '\0'; + + sock->default_value = dval; + break; + } + } +} + + +static void standard_node_socket_interface_init_socket(bNodeTree *UNUSED(ntree), bNodeSocket *UNUSED(stemp), bNode *UNUSED(node), bNodeSocket *sock, const char *UNUSED(data_path)) +{ + /* initialize the type value */ + sock->type = sock->typeinfo->type; +} + +static bNodeSocketType *make_standard_socket_type(int type, int subtype) +{ + extern void ED_init_standard_node_socket_type(bNodeSocketType *); + + const char *socket_idname = nodeStaticSocketType(type, subtype); + const char *interface_idname = nodeStaticSocketInterfaceType(type, subtype); + bNodeSocketType *stype; + StructRNA *srna; + + stype = MEM_callocN(sizeof(bNodeSocketType), "node socket C type"); + BLI_strncpy(stype->idname, socket_idname, sizeof(stype->idname)); + + /* set the RNA type + * uses the exact same identifier as the socket type idname */ + srna = stype->ext_socket.srna = RNA_struct_find(socket_idname); + BLI_assert(srna != NULL); + /* associate the RNA type with the socket type */ + RNA_struct_blender_type_set(srna, stype); + + /* set the interface RNA type */ + srna = stype->ext_interface.srna = RNA_struct_find(interface_idname); + BLI_assert(srna != NULL); + /* associate the RNA type with the socket type */ + RNA_struct_blender_type_set(srna, stype); + + /* extra type info for standard socket types */ + stype->type = type; + stype->subtype = subtype; + + /* XXX bad-level call! needed for setting draw callbacks */ + ED_init_standard_node_socket_type(stype); + + stype->interface_init_socket = standard_node_socket_interface_init_socket; + + return stype; +} + +static bNodeSocketType *make_socket_type_virtual(void) +{ + extern void ED_init_node_socket_type_virtual(bNodeSocketType *); + + const char *socket_idname = "NodeSocketVirtual"; + bNodeSocketType *stype; + StructRNA *srna; + + stype = MEM_callocN(sizeof(bNodeSocketType), "node socket C type"); + BLI_strncpy(stype->idname, socket_idname, sizeof(stype->idname)); + + /* set the RNA type + * uses the exact same identifier as the socket type idname */ + srna = stype->ext_socket.srna = RNA_struct_find(socket_idname); + BLI_assert(srna != NULL); + /* associate the RNA type with the socket type */ + RNA_struct_blender_type_set(srna, stype); + + ED_init_node_socket_type_virtual(stype); + + return stype; +} + + +void register_standard_node_socket_types() +{ + /* draw callbacks are set in drawnode.c to avoid bad-level calls */ + + nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_NONE)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_UNSIGNED)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_PERCENTAGE)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_FACTOR)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_ANGLE)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_TIME)); + + nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_NONE)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_UNSIGNED)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_PERCENTAGE)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_FACTOR)); + + nodeRegisterSocketType(make_standard_socket_type(SOCK_BOOLEAN, PROP_NONE)); + + nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_NONE)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_TRANSLATION)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_DIRECTION)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_VELOCITY)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_ACCELERATION)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_EULER)); + nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_XYZ)); + + nodeRegisterSocketType(make_standard_socket_type(SOCK_RGBA, PROP_NONE)); + + nodeRegisterSocketType(make_standard_socket_type(SOCK_STRING, PROP_NONE)); + + nodeRegisterSocketType(make_standard_socket_type(SOCK_SHADER, PROP_NONE)); + + nodeRegisterSocketType(make_socket_type_virtual()); } diff --git a/source/blender/nodes/intern/node_util.c b/source/blender/nodes/intern/node_util.c index 09e6ddd18a5..c622c1c5227 100644 --- a/source/blender/nodes/intern/node_util.c +++ b/source/blender/nodes/intern/node_util.c @@ -30,6 +30,7 @@ */ #include <limits.h> +#include <string.h> #include "DNA_action_types.h" #include "DNA_node_types.h" @@ -63,17 +64,17 @@ void node_free_standard_storage(bNode *node) } } -void node_copy_curves(bNode *orig_node, bNode *new_node) +void node_copy_curves(bNodeTree *UNUSED(dest_ntree), bNode *dest_node, bNode *src_node) { - new_node->storage = curvemapping_copy(orig_node->storage); + dest_node->storage = curvemapping_copy(src_node->storage); } -void node_copy_standard_storage(bNode *orig_node, bNode *new_node) +void node_copy_standard_storage(bNodeTree *UNUSED(dest_ntree), bNode *dest_node, bNode *src_node) { - new_node->storage = MEM_dupallocN(orig_node->storage); + dest_node->storage = MEM_dupallocN(src_node->storage); } -void *node_initexec_curves(bNode *node) +void *node_initexec_curves(bNodeExecContext *UNUSED(context), bNode *node, bNodeInstanceKey UNUSED(key)) { curvemapping_initialize(node->storage); return NULL; /* unused return */ @@ -129,6 +130,8 @@ void node_update_internal_links_default(bNodeTree *ntree, bNode *node) fromindex = INT_MAX; fromsock = NULL; for (link=ntree->links.first; link; link=link->next) { + if (nodeLinkIsHidden(link)) + continue; if (link->tonode == node && link->tosock->type == datatype) { int index = BLI_findindex(&node->inputs, link->tosock); if (index < fromindex) { @@ -146,6 +149,8 @@ void node_update_internal_links_default(bNodeTree *ntree, bNode *node) toindex = INT_MAX; tosock = NULL; for (link=ntree->links.first; link; link=link->next) { + if (nodeLinkIsHidden(link)) + continue; if (link->fromnode == node && link->fromsock->type == datatype) { int index = BLI_findindex(&node->outputs, link->fromsock); if (index < toindex) { @@ -188,3 +193,45 @@ void node_update_internal_links_default(bNodeTree *ntree, bNode *node) BLI_addtail(&node->internal_links, ilink); } } + +float node_socket_get_float(bNodeTree *ntree, bNode *UNUSED(node), bNodeSocket *sock) +{ + PointerRNA ptr; + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr); + return RNA_float_get(&ptr, "default_value"); +} + +void node_socket_set_float(bNodeTree *ntree, bNode *UNUSED(node), bNodeSocket *sock, float value) +{ + PointerRNA ptr; + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr); + RNA_float_set(&ptr, "default_value", value); +} + +void node_socket_get_color(bNodeTree *ntree, bNode *UNUSED(node), bNodeSocket *sock, float *value) +{ + PointerRNA ptr; + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr); + RNA_float_get_array(&ptr, "default_value", value); +} + +void node_socket_set_color(bNodeTree *ntree, bNode *UNUSED(node), bNodeSocket *sock, const float *value) +{ + PointerRNA ptr; + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr); + RNA_float_set_array(&ptr, "default_value", value); +} + +void node_socket_get_vector(bNodeTree *ntree, bNode *UNUSED(node), bNodeSocket *sock, float *value) +{ + PointerRNA ptr; + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr); + RNA_float_get_array(&ptr, "default_value", value); +} + +void node_socket_set_vector(bNodeTree *ntree, bNode *UNUSED(node), bNodeSocket *sock, const float *value) +{ + PointerRNA ptr; + RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr); + RNA_float_set_array(&ptr, "default_value", value); +} diff --git a/source/blender/nodes/intern/node_util.h b/source/blender/nodes/intern/node_util.h index 6b783915816..2b3f84420f9 100644 --- a/source/blender/nodes/intern/node_util.h +++ b/source/blender/nodes/intern/node_util.h @@ -35,6 +35,8 @@ #include "DNA_listBase.h" +#include "BLI_utildefines.h" + #include "BKE_node.h" #include "MEM_guardedalloc.h" @@ -43,17 +45,29 @@ #include "GPU_material.h" /* For Shader muting GPU code... */ +#include "RNA_access.h" + struct bNodeTree; struct bNode; +/* data for initializing node execution */ +typedef struct bNodeExecContext { + struct bNodeInstanceHash *previews; +} bNodeExecContext; + +typedef struct bNodeExecData { + void *data; /* custom data storage */ + struct bNodePreview *preview; /* optional preview image */ +} bNodeExecData; + /**** Storage Data ****/ extern void node_free_curves(struct bNode *node); extern void node_free_standard_storage(struct bNode *node); -extern void node_copy_curves(struct bNode *orig_node, struct bNode *new_node); -extern void node_copy_standard_storage(struct bNode *orig_node, struct bNode *new_node); -extern void *node_initexec_curves(struct bNode *node); +extern void node_copy_curves(struct bNodeTree *dest_ntree, struct bNode *dest_node, struct bNode *src_node); +extern void node_copy_standard_storage(struct bNodeTree *dest_ntree, struct bNode *dest_node, struct bNode *src_node); +extern void *node_initexec_curves(struct bNodeExecContext *context, struct bNode *node, bNodeInstanceKey key); /**** Labels ****/ @@ -64,4 +78,11 @@ const char *node_filter_label(struct bNode *node); void node_update_internal_links_default(struct bNodeTree *ntree, struct bNode *node); +float node_socket_get_float(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock); +void node_socket_set_float(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock, float value); +void node_socket_get_color(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock, float *value); +void node_socket_set_color(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock, const float *value); +void node_socket_get_vector(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock, float *value); +void node_socket_set_vector(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock, const float *value); + #endif diff --git a/source/blender/nodes/shader/node_shader_tree.c b/source/blender/nodes/shader/node_shader_tree.c index 8fde0b9c342..30da509c09d 100644 --- a/source/blender/nodes/shader/node_shader_tree.c +++ b/source/blender/nodes/shader/node_shader_tree.c @@ -36,6 +36,7 @@ #include "DNA_material_types.h" #include "DNA_node_types.h" #include "DNA_scene_types.h" +#include "DNA_space_types.h" #include "DNA_world_types.h" #include "BLI_listbase.h" @@ -45,11 +46,14 @@ #include "BLF_translation.h" +#include "BKE_context.h" #include "BKE_global.h" #include "BKE_main.h" #include "BKE_node.h" #include "BKE_scene.h" +#include "RNA_access.h" + #include "GPU_material.h" #include "RE_shader_ext.h" @@ -59,23 +63,45 @@ #include "node_util.h" #include "node_shader_util.h" -static void foreach_nodetree(Main *main, void *calldata, bNodeTreeCallback func) +static int shader_tree_poll(const bContext *C, bNodeTreeType *UNUSED(treetype)) { - Material *ma; - Lamp *la; - World *wo; - - for (ma = main->mat.first; ma; ma = ma->id.next) - if (ma->nodetree) - func(calldata, &ma->id, ma->nodetree); - - for (la = main->lamp.first; la; la = la->id.next) - if (la->nodetree) - func(calldata, &la->id, la->nodetree); + Scene *scene = CTX_data_scene(C); + /* allow empty engine string too, this is from older versions that didn't have registerable engines yet */ + return (scene->r.engine[0] == '\0' + || strcmp(scene->r.engine, "BLENDER_RENDER")==0 + || strcmp(scene->r.engine, "CYCLES")==0); +} - for (wo = main->world.first; wo; wo = wo->id.next) - if (wo->nodetree) - func(calldata, &wo->id, wo->nodetree); +static void shader_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); + Object *ob = OBACT; + + if (snode->shaderfrom == SNODE_SHADER_OBJECT) { + if (ob) { + if (ob->type == OB_LAMP) { + *r_from = &ob->id; + *r_id = ob->data; + *r_ntree = ((Lamp *)ob->data)->nodetree; + } + else { + Material *ma = give_current_material(ob, ob->actcol); + if (ma) { + *r_from = &ob->id; + *r_id = &ma->id; + *r_ntree = ma->nodetree; + } + } + } + } + else { /* SNODE_SHADER_WORLD */ + if (scene->world) { + *r_from = NULL; + *r_id = &scene->world->id; + *r_ntree = scene->world->nodetree; + } + } } static void foreach_nodeclass(Scene *scene, void *calldata, bNodeClassCallback func) @@ -93,6 +119,7 @@ static void foreach_nodeclass(Scene *scene, void *calldata, bNodeClassCallback f func(calldata, NODE_CLASS_CONVERTOR, N_("Convertor")); func(calldata, NODE_CLASS_SCRIPT, N_("Script")); func(calldata, NODE_CLASS_GROUP, N_("Group")); + func(calldata, NODE_CLASS_INTERFACE, N_("Interface")); func(calldata, NODE_CLASS_LAYOUT, N_("Layout")); } @@ -111,24 +138,8 @@ static void localize(bNodeTree *localtree, bNodeTree *UNUSED(ntree)) } } -static void local_sync(bNodeTree *localtree, bNodeTree *ntree) +static void local_sync(bNodeTree *UNUSED(localtree), bNodeTree *UNUSED(ntree)) { - bNode *lnode; - - /* copy over contents of previews */ - for (lnode = localtree->nodes.first; lnode; lnode = lnode->next) { - if (ntreeNodeExists(ntree, lnode->new_node)) { - bNode *node = lnode->new_node; - - if (node->preview && node->preview->rect) { - if (lnode->preview && lnode->preview->rect) { - int xsize = node->preview->xsize; - int ysize = node->preview->ysize; - memcpy(node->preview->rect, lnode->preview->rect, 4 * xsize + xsize * ysize * sizeof(char) * 4); - } - } - } - } } static void update(bNodeTree *ntree) @@ -136,26 +147,36 @@ static void update(bNodeTree *ntree) ntreeSetOutput(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); + } } -bNodeTreeType ntreeType_Shader = { - /* type */ NTREE_SHADER, - /* id_name */ "NTShader Nodetree", +bNodeTreeType *ntreeType_Shader; + +void register_node_tree_type_sh() +{ + bNodeTreeType *tt = ntreeType_Shader = MEM_callocN(sizeof(bNodeTreeType), "shader node tree type"); + + tt->type = NTREE_SHADER; + strcpy(tt->idname, "ShaderNodeTree"); + strcpy(tt->ui_name, "Shader"); + tt->ui_icon = 0; /* defined in drawnode.c */ + strcpy(tt->ui_description, ""); - /* node_types */ { NULL, NULL }, + tt->foreach_nodeclass = foreach_nodeclass; + tt->localize = localize; + tt->local_sync = local_sync; + tt->update = update; + tt->poll = shader_tree_poll; + tt->get_from_context = shader_get_from_context; - /* free_cache */ NULL, - /* free_node_cache */ NULL, - /* foreach_nodetree */ foreach_nodetree, - /* foreach_nodeclass */ foreach_nodeclass, - /* localize */ localize, - /* local_sync */ local_sync, - /* local_merge */ NULL, - /* update */ update, - /* update_node */ NULL, - /* validate_link */ NULL, - /* update_internal_links */ node_update_internal_links_default -}; + tt->ext.srna = &RNA_ShaderNodeTree; + + ntreeTypeAdd(tt); +} /* GPU material from shader nodes */ @@ -163,11 +184,11 @@ void ntreeGPUMaterialNodes(bNodeTree *ntree, GPUMaterial *mat) { bNodeTreeExec *exec; - exec = ntreeShaderBeginExecTree(ntree, 1); + exec = ntreeShaderBeginExecTree(ntree); ntreeExecGPUNodes(exec, mat, 1); - ntreeShaderEndExecTree(exec, 1); + ntreeShaderEndExecTree(exec); } /* **************** call to switch lamploop for material node ************ */ @@ -180,27 +201,16 @@ void set_node_shader_lamp_loop(void (*lamp_loop_func)(ShadeInput *, ShadeResult } -/* XXX Group nodes must set use_tree_data to false, since their trees can be shared by multiple nodes. - * If use_tree_data is true, the ntree->execdata pointer is checked to avoid multiple execution of top-level trees. - */ -bNodeTreeExec *ntreeShaderBeginExecTree(bNodeTree *ntree, int use_tree_data) +bNodeTreeExec *ntreeShaderBeginExecTree_internal(bNodeExecContext *context, bNodeTree *ntree, bNodeInstanceKey parent_key) { bNodeTreeExec *exec; bNode *node; - if (use_tree_data) { - /* XXX hack: prevent exec data from being generated twice. - * this should be handled by the renderer! - */ - if (ntree->execdata) - return ntree->execdata; - } - /* ensures only a single output node is enabled */ ntreeSetOutput(ntree); /* common base initialization */ - exec = ntree_exec_begin(ntree); + exec = ntree_exec_begin(context, ntree, parent_key); /* allocate the thread stack listbase array */ exec->threadstack = MEM_callocN(BLENDER_MAX_THREADS * sizeof(ListBase), "thread stack array"); @@ -208,43 +218,58 @@ bNodeTreeExec *ntreeShaderBeginExecTree(bNodeTree *ntree, int use_tree_data) for (node = exec->nodetree->nodes.first; node; node = node->next) node->need_exec = 1; - if (use_tree_data) { - /* XXX this should not be necessary, but is still used for cmp/sha/tex nodes, - * which only store the ntree pointer. Should be fixed at some point! - */ - ntree->execdata = exec; - } + return exec; +} + +bNodeTreeExec *ntreeShaderBeginExecTree(bNodeTree *ntree) +{ + bNodeExecContext context; + bNodeTreeExec *exec; + + /* XXX hack: prevent exec data from being generated twice. + * this should be handled by the renderer! + */ + if (ntree->execdata) + return ntree->execdata; + + context.previews = ntree->previews; + + exec = ntreeShaderBeginExecTree_internal(&context, ntree, NODE_INSTANCE_KEY_BASE); + + /* XXX this should not be necessary, but is still used for cmp/sha/tex nodes, + * which only store the ntree pointer. Should be fixed at some point! + */ + ntree->execdata = exec; return exec; } -/* XXX Group nodes must set use_tree_data to false, since their trees can be shared by multiple nodes. - * If use_tree_data is true, the ntree->execdata pointer is checked to avoid multiple execution of top-level trees. - */ -void ntreeShaderEndExecTree(bNodeTreeExec *exec, int use_tree_data) +void ntreeShaderEndExecTree_internal(bNodeTreeExec *exec) { - if (exec) { - bNodeTree *ntree = exec->nodetree; - bNodeThreadStack *nts; - int a; - - if (exec->threadstack) { - for (a = 0; a < BLENDER_MAX_THREADS; a++) { - for (nts = exec->threadstack[a].first; nts; nts = nts->next) - if (nts->stack) MEM_freeN(nts->stack); - BLI_freelistN(&exec->threadstack[a]); - } - - MEM_freeN(exec->threadstack); - exec->threadstack = NULL; + bNodeThreadStack *nts; + int a; + + if (exec->threadstack) { + for (a = 0; a < BLENDER_MAX_THREADS; a++) { + for (nts = exec->threadstack[a].first; nts; nts = nts->next) + if (nts->stack) MEM_freeN(nts->stack); + BLI_freelistN(&exec->threadstack[a]); } - ntree_exec_end(exec); + MEM_freeN(exec->threadstack); + exec->threadstack = NULL; + } + + ntree_exec_end(exec); +} + +void ntreeShaderEndExecTree(bNodeTreeExec *exec) +{ + if (exec) { + ntreeShaderEndExecTree_internal(exec); - if (use_tree_data) { - /* XXX clear nodetree backpointer to exec data, same problem as noted in ntreeBeginExecTree */ - ntree->execdata = NULL; - } + /* XXX clear nodetree backpointer to exec data, same problem as noted in ntreeBeginExecTree */ + exec->nodetree->execdata = NULL; } } @@ -272,7 +297,7 @@ bool ntreeShaderExecTree(bNodeTree *ntree, ShadeInput *shi, ShadeResult *shr) if (!exec) { BLI_lock_thread(LOCK_NODES); if (!ntree->execdata) - ntree->execdata = ntreeShaderBeginExecTree(ntree, 1); + ntree->execdata = ntreeShaderBeginExecTree(ntree); BLI_unlock_thread(LOCK_NODES); exec = ntree->execdata; diff --git a/source/blender/nodes/shader/node_shader_util.c b/source/blender/nodes/shader/node_shader_util.c index 1123a0dc44a..040172d9998 100644 --- a/source/blender/nodes/shader/node_shader_util.c +++ b/source/blender/nodes/shader/node_shader_util.c @@ -36,6 +36,20 @@ #include "node_exec.h" + +int sh_node_poll_default(bNodeType *UNUSED(ntype), bNodeTree *ntree) +{ + return (strcmp(ntree->idname, "ShaderNodeTree")==0); +} + +void sh_node_type_base(struct bNodeType *ntype, int type, const char *name, short nclass, short flag) +{ + node_type_base(ntype, type, name, nclass, flag); + + ntype->poll = sh_node_poll_default; + ntype->update_internal_links = node_update_internal_links_default; +} + /* ****** */ void nodestack_get_vec(float *in, short type_in, bNodeStack *ns) @@ -123,74 +137,6 @@ void ntreeShaderGetTexcoMode(bNodeTree *ntree, int r_mode, short *texco, int *mo } } -/* nodes that use ID data get synced with local data */ -void nodeShaderSynchronizeID(bNode *node, int copyto) -{ - if (node->id==NULL) return; - - if (ELEM(node->type, SH_NODE_MATERIAL, SH_NODE_MATERIAL_EXT)) { - bNodeSocket *sock; - Material *ma= (Material *)node->id; - int a; - - /* hrmf, case in loop isn't super fast, but we don't edit 100s of material at same time either! */ - for (a=0, sock= node->inputs.first; sock; sock= sock->next, a++) { - if (!nodeSocketIsHidden(sock)) { - if (copyto) { - switch (a) { - case MAT_IN_COLOR: - copy_v3_v3(&ma->r, ((bNodeSocketValueRGBA *)sock->default_value)->value); break; - case MAT_IN_SPEC: - copy_v3_v3(&ma->specr, ((bNodeSocketValueRGBA *)sock->default_value)->value); break; - case MAT_IN_REFL: - ma->ref= ((bNodeSocketValueFloat *)sock->default_value)->value; break; - case MAT_IN_MIR: - copy_v3_v3(&ma->mirr, ((bNodeSocketValueRGBA *)sock->default_value)->value); break; - case MAT_IN_AMB: - ma->amb = ((bNodeSocketValueFloat *)sock->default_value)->value; break; - case MAT_IN_EMIT: - ma->emit = ((bNodeSocketValueFloat *)sock->default_value)->value; break; - case MAT_IN_SPECTRA: - ma->spectra = ((bNodeSocketValueFloat *)sock->default_value)->value; break; - case MAT_IN_RAY_MIRROR: - ma->ray_mirror = ((bNodeSocketValueFloat *)sock->default_value)->value; break; - case MAT_IN_ALPHA: - ma->alpha = ((bNodeSocketValueFloat *)sock->default_value)->value; break; - case MAT_IN_TRANSLUCENCY: - ma->translucency = ((bNodeSocketValueFloat *)sock->default_value)->value; break; - } - } - else { - switch (a) { - case MAT_IN_COLOR: - copy_v3_v3(((bNodeSocketValueRGBA *)sock->default_value)->value, &ma->r); break; - case MAT_IN_SPEC: - copy_v3_v3(((bNodeSocketValueRGBA *)sock->default_value)->value, &ma->specr); break; - case MAT_IN_REFL: - ((bNodeSocketValueFloat *)sock->default_value)->value= ma->ref; break; - case MAT_IN_MIR: - copy_v3_v3(((bNodeSocketValueRGBA *)sock->default_value)->value, &ma->mirr); break; - case MAT_IN_AMB: - ((bNodeSocketValueFloat *)sock->default_value)->value = ma->amb; break; - case MAT_IN_EMIT: - ((bNodeSocketValueFloat *)sock->default_value)->value = ma->emit; break; - case MAT_IN_SPECTRA: - ((bNodeSocketValueFloat *)sock->default_value)->value = ma->spectra; break; - case MAT_IN_RAY_MIRROR: - ((bNodeSocketValueFloat *)sock->default_value)->value = ma->ray_mirror; break; - case MAT_IN_ALPHA: - ((bNodeSocketValueFloat *)sock->default_value)->value = ma->alpha; break; - case MAT_IN_TRANSLUCENCY: - ((bNodeSocketValueFloat *)sock->default_value)->value = ma->translucency; break; - } - } - } - } - } - -} - - void node_gpu_stack_from_data(struct GPUNodeStack *gs, int type, bNodeStack *ns) { memset(gs, 0, sizeof(*gs)); @@ -249,23 +195,24 @@ static void data_from_gpu_stack_list(ListBase *sockets, bNodeStack **ns, GPUNode bNode *nodeGetActiveTexture(bNodeTree *ntree) { /* this is the node we texture paint and draw in textured draw */ - bNode *node; + bNode *node, *tnode; if (!ntree) return NULL; - /* check for group edit */ - for (node= ntree->nodes.first; node; node= node->next) - if (node->flag & NODE_GROUP_EDIT) - break; - - if (node) - ntree = (bNodeTree *)node->id; - for (node= ntree->nodes.first; node; node= node->next) if (node->flag & NODE_ACTIVE_TEXTURE) return node; + /* node active texture node in this tree, look inside groups */ + for(node= ntree->nodes.first; node; node= node->next) { + if (node->type==NODE_GROUP) { + tnode = nodeGetActiveTexture((bNodeTree*)node->id); + if (tnode) + return tnode; + } + } + return NULL; } @@ -299,14 +246,7 @@ void ntreeExecGPUNodes(bNodeTreeExec *exec, GPUMaterial *mat, int do_outputs) node_get_stack(node, stack, nsin, nsout); gpu_stack_from_data_list(gpuin, &node->inputs, nsin); gpu_stack_from_data_list(gpuout, &node->outputs, nsout); - if (node->typeinfo->gpufunc(mat, node, gpuin, gpuout)) - data_from_gpu_stack_list(&node->outputs, nsout, gpuout); - } - else if (node->typeinfo->gpuextfunc) { - node_get_stack(node, stack, nsin, nsout); - gpu_stack_from_data_list(gpuin, &node->inputs, nsin); - gpu_stack_from_data_list(gpuout, &node->outputs, nsout); - if (node->typeinfo->gpuextfunc(mat, node, nodeexec->data, gpuin, gpuout)) + if (node->typeinfo->gpufunc(mat, node, &nodeexec->data, gpuin, gpuout)) data_from_gpu_stack_list(&node->outputs, nsout, gpuout); } } diff --git a/source/blender/nodes/shader/node_shader_util.h b/source/blender/nodes/shader/node_shader_util.h index 9c911501435..57b129335bb 100644 --- a/source/blender/nodes/shader/node_shader_util.h +++ b/source/blender/nodes/shader/node_shader_util.h @@ -79,6 +79,11 @@ #include "GPU_material.h" + +int sh_node_poll_default(struct bNodeType *ntype, struct bNodeTree *ntree); +void sh_node_type_base(struct bNodeType *ntype, int type, const char *name, short nclass, short flag); + + /* ********* exec data struct, remains internal *********** */ typedef struct ShaderCallData { @@ -86,40 +91,6 @@ typedef struct ShaderCallData { ShadeResult *shr; /* from render pipe */ } ShaderCallData; -/* output socket defines */ -#define GEOM_OUT_GLOB 0 -#define GEOM_OUT_LOCAL 1 -#define GEOM_OUT_VIEW 2 -#define GEOM_OUT_ORCO 3 -#define GEOM_OUT_UV 4 -#define GEOM_OUT_NORMAL 5 -#define GEOM_OUT_VCOL 6 -#define GEOM_OUT_VCOL_ALPHA 7 -#define GEOM_OUT_FRONTBACK 8 - - -/* input socket defines */ -#define MAT_IN_COLOR 0 -#define MAT_IN_SPEC 1 -#define MAT_IN_REFL 2 -#define MAT_IN_NORMAL 3 -#define MAT_IN_MIR 4 -#define MAT_IN_AMB 5 -#define MAT_IN_EMIT 6 -#define MAT_IN_SPECTRA 7 -#define MAT_IN_RAY_MIRROR 8 -#define MAT_IN_ALPHA 9 -#define MAT_IN_TRANSLUCENCY 10 -#define NUM_MAT_IN 11 /* for array size */ - -/* output socket defines */ -#define MAT_OUT_COLOR 0 -#define MAT_OUT_ALPHA 1 -#define MAT_OUT_NORMAL 2 -#define MAT_OUT_DIFFUSE 3 -#define MAT_OUT_SPEC 4 -#define MAT_OUT_AO 5 - extern void node_ID_title_cb(void *node_v, void *unused_v); void nodestack_get_vec(float *in, short type_in, bNodeStack *ns); diff --git a/source/blender/nodes/shader/nodes/node_shader_add_shader.c b/source/blender/nodes/shader/nodes/node_shader_add_shader.c index ec868b2cc38..75d4fb1a30a 100644 --- a/source/blender/nodes/shader/nodes/node_shader_add_shader.c +++ b/source/blender/nodes/shader/nodes/node_shader_add_shader.c @@ -40,24 +40,23 @@ static bNodeSocketTemplate sh_node_add_shader_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_add_shader(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_add_shader(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_add_shader", in, out); } /* node type definition */ -void register_node_type_sh_add_shader(bNodeTreeType *ttype) +void register_node_type_sh_add_shader() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_ADD_SHADER, "Add Shader", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_ADD_SHADER, "Add Shader", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_add_shader_in, sh_node_add_shader_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_add_shader); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.c b/source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.c index 7dfefc9ece0..85814c4a041 100644 --- a/source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.c +++ b/source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.c @@ -39,25 +39,24 @@ static bNodeSocketTemplate sh_node_ambient_occlusion_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_ambient_occlusion(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_ambient_occlusion(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_ambient_occlusion", in, out, GPU_builtin(GPU_VIEW_NORMAL)); } /* node type definition */ -void register_node_type_sh_ambient_occlusion(bNodeTreeType *ttype) +void register_node_type_sh_ambient_occlusion() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_AMBIENT_OCCLUSION, "Ambient Occlusion", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_AMBIENT_OCCLUSION, "Ambient Occlusion", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_ambient_occlusion_in, sh_node_ambient_occlusion_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_ambient_occlusion); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_attribute.c b/source/blender/nodes/shader/nodes/node_shader_attribute.c index 9b2ed2f14f0..b6463655755 100644 --- a/source/blender/nodes/shader/nodes/node_shader_attribute.c +++ b/source/blender/nodes/shader/nodes/node_shader_attribute.c @@ -36,25 +36,23 @@ static bNodeSocketTemplate sh_node_attribute_out[] = { { -1, 0, "" } }; -static void node_shader_init_attribute(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_attribute(bNodeTree *UNUSED(ntree), bNode *node) { NodeShaderAttribute *attr = MEM_callocN(sizeof(NodeShaderAttribute), "NodeShaderAttribute"); node->storage = attr; } /* node type definition */ -void register_node_type_sh_attribute(bNodeTreeType *ttype) +void register_node_type_sh_attribute() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_ATTRIBUTE, "Attribute", NODE_CLASS_INPUT, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_ATTRIBUTE, "Attribute", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, sh_node_attribute_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_attribute); node_type_storage(&ntype, "NodeShaderAttribute", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); - node_type_gpu(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_background.c b/source/blender/nodes/shader/nodes/node_shader_background.c index d82c513540c..b109a2e4596 100644 --- a/source/blender/nodes/shader/nodes/node_shader_background.c +++ b/source/blender/nodes/shader/nodes/node_shader_background.c @@ -41,18 +41,16 @@ static bNodeSocketTemplate sh_node_background_out[] = { }; /* node type definition */ -void register_node_type_sh_background(bNodeTreeType *ttype) +void register_node_type_sh_background() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BACKGROUND, "Background", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_BACKGROUND, "Background", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_background_in, sh_node_background_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); - node_type_gpu(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_brightness.c b/source/blender/nodes/shader/nodes/node_shader_brightness.c index fa77fce4c88..ccdbddadb14 100644 --- a/source/blender/nodes/shader/nodes/node_shader_brightness.c +++ b/source/blender/nodes/shader/nodes/node_shader_brightness.c @@ -43,23 +43,22 @@ static bNodeSocketTemplate sh_node_brightcontrast_out[] = { { -1, 0, "" } }; -static int gpu_shader_brightcontrast(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_brightcontrast(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "brightness_contrast", in, out); } -void register_node_type_sh_brightcontrast(bNodeTreeType *ttype) +void register_node_type_sh_brightcontrast() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BRIGHTCONTRAST, "Bright/Contrast", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_BRIGHTCONTRAST, "Bright/Contrast", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_brightcontrast_in, sh_node_brightcontrast_out); node_type_size(&ntype, 140, 100, 320); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, gpu_shader_brightcontrast); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_anisotropic.c b/source/blender/nodes/shader/nodes/node_shader_bsdf_anisotropic.c index 71780e9316e..e4b9c372607 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_anisotropic.c +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_anisotropic.c @@ -44,7 +44,7 @@ static bNodeSocketTemplate sh_node_bsdf_anisotropic_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_bsdf_anisotropic(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_bsdf_anisotropic(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[3].link) in[3].link = GPU_builtin(GPU_VIEW_NORMAL); @@ -53,18 +53,17 @@ static int node_shader_gpu_bsdf_anisotropic(GPUMaterial *mat, bNode *UNUSED(node } /* node type definition */ -void register_node_type_sh_bsdf_anisotropic(bNodeTreeType *ttype) +void register_node_type_sh_bsdf_anisotropic() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BSDF_ANISOTROPIC, "Anisotropic BSDF", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_BSDF_ANISOTROPIC, "Anisotropic BSDF", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_bsdf_anisotropic_in, sh_node_bsdf_anisotropic_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_bsdf_anisotropic); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_diffuse.c b/source/blender/nodes/shader/nodes/node_shader_bsdf_diffuse.c index ad9f197afb8..466c2db07d4 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_diffuse.c +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_diffuse.c @@ -41,7 +41,7 @@ static bNodeSocketTemplate sh_node_bsdf_diffuse_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_bsdf_diffuse(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_bsdf_diffuse(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[2].link) in[2].link = GPU_builtin(GPU_VIEW_NORMAL); @@ -50,18 +50,17 @@ static int node_shader_gpu_bsdf_diffuse(GPUMaterial *mat, bNode *UNUSED(node), G } /* node type definition */ -void register_node_type_sh_bsdf_diffuse(bNodeTreeType *ttype) +void register_node_type_sh_bsdf_diffuse() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BSDF_DIFFUSE, "Diffuse BSDF", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_BSDF_DIFFUSE, "Diffuse BSDF", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_bsdf_diffuse_in, sh_node_bsdf_diffuse_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_bsdf_diffuse); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_glass.c b/source/blender/nodes/shader/nodes/node_shader_bsdf_glass.c index 9e188092570..b36a754e129 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_glass.c +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_glass.c @@ -42,7 +42,7 @@ static bNodeSocketTemplate sh_node_bsdf_glass_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_bsdf_glass(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_bsdf_glass(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[3].link) in[3].link = GPU_builtin(GPU_VIEW_NORMAL); @@ -51,18 +51,17 @@ static int node_shader_gpu_bsdf_glass(GPUMaterial *mat, bNode *UNUSED(node), GPU } /* node type definition */ -void register_node_type_sh_bsdf_glass(bNodeTreeType *ttype) +void register_node_type_sh_bsdf_glass() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BSDF_GLASS, "Glass BSDF", NODE_CLASS_SHADER, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_BSDF_GLASS, "Glass BSDF", NODE_CLASS_SHADER, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_bsdf_glass_in, sh_node_bsdf_glass_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_bsdf_glass); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_glossy.c b/source/blender/nodes/shader/nodes/node_shader_bsdf_glossy.c index 5e32930b707..00d4f18fe65 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_glossy.c +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_glossy.c @@ -41,7 +41,7 @@ static bNodeSocketTemplate sh_node_bsdf_glossy_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_bsdf_glossy(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_bsdf_glossy(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[2].link) in[2].link = GPU_builtin(GPU_VIEW_NORMAL); @@ -50,18 +50,17 @@ static int node_shader_gpu_bsdf_glossy(GPUMaterial *mat, bNode *UNUSED(node), GP } /* node type definition */ -void register_node_type_sh_bsdf_glossy(bNodeTreeType *ttype) +void register_node_type_sh_bsdf_glossy() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BSDF_GLOSSY, "Glossy BSDF", NODE_CLASS_SHADER, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_BSDF_GLOSSY, "Glossy BSDF", NODE_CLASS_SHADER, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_bsdf_glossy_in, sh_node_bsdf_glossy_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_bsdf_glossy); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_refraction.c b/source/blender/nodes/shader/nodes/node_shader_bsdf_refraction.c index 99e66e39002..e8509c489ef 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_refraction.c +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_refraction.c @@ -42,7 +42,7 @@ static bNodeSocketTemplate sh_node_bsdf_refraction_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_bsdf_refraction(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_bsdf_refraction(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[3].link) in[3].link = GPU_builtin(GPU_VIEW_NORMAL); @@ -51,18 +51,17 @@ static int node_shader_gpu_bsdf_refraction(GPUMaterial *mat, bNode *UNUSED(node) } /* node type definition */ -void register_node_type_sh_bsdf_refraction(bNodeTreeType *ttype) +void register_node_type_sh_bsdf_refraction() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BSDF_REFRACTION, "Refraction BSDF", NODE_CLASS_SHADER, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_BSDF_REFRACTION, "Refraction BSDF", NODE_CLASS_SHADER, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_bsdf_refraction_in, sh_node_bsdf_refraction_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_bsdf_refraction); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_translucent.c b/source/blender/nodes/shader/nodes/node_shader_bsdf_translucent.c index 3c7084886b7..ab4ced3f99e 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_translucent.c +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_translucent.c @@ -40,7 +40,7 @@ static bNodeSocketTemplate sh_node_bsdf_translucent_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_bsdf_translucent(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_bsdf_translucent(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[1].link) in[1].link = GPU_builtin(GPU_VIEW_NORMAL); @@ -49,18 +49,17 @@ static int node_shader_gpu_bsdf_translucent(GPUMaterial *mat, bNode *UNUSED(node } /* node type definition */ -void register_node_type_sh_bsdf_translucent(bNodeTreeType *ttype) +void register_node_type_sh_bsdf_translucent() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BSDF_TRANSLUCENT, "Translucent BSDF", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_BSDF_TRANSLUCENT, "Translucent BSDF", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_bsdf_translucent_in, sh_node_bsdf_translucent_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_bsdf_translucent); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_transparent.c b/source/blender/nodes/shader/nodes/node_shader_bsdf_transparent.c index 7fb452ad78d..843454dbb3e 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_transparent.c +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_transparent.c @@ -39,24 +39,23 @@ static bNodeSocketTemplate sh_node_bsdf_transparent_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_bsdf_transparent(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_bsdf_transparent(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_bsdf_transparent", in, out); } /* node type definition */ -void register_node_type_sh_bsdf_transparent(bNodeTreeType *ttype) +void register_node_type_sh_bsdf_transparent() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BSDF_TRANSPARENT, "Transparent BSDF", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_BSDF_TRANSPARENT, "Transparent BSDF", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_bsdf_transparent_in, sh_node_bsdf_transparent_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_bsdf_transparent); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_velvet.c b/source/blender/nodes/shader/nodes/node_shader_bsdf_velvet.c index a4d25d42d4e..ff9fd3a07fe 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bsdf_velvet.c +++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_velvet.c @@ -41,7 +41,7 @@ static bNodeSocketTemplate sh_node_bsdf_velvet_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_bsdf_velvet(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_bsdf_velvet(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[2].link) in[2].link = GPU_builtin(GPU_VIEW_NORMAL); @@ -50,18 +50,17 @@ static int node_shader_gpu_bsdf_velvet(GPUMaterial *mat, bNode *UNUSED(node), GP } /* node type definition */ -void register_node_type_sh_bsdf_velvet(bNodeTreeType *ttype) +void register_node_type_sh_bsdf_velvet() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BSDF_VELVET, "Velvet BSDF", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_BSDF_VELVET, "Velvet BSDF", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_bsdf_velvet_in, sh_node_bsdf_velvet_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_bsdf_velvet); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_bump.c b/source/blender/nodes/shader/nodes/node_shader_bump.c index b0605f9b248..00733ebaf5c 100644 --- a/source/blender/nodes/shader/nodes/node_shader_bump.c +++ b/source/blender/nodes/shader/nodes/node_shader_bump.c @@ -46,23 +46,22 @@ static bNodeSocketTemplate sh_node_bump_out[] = { { -1, 0, "" } }; -static int gpu_shader_bump(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_bump(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_bump", in, out, GPU_builtin(GPU_VIEW_NORMAL)); } /* node type definition */ -void register_node_type_sh_bump(bNodeTreeType *ttype) +void register_node_type_sh_bump() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_BUMP, "Bump", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_BUMP, "Bump", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_bump_in, sh_node_bump_out); node_type_size(&ntype, 150, 60, 200); node_type_storage(&ntype, "BumpNode", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, gpu_shader_bump); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_camera.c b/source/blender/nodes/shader/nodes/node_shader_camera.c index fd36a94516e..8a406bc7f74 100644 --- a/source/blender/nodes/shader/nodes/node_shader_camera.c +++ b/source/blender/nodes/shader/nodes/node_shader_camera.c @@ -41,7 +41,7 @@ static bNodeSocketTemplate sh_node_camera_out[] = { }; -static void node_shader_exec_camera(void *data, bNode *UNUSED(node), bNodeStack **UNUSED(in), bNodeStack **out) +static void node_shader_exec_camera(void *data, int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **UNUSED(in), bNodeStack **out) { if (data) { ShadeInput *shi= ((ShaderCallData *)data)->shi; /* Data we need for shading. */ @@ -52,22 +52,22 @@ static void node_shader_exec_camera(void *data, bNode *UNUSED(node), bNodeStack } } -static int gpu_shader_camera(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_camera(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "camera", in, out, GPU_builtin(GPU_VIEW_POSITION)); } -void register_node_type_sh_camera(bNodeTreeType *ttype) +void register_node_type_sh_camera() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_CAMERA, "Camera Data", NODE_CLASS_INPUT, 0); + sh_node_type_base(&ntype, SH_NODE_CAMERA, "Camera Data", NODE_CLASS_INPUT, 0); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, sh_node_camera_out); node_type_size(&ntype, 95, 95, 120); node_type_storage(&ntype, "node_camera", NULL, NULL); - node_type_exec(&ntype, node_shader_exec_camera); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_camera); node_type_gpu(&ntype, gpu_shader_camera); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_common.c b/source/blender/nodes/shader/nodes/node_shader_common.c index 9c784709de3..8c148b86610 100644 --- a/source/blender/nodes/shader/nodes/node_shader_common.c +++ b/source/blender/nodes/shader/nodes/node_shader_common.c @@ -38,9 +38,12 @@ #include "BKE_node.h" #include "node_shader_util.h" +#include "NOD_common.h" #include "node_common.h" #include "node_exec.h" +#include "RNA_access.h" + static void copy_stack(bNodeStack *to, bNodeStack *from) { if (to != from) { @@ -61,16 +64,14 @@ static void move_stack(bNodeStack *to, bNodeStack *from) to->datatype = from->datatype; to->is_copy = from->is_copy; - zero_v4(from->vec); from->data = NULL; - from->datatype = 0; from->is_copy = 0; } } /**** GROUP ****/ -static void *group_initexec(bNode *node) +static void *group_initexec(bNodeExecContext *context, bNode *node, bNodeInstanceKey key) { bNodeTree *ngroup = (bNodeTree *)node->id; bNodeTreeExec *exec; @@ -79,7 +80,7 @@ static void *group_initexec(bNode *node) return NULL; /* initialize the internal node tree execution */ - exec = ntreeShaderBeginExecTree(ngroup, 0); + exec = ntreeShaderBeginExecTree_internal(context, ngroup, key); return exec; } @@ -88,42 +89,55 @@ static void group_freeexec(bNode *UNUSED(node), void *nodedata) { bNodeTreeExec*gexec = (bNodeTreeExec *)nodedata; - ntreeShaderEndExecTree(gexec, 0); + ntreeShaderEndExecTree_internal(gexec); } /* Copy inputs to the internal stack. */ -static void group_copy_inputs(bNode *node, bNodeStack **in, bNodeStack *gstack) +static void group_copy_inputs(bNode *gnode, bNodeStack **in, bNodeStack *gstack) { + bNodeTree *ngroup = (bNodeTree*)gnode->id; + bNode *node; bNodeSocket *sock; bNodeStack *ns; int a; - for (sock=node->inputs.first, a=0; sock; sock=sock->next, ++a) { - if (sock->groupsock) { - ns = node_get_socket_stack(gstack, sock->groupsock); - copy_stack(ns, in[a]); + + for (node = ngroup->nodes.first; node; node = node->next) { + if (node->type == NODE_GROUP_INPUT) { + for (sock = node->outputs.first, a = 0; sock; sock = sock->next, ++a) { + ns = node_get_socket_stack(gstack, sock); + if (ns) + copy_stack(ns, in[a]); + } } } } /* Copy internal results to the external outputs. */ -static void group_move_outputs(bNode *node, bNodeStack **out, bNodeStack *gstack) +static void group_move_outputs(bNode *gnode, bNodeStack **out, bNodeStack *gstack) { + bNodeTree *ngroup = (bNodeTree*)gnode->id; + bNode *node; bNodeSocket *sock; bNodeStack *ns; int a; - for (sock=node->outputs.first, a=0; sock; sock=sock->next, ++a) { - if (sock->groupsock) { - ns = node_get_socket_stack(gstack, sock->groupsock); - move_stack(out[a], ns); + + for (node = ngroup->nodes.first; node; node = node->next) { + if (node->type == NODE_GROUP_OUTPUT && (node->flag & NODE_DO_OUTPUT)) { + for (sock = node->inputs.first, a = 0; sock; sock = sock->next, ++a) { + ns = node_get_socket_stack(gstack, sock); + if (ns) + move_stack(out[a], ns); + } + break; /* only one active output node */ } } } -static void group_execute(void *data, int thread, struct bNode *node, void *nodedata, struct bNodeStack **in, struct bNodeStack **out) +static void group_execute(void *data, int thread, struct bNode *node, bNodeExecData *execdata, struct bNodeStack **in, struct bNodeStack **out) { - bNodeTreeExec *exec = (bNodeTreeExec *)nodedata; + bNodeTreeExec *exec = execdata->data; bNodeThreadStack *nts; if (!exec) @@ -147,62 +161,88 @@ static void group_execute(void *data, int thread, struct bNode *node, void *node ntreeReleaseThreadStack(nts); } -static void group_gpu_copy_inputs(bNode *node, GPUNodeStack *in, bNodeStack *gstack) +static void group_gpu_copy_inputs(bNode *gnode, GPUNodeStack *in, bNodeStack *gstack) { + bNodeTree *ngroup = (bNodeTree*)gnode->id; + bNode *node; bNodeSocket *sock; bNodeStack *ns; int a; - for (sock=node->inputs.first, a=0; sock; sock=sock->next, ++a) { - if (sock->groupsock) { - ns = node_get_socket_stack(gstack, sock->groupsock); - /* convert the external gpu stack back to internal node stack data */ - node_data_from_gpu_stack(ns, &in[a]); + + for (node = ngroup->nodes.first; node; node = node->next) { + if (node->type == NODE_GROUP_INPUT) { + for (sock = node->outputs.first, a = 0; sock; sock = sock->next, ++a) { + ns = node_get_socket_stack(gstack, sock); + if (ns) { + /* convert the external gpu stack back to internal node stack data */ + node_data_from_gpu_stack(ns, &in[a]); + } + } } } } /* Copy internal results to the external outputs. */ -static void group_gpu_move_outputs(bNode *node, GPUNodeStack *out, bNodeStack *gstack) +static void group_gpu_move_outputs(bNode *gnode, GPUNodeStack *out, bNodeStack *gstack) { + bNodeTree *ngroup = (bNodeTree*)gnode->id; + bNode *node; bNodeSocket *sock; bNodeStack *ns; int a; - for (sock=node->outputs.first, a=0; sock; sock=sock->next, ++a) { - if (sock->groupsock) { - ns = node_get_socket_stack(gstack, sock->groupsock); - /* convert the node stack data result back to gpu stack */ - node_gpu_stack_from_data(&out[a], sock->type, ns); + + for (node = ngroup->nodes.first; node; node = node->next) { + if (node->type == NODE_GROUP_OUTPUT && (node->flag & NODE_DO_OUTPUT)) { + for (sock = node->inputs.first, a = 0; sock; sock = sock->next, ++a) { + ns = node_get_socket_stack(gstack, sock); + if (ns) { + /* convert the node stack data result back to gpu stack */ + node_gpu_stack_from_data(&out[a], sock->type, ns); + } + } + break; /* only one active output node */ } } } -static int gpu_group_execute(GPUMaterial *mat, bNode *node, void *nodedata, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_group_execute(GPUMaterial *mat, bNode *node, bNodeExecData *execdata, GPUNodeStack *in, GPUNodeStack *out) { - bNodeTreeExec *exec = (bNodeTreeExec *)nodedata; + bNodeTreeExec *exec = execdata->data; group_gpu_copy_inputs(node, in, exec->stack); + #if 0 /* XXX NODE_GROUP_EDIT is deprecated, depends on node space */ ntreeExecGPUNodes(exec, mat, (node->flag & NODE_GROUP_EDIT)); + #else + ntreeExecGPUNodes(exec, mat, 0); + #endif group_gpu_move_outputs(node, out, exec->stack); return 1; } -void register_node_type_sh_group(bNodeTreeType *ttype) +void register_node_type_sh_group() { static bNodeType ntype; - - node_type_base(ttype, &ntype, NODE_GROUP, "Group", NODE_CLASS_GROUP, NODE_OPTIONS|NODE_CONST_OUTPUT); + + /* NB: cannot use sh_node_type_base for node group, because it would map the node type + * to the shared NODE_GROUP integer type id. + */ + node_type_base_custom(&ntype, "ShaderNodeGroup", "Group", NODE_CLASS_GROUP, NODE_OPTIONS | NODE_CONST_OUTPUT); + ntype.type = NODE_GROUP; + ntype.poll = sh_node_poll_default; + ntype.update_internal_links = node_update_internal_links_default; + ntype.ext.srna = RNA_struct_find("ShaderNodeGroup"); + BLI_assert(ntype.ext.srna != NULL); + RNA_struct_blender_type_set(ntype.ext.srna, &ntype); + node_type_socket_templates(&ntype, NULL, NULL); node_type_size(&ntype, 120, 60, 200); node_type_label(&ntype, node_group_label); - node_type_init(&ntype, node_group_init); - node_type_valid(&ntype, node_group_valid); - node_type_template(&ntype, node_group_template); node_type_update(&ntype, NULL, node_group_verify); - node_type_group_edit(&ntype, node_group_edit_get, node_group_edit_set, node_group_edit_clear); - node_type_exec_new(&ntype, group_initexec, group_freeexec, group_execute); - node_type_gpu_ext(&ntype, gpu_group_execute); + strcpy(ntype.group_tree_idname, "ShaderNodeTree"); + node_type_exec(&ntype, group_initexec, group_freeexec, group_execute); + node_type_gpu(&ntype, gpu_group_execute); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_curves.c b/source/blender/nodes/shader/nodes/node_shader_curves.c index 216e10a7e9a..7a6d4a08db0 100644 --- a/source/blender/nodes/shader/nodes/node_shader_curves.c +++ b/source/blender/nodes/shader/nodes/node_shader_curves.c @@ -45,7 +45,7 @@ static bNodeSocketTemplate sh_node_curve_vec_out[] = { { -1, 0, "" } }; -static void node_shader_exec_curve_vec(void *UNUSED(data), bNode *node, bNodeStack **in, bNodeStack **out) +static void node_shader_exec_curve_vec(void *UNUSED(data), int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { float vec[3]; @@ -55,12 +55,12 @@ static void node_shader_exec_curve_vec(void *UNUSED(data), bNode *node, bNodeSta curvemapping_evaluate3F(node->storage, out[0]->vec, vec); } -static void node_shader_init_curve_vec(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_curve_vec(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= curvemapping_add(3, -1.0f, -1.0f, 1.0f, 1.0f); } -static int gpu_shader_curve_vec(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_curve_vec(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { float *array; int size; @@ -69,21 +69,20 @@ static int gpu_shader_curve_vec(GPUMaterial *mat, bNode *node, GPUNodeStack *in, return GPU_stack_link(mat, "curves_vec", in, out, GPU_texture(size, array)); } -void register_node_type_sh_curve_vec(bNodeTreeType *ttype) +void register_node_type_sh_curve_vec() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_CURVE_VEC, "Vector Curves", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_CURVE_VEC, "Vector Curves", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_curve_vec_in, sh_node_curve_vec_out); node_type_size(&ntype, 200, 140, 320); node_type_init(&ntype, node_shader_init_curve_vec); node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); - node_type_exec(&ntype, node_shader_exec_curve_vec); - node_type_exec_new(&ntype, node_initexec_curves, NULL, NULL); /* only for its initexec func */ + node_type_exec(&ntype, node_initexec_curves, NULL, node_shader_exec_curve_vec); node_type_gpu(&ntype, gpu_shader_curve_vec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } @@ -99,7 +98,7 @@ static bNodeSocketTemplate sh_node_curve_rgb_out[] = { { -1, 0, "" } }; -static void node_shader_exec_curve_rgb(void *UNUSED(data), bNode *node, bNodeStack **in, bNodeStack **out) +static void node_shader_exec_curve_rgb(void *UNUSED(data), int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { float vec[3]; @@ -112,12 +111,12 @@ static void node_shader_exec_curve_rgb(void *UNUSED(data), bNode *node, bNodeSta } } -static void node_shader_init_curve_rgb(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_curve_rgb(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= curvemapping_add(4, 0.0f, 0.0f, 1.0f, 1.0f); } -static int gpu_shader_curve_rgb(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_curve_rgb(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { float *array; int size; @@ -127,19 +126,18 @@ static int gpu_shader_curve_rgb(GPUMaterial *mat, bNode *node, GPUNodeStack *in, return GPU_stack_link(mat, "curves_rgb", in, out, GPU_texture(size, array)); } -void register_node_type_sh_curve_rgb(bNodeTreeType *ttype) +void register_node_type_sh_curve_rgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_curve_rgb_in, sh_node_curve_rgb_out); node_type_size(&ntype, 200, 140, 320); node_type_init(&ntype, node_shader_init_curve_rgb); node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); - node_type_exec(&ntype, node_shader_exec_curve_rgb); - node_type_exec_new(&ntype, node_initexec_curves, NULL, NULL); /* only for its initexec func */ + node_type_exec(&ntype, node_initexec_curves, NULL, node_shader_exec_curve_rgb); node_type_gpu(&ntype, gpu_shader_curve_rgb); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_emission.c b/source/blender/nodes/shader/nodes/node_shader_emission.c index 0c4cb7ed51c..d330afbdabe 100644 --- a/source/blender/nodes/shader/nodes/node_shader_emission.c +++ b/source/blender/nodes/shader/nodes/node_shader_emission.c @@ -40,24 +40,23 @@ static bNodeSocketTemplate sh_node_emission_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_emission(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_emission(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_emission", in, out, GPU_builtin(GPU_VIEW_NORMAL)); } /* node type definition */ -void register_node_type_sh_emission(bNodeTreeType *ttype) +void register_node_type_sh_emission() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_EMISSION, "Emission", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_EMISSION, "Emission", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_emission_in, sh_node_emission_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_emission); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_fresnel.c b/source/blender/nodes/shader/nodes/node_shader_fresnel.c index 80913e6b07a..fe15cc9bc04 100644 --- a/source/blender/nodes/shader/nodes/node_shader_fresnel.c +++ b/source/blender/nodes/shader/nodes/node_shader_fresnel.c @@ -38,25 +38,24 @@ static bNodeSocketTemplate sh_node_fresnel_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_fresnel(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_fresnel(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { /* todo: is incoming vector normalized? */ return GPU_stack_link(mat, "node_fresnel", in, out, GPU_builtin(GPU_VIEW_NORMAL), GPU_builtin(GPU_VIEW_POSITION)); } /* node type definition */ -void register_node_type_sh_fresnel(bNodeTreeType *ttype) +void register_node_type_sh_fresnel() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_FRESNEL, "Fresnel", NODE_CLASS_INPUT, 0); + sh_node_type_base(&ntype, SH_NODE_FRESNEL, "Fresnel", NODE_CLASS_INPUT, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_fresnel_in, sh_node_fresnel_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_fresnel); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_gamma.c b/source/blender/nodes/shader/nodes/node_shader_gamma.c index 365bac77004..35b01cfb73e 100644 --- a/source/blender/nodes/shader/nodes/node_shader_gamma.c +++ b/source/blender/nodes/shader/nodes/node_shader_gamma.c @@ -41,18 +41,16 @@ static bNodeSocketTemplate sh_node_gamma_out[] = { { -1, 0, "" } }; -void register_node_type_sh_gamma(bNodeTreeType *ttype) +void register_node_type_sh_gamma() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_GAMMA, "Gamma", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_GAMMA, "Gamma", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_gamma_in, sh_node_gamma_out); node_type_size(&ntype, 140, 100, 320); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); - node_type_gpu(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_geom.c b/source/blender/nodes/shader/nodes/node_shader_geom.c index eb3d462d616..166e9453f35 100644 --- a/source/blender/nodes/shader/nodes/node_shader_geom.c +++ b/source/blender/nodes/shader/nodes/node_shader_geom.c @@ -51,7 +51,7 @@ static bNodeSocketTemplate sh_node_geom_out[] = { }; /* node execute callback */ -static void node_shader_exec_geom(void *data, bNode *node, bNodeStack **UNUSED(in), bNodeStack **out) +static void node_shader_exec_geom(void *data, int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **UNUSED(in), bNodeStack **out) { if (data) { ShadeInput *shi= ((ShaderCallData *)data)->shi; @@ -120,12 +120,12 @@ static void node_shader_exec_geom(void *data, bNode *node, bNodeStack **UNUSED(i } } -static void node_shader_init_geometry(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_geometry(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= MEM_callocN(sizeof(NodeGeometry), "NodeGeometry"); } -static int gpu_shader_geom(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_geom(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { NodeGeometry *ngeo= (NodeGeometry*)node->storage; GPUNodeLink *orco = GPU_attribute(CD_ORCO, ""); @@ -138,18 +138,18 @@ static int gpu_shader_geom(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUN } /* node type definition */ -void register_node_type_sh_geom(bNodeTreeType *ttype) +void register_node_type_sh_geom() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_GEOMETRY, "Geometry", NODE_CLASS_INPUT, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_GEOMETRY, "Geometry", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING); node_type_socket_templates(&ntype, NULL, sh_node_geom_out); node_type_size(&ntype, 120, 80, 160); node_type_init(&ntype, node_shader_init_geometry); node_type_storage(&ntype, "NodeGeometry", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, node_shader_exec_geom); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_geom); node_type_gpu(&ntype, gpu_shader_geom); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_geometry.c b/source/blender/nodes/shader/nodes/node_shader_geometry.c index acef885d2d4..f57caa2f798 100644 --- a/source/blender/nodes/shader/nodes/node_shader_geometry.c +++ b/source/blender/nodes/shader/nodes/node_shader_geometry.c @@ -40,7 +40,7 @@ static bNodeSocketTemplate sh_node_geometry_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_geometry(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_geometry(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_geometry", in, out, GPU_builtin(GPU_VIEW_POSITION), GPU_builtin(GPU_VIEW_NORMAL), @@ -48,18 +48,17 @@ static int node_shader_gpu_geometry(GPUMaterial *mat, bNode *UNUSED(node), GPUNo } /* node type definition */ -void register_node_type_sh_geometry(bNodeTreeType *ttype) +void register_node_type_sh_geometry() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_NEW_GEOMETRY, "Geometry", NODE_CLASS_INPUT, 0); + sh_node_type_base(&ntype, SH_NODE_NEW_GEOMETRY, "Geometry", NODE_CLASS_INPUT, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, sh_node_geometry_out); node_type_size(&ntype, 120, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_geometry); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_hair_info.c b/source/blender/nodes/shader/nodes/node_shader_hair_info.c index 5cd4c8bd1d3..f03373ad066 100644 --- a/source/blender/nodes/shader/nodes/node_shader_hair_info.c +++ b/source/blender/nodes/shader/nodes/node_shader_hair_info.c @@ -36,18 +36,16 @@ static bNodeSocketTemplate outputs[] = { }; /* node type definition */ -void register_node_type_sh_hair_info(bNodeTreeType *ttype) +void register_node_type_sh_hair_info() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_HAIR_INFO, "Hair Info", NODE_CLASS_INPUT, 0); + sh_node_type_base(&ntype, SH_NODE_HAIR_INFO, "Hair Info", NODE_CLASS_INPUT, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, outputs); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); - node_type_gpu(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_holdout.c b/source/blender/nodes/shader/nodes/node_shader_holdout.c index 18ad4994c9b..04769cad590 100644 --- a/source/blender/nodes/shader/nodes/node_shader_holdout.c +++ b/source/blender/nodes/shader/nodes/node_shader_holdout.c @@ -40,18 +40,16 @@ static bNodeSocketTemplate sh_node_holdout_out[] = { /* node type definition */ -void register_node_type_sh_holdout(bNodeTreeType *ttype) +void register_node_type_sh_holdout() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_HOLDOUT, "Holdout", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_HOLDOUT, "Holdout", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_holdout_in, sh_node_holdout_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); - node_type_gpu(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_hueSatVal.c b/source/blender/nodes/shader/nodes/node_shader_hueSatVal.c index b635ad1edd9..f4a5462b8cc 100644 --- a/source/blender/nodes/shader/nodes/node_shader_hueSatVal.c +++ b/source/blender/nodes/shader/nodes/node_shader_hueSatVal.c @@ -69,27 +69,27 @@ static void do_hue_sat_fac(bNode *UNUSED(node), float *out, float *hue, float *s } } -static void node_shader_exec_hue_sat(void *UNUSED(data), bNode *node, bNodeStack **in, bNodeStack **out) +static void node_shader_exec_hue_sat(void *UNUSED(data), int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { do_hue_sat_fac(node, out[0]->vec, in[0]->vec, in[1]->vec, in[2]->vec, in[4]->vec, in[3]->vec); } -static int gpu_shader_hue_sat(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_hue_sat(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "hue_sat", in, out); } -void register_node_type_sh_hue_sat(bNodeTreeType *ttype) +void register_node_type_sh_hue_sat() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_hue_sat_in, sh_node_hue_sat_out); node_type_size(&ntype, 150, 80, 250); - node_type_exec(&ntype, node_shader_exec_hue_sat); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_hue_sat); node_type_gpu(&ntype, gpu_shader_hue_sat); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_invert.c b/source/blender/nodes/shader/nodes/node_shader_invert.c index 2ea858f4e34..f3d4efc82d7 100644 --- a/source/blender/nodes/shader/nodes/node_shader_invert.c +++ b/source/blender/nodes/shader/nodes/node_shader_invert.c @@ -46,7 +46,7 @@ static bNodeSocketTemplate sh_node_invert_out[] = { { -1, 0, "" } }; -static void node_shader_exec_invert(void *UNUSED(data), bNode *UNUSED(node), bNodeStack **in, +static void node_shader_exec_invert(void *UNUSED(data), int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { float col[3], facm; @@ -67,21 +67,21 @@ bNodeStack **out) copy_v3_v3(out[0]->vec, col); } -static int gpu_shader_invert(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_invert(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "invert", in, out); } -void register_node_type_sh_invert(bNodeTreeType *ttype) +void register_node_type_sh_invert() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_invert_in, sh_node_invert_out); node_type_size(&ntype, 90, 80, 100); - node_type_exec(&ntype, node_shader_exec_invert); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_invert); node_type_gpu(&ntype, gpu_shader_invert); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_layer_weight.c b/source/blender/nodes/shader/nodes/node_shader_layer_weight.c index 3058483ebef..5b7cb4730ae 100644 --- a/source/blender/nodes/shader/nodes/node_shader_layer_weight.c +++ b/source/blender/nodes/shader/nodes/node_shader_layer_weight.c @@ -40,24 +40,23 @@ static bNodeSocketTemplate sh_node_layer_weight_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_layer_weight(GPUMaterial *UNUSED(mat), bNode *UNUSED(node), GPUNodeStack *UNUSED(in), GPUNodeStack *UNUSED(out)) +static int node_shader_gpu_layer_weight(GPUMaterial *UNUSED(mat), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *UNUSED(in), GPUNodeStack *UNUSED(out)) { return 0; } /* node type definition */ -void register_node_type_sh_layer_weight(bNodeTreeType *ttype) +void register_node_type_sh_layer_weight() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_LAYER_WEIGHT, "Layer Weight", NODE_CLASS_INPUT, 0); + sh_node_type_base(&ntype, SH_NODE_LAYER_WEIGHT, "Layer Weight", NODE_CLASS_INPUT, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_layer_weight_in, sh_node_layer_weight_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_layer_weight); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_light_falloff.c b/source/blender/nodes/shader/nodes/node_shader_light_falloff.c index 2dec244ae3a..e30c59f6920 100644 --- a/source/blender/nodes/shader/nodes/node_shader_light_falloff.c +++ b/source/blender/nodes/shader/nodes/node_shader_light_falloff.c @@ -44,25 +44,24 @@ static bNodeSocketTemplate sh_node_light_falloff_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_light_falloff(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_light_falloff(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_light_falloff", in, out); } /* node type definition */ -void register_node_type_sh_light_falloff(bNodeTreeType *ttype) +void register_node_type_sh_light_falloff(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_LIGHT_FALLOFF, "Light Falloff", NODE_CLASS_OP_COLOR, 0); + sh_node_type_base(&ntype, SH_NODE_LIGHT_FALLOFF, "Light Falloff", NODE_CLASS_OP_COLOR, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_light_falloff_in, sh_node_light_falloff_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_light_falloff); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_light_path.c b/source/blender/nodes/shader/nodes/node_shader_light_path.c index b4a3d4e01e1..93efc5abfa4 100644 --- a/source/blender/nodes/shader/nodes/node_shader_light_path.c +++ b/source/blender/nodes/shader/nodes/node_shader_light_path.c @@ -41,24 +41,23 @@ static bNodeSocketTemplate sh_node_light_path_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_light_path(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_light_path(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_light_path", in, out); } /* node type definition */ -void register_node_type_sh_light_path(bNodeTreeType *ttype) +void register_node_type_sh_light_path() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_LIGHT_PATH, "Light Path", NODE_CLASS_INPUT, 0); + sh_node_type_base(&ntype, SH_NODE_LIGHT_PATH, "Light Path", NODE_CLASS_INPUT, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, sh_node_light_path_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_light_path); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_mapping.c b/source/blender/nodes/shader/nodes/node_shader_mapping.c index 396c1ac60bf..fc3ef736737 100644 --- a/source/blender/nodes/shader/nodes/node_shader_mapping.c +++ b/source/blender/nodes/shader/nodes/node_shader_mapping.c @@ -44,7 +44,7 @@ static bNodeSocketTemplate sh_node_mapping_out[] = { }; /* do the regular mapping options for blender textures */ -static void node_shader_exec_mapping(void *UNUSED(data), bNode *node, bNodeStack **in, bNodeStack **out) +static void node_shader_exec_mapping(void *UNUSED(data), int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { TexMapping *texmap= node->storage; float *vec= out[0]->vec; @@ -67,12 +67,12 @@ static void node_shader_exec_mapping(void *UNUSED(data), bNode *node, bNodeStack } -static void node_shader_init_mapping(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_mapping(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= add_tex_mapping(); } -static int gpu_shader_mapping(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_mapping(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { TexMapping *texmap= node->storage; float domin= (texmap->flag & TEXMAP_CLIP_MIN) != 0; @@ -86,18 +86,18 @@ static int gpu_shader_mapping(GPUMaterial *mat, bNode *node, GPUNodeStack *in, G return GPU_stack_link(mat, "mapping", in, out, tmat, tmin, tmax, tdomin, tdomax); } -void register_node_type_sh_mapping(bNodeTreeType *ttype) +void register_node_type_sh_mapping() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_MAPPING, "Mapping", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_MAPPING, "Mapping", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_mapping_in, sh_node_mapping_out); node_type_size(&ntype, 240, 160, 320); node_type_init(&ntype, node_shader_init_mapping); node_type_storage(&ntype, "TexMapping", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, node_shader_exec_mapping); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_mapping); node_type_gpu(&ntype, gpu_shader_mapping); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_material.c b/source/blender/nodes/shader/nodes/node_shader_material.c index a36f35c646d..29612ff74e2 100644 --- a/source/blender/nodes/shader/nodes/node_shader_material.c +++ b/source/blender/nodes/shader/nodes/node_shader_material.c @@ -29,7 +29,6 @@ * \ingroup shdnodes */ - #include "node_shader_util.h" /* **************** MATERIAL ******************** */ @@ -76,7 +75,7 @@ static bNodeSocketTemplate sh_node_material_ext_out[] = { { -1, 0, "" } }; -static void node_shader_exec_material(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void node_shader_exec_material(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { if (data && node->id) { ShadeResult shrnode; @@ -170,7 +169,7 @@ static void node_shader_exec_material(void *data, bNode *node, bNodeStack **in, col[3] = shrnode.alpha; if (shi->do_preview) - nodeAddToPreview(node, col, shi->xs, shi->ys, shi->do_manage); + BKE_node_preview_set_pixel(execdata->preview, col, shi->xs, shi->ys, shi->do_manage); copy_v3_v3(out[MAT_OUT_COLOR]->vec, col); out[MAT_OUT_ALPHA]->vec[0] = shrnode.alpha; @@ -208,7 +207,7 @@ static void node_shader_exec_material(void *data, bNode *node, bNodeStack **in, } -static void node_shader_init_material(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_material(bNodeTree *UNUSED(ntree), bNode *node) { node->custom1= SH_NODE_MAT_DIFF|SH_NODE_MAT_SPEC; } @@ -224,7 +223,7 @@ static GPUNodeLink *gpu_get_input_link(GPUNodeStack *in) return GPU_uniform(in->vec); } -static int gpu_shader_material(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_material(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (node->id) { GPUShadeInput shi; @@ -308,33 +307,33 @@ static int gpu_shader_material(GPUMaterial *mat, bNode *node, GPUNodeStack *in, return 0; } -void register_node_type_sh_material(bNodeTreeType *ttype) +void register_node_type_sh_material() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_MATERIAL, "Material", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW); + sh_node_type_base(&ntype, SH_NODE_MATERIAL, "Material", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW); node_type_compatibility(&ntype, NODE_OLD_SHADING); node_type_socket_templates(&ntype, sh_node_material_in, sh_node_material_out); node_type_size(&ntype, 120, 80, 240); node_type_init(&ntype, node_shader_init_material); - node_type_exec(&ntype, node_shader_exec_material); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_material); node_type_gpu(&ntype, gpu_shader_material); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } -void register_node_type_sh_material_ext(bNodeTreeType *ttype) +void register_node_type_sh_material_ext() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_MATERIAL_EXT, "Extended Material", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW); + sh_node_type_base(&ntype, SH_NODE_MATERIAL_EXT, "Extended Material", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW); node_type_compatibility(&ntype, NODE_OLD_SHADING); node_type_socket_templates(&ntype, sh_node_material_ext_in, sh_node_material_ext_out); node_type_size(&ntype, 120, 80, 240); node_type_init(&ntype, node_shader_init_material); - node_type_exec(&ntype, node_shader_exec_material); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_material); node_type_gpu(&ntype, gpu_shader_material); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_math.c b/source/blender/nodes/shader/nodes/node_shader_math.c index 0b71a3f13b4..08ba48176bb 100644 --- a/source/blender/nodes/shader/nodes/node_shader_math.c +++ b/source/blender/nodes/shader/nodes/node_shader_math.c @@ -45,8 +45,7 @@ static bNodeSocketTemplate sh_node_math_out[] = { { -1, 0, "" } }; -static void node_shader_exec_math(void *UNUSED(data), bNode *node, bNodeStack **in, -bNodeStack **out) +static void node_shader_exec_math(void *UNUSED(data), int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { switch (node->custom1) { @@ -207,7 +206,7 @@ bNodeStack **out) } } -static int gpu_shader_math(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_math(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { static const char *names[] = {"math_add", "math_subtract", "math_multiply", "math_divide", "math_sine", "math_cosine", "math_tangent", "math_asin", @@ -256,18 +255,18 @@ static int gpu_shader_math(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUN return 1; } -void register_node_type_sh_math(bNodeTreeType *ttype) +void register_node_type_sh_math() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_math_in, sh_node_math_out); node_type_size(&ntype, 120, 110, 160); node_type_label(&ntype, node_math_label); node_type_storage(&ntype, "node_math", NULL, NULL); - node_type_exec(&ntype, node_shader_exec_math); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_math); node_type_gpu(&ntype, gpu_shader_math); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_mixRgb.c b/source/blender/nodes/shader/nodes/node_shader_mixRgb.c index 18dcc8f7fef..2bbdf91dc65 100644 --- a/source/blender/nodes/shader/nodes/node_shader_mixRgb.c +++ b/source/blender/nodes/shader/nodes/node_shader_mixRgb.c @@ -44,7 +44,7 @@ static bNodeSocketTemplate sh_node_mix_rgb_out[] = { { -1, 0, "" } }; -static void node_shader_exec_mix_rgb(void *UNUSED(data), bNode *node, bNodeStack **in, bNodeStack **out) +static void node_shader_exec_mix_rgb(void *UNUSED(data), int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { /* stack order in: fac, col1, col2 */ /* stack order out: col */ @@ -62,7 +62,7 @@ static void node_shader_exec_mix_rgb(void *UNUSED(data), bNode *node, bNodeStack copy_v3_v3(out[0]->vec, col); } -static int gpu_shader_mix_rgb(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_mix_rgb(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { static const char *names[] = {"mix_blend", "mix_add", "mix_mult", "mix_sub", "mix_screen", "mix_div", "mix_diff", "mix_dark", "mix_light", @@ -73,17 +73,17 @@ static int gpu_shader_mix_rgb(GPUMaterial *mat, bNode *node, GPUNodeStack *in, G } -void register_node_type_sh_mix_rgb(bNodeTreeType *ttype) +void register_node_type_sh_mix_rgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_mix_rgb_in, sh_node_mix_rgb_out); node_type_size(&ntype, 100, 60, 150); node_type_label(&ntype, node_blend_label); - node_type_exec(&ntype, node_shader_exec_mix_rgb); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_mix_rgb); node_type_gpu(&ntype, gpu_shader_mix_rgb); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_mix_shader.c b/source/blender/nodes/shader/nodes/node_shader_mix_shader.c index 039e63a4dea..56178a8ddbe 100644 --- a/source/blender/nodes/shader/nodes/node_shader_mix_shader.c +++ b/source/blender/nodes/shader/nodes/node_shader_mix_shader.c @@ -41,24 +41,23 @@ static bNodeSocketTemplate sh_node_mix_shader_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_mix_shader(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_mix_shader(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_mix_shader", in, out); } /* node type definition */ -void register_node_type_sh_mix_shader(bNodeTreeType *ttype) +void register_node_type_sh_mix_shader() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_MIX_SHADER, "Mix Shader", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_MIX_SHADER, "Mix Shader", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_mix_shader_in, sh_node_mix_shader_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_mix_shader); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_normal.c b/source/blender/nodes/shader/nodes/node_shader_normal.c index 0ad58d6af76..a1f00ee0c33 100644 --- a/source/blender/nodes/shader/nodes/node_shader_normal.c +++ b/source/blender/nodes/shader/nodes/node_shader_normal.c @@ -39,26 +39,14 @@ static bNodeSocketTemplate sh_node_normal_in[] = { }; static bNodeSocketTemplate sh_node_normal_out[] = { - { SOCK_VECTOR, 0, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_DIRECTION}, + { SOCK_VECTOR, 0, N_("Normal"), 0.0f, 0.0f, 1.0f, 0.0f, -1.0f, 1.0f, PROP_DIRECTION}, { SOCK_FLOAT, 0, N_("Dot")}, { -1, 0, "" } }; -static void node_shader_init_normal(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) -{ - bNodeSocket *sock= node->outputs.first; - bNodeSocketValueVector *dval= (bNodeSocketValueVector*)sock->default_value; - - /* output value is used for normal vector */ - dval->value[0] = 0.0f; - dval->value[1] = 0.0f; - dval->value[2] = 1.0f; -} - /* generates normal, does dot product */ -static void node_shader_exec_normal(void *UNUSED(data), bNode *node, bNodeStack **in, bNodeStack **out) +static void node_shader_exec_normal(void *UNUSED(data), int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { - bNodeSocket *sock= node->outputs.first; float vec[3]; /* stack order input: normal */ @@ -66,29 +54,25 @@ static void node_shader_exec_normal(void *UNUSED(data), bNode *node, bNodeStack nodestack_get_vec(vec, SOCK_VECTOR, in[0]); - copy_v3_v3(out[0]->vec, ((bNodeSocketValueVector*)sock->default_value)->value); /* render normals point inside... the widget points outside */ - out[1]->vec[0] = -dot_v3v3(out[0]->vec, vec); + out[1]->vec[0] = -dot_v3v3(vec, out[0]->vec); } -static int gpu_shader_normal(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_normal(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { - bNodeSocket *sock= node->outputs.first; - GPUNodeLink *vec = GPU_uniform(((bNodeSocketValueVector*)sock->default_value)->value); - + GPUNodeLink *vec = GPU_uniform(out[0].vec); return GPU_stack_link(mat, "normal", in, out, vec); } -void register_node_type_sh_normal(bNodeTreeType *ttype) +void register_node_type_sh_normal() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_NORMAL, "Normal", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_NORMAL, "Normal", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_normal_in, sh_node_normal_out); - node_type_init(&ntype, node_shader_init_normal); - node_type_exec(&ntype, node_shader_exec_normal); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_normal); node_type_gpu(&ntype, gpu_shader_normal); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_normal_map.c b/source/blender/nodes/shader/nodes/node_shader_normal_map.c index 6a4eb9d81df..bca1b0e2798 100644 --- a/source/blender/nodes/shader/nodes/node_shader_normal_map.c +++ b/source/blender/nodes/shader/nodes/node_shader_normal_map.c @@ -40,31 +40,30 @@ static bNodeSocketTemplate sh_node_normal_map_out[] = { { -1, 0, "" } }; -static void node_shader_init_normal_map(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_normal_map(bNodeTree *UNUSED(ntree), bNode *node) { NodeShaderNormalMap *attr = MEM_callocN(sizeof(NodeShaderNormalMap), "NodeShaderNormalMap"); node->storage = attr; } -static int gpu_shader_normal_map(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_normal_map(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_normal_map", in, out, GPU_builtin(GPU_VIEW_NORMAL)); } /* node type definition */ -void register_node_type_sh_normal_map(bNodeTreeType *ttype) +void register_node_type_sh_normal_map() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_NORMAL_MAP, "Normal Map", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_NORMAL_MAP, "Normal Map", NODE_CLASS_OP_VECTOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_normal_map_in, sh_node_normal_map_out); node_type_size(&ntype, 250, 60, 250); node_type_init(&ntype, node_shader_init_normal_map); node_type_storage(&ntype, "NodeShaderNormalMap", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, gpu_shader_normal_map); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_object_info.c b/source/blender/nodes/shader/nodes/node_shader_object_info.c index ef283004d46..d00037546ea 100644 --- a/source/blender/nodes/shader/nodes/node_shader_object_info.c +++ b/source/blender/nodes/shader/nodes/node_shader_object_info.c @@ -37,25 +37,24 @@ static bNodeSocketTemplate sh_node_object_info_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_object_info(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_object_info(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "node_object_info", in, out); } /* node type definition */ -void register_node_type_sh_object_info(bNodeTreeType *ttype) +void register_node_type_sh_object_info(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_OBJECT_INFO, "Object Info", NODE_CLASS_INPUT, 0); + sh_node_type_base(&ntype, SH_NODE_OBJECT_INFO, "Object Info", NODE_CLASS_INPUT, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, sh_node_object_info_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_object_info); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_output.c b/source/blender/nodes/shader/nodes/node_shader_output.c index 6f7f900aecd..4c2fdf146da 100644 --- a/source/blender/nodes/shader/nodes/node_shader_output.c +++ b/source/blender/nodes/shader/nodes/node_shader_output.c @@ -39,7 +39,7 @@ static bNodeSocketTemplate sh_node_output_in[] = { { -1, 0, "" } }; -static void node_shader_exec_output(void *data, bNode *node, bNodeStack **in, bNodeStack **UNUSED(out)) +static void node_shader_exec_output(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **UNUSED(out)) { if (data) { ShadeInput *shi= ((ShaderCallData *)data)->shi; @@ -50,7 +50,7 @@ static void node_shader_exec_output(void *data, bNode *node, bNodeStack **in, bN nodestack_get_vec(col+3, SOCK_FLOAT, in[1]); if (shi->do_preview) { - nodeAddToPreview(node, col, shi->xs, shi->ys, shi->do_manage); + BKE_node_preview_set_pixel(execdata->preview, col, shi->xs, shi->ys, shi->do_manage); node->lasty= shi->ys; } @@ -65,7 +65,7 @@ static void node_shader_exec_output(void *data, bNode *node, bNodeStack **in, bN } } -static int gpu_shader_output(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_output(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { GPUNodeLink *outlink; @@ -80,19 +80,19 @@ static int gpu_shader_output(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack return 1; } -void register_node_type_sh_output(bNodeTreeType *ttype) +void register_node_type_sh_output() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_OUTPUT, "Output", NODE_CLASS_OUTPUT, NODE_PREVIEW); + sh_node_type_base(&ntype, SH_NODE_OUTPUT, "Output", NODE_CLASS_OUTPUT, NODE_PREVIEW); node_type_compatibility(&ntype, NODE_OLD_SHADING); node_type_socket_templates(&ntype, sh_node_output_in, NULL); node_type_size(&ntype, 80, 60, 200); - node_type_exec(&ntype, node_shader_exec_output); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_output); node_type_gpu(&ntype, gpu_shader_output); /* Do not allow muting output node. */ node_type_internal_links(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_output_lamp.c b/source/blender/nodes/shader/nodes/node_shader_output_lamp.c index ce406a8f5a1..e44326428b5 100644 --- a/source/blender/nodes/shader/nodes/node_shader_output_lamp.c +++ b/source/blender/nodes/shader/nodes/node_shader_output_lamp.c @@ -35,21 +35,19 @@ static bNodeSocketTemplate sh_node_output_lamp_in[] = { }; /* node type definition */ -void register_node_type_sh_output_lamp(bNodeTreeType *ttype) +void register_node_type_sh_output_lamp() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_OUTPUT_LAMP, "Lamp Output", NODE_CLASS_OUTPUT, 0); + sh_node_type_base(&ntype, SH_NODE_OUTPUT_LAMP, "Lamp Output", NODE_CLASS_OUTPUT, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_output_lamp_in, NULL); node_type_size(&ntype, 120, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); - node_type_gpu(&ntype, NULL); /* Do not allow muting output node. */ node_type_internal_links(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_output_material.c b/source/blender/nodes/shader/nodes/node_shader_output_material.c index f185e13010b..90030d6699b 100644 --- a/source/blender/nodes/shader/nodes/node_shader_output_material.c +++ b/source/blender/nodes/shader/nodes/node_shader_output_material.c @@ -36,7 +36,7 @@ static bNodeSocketTemplate sh_node_output_material_in[] = { { -1, 0, "" } }; -static int node_shader_gpu_output_material(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_output_material(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { GPUNodeLink *outlink; @@ -48,21 +48,20 @@ static int node_shader_gpu_output_material(GPUMaterial *mat, bNode *UNUSED(node) /* node type definition */ -void register_node_type_sh_output_material(bNodeTreeType *ttype) +void register_node_type_sh_output_material() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_OUTPUT_MATERIAL, "Material Output", NODE_CLASS_OUTPUT, 0); + sh_node_type_base(&ntype, SH_NODE_OUTPUT_MATERIAL, "Material Output", NODE_CLASS_OUTPUT, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_output_material_in, NULL); node_type_size(&ntype, 120, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_output_material); /* Do not allow muting output node. */ node_type_internal_links(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_output_world.c b/source/blender/nodes/shader/nodes/node_shader_output_world.c index 953197ab2cd..e9a60bd34e3 100644 --- a/source/blender/nodes/shader/nodes/node_shader_output_world.c +++ b/source/blender/nodes/shader/nodes/node_shader_output_world.c @@ -36,21 +36,19 @@ static bNodeSocketTemplate sh_node_output_world_in[] = { }; /* node type definition */ -void register_node_type_sh_output_world(bNodeTreeType *ttype) +void register_node_type_sh_output_world() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_OUTPUT_WORLD, "World Output", NODE_CLASS_OUTPUT, 0); + sh_node_type_base(&ntype, SH_NODE_OUTPUT_WORLD, "World Output", NODE_CLASS_OUTPUT, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_output_world_in, NULL); node_type_size(&ntype, 120, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); - node_type_gpu(&ntype, NULL); /* Do not allow muting output node. */ node_type_internal_links(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_particle_info.c b/source/blender/nodes/shader/nodes/node_shader_particle_info.c index c7e31d117cc..e4d91d524d2 100644 --- a/source/blender/nodes/shader/nodes/node_shader_particle_info.c +++ b/source/blender/nodes/shader/nodes/node_shader_particle_info.c @@ -42,15 +42,15 @@ static bNodeSocketTemplate outputs[] = { }; /* node type definition */ -void register_node_type_sh_particle_info(bNodeTreeType *ttype) +void register_node_type_sh_particle_info(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_PARTICLE_INFO, "Particle Info", NODE_CLASS_INPUT, 0); + sh_node_type_base(&ntype, SH_NODE_PARTICLE_INFO, "Particle Info", NODE_CLASS_INPUT, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, outputs); node_type_size(&ntype, 150, 60, 200); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_rgb.c b/source/blender/nodes/shader/nodes/node_shader_rgb.c index f37ff1d511b..b3215fc6803 100644 --- a/source/blender/nodes/shader/nodes/node_shader_rgb.c +++ b/source/blender/nodes/shader/nodes/node_shader_rgb.c @@ -34,49 +34,25 @@ /* **************** RGB ******************** */ static bNodeSocketTemplate sh_node_rgb_out[] = { - { SOCK_RGBA, 0, N_("Color")}, + { SOCK_RGBA, 0, N_("Color"), 0.5f, 0.5f, 0.5f, 1.0f}, { -1, 0, "" } }; -static void node_shader_init_rgb(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static int gpu_shader_rgb(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { - bNodeSocket *sock= node->outputs.first; - bNodeSocketValueRGBA *dval= (bNodeSocketValueRGBA*)sock->default_value; - /* uses the default value of the output socket, must be initialized here */ - dval->value[0] = 0.5f; - dval->value[1] = 0.5f; - dval->value[2] = 0.5f; - dval->value[3] = 1.0f; -} - -static void node_shader_exec_rgb(void *UNUSED(data), bNode *node, bNodeStack **UNUSED(in), bNodeStack **out) -{ - bNodeSocket *sock= node->outputs.first; - float *col= ((bNodeSocketValueRGBA*)sock->default_value)->value; - - copy_v3_v3(out[0]->vec, col); -} - -static int gpu_shader_rgb(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) -{ - bNodeSocket *sock= node->outputs.first; - float *col= ((bNodeSocketValueRGBA*)sock->default_value)->value; - GPUNodeLink *vec = GPU_uniform(col); - + GPUNodeLink *vec = GPU_uniform(out[0].vec); return GPU_stack_link(mat, "set_rgba", in, out, vec); } -void register_node_type_sh_rgb(bNodeTreeType *ttype) +void register_node_type_sh_rgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_RGB, "RGB", NODE_CLASS_INPUT, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_RGB, "RGB", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, sh_node_rgb_out); - node_type_init(&ntype, node_shader_init_rgb); node_type_size(&ntype, 140, 80, 140); - node_type_exec(&ntype, node_shader_exec_rgb); node_type_gpu(&ntype, gpu_shader_rgb); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_script.c b/source/blender/nodes/shader/nodes/node_shader_script.c index b5563658a64..8b4c2702474 100644 --- a/source/blender/nodes/shader/nodes/node_shader_script.c +++ b/source/blender/nodes/shader/nodes/node_shader_script.c @@ -35,7 +35,7 @@ /* **************** Script ******************** */ -static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void init(bNodeTree *UNUSED(ntree), bNode *node) { NodeShaderScript *nss = MEM_callocN(sizeof(NodeShaderScript), "shader script node"); node->storage = nss; @@ -50,37 +50,29 @@ static void node_free_script(bNode *node) MEM_freeN(nss->bytecode); } - if (nss->prop) { - IDP_FreeProperty(nss->prop); - MEM_freeN(nss->prop); - } - MEM_freeN(nss); } } -static void node_copy_script(bNode *orig_node, bNode *new_node) +static void node_copy_script(bNodeTree *UNUSED(dest_ntree), bNode *dest_node, bNode *src_node) { - NodeShaderScript *orig_nss = orig_node->storage; - NodeShaderScript *new_nss = MEM_dupallocN(orig_nss); - - if (orig_nss->bytecode) - new_nss->bytecode = MEM_dupallocN(orig_nss->bytecode); + NodeShaderScript *src_nss = src_node->storage; + NodeShaderScript *dest_nss = MEM_dupallocN(src_nss); - if (orig_nss->prop) - new_nss->prop = IDP_CopyProperty(orig_nss->prop); + if (src_nss->bytecode) + dest_nss->bytecode = MEM_dupallocN(src_nss->bytecode); - new_node->storage = new_nss; + dest_node->storage = dest_nss; } -void register_node_type_sh_script(bNodeTreeType *ttype) +void register_node_type_sh_script() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_SCRIPT, "Script", NODE_CLASS_SCRIPT, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_SCRIPT, "Script", NODE_CLASS_SCRIPT, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_init(&ntype, init); node_type_storage(&ntype, "NodeShaderScript", node_free_script, node_copy_script); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_sepcombRGB.c b/source/blender/nodes/shader/nodes/node_shader_sepcombRGB.c index 70fba161de9..1f6cd3506e9 100644 --- a/source/blender/nodes/shader/nodes/node_shader_sepcombRGB.c +++ b/source/blender/nodes/shader/nodes/node_shader_sepcombRGB.c @@ -44,30 +44,30 @@ static bNodeSocketTemplate sh_node_seprgb_out[] = { { -1, 0, "" } }; -static void node_shader_exec_seprgb(void *UNUSED(data), bNode *UNUSED(node), bNodeStack **in, bNodeStack **out) +static void node_shader_exec_seprgb(void *UNUSED(data), int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { out[0]->vec[0] = in[0]->vec[0]; out[1]->vec[0] = in[0]->vec[1]; out[2]->vec[0] = in[0]->vec[2]; } -static int gpu_shader_seprgb(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_seprgb(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "separate_rgb", in, out); } -void register_node_type_sh_seprgb(bNodeTreeType *ttype) +void register_node_type_sh_seprgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_SEPRGB, "Separate RGB", NODE_CLASS_CONVERTOR, 0); + sh_node_type_base(&ntype, SH_NODE_SEPRGB, "Separate RGB", NODE_CLASS_CONVERTOR, 0); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_seprgb_in, sh_node_seprgb_out); node_type_size(&ntype, 80, 40, 140); - node_type_exec(&ntype, node_shader_exec_seprgb); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_seprgb); node_type_gpu(&ntype, gpu_shader_seprgb); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } @@ -84,28 +84,28 @@ static bNodeSocketTemplate sh_node_combrgb_out[] = { { -1, 0, "" } }; -static void node_shader_exec_combrgb(void *UNUSED(data), bNode *UNUSED(node), bNodeStack **in, bNodeStack **out) +static void node_shader_exec_combrgb(void *UNUSED(data), int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { out[0]->vec[0] = in[0]->vec[0]; out[0]->vec[1] = in[1]->vec[0]; out[0]->vec[2] = in[2]->vec[0]; } -static int gpu_shader_combrgb(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_combrgb(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "combine_rgb", in, out); } -void register_node_type_sh_combrgb(bNodeTreeType *ttype) +void register_node_type_sh_combrgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_COMBRGB, "Combine RGB", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_COMBRGB, "Combine RGB", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_combrgb_in, sh_node_combrgb_out); node_type_size(&ntype, 80, 40, 140); - node_type_exec(&ntype, node_shader_exec_combrgb); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_combrgb); node_type_gpu(&ntype, gpu_shader_combrgb); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_squeeze.c b/source/blender/nodes/shader/nodes/node_shader_squeeze.c index 8073f4b01d2..538efb15cb3 100644 --- a/source/blender/nodes/shader/nodes/node_shader_squeeze.c +++ b/source/blender/nodes/shader/nodes/node_shader_squeeze.c @@ -45,7 +45,7 @@ static bNodeSocketTemplate sh_node_squeeze_out[] = { { -1, 0, "" } }; -static void node_shader_exec_squeeze(void *UNUSED(data), bNode *UNUSED(node), bNodeStack **in, bNodeStack **out) +static void node_shader_exec_squeeze(void *UNUSED(data), int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { float vec[3]; @@ -56,22 +56,22 @@ static void node_shader_exec_squeeze(void *UNUSED(data), bNode *UNUSED(node), bN out[0]->vec[0] = 1.0f / (1.0f + powf(M_E, -((vec[0] - vec[2]) * vec[1]))); } -static int gpu_shader_squeeze(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_squeeze(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "squeeze", in, out); } -void register_node_type_sh_squeeze(bNodeTreeType *ttype) +void register_node_type_sh_squeeze() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_SQUEEZE, "Squeeze Value", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_SQUEEZE, "Squeeze Value", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING); node_type_socket_templates(&ntype, sh_node_squeeze_in, sh_node_squeeze_out); node_type_size(&ntype, 120, 110, 160); node_type_storage(&ntype, "node_squeeze", NULL, NULL); - node_type_exec(&ntype, node_shader_exec_squeeze); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_squeeze); node_type_gpu(&ntype, gpu_shader_squeeze); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tangent.c b/source/blender/nodes/shader/nodes/node_shader_tangent.c index 6c0d6d7cd9f..a51c943285b 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tangent.c +++ b/source/blender/nodes/shader/nodes/node_shader_tangent.c @@ -34,7 +34,7 @@ static bNodeSocketTemplate sh_node_tangent_out[] = { { -1, 0, "" } }; -static void node_shader_init_tangent(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tangent(bNodeTree *UNUSED(ntree), bNode *node) { NodeShaderTangent *attr = MEM_callocN(sizeof(NodeShaderTangent), "NodeShaderTangent"); attr->axis = SHD_TANGENT_AXIS_Z; @@ -42,19 +42,16 @@ static void node_shader_init_tangent(bNodeTree *UNUSED(ntree), bNode *node, bNod } /* node type definition */ -void register_node_type_sh_tangent(bNodeTreeType *ttype) +void register_node_type_sh_tangent() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TANGENT, "Tangent", NODE_CLASS_INPUT, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TANGENT, "Tangent", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, sh_node_tangent_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tangent); node_type_storage(&ntype, "NodeShaderTangent", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); - node_type_gpu(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } - diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_brick.c b/source/blender/nodes/shader/nodes/node_shader_tex_brick.c index 66bf0267586..dad74d324f8 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_brick.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_brick.c @@ -48,7 +48,7 @@ static bNodeSocketTemplate sh_node_tex_brick_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_brick(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_brick(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexBrick *tex = MEM_callocN(sizeof(NodeTexBrick), "NodeTexBrick"); default_tex_mapping(&tex->base.tex_mapping); @@ -62,7 +62,7 @@ static void node_shader_init_tex_brick(bNodeTree *UNUSED(ntree), bNode* node, bN node->storage = tex; } -static int node_shader_gpu_tex_brick(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_brick(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[0].link) in[0].link = GPU_attribute(CD_ORCO, ""); @@ -73,18 +73,17 @@ static int node_shader_gpu_tex_brick(GPUMaterial *mat, bNode *node, GPUNodeStack } /* node type definition */ -void register_node_type_sh_tex_brick(bNodeTreeType *ttype) +void register_node_type_sh_tex_brick(void) { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_BRICK, "Brick Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TEX_BRICK, "Brick Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_brick_in, sh_node_tex_brick_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_brick); node_type_storage(&ntype, "NodeTexBrick", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_brick); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_checker.c b/source/blender/nodes/shader/nodes/node_shader_tex_checker.c index 8a2ae2d40dc..aff92e58f90 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_checker.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_checker.c @@ -43,7 +43,7 @@ static bNodeSocketTemplate sh_node_tex_checker_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_checker(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_checker(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexChecker *tex = MEM_callocN(sizeof(NodeTexChecker), "NodeTexChecker"); default_tex_mapping(&tex->base.tex_mapping); @@ -52,7 +52,7 @@ static void node_shader_init_tex_checker(bNodeTree *UNUSED(ntree), bNode *node, node->storage = tex; } -static int node_shader_gpu_tex_checker(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_checker(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[0].link) in[0].link = GPU_attribute(CD_ORCO, ""); @@ -63,18 +63,17 @@ static int node_shader_gpu_tex_checker(GPUMaterial *mat, bNode *node, GPUNodeSta } /* node type definition */ -void register_node_type_sh_tex_checker(bNodeTreeType *ttype) +void register_node_type_sh_tex_checker() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_CHECKER, "Checker Texture", NODE_CLASS_TEXTURE, 0); + sh_node_type_base(&ntype, SH_NODE_TEX_CHECKER, "Checker Texture", NODE_CLASS_TEXTURE, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_checker_in, sh_node_tex_checker_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_checker); node_type_storage(&ntype, "NodeTexChecker", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_checker); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_coord.c b/source/blender/nodes/shader/nodes/node_shader_tex_coord.c index dd717874951..d2b69aebf96 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_coord.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_coord.c @@ -42,7 +42,7 @@ static bNodeSocketTemplate sh_node_tex_coord_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_tex_coord(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_coord(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { GPUNodeLink *orco = GPU_attribute(CD_ORCO, ""); GPUNodeLink *mtface = GPU_attribute(CD_MTFACE, ""); @@ -53,18 +53,17 @@ static int node_shader_gpu_tex_coord(GPUMaterial *mat, bNode *UNUSED(node), GPUN } /* node type definition */ -void register_node_type_sh_tex_coord(bNodeTreeType *ttype) +void register_node_type_sh_tex_coord() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_COORD, "Texture Coordinate", NODE_CLASS_INPUT, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TEX_COORD, "Texture Coordinate", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, sh_node_tex_coord_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_coord); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_environment.c b/source/blender/nodes/shader/nodes/node_shader_tex_environment.c index d2d0870e2ed..25cc892c944 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_environment.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_environment.c @@ -41,7 +41,7 @@ static bNodeSocketTemplate sh_node_tex_environment_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_environment(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_environment(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexEnvironment *tex = MEM_callocN(sizeof(NodeTexEnvironment), "NodeTexEnvironment"); default_tex_mapping(&tex->base.tex_mapping); @@ -56,7 +56,7 @@ static void node_shader_init_tex_environment(bNodeTree *UNUSED(ntree), bNode *no node->storage = tex; } -static int node_shader_gpu_tex_environment(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_environment(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { Image *ima= (Image*)node->id; ImageUser *iuser= NULL; @@ -88,18 +88,17 @@ static int node_shader_gpu_tex_environment(GPUMaterial *mat, bNode *node, GPUNod } /* node type definition */ -void register_node_type_sh_tex_environment(bNodeTreeType *ttype) +void register_node_type_sh_tex_environment() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_ENVIRONMENT, "Environment Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TEX_ENVIRONMENT, "Environment Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_environment_in, sh_node_tex_environment_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_environment); node_type_storage(&ntype, "NodeTexEnvironment", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_environment); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_gradient.c b/source/blender/nodes/shader/nodes/node_shader_tex_gradient.c index 0802ecdea1d..ab962c946f2 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_gradient.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_gradient.c @@ -40,7 +40,7 @@ static bNodeSocketTemplate sh_node_tex_gradient_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_gradient(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_gradient(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexGradient *tex = MEM_callocN(sizeof(NodeTexGradient), "NodeTexGradient"); default_tex_mapping(&tex->base.tex_mapping); @@ -50,7 +50,7 @@ static void node_shader_init_tex_gradient(bNodeTree *UNUSED(ntree), bNode *node, node->storage = tex; } -static int node_shader_gpu_tex_gradient(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_gradient(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[0].link) in[0].link = GPU_attribute(CD_ORCO, ""); @@ -61,18 +61,17 @@ static int node_shader_gpu_tex_gradient(GPUMaterial *mat, bNode *node, GPUNodeSt } /* node type definition */ -void register_node_type_sh_tex_gradient(bNodeTreeType *ttype) +void register_node_type_sh_tex_gradient() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_GRADIENT, "Gradient Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TEX_GRADIENT, "Gradient Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_gradient_in, sh_node_tex_gradient_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_gradient); node_type_storage(&ntype, "NodeTexGradient", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_gradient); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_image.c b/source/blender/nodes/shader/nodes/node_shader_tex_image.c index 49b38434246..a30acd80712 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_image.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_image.c @@ -42,7 +42,7 @@ static bNodeSocketTemplate sh_node_tex_image_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_image(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_image(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexImage *tex = MEM_callocN(sizeof(NodeTexImage), "NodeTexImage"); default_tex_mapping(&tex->base.tex_mapping); @@ -56,7 +56,7 @@ static void node_shader_init_tex_image(bNodeTree *UNUSED(ntree), bNode *node, bN node->storage = tex; } -static int node_shader_gpu_tex_image(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_image(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { Image *ima= (Image*)node->id; ImageUser *iuser= NULL; @@ -88,18 +88,17 @@ static int node_shader_gpu_tex_image(GPUMaterial *mat, bNode *node, GPUNodeStack } /* node type definition */ -void register_node_type_sh_tex_image(bNodeTreeType *ttype) +void register_node_type_sh_tex_image() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_IMAGE, "Image Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TEX_IMAGE, "Image Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_image_in, sh_node_tex_image_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_image); node_type_storage(&ntype, "NodeTexImage", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_image); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_magic.c b/source/blender/nodes/shader/nodes/node_shader_tex_magic.c index 86feabbcc2b..8d32cac9dab 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_magic.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_magic.c @@ -42,7 +42,7 @@ static bNodeSocketTemplate sh_node_tex_magic_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_magic(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_magic(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexMagic *tex = MEM_callocN(sizeof(NodeTexMagic), "NodeTexMagic"); default_tex_mapping(&tex->base.tex_mapping); @@ -52,7 +52,7 @@ static void node_shader_init_tex_magic(bNodeTree *UNUSED(ntree), bNode *node, bN node->storage = tex; } -static int node_shader_gpu_tex_magic(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_magic(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { NodeTexMagic *tex = (NodeTexMagic*)node->storage; float depth = tex->depth; @@ -66,18 +66,17 @@ static int node_shader_gpu_tex_magic(GPUMaterial *mat, bNode *node, GPUNodeStack } /* node type definition */ -void register_node_type_sh_tex_magic(bNodeTreeType *ttype) +void register_node_type_sh_tex_magic() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_MAGIC, "Magic Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TEX_MAGIC, "Magic Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_magic_in, sh_node_tex_magic_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_magic); node_type_storage(&ntype, "NodeTexMagic", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_magic); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.c b/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.c index cd4b5743e14..d4f7c9d0c1c 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.c @@ -46,7 +46,7 @@ static bNodeSocketTemplate sh_node_tex_musgrave_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_musgrave(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_musgrave(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexMusgrave *tex = MEM_callocN(sizeof(NodeTexMusgrave), "NodeTexMusgrave"); default_tex_mapping(&tex->base.tex_mapping); @@ -56,7 +56,7 @@ static void node_shader_init_tex_musgrave(bNodeTree *UNUSED(ntree), bNode *node, node->storage = tex; } -static int node_shader_gpu_tex_musgrave(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_musgrave(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[0].link) in[0].link = GPU_attribute(CD_ORCO, ""); @@ -67,18 +67,17 @@ static int node_shader_gpu_tex_musgrave(GPUMaterial *mat, bNode *node, GPUNodeSt } /* node type definition */ -void register_node_type_sh_tex_musgrave(bNodeTreeType *ttype) +void register_node_type_sh_tex_musgrave() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_MUSGRAVE, "Musgrave Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TEX_MUSGRAVE, "Musgrave Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_musgrave_in, sh_node_tex_musgrave_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_musgrave); node_type_storage(&ntype, "NodeTexMusgrave", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_musgrave); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_noise.c b/source/blender/nodes/shader/nodes/node_shader_tex_noise.c index 18788f9e72c..0143645f448 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_noise.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_noise.c @@ -43,7 +43,7 @@ static bNodeSocketTemplate sh_node_tex_noise_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_noise(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_noise(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexNoise *tex = MEM_callocN(sizeof(NodeTexNoise), "NodeTexNoise"); default_tex_mapping(&tex->base.tex_mapping); @@ -52,7 +52,7 @@ static void node_shader_init_tex_noise(bNodeTree *UNUSED(ntree), bNode *node, bN node->storage = tex; } -static int node_shader_gpu_tex_noise(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_noise(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[0].link) in[0].link = GPU_attribute(CD_ORCO, ""); @@ -63,18 +63,17 @@ static int node_shader_gpu_tex_noise(GPUMaterial *mat, bNode *node, GPUNodeStack } /* node type definition */ -void register_node_type_sh_tex_noise(bNodeTreeType *ttype) +void register_node_type_sh_tex_noise() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_NOISE, "Noise Texture", NODE_CLASS_TEXTURE, 0); + sh_node_type_base(&ntype, SH_NODE_TEX_NOISE, "Noise Texture", NODE_CLASS_TEXTURE, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_noise_in, sh_node_tex_noise_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_noise); node_type_storage(&ntype, "NodeTexNoise", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_noise); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_sky.c b/source/blender/nodes/shader/nodes/node_shader_tex_sky.c index 7a1b853a7f4..2aa977bade6 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_sky.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_sky.c @@ -39,7 +39,7 @@ static bNodeSocketTemplate sh_node_tex_sky_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_sky(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_sky(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexSky *tex = MEM_callocN(sizeof(NodeTexSky), "NodeTexSky"); default_tex_mapping(&tex->base.tex_mapping); @@ -52,7 +52,7 @@ static void node_shader_init_tex_sky(bNodeTree *UNUSED(ntree), bNode *node, bNod node->storage = tex; } -static int node_shader_gpu_tex_sky(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_sky(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[0].link) in[0].link = GPU_attribute(CD_ORCO, ""); @@ -63,18 +63,17 @@ static int node_shader_gpu_tex_sky(GPUMaterial *mat, bNode *node, GPUNodeStack * } /* node type definition */ -void register_node_type_sh_tex_sky(bNodeTreeType *ttype) +void register_node_type_sh_tex_sky() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_SKY, "Sky Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TEX_SKY, "Sky Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_sky_in, sh_node_tex_sky_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_sky); node_type_storage(&ntype, "NodeTexSky", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_sky); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.c b/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.c index d4cc24687b3..cf7d775914e 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.c @@ -41,7 +41,7 @@ static bNodeSocketTemplate sh_node_tex_voronoi_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_voronoi(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_voronoi(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexVoronoi *tex = MEM_callocN(sizeof(NodeTexVoronoi), "NodeTexVoronoi"); default_tex_mapping(&tex->base.tex_mapping); @@ -51,7 +51,7 @@ static void node_shader_init_tex_voronoi(bNodeTree *UNUSED(ntree), bNode *node, node->storage = tex; } -static int node_shader_gpu_tex_voronoi(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_voronoi(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[0].link) in[0].link = GPU_attribute(CD_ORCO, ""); @@ -62,18 +62,17 @@ static int node_shader_gpu_tex_voronoi(GPUMaterial *mat, bNode *node, GPUNodeSta } /* node type definition */ -void register_node_type_sh_tex_voronoi(bNodeTreeType *ttype) +void register_node_type_sh_tex_voronoi() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_VORONOI, "Voronoi Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TEX_VORONOI, "Voronoi Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_voronoi_in, sh_node_tex_voronoi_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_voronoi); node_type_storage(&ntype, "NodeTexVoronoi", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_voronoi); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_wave.c b/source/blender/nodes/shader/nodes/node_shader_tex_wave.c index 8b23de0310c..2f085df8d07 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_wave.c +++ b/source/blender/nodes/shader/nodes/node_shader_tex_wave.c @@ -44,7 +44,7 @@ static bNodeSocketTemplate sh_node_tex_wave_out[] = { { -1, 0, "" } }; -static void node_shader_init_tex_wave(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_tex_wave(bNodeTree *UNUSED(ntree), bNode *node) { NodeTexWave *tex = MEM_callocN(sizeof(NodeTexWave), "NodeTexWave"); default_tex_mapping(&tex->base.tex_mapping); @@ -54,7 +54,7 @@ static void node_shader_init_tex_wave(bNodeTree *UNUSED(ntree), bNode *node, bNo node->storage = tex; } -static int node_shader_gpu_tex_wave(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int node_shader_gpu_tex_wave(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { if (!in[0].link) in[0].link = GPU_attribute(CD_ORCO, ""); @@ -65,18 +65,17 @@ static int node_shader_gpu_tex_wave(GPUMaterial *mat, bNode *node, GPUNodeStack } /* node type definition */ -void register_node_type_sh_tex_wave(bNodeTreeType *ttype) +void register_node_type_sh_tex_wave() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEX_WAVE, "Wave Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_TEX_WAVE, "Wave Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_tex_wave_in, sh_node_tex_wave_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, node_shader_init_tex_wave); node_type_storage(&ntype, "NodeTexWave", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_tex_wave); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_texture.c b/source/blender/nodes/shader/nodes/node_shader_texture.c index ec238b62408..4f6cc574be3 100644 --- a/source/blender/nodes/shader/nodes/node_shader_texture.c +++ b/source/blender/nodes/shader/nodes/node_shader_texture.c @@ -48,7 +48,7 @@ static bNodeSocketTemplate sh_node_texture_out[] = { { -1, 0, "" } }; -static void node_shader_exec_texture(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void node_shader_exec_texture(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { if (data && node->id) { ShadeInput *shi= ((ShaderCallData *)data)->shi; @@ -113,13 +113,14 @@ static void node_shader_exec_texture(void *data, bNode *node, bNodeStack **in, b copy_v3_v3(out[2]->vec, nor); - if (shi->do_preview) - nodeAddToPreview(node, out[1]->vec, shi->xs, shi->ys, shi->do_manage); + if (shi->do_preview) { + BKE_node_preview_set_pixel(execdata->preview, out[1]->vec, shi->xs, shi->ys, shi->do_manage); + } } } -static int gpu_shader_texture(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_texture(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { Tex *tex = (Tex*)node->id; @@ -143,16 +144,16 @@ static int gpu_shader_texture(GPUMaterial *mat, bNode *node, GPUNodeStack *in, G return 0; } -void register_node_type_sh_texture(bNodeTreeType *ttype) +void register_node_type_sh_texture() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW); + sh_node_type_base(&ntype, SH_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW); node_type_compatibility(&ntype, NODE_OLD_SHADING); node_type_socket_templates(&ntype, sh_node_texture_in, sh_node_texture_out); node_type_size(&ntype, 120, 80, 240); - node_type_exec(&ntype, node_shader_exec_texture); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_texture); node_type_gpu(&ntype, gpu_shader_texture); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_valToRgb.c b/source/blender/nodes/shader/nodes/node_shader_valToRgb.c index 182487d343e..e70ac6b700e 100644 --- a/source/blender/nodes/shader/nodes/node_shader_valToRgb.c +++ b/source/blender/nodes/shader/nodes/node_shader_valToRgb.c @@ -43,7 +43,7 @@ static bNodeSocketTemplate sh_node_valtorgb_out[] = { { -1, 0, "" } }; -static void node_shader_exec_valtorgb(void *UNUSED(data), bNode *node, bNodeStack **in, bNodeStack **out) +static void node_shader_exec_valtorgb(void *UNUSED(data), int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { /* stack order in: fac */ /* stack order out: col, alpha */ @@ -57,12 +57,12 @@ static void node_shader_exec_valtorgb(void *UNUSED(data), bNode *node, bNodeStac } } -static void node_shader_init_valtorgb(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void node_shader_init_valtorgb(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= add_colorband(1); } -static int gpu_shader_valtorgb(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_valtorgb(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { float *array; int size; @@ -71,20 +71,20 @@ static int gpu_shader_valtorgb(GPUMaterial *mat, bNode *node, GPUNodeStack *in, return GPU_stack_link(mat, "valtorgb", in, out, GPU_texture(size, array)); } -void register_node_type_sh_valtorgb(bNodeTreeType *ttype) +void register_node_type_sh_valtorgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_valtorgb_in, sh_node_valtorgb_out); node_type_size(&ntype, 240, 200, 300); node_type_init(&ntype, node_shader_init_valtorgb); node_type_storage(&ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, node_shader_exec_valtorgb); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_valtorgb); node_type_gpu(&ntype, gpu_shader_valtorgb); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } @@ -99,7 +99,7 @@ static bNodeSocketTemplate sh_node_rgbtobw_out[] = { }; -static void node_shader_exec_rgbtobw(void *UNUSED(data), bNode *UNUSED(node), bNodeStack **in, bNodeStack **out) +static void node_shader_exec_rgbtobw(void *UNUSED(data), int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { /* stack order out: bw */ /* stack order in: col */ @@ -107,21 +107,21 @@ static void node_shader_exec_rgbtobw(void *UNUSED(data), bNode *UNUSED(node), bN out[0]->vec[0] = rgb_to_bw(in[0]->vec); } -static int gpu_shader_rgbtobw(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_rgbtobw(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { return GPU_stack_link(mat, "rgbtobw", in, out); } -void register_node_type_sh_rgbtobw(bNodeTreeType *ttype) +void register_node_type_sh_rgbtobw() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTOR, 0); + sh_node_type_base(&ntype, SH_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTOR, 0); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_rgbtobw_in, sh_node_rgbtobw_out); node_type_size(&ntype, 80, 40, 120); - node_type_exec(&ntype, node_shader_exec_rgbtobw); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_rgbtobw); node_type_gpu(&ntype, gpu_shader_rgbtobw); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_value.c b/source/blender/nodes/shader/nodes/node_shader_value.c index a3d1e5afec2..00a23283a14 100644 --- a/source/blender/nodes/shader/nodes/node_shader_value.c +++ b/source/blender/nodes/shader/nodes/node_shader_value.c @@ -34,49 +34,25 @@ /* **************** VALUE ******************** */ static bNodeSocketTemplate sh_node_value_out[] = { - /* XXX value nodes use the output sockets for buttons, so we need explicit limits here! */ - { SOCK_FLOAT, 0, N_("Value"), 0.0f, 0.0f, 0.0f, 0.0f, -FLT_MAX, FLT_MAX}, + { SOCK_FLOAT, 0, N_("Value"), 0.5f, 0, 0, 0, -FLT_MAX, FLT_MAX, PROP_NONE}, { -1, 0, "" } }; -static void node_shader_init_value(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static int gpu_shader_value(GPUMaterial *mat, bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { - bNodeSocket *sock= node->outputs.first; - bNodeSocketValueFloat *dval= (bNodeSocketValueFloat*)sock->default_value; - /* uses the default value of the output socket, must be initialized here */ - dval->value = 0.5f; - dval->min = -FLT_MAX; - dval->max = FLT_MAX; -} - -static void node_shader_exec_value(void *UNUSED(data), bNode *node, bNodeStack **UNUSED(in), bNodeStack **out) -{ - bNodeSocket *sock= node->outputs.first; - float val= ((bNodeSocketValueFloat*)sock->default_value)->value; - - out[0]->vec[0] = val; -} - -static int gpu_shader_value(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) -{ - bNodeSocket *sock= node->outputs.first; - float *val= &((bNodeSocketValueFloat*)sock->default_value)->value; - GPUNodeLink *vec = GPU_uniform(val); - + GPUNodeLink *vec = GPU_uniform(out[0].vec); return GPU_stack_link(mat, "set_value", in, out, vec); } -void register_node_type_sh_value(bNodeTreeType *ttype) +void register_node_type_sh_value() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_VALUE, "Value", NODE_CLASS_INPUT, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_VALUE, "Value", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, NULL, sh_node_value_out); - node_type_init(&ntype, node_shader_init_value); node_type_size(&ntype, 80, 50, 120); - node_type_exec(&ntype, node_shader_exec_value); node_type_gpu(&ntype, gpu_shader_value); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_vectMath.c b/source/blender/nodes/shader/nodes/node_shader_vectMath.c index 3e00421ddf0..7a76f408916 100644 --- a/source/blender/nodes/shader/nodes/node_shader_vectMath.c +++ b/source/blender/nodes/shader/nodes/node_shader_vectMath.c @@ -47,7 +47,7 @@ static bNodeSocketTemplate sh_node_vect_math_out[] = { { -1, 0, "" } }; -static void node_shader_exec_vect_math(void *UNUSED(data), bNode *node, bNodeStack **in, bNodeStack **out) +static void node_shader_exec_vect_math(void *UNUSED(data), int UNUSED(thread), bNode *node, bNodeExecData *UNUSED(execdata), bNodeStack **in, bNodeStack **out) { float vec1[3], vec2[3]; @@ -102,7 +102,7 @@ static void node_shader_exec_vect_math(void *UNUSED(data), bNode *node, bNodeSta } -static int gpu_shader_vect_math(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out) +static int gpu_shader_vect_math(GPUMaterial *mat, bNode *node, bNodeExecData *UNUSED(execdata), GPUNodeStack *in, GPUNodeStack *out) { static const char *names[] = {"vec_math_add", "vec_math_sub", "vec_math_average", "vec_math_dot", "vec_math_cross", @@ -139,18 +139,18 @@ static int gpu_shader_vect_math(GPUMaterial *mat, bNode *node, GPUNodeStack *in, return 1; } -void register_node_type_sh_vect_math(bNodeTreeType *ttype) +void register_node_type_sh_vect_math() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_VECT_MATH, "Vector Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + sh_node_type_base(&ntype, SH_NODE_VECT_MATH, "Vector Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_vect_math_in, sh_node_vect_math_out); node_type_size(&ntype, 80, 75, 140); node_type_label(&ntype, node_vect_math_label); node_type_storage(&ntype, "node_vect_math", NULL, NULL); - node_type_exec(&ntype, node_shader_exec_vect_math); + node_type_exec(&ntype, NULL, NULL, node_shader_exec_vect_math); node_type_gpu(&ntype, gpu_shader_vect_math); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_volume_isotropic.c b/source/blender/nodes/shader/nodes/node_shader_volume_isotropic.c index 5451eb303cc..5ce62e2e15b 100644 --- a/source/blender/nodes/shader/nodes/node_shader_volume_isotropic.c +++ b/source/blender/nodes/shader/nodes/node_shader_volume_isotropic.c @@ -40,24 +40,23 @@ static bNodeSocketTemplate sh_node_volume_isotropic_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_volume_isotropic(GPUMaterial *UNUSED(mat), bNode *UNUSED(node), GPUNodeStack *UNUSED(in), GPUNodeStack *UNUSED(out)) +static int node_shader_gpu_volume_isotropic(GPUMaterial *UNUSED(mat), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *UNUSED(in), GPUNodeStack *UNUSED(out)) { return 0; } /* node type definition */ -void register_node_type_sh_volume_isotropic(bNodeTreeType *ttype) +void register_node_type_sh_volume_isotropic() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_VOLUME_ISOTROPIC, "Isotropic Volume", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_VOLUME_ISOTROPIC, "Isotropic Volume", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_volume_isotropic_in, sh_node_volume_isotropic_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_volume_isotropic); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/shader/nodes/node_shader_volume_transparent.c b/source/blender/nodes/shader/nodes/node_shader_volume_transparent.c index ad7d7fceda3..cd4ad5d0080 100644 --- a/source/blender/nodes/shader/nodes/node_shader_volume_transparent.c +++ b/source/blender/nodes/shader/nodes/node_shader_volume_transparent.c @@ -40,24 +40,23 @@ static bNodeSocketTemplate sh_node_volume_transparent_out[] = { { -1, 0, "" } }; -static int node_shader_gpu_volume_transparent(GPUMaterial *UNUSED(mat), bNode *UNUSED(node), GPUNodeStack *UNUSED(in), GPUNodeStack *UNUSED(out)) +static int node_shader_gpu_volume_transparent(GPUMaterial *UNUSED(mat), bNode *UNUSED(node), bNodeExecData *UNUSED(execdata), GPUNodeStack *UNUSED(in), GPUNodeStack *UNUSED(out)) { return 0; } /* node type definition */ -void register_node_type_sh_volume_transparent(bNodeTreeType *ttype) +void register_node_type_sh_volume_transparent() { static bNodeType ntype; - node_type_base(ttype, &ntype, SH_NODE_VOLUME_TRANSPARENT, "Transparent Volume", NODE_CLASS_SHADER, 0); + sh_node_type_base(&ntype, SH_NODE_VOLUME_TRANSPARENT, "Transparent Volume", NODE_CLASS_SHADER, 0); node_type_compatibility(&ntype, NODE_NEW_SHADING); node_type_socket_templates(&ntype, sh_node_volume_transparent_in, sh_node_volume_transparent_out); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, NULL); node_type_storage(&ntype, "", NULL, NULL); - node_type_exec(&ntype, NULL); node_type_gpu(&ntype, node_shader_gpu_volume_transparent); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/node_texture_tree.c b/source/blender/nodes/texture/node_texture_tree.c index ba94531c259..0690ccdd19f 100644 --- a/source/blender/nodes/texture/node_texture_tree.c +++ b/source/blender/nodes/texture/node_texture_tree.c @@ -34,6 +34,7 @@ #include "DNA_texture_types.h" #include "DNA_node_types.h" +#include "DNA_space_types.h" #include "BLI_listbase.h" #include "BLI_threads.h" @@ -41,9 +42,11 @@ #include "BLF_translation.h" +#include "BKE_context.h" #include "BKE_global.h" #include "BKE_main.h" #include "BKE_node.h" +#include "BKE_paint.h" #include "node_common.h" #include "node_exec.h" @@ -51,16 +54,57 @@ #include "NOD_texture.h" #include "node_texture_util.h" +#include "RNA_access.h" + #include "RE_pipeline.h" #include "RE_shader_ext.h" -static void foreach_nodetree(Main *main, void *calldata, bNodeTreeCallback func) +static void texture_get_from_context(const bContext *C, bNodeTreeType *UNUSED(treetype), bNodeTree **r_ntree, ID **r_id, ID **r_from) { - Tex *tx; - for (tx = main->tex.first; tx; tx = tx->id.next) { - if (tx->nodetree) { - func(calldata, &tx->id, tx->nodetree); + SpaceNode *snode = CTX_wm_space_node(C); + Scene *scene = CTX_data_scene(C); + Object *ob = OBACT; + Tex *tx = NULL; + + if (snode->texfrom == SNODE_TEX_OBJECT) { + if (ob) { + tx = give_current_object_texture(ob); + if (tx) { + if (ob->type == OB_LAMP) + *r_from = (ID*)ob->data; + else + *r_from = (ID*)give_current_material(ob, ob->actcol); + + /* from is not set fully for material nodes, should be ID + Node then */ + *r_id = &tx->id; + *r_ntree = tx->nodetree; + } + } + } + else if (snode->texfrom == SNODE_TEX_WORLD) { + tx = give_current_world_texture(scene->world); + if (tx) { + *r_from = (ID *)scene->world; + *r_id = &tx->id; + *r_ntree = tx->nodetree; + } + } + else { + struct Brush *brush = NULL; + + if (ob && (ob->mode & OB_MODE_SCULPT)) + brush = paint_brush(&scene->toolsettings->sculpt->paint); + else + brush = 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; + } } } } @@ -75,6 +119,7 @@ static void foreach_nodeclass(Scene *UNUSED(scene), void *calldata, bNodeClassCa func(calldata, NODE_CLASS_CONVERTOR, N_("Convertor")); 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")); } @@ -93,49 +138,42 @@ static void localize(bNodeTree *localtree, bNodeTree *UNUSED(ntree)) } } -static void local_sync(bNodeTree *localtree, bNodeTree *ntree) +static void local_sync(bNodeTree *UNUSED(localtree), bNodeTree *UNUSED(ntree)) { - bNode *lnode; - - /* copy over contents of previews */ - for (lnode = localtree->nodes.first; lnode; lnode = lnode->next) { - if (ntreeNodeExists(ntree, lnode->new_node)) { - bNode *node = lnode->new_node; - - if (node->preview && node->preview->rect) { - if (lnode->preview && lnode->preview->rect) { - int xsize = node->preview->xsize; - int ysize = node->preview->ysize; - memcpy(node->preview->rect, lnode->preview->rect, 4 * xsize + xsize * ysize * sizeof(char) * 4); - } - } - } - } } 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); + } } -bNodeTreeType ntreeType_Texture = { - /* type */ NTREE_TEXTURE, - /* id_name */ "NTTexture Nodetree", +bNodeTreeType *ntreeType_Texture; + +void register_node_tree_type_tex() +{ + bNodeTreeType *tt = ntreeType_Texture = MEM_callocN(sizeof(bNodeTreeType), "texture node tree type"); - /* node_types */ { NULL, NULL }, + tt->type = NTREE_TEXTURE; + strcpy(tt->idname, "TextureNodeTree"); + strcpy(tt->ui_name, "Texture"); + tt->ui_icon = 0; /* defined in drawnode.c */ + strcpy(tt->ui_description, ""); - /* free_cache */ NULL, - /* free_node_cache */ NULL, - /* foreach_nodetree */ foreach_nodetree, - /* foreach_nodeclass */ foreach_nodeclass, - /* localize */ localize, - /* local_sync */ local_sync, - /* local_merge */ NULL, - /* update */ update, - /* update_node */ NULL, - /* validate_link */ NULL, - /* update_internal_links */ node_update_internal_links_default -}; + tt->foreach_nodeclass = foreach_nodeclass; + tt->update = update; + tt->localize = localize; + tt->local_sync = local_sync; + tt->get_from_context = texture_get_from_context; + + tt->ext.srna = &RNA_TextureNodeTree; + + ntreeTypeAdd(tt); +} int ntreeTexTagAnimated(bNodeTree *ntree) { @@ -158,24 +196,13 @@ int ntreeTexTagAnimated(bNodeTree *ntree) return 0; } -/* XXX Group nodes must set use_tree_data to false, since their trees can be shared by multiple nodes. - * If use_tree_data is true, the ntree->execdata pointer is checked to avoid multiple execution of top-level trees. - */ -bNodeTreeExec *ntreeTexBeginExecTree(bNodeTree *ntree, int use_tree_data) +bNodeTreeExec *ntreeTexBeginExecTree_internal(bNodeExecContext *context, bNodeTree *ntree, bNodeInstanceKey parent_key) { bNodeTreeExec *exec; bNode *node; - if (use_tree_data) { - /* XXX hack: prevent exec data from being generated twice. - * this should be handled by the renderer! - */ - if (ntree->execdata) - return ntree->execdata; - } - /* common base initialization */ - exec = ntree_exec_begin(ntree); + exec = ntree_exec_begin(context, ntree, parent_key); /* allocate the thread stack listbase array */ exec->threadstack = MEM_callocN(BLENDER_MAX_THREADS * sizeof(ListBase), "thread stack array"); @@ -183,12 +210,28 @@ bNodeTreeExec *ntreeTexBeginExecTree(bNodeTree *ntree, int use_tree_data) for (node = exec->nodetree->nodes.first; node; node = node->next) node->need_exec = 1; - if (use_tree_data) { - /* XXX this should not be necessary, but is still used for cmp/sha/tex nodes, - * which only store the ntree pointer. Should be fixed at some point! - */ - ntree->execdata = exec; - } + return exec; +} + +bNodeTreeExec *ntreeTexBeginExecTree(bNodeTree *ntree) +{ + bNodeExecContext context; + bNodeTreeExec *exec; + + /* XXX hack: prevent exec data from being generated twice. + * this should be handled by the renderer! + */ + if (ntree->execdata) + return ntree->execdata; + + context.previews = ntree->previews; + + exec = ntreeTexBeginExecTree_internal(&context, ntree, NODE_INSTANCE_KEY_BASE); + + /* XXX this should not be necessary, but is still used for cmp/sha/tex nodes, + * which only store the ntree pointer. Should be fixed at some point! + */ + ntree->execdata = exec; return exec; } @@ -207,35 +250,34 @@ static void tex_free_delegates(bNodeTreeExec *exec) MEM_freeN(ns->data); } -/* XXX Group nodes must set use_tree_data to false, since their trees can be shared by multiple nodes. - * If use_tree_data is true, the ntree->execdata pointer is checked to avoid multiple execution of top-level trees. - */ -void ntreeTexEndExecTree(bNodeTreeExec *exec, int use_tree_data) +void ntreeTexEndExecTree_internal(bNodeTreeExec *exec) { - if (exec) { - bNodeTree *ntree = exec->nodetree; - bNodeThreadStack *nts; - int a; + bNodeThreadStack *nts; + int a; + + if (exec->threadstack) { + tex_free_delegates(exec); - if (exec->threadstack) { - tex_free_delegates(exec); - - for (a = 0; a < BLENDER_MAX_THREADS; a++) { - for (nts = exec->threadstack[a].first; nts; nts = nts->next) - if (nts->stack) MEM_freeN(nts->stack); - BLI_freelistN(&exec->threadstack[a]); - } - - MEM_freeN(exec->threadstack); - exec->threadstack = NULL; + for (a = 0; a < BLENDER_MAX_THREADS; a++) { + for (nts = exec->threadstack[a].first; nts; nts = nts->next) + if (nts->stack) MEM_freeN(nts->stack); + BLI_freelistN(&exec->threadstack[a]); } - ntree_exec_end(exec); + MEM_freeN(exec->threadstack); + exec->threadstack = NULL; + } + + ntree_exec_end(exec); +} + +void ntreeTexEndExecTree(bNodeTreeExec *exec) +{ + if (exec) { + ntreeTexEndExecTree_internal(exec); - if (use_tree_data) { - /* XXX clear nodetree backpointer to exec data, same problem as noted in ntreeBeginExecTree */ - ntree->execdata = NULL; - } + /* XXX clear nodetree backpointer to exec data, same problem as noted in ntreeBeginExecTree */ + exec->nodetree->execdata = NULL; } } @@ -275,7 +317,7 @@ int ntreeTexExecTree( if (!exec) { BLI_lock_thread(LOCK_NODES); if (!nodes->execdata) - ntreeTexBeginExecTree(nodes, 1); + ntreeTexBeginExecTree(nodes); BLI_unlock_thread(LOCK_NODES); exec = nodes->execdata; diff --git a/source/blender/nodes/texture/node_texture_util.c b/source/blender/nodes/texture/node_texture_util.c index 06473d800d0..80644157b02 100644 --- a/source/blender/nodes/texture/node_texture_util.c +++ b/source/blender/nodes/texture/node_texture_util.c @@ -49,13 +49,28 @@ #include <assert.h> #include "node_texture_util.h" + +int tex_node_poll_default(bNodeType *UNUSED(ntype), bNodeTree *ntree) +{ + return (strcmp(ntree->idname, "TextureNodeTree")==0); +} + +void tex_node_type_base(struct bNodeType *ntype, int type, const char *name, short nclass, short flag) +{ + node_type_base(ntype, type, name, nclass, flag); + + ntype->poll = tex_node_poll_default; + ntype->update_internal_links = node_update_internal_links_default; +} + + static void tex_call_delegate(TexDelegate *dg, float *out, TexParams *params, short thread) { if (dg->node->need_exec) { dg->fn(out, params, dg->node, dg->in, thread); if (dg->cdata->do_preview) - tex_do_preview(dg->node, params->previewco, out); + tex_do_preview(dg->preview, params->previewco, out); } } @@ -112,19 +127,17 @@ void params_from_cdata(TexParams *out, TexCallData *in) out->mtex = in->mtex; } -void tex_do_preview(bNode *node, const float coord[2], const float col[4]) +void tex_do_preview(bNodePreview *preview, const float coord[2], const float col[4]) { - bNodePreview *preview = node->preview; - if (preview) { int xs = ((coord[0] + 1.0f) * 0.5f) * preview->xsize; int ys = ((coord[1] + 1.0f) * 0.5f) * preview->ysize; - - nodeAddToPreview(node, col, xs, ys, 0); /* 0 = no color management */ + + BKE_node_preview_set_pixel(preview, col, xs, ys, 0); /* 0 = no color management */ } } -void tex_output(bNode *node, bNodeStack **in, bNodeStack *out, TexFn texfn, TexCallData *cdata) +void tex_output(bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack *out, TexFn texfn, TexCallData *cdata) { TexDelegate *dg; if (!out->data) @@ -136,6 +149,7 @@ void tex_output(bNode *node, bNodeStack **in, bNodeStack *out, TexFn texfn, TexC dg->cdata = cdata; dg->fn = texfn; dg->node = node; + dg->preview = execdata->preview; memcpy(dg->in, in, MAX_SOCKET * sizeof(bNodeStack *)); dg->type = out->sockettype; } diff --git a/source/blender/nodes/texture/node_texture_util.h b/source/blender/nodes/texture/node_texture_util.h index 3b2a7e14f69..b81ea51ddff 100644 --- a/source/blender/nodes/texture/node_texture_util.h +++ b/source/blender/nodes/texture/node_texture_util.h @@ -65,6 +65,7 @@ #include "BKE_library.h" #include "node_util.h" +#include "NOD_texture.h" #include "NOD_texture.h" @@ -111,16 +112,21 @@ typedef struct TexDelegate { TexCallData *cdata; TexFn fn; bNode *node; + bNodePreview *preview; bNodeStack *in[MAX_SOCKET]; int type; } TexDelegate; + +int tex_node_poll_default(struct bNodeType *ntype, struct bNodeTree *ntree); +void tex_node_type_base(struct bNodeType *ntype, int type, const char *name, short nclass, short flag); + void tex_input_rgba(float *out, bNodeStack *in, TexParams *params, short thread); void tex_input_vec(float *out, bNodeStack *in, TexParams *params, short thread); float tex_input_value(bNodeStack *in, TexParams *params, short thread); -void tex_output(bNode *node, bNodeStack **in, bNodeStack *out, TexFn texfn, TexCallData *data); -void tex_do_preview(bNode *node, const float coord[2], const float col[4]); +void tex_output(bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack *out, TexFn texfn, TexCallData *data); +void tex_do_preview(bNodePreview *preview, const float coord[2], const float col[4]); void params_from_cdata(TexParams *out, TexCallData *in); diff --git a/source/blender/nodes/texture/nodes/node_texture_at.c b/source/blender/nodes/texture/nodes/node_texture_at.c index 4c2d276b902..ef930a39fe3 100644 --- a/source/blender/nodes/texture/nodes/node_texture_at.c +++ b/source/blender/nodes/texture/nodes/node_texture_at.c @@ -53,19 +53,19 @@ static void colorfn(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack ** tex_input_rgba(out, in[0], &np, thread); } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_at(bNodeTreeType *ttype) +void register_node_type_tex_at() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_AT, "At", NODE_CLASS_DISTORT, 0); + tex_node_type_base(&ntype, TEX_NODE_AT, "At", NODE_CLASS_DISTORT, 0); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 140, 100, 320); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_bricks.c b/source/blender/nodes/texture/nodes/node_texture_bricks.c index b4f81f08e43..afcbf4216c3 100644 --- a/source/blender/nodes/texture/nodes/node_texture_bricks.c +++ b/source/blender/nodes/texture/nodes/node_texture_bricks.c @@ -50,7 +50,7 @@ static bNodeSocketTemplate outputs[] = { { -1, 0, "" } }; -static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void init(bNodeTree *UNUSED(ntree), bNode *node) { node->custom3 = 0.5; /* offset */ node->custom4 = 1.0; /* squash */ @@ -116,20 +116,20 @@ static void colorfn(float *out, TexParams *p, bNode *node, bNodeStack **in, shor } } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_bricks(bNodeTreeType *ttype) +void register_node_type_tex_bricks() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_BRICKS, "Bricks", NODE_CLASS_PATTERN, NODE_PREVIEW|NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_BRICKS, "Bricks", NODE_CLASS_PATTERN, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 150, 60, 150); node_type_init(&ntype, init); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_checker.c b/source/blender/nodes/texture/nodes/node_texture_checker.c index 1f653d1f7b9..53c91db0312 100644 --- a/source/blender/nodes/texture/nodes/node_texture_checker.c +++ b/source/blender/nodes/texture/nodes/node_texture_checker.c @@ -65,19 +65,19 @@ static void colorfn(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack ** } } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_checker(bNodeTreeType *ttype) +void register_node_type_tex_checker() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_CHECKER, "Checker", NODE_CLASS_PATTERN, NODE_PREVIEW|NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_CHECKER, "Checker", NODE_CLASS_PATTERN, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 100, 60, 150); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_common.c b/source/blender/nodes/texture/nodes/node_texture_common.c index aa427ff3587..2af2a3a1999 100644 --- a/source/blender/nodes/texture/nodes/node_texture_common.c +++ b/source/blender/nodes/texture/nodes/node_texture_common.c @@ -38,9 +38,12 @@ #include "BKE_node.h" #include "node_texture_util.h" +#include "NOD_common.h" #include "node_common.h" #include "node_exec.h" +#include "RNA_access.h" + static void copy_stack(bNodeStack *to, bNodeStack *from) { if (to != from) { @@ -55,7 +58,7 @@ static void copy_stack(bNodeStack *to, bNodeStack *from) /**** GROUP ****/ -static void *group_initexec(bNode *node) +static void *group_initexec(bNodeExecContext *context, bNode *node, bNodeInstanceKey key) { bNodeTree *ngroup= (bNodeTree*)node->id; void *exec; @@ -64,7 +67,7 @@ static void *group_initexec(bNode *node) return NULL; /* initialize the internal node tree execution */ - exec = ntreeTexBeginExecTree(ngroup, 0); + exec = ntreeTexBeginExecTree_internal(context, ngroup, key); return exec; } @@ -73,43 +76,56 @@ static void group_freeexec(bNode *UNUSED(node), void *nodedata) { bNodeTreeExec*gexec= (bNodeTreeExec*)nodedata; - ntreeTexEndExecTree(gexec, 0); + ntreeTexEndExecTree_internal(gexec); } /* Copy inputs to the internal stack. * This is a shallow copy, no buffers are duplicated here! */ -static void group_copy_inputs(bNode *node, bNodeStack **in, bNodeStack *gstack) +static void group_copy_inputs(bNode *gnode, bNodeStack **in, bNodeStack *gstack) { + bNodeTree *ngroup = (bNodeTree*)gnode->id; + bNode *node; bNodeSocket *sock; bNodeStack *ns; int a; - for (sock=node->inputs.first, a=0; sock; sock=sock->next, ++a) { - if (sock->groupsock) { - ns = node_get_socket_stack(gstack, sock->groupsock); - copy_stack(ns, in[a]); + + for (node = ngroup->nodes.first; node; node = node->next) { + if (node->type == NODE_GROUP_INPUT) { + for (sock = node->outputs.first, a = 0; sock; sock = sock->next, ++a) { + ns = node_get_socket_stack(gstack, sock); + if (ns) + copy_stack(ns, in[a]); + } } } } /* Copy internal results to the external outputs. */ -static void group_copy_outputs(bNode *node, bNodeStack **out, bNodeStack *gstack) +static void group_copy_outputs(bNode *gnode, bNodeStack **out, bNodeStack *gstack) { + bNodeTree *ngroup = (bNodeTree*)gnode->id; + bNode *node; bNodeSocket *sock; bNodeStack *ns; int a; - for (sock=node->outputs.first, a=0; sock; sock=sock->next, ++a) { - if (sock->groupsock) { - ns = node_get_socket_stack(gstack, sock->groupsock); - copy_stack(out[a], ns); + + for (node = ngroup->nodes.first; node; node = node->next) { + if (node->type == NODE_GROUP_OUTPUT && (node->flag & NODE_DO_OUTPUT)) { + for (sock = node->inputs.first, a = 0; sock; sock = sock->next, ++a) { + ns = node_get_socket_stack(gstack, sock); + if (ns) + copy_stack(out[a], ns); + } + break; /* only one active output node */ } } } -static void group_execute(void *data, int thread, struct bNode *node, void *nodedata, struct bNodeStack **in, struct bNodeStack **out) +static void group_execute(void *data, int thread, struct bNode *node, bNodeExecData *execdata, struct bNodeStack **in, struct bNodeStack **out) { - bNodeTreeExec *exec= (bNodeTreeExec*)nodedata; + bNodeTreeExec *exec= execdata->data; bNodeThreadStack *nts; if (!exec) @@ -133,20 +149,27 @@ static void group_execute(void *data, int thread, struct bNode *node, void *node ntreeReleaseThreadStack(nts); } -void register_node_type_tex_group(bNodeTreeType *ttype) +void register_node_type_tex_group() { static bNodeType ntype; - node_type_base(ttype, &ntype, NODE_GROUP, "Group", NODE_CLASS_GROUP, NODE_OPTIONS|NODE_CONST_OUTPUT); + /* NB: cannot use sh_node_type_base for node group, because it would map the node type + * to the shared NODE_GROUP integer type id. + */ + node_type_base_custom(&ntype, "TextureNodeGroup", "Group", NODE_CLASS_GROUP, NODE_OPTIONS | NODE_CONST_OUTPUT); + ntype.type = NODE_GROUP; + ntype.poll = tex_node_poll_default; + ntype.update_internal_links = node_update_internal_links_default; + ntype.ext.srna = RNA_struct_find("TextureNodeGroup"); + BLI_assert(ntype.ext.srna != NULL); + RNA_struct_blender_type_set(ntype.ext.srna, &ntype); + node_type_socket_templates(&ntype, NULL, NULL); node_type_size(&ntype, 120, 60, 200); node_type_label(&ntype, node_group_label); - node_type_init(&ntype, node_group_init); - node_type_valid(&ntype, node_group_valid); - node_type_template(&ntype, node_group_template); node_type_update(&ntype, NULL, node_group_verify); - node_type_group_edit(&ntype, node_group_edit_get, node_group_edit_set, node_group_edit_clear); - node_type_exec_new(&ntype, group_initexec, group_freeexec, group_execute); + strcpy(ntype.group_tree_idname, "TextureNodeTree"); + node_type_exec(&ntype, group_initexec, group_freeexec, group_execute); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_compose.c b/source/blender/nodes/texture/nodes/node_texture_compose.c index 43a8ba1babf..ddaae829da9 100644 --- a/source/blender/nodes/texture/nodes/node_texture_compose.c +++ b/source/blender/nodes/texture/nodes/node_texture_compose.c @@ -52,19 +52,19 @@ static void colorfn(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack ** out[i] = tex_input_value(in[i], p, thread); } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_compose(bNodeTreeType *ttype) +void register_node_type_tex_compose() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_COMPOSE, "Combine RGBA", NODE_CLASS_OP_COLOR, 0); + tex_node_type_base(&ntype, TEX_NODE_COMPOSE, "Combine RGBA", NODE_CLASS_OP_COLOR, 0); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 100, 60, 150); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_coord.c b/source/blender/nodes/texture/nodes/node_texture_coord.c index 971520ebc38..94793288ec3 100644 --- a/source/blender/nodes/texture/nodes/node_texture_coord.c +++ b/source/blender/nodes/texture/nodes/node_texture_coord.c @@ -43,20 +43,20 @@ static void vectorfn(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack * copy_v3_v3(out, p->co); } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &vectorfn, data); + tex_output(node, execdata, in, out[0], &vectorfn, data); } -void register_node_type_tex_coord(bNodeTreeType *ttype) +void register_node_type_tex_coord() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_COORD, "Coordinates", NODE_CLASS_INPUT, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_COORD, "Coordinates", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, outputs); node_type_size(&ntype, 120, 110, 160); node_type_storage(&ntype, "node_coord", NULL, NULL); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_curves.c b/source/blender/nodes/texture/nodes/node_texture_curves.c index 5980f938938..94235eae93c 100644 --- a/source/blender/nodes/texture/nodes/node_texture_curves.c +++ b/source/blender/nodes/texture/nodes/node_texture_curves.c @@ -54,32 +54,31 @@ static void time_colorfn(float *out, TexParams *p, bNode *node, bNodeStack **UNU out[0] = CLAMPIS(fac, 0.0f, 1.0f); } -static void time_exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void time_exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &time_colorfn, data); + tex_output(node, execdata, in, out[0], &time_colorfn, data); } -static void time_init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void time_init(bNodeTree *UNUSED(ntree), bNode *node) { node->custom1= 1; node->custom2= 250; node->storage= curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f); } -void register_node_type_tex_curve_time(bNodeTreeType *ttype) +void register_node_type_tex_curve_time() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_CURVE_TIME, "Time", NODE_CLASS_INPUT, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_CURVE_TIME, "Time", NODE_CLASS_INPUT, NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, time_outputs); node_type_size(&ntype, 140, 100, 320); node_type_init(&ntype, time_init); node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); - node_type_exec(&ntype, time_exec); - node_type_exec_new(&ntype, node_initexec_curves, NULL, NULL); /* only for its initexec func */ + node_type_exec(&ntype, node_initexec_curves, NULL, time_exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } /* **************** CURVE RGB ******************** */ @@ -102,27 +101,26 @@ static void rgb_colorfn(float *out, TexParams *p, bNode *node, bNodeStack **in, out[3] = cin[3]; } -static void rgb_exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void rgb_exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &rgb_colorfn, data); + tex_output(node, execdata, in, out[0], &rgb_colorfn, data); } -static void rgb_init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void rgb_init(bNodeTree *UNUSED(ntree), bNode *node) { node->storage= curvemapping_add(4, 0.0f, 0.0f, 1.0f, 1.0f); } -void register_node_type_tex_curve_rgb(bNodeTreeType *ttype) +void register_node_type_tex_curve_rgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, rgb_inputs, rgb_outputs); node_type_size(&ntype, 200, 140, 320); node_type_init(&ntype, rgb_init); node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves); - node_type_exec(&ntype, rgb_exec); - node_type_exec_new(&ntype, node_initexec_curves, NULL, NULL); /* only for its initexec func */ + node_type_exec(&ntype, node_initexec_curves, NULL, rgb_exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_decompose.c b/source/blender/nodes/texture/nodes/node_texture_decompose.c index 0866428ca6c..fa2c1d6398f 100644 --- a/source/blender/nodes/texture/nodes/node_texture_decompose.c +++ b/source/blender/nodes/texture/nodes/node_texture_decompose.c @@ -70,22 +70,22 @@ static void valuefn_a(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack *out = out[3]; } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &valuefn_r, data); - tex_output(node, in, out[1], &valuefn_g, data); - tex_output(node, in, out[2], &valuefn_b, data); - tex_output(node, in, out[3], &valuefn_a, data); + tex_output(node, execdata, in, out[0], &valuefn_r, data); + tex_output(node, execdata, in, out[1], &valuefn_g, data); + tex_output(node, execdata, in, out[2], &valuefn_b, data); + tex_output(node, execdata, in, out[3], &valuefn_a, data); } -void register_node_type_tex_decompose(bNodeTreeType *ttype) +void register_node_type_tex_decompose() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_DECOMPOSE, "Separate RGBA", NODE_CLASS_OP_COLOR, 0); + tex_node_type_base(&ntype, TEX_NODE_DECOMPOSE, "Separate RGBA", NODE_CLASS_OP_COLOR, 0); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 100, 60, 150); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_distance.c b/source/blender/nodes/texture/nodes/node_texture_distance.c index 8c3b1555d5d..fefa093481d 100644 --- a/source/blender/nodes/texture/nodes/node_texture_distance.c +++ b/source/blender/nodes/texture/nodes/node_texture_distance.c @@ -56,20 +56,20 @@ static void valuefn(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack ** *out = len_v3v3(co2, co1); } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &valuefn, data); + tex_output(node, execdata, in, out[0], &valuefn, data); } -void register_node_type_tex_distance(bNodeTreeType *ttype) +void register_node_type_tex_distance() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_DISTANCE, "Distance", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_DISTANCE, "Distance", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 120, 110, 160); node_type_storage(&ntype, "node_distance", NULL, NULL); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_hueSatVal.c b/source/blender/nodes/texture/nodes/node_texture_hueSatVal.c index b5e9969a830..c5acf01801c 100644 --- a/source/blender/nodes/texture/nodes/node_texture_hueSatVal.c +++ b/source/blender/nodes/texture/nodes/node_texture_hueSatVal.c @@ -87,19 +87,19 @@ static void colorfn(float *out, TexParams *p, bNode *node, bNodeStack **in, shor out[3] = col[3]; } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_hue_sat(bNodeTreeType *ttype) +void register_node_type_tex_hue_sat() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 150, 80, 250); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_image.c b/source/blender/nodes/texture/nodes/node_texture_image.c index 2ef1669a266..e897b0e4e96 100644 --- a/source/blender/nodes/texture/nodes/node_texture_image.c +++ b/source/blender/nodes/texture/nodes/node_texture_image.c @@ -83,12 +83,12 @@ static void colorfn(float *out, TexParams *p, bNode *node, bNodeStack **UNUSED(i } } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void init(bNodeTree *UNUSED(ntree), bNode *node) { ImageUser *iuser= MEM_callocN(sizeof(ImageUser), "node image user"); node->storage= iuser; @@ -97,16 +97,16 @@ static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(nt iuser->ok= 1; } -void register_node_type_tex_image(bNodeTreeType *ttype) +void register_node_type_tex_image() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_IMAGE, "Image", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_IMAGE, "Image", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, NULL, outputs); node_type_size(&ntype, 120, 80, 300); node_type_init(&ntype, init); node_type_storage(&ntype, "ImageUser", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_invert.c b/source/blender/nodes/texture/nodes/node_texture_invert.c index 9c2963d2dc2..aa394bff8bc 100644 --- a/source/blender/nodes/texture/nodes/node_texture_invert.c +++ b/source/blender/nodes/texture/nodes/node_texture_invert.c @@ -58,19 +58,19 @@ static void colorfn(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack ** out[3] = col[3]; } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_invert(bNodeTreeType *ttype) +void register_node_type_tex_invert() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 90, 80, 100); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_math.c b/source/blender/nodes/texture/nodes/node_texture_math.c index 95d70ccc7d6..e83579070a9 100644 --- a/source/blender/nodes/texture/nodes/node_texture_math.c +++ b/source/blender/nodes/texture/nodes/node_texture_math.c @@ -181,21 +181,21 @@ static void valuefn(float *out, TexParams *p, bNode *node, bNodeStack **in, shor } } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &valuefn, data); + tex_output(node, execdata, in, out[0], &valuefn, data); } -void register_node_type_tex_math(bNodeTreeType *ttype) +void register_node_type_tex_math() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 120, 110, 160); node_type_label(&ntype, node_math_label); node_type_storage(&ntype, "node_math", NULL, NULL); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_mixRgb.c b/source/blender/nodes/texture/nodes/node_texture_mixRgb.c index fe04854c734..7a68af4b1e2 100644 --- a/source/blender/nodes/texture/nodes/node_texture_mixRgb.c +++ b/source/blender/nodes/texture/nodes/node_texture_mixRgb.c @@ -59,20 +59,20 @@ static void colorfn(float *out, TexParams *p, bNode *node, bNodeStack **in, shor ramp_blend(node->custom1, out, fac, col2); } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_mix_rgb(bNodeTreeType *ttype) +void register_node_type_tex_mix_rgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 100, 60, 150); node_type_label(&ntype, node_blend_label); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_output.c b/source/blender/nodes/texture/nodes/node_texture_output.c index 2f5efe8c45e..8c8f7622d29 100644 --- a/source/blender/nodes/texture/nodes/node_texture_output.c +++ b/source/blender/nodes/texture/nodes/node_texture_output.c @@ -41,7 +41,7 @@ static bNodeSocketTemplate inputs[] = { }; /* applies to render pipeline */ -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **UNUSED(out)) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **UNUSED(out)) { TexCallData *cdata = (TexCallData *)data; TexResult *target = cdata->target; @@ -54,7 +54,7 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **UNUSED(o tex_input_rgba(&target->tr, in[1], ¶ms, cdata->thread); else tex_input_rgba(&target->tr, in[0], ¶ms, cdata->thread); - tex_do_preview(node, params.co, &target->tr); + tex_do_preview(execdata->preview, params.co, &target->tr); } else { /* 0 means don't care, so just use first */ @@ -141,7 +141,7 @@ static void assign_index(struct bNode *node) node->custom1 = index; } -static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void init(bNodeTree *UNUSED(ntree), bNode *node) { TexNodeOutput *tno = MEM_callocN(sizeof(TexNodeOutput), "TEX_output"); node->storage= tno; @@ -151,26 +151,26 @@ static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(nt assign_index(node); } -static void copy(bNode *orig, bNode *new) +static void copy(bNodeTree *dest_ntree, bNode *dest_node, bNode *src_node) { - node_copy_standard_storage(orig, new); - unique_name(new); - assign_index(new); + node_copy_standard_storage(dest_ntree, dest_node, src_node); + unique_name(dest_node); + assign_index(dest_node); } -void register_node_type_tex_output(bNodeTreeType *ttype) +void register_node_type_tex_output() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_OUTPUT, "Output", NODE_CLASS_OUTPUT, NODE_PREVIEW|NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_OUTPUT, "Output", NODE_CLASS_OUTPUT, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, NULL); node_type_size(&ntype, 150, 60, 200); node_type_init(&ntype, init); node_type_storage(&ntype, "TexNodeOutput", node_free_standard_storage, copy); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); /* Do not allow muting output. */ node_type_internal_links(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_proc.c b/source/blender/nodes/texture/nodes/node_texture_proc.c index de2dac22d81..504e77ebb27 100644 --- a/source/blender/nodes/texture/nodes/node_texture_proc.c +++ b/source/blender/nodes/texture/nodes/node_texture_proc.c @@ -129,11 +129,11 @@ static int count_outputs(bNode *node) { \ texfn(result, p, node, in, 1, &name##_map_inputs, thread); \ } \ - static void name##_exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) \ + 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, in, out[0], &name##_colorfn, data); \ - if (outs >= 2) tex_output(node, in, out[1], &name##_normalfn, data); \ + 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); \ } @@ -281,7 +281,7 @@ ProcDef(stucci) /* --- */ -static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void init(bNodeTree *UNUSED(ntree), bNode *node) { Tex *tex = MEM_callocN(sizeof(Tex), "Tex"); node->storage= tex; @@ -296,18 +296,18 @@ static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(nt /* Node type definitions */ #define TexDef(TEXTYPE, outputs, name, Name) \ -void register_node_type_tex_proc_##name(bNodeTreeType *ttype) \ +void register_node_type_tex_proc_##name() \ { \ static bNodeType ntype; \ \ - node_type_base(ttype, &ntype, TEX_NODE_PROC+TEXTYPE, Name, NODE_CLASS_TEXTURE, NODE_PREVIEW|NODE_OPTIONS); \ + tex_node_type_base(&ntype, TEX_NODE_PROC+TEXTYPE, Name, NODE_CLASS_TEXTURE, NODE_PREVIEW|NODE_OPTIONS); \ node_type_socket_templates(&ntype, name##_inputs, outputs); \ node_type_size(&ntype, 140, 80, 140); \ node_type_init(&ntype, init); \ node_type_storage(&ntype, "Tex", node_free_standard_storage, node_copy_standard_storage); \ - node_type_exec(&ntype, name##_exec); \ + node_type_exec(&ntype, NULL, NULL, name##_exec); \ \ - nodeRegisterType(ttype, &ntype); \ + nodeRegisterType(&ntype); \ } #define C outputs_color_only diff --git a/source/blender/nodes/texture/nodes/node_texture_rotate.c b/source/blender/nodes/texture/nodes/node_texture_rotate.c index 1b1d57044a3..8f3f66dbee4 100644 --- a/source/blender/nodes/texture/nodes/node_texture_rotate.c +++ b/source/blender/nodes/texture/nodes/node_texture_rotate.c @@ -90,19 +90,19 @@ static void colorfn(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack ** tex_input_rgba(out, in[0], &np, thread); } } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_rotate(bNodeTreeType *ttype) +void register_node_type_tex_rotate() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_ROTATE, "Rotate", NODE_CLASS_DISTORT, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_ROTATE, "Rotate", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 140, 100, 320); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_scale.c b/source/blender/nodes/texture/nodes/node_texture_scale.c index 56562724fb9..67e0c064b7c 100644 --- a/source/blender/nodes/texture/nodes/node_texture_scale.c +++ b/source/blender/nodes/texture/nodes/node_texture_scale.c @@ -63,19 +63,19 @@ static void colorfn(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack ** tex_input_rgba(out, in[0], &np, thread); } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_scale(bNodeTreeType *ttype) +void register_node_type_tex_scale() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_SCALE, "Scale", NODE_CLASS_DISTORT, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_SCALE, "Scale", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 90, 80, 100); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_texture.c b/source/blender/nodes/texture/nodes/node_texture_texture.c index f839f485976..9970c3c2a26 100644 --- a/source/blender/nodes/texture/nodes/node_texture_texture.c +++ b/source/blender/nodes/texture/nodes/node_texture_texture.c @@ -90,19 +90,19 @@ static void colorfn(float *out, TexParams *p, bNode *node, bNodeStack **in, shor } } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_texture(bNodeTreeType *ttype) +void register_node_type_tex_texture() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 120, 80, 240); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_translate.c b/source/blender/nodes/texture/nodes/node_texture_translate.c index a95cb00a47d..3d5db4f863a 100644 --- a/source/blender/nodes/texture/nodes/node_texture_translate.c +++ b/source/blender/nodes/texture/nodes/node_texture_translate.c @@ -59,19 +59,19 @@ static void colorfn(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack ** tex_input_rgba(out, in[0], &np, thread); } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &colorfn, data); + tex_output(node, execdata, in, out[0], &colorfn, data); } -void register_node_type_tex_translate(bNodeTreeType *ttype) +void register_node_type_tex_translate() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_TRANSLATE, "Translate", NODE_CLASS_DISTORT, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_TRANSLATE, "Translate", NODE_CLASS_DISTORT, NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 90, 80, 100); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_valToNor.c b/source/blender/nodes/texture/nodes/node_texture_valToNor.c index bbfc1fa616b..d7495f9833d 100644 --- a/source/blender/nodes/texture/nodes/node_texture_valToNor.c +++ b/source/blender/nodes/texture/nodes/node_texture_valToNor.c @@ -75,19 +75,19 @@ static void normalfn(float *out, TexParams *p, bNode *UNUSED(node), bNodeStack * out[1] = val-nor[1]; out[2] = val-nor[2]; } -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &normalfn, data); + tex_output(node, execdata, in, out[0], &normalfn, data); } -void register_node_type_tex_valtonor(bNodeTreeType *ttype) +void register_node_type_tex_valtonor() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_VALTONOR, "Value to Normal", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_VALTONOR, "Value to Normal", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 90, 80, 100); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_valToRgb.c b/source/blender/nodes/texture/nodes/node_texture_valToRgb.c index 78635453fc1..fec89aa03eb 100644 --- a/source/blender/nodes/texture/nodes/node_texture_valToRgb.c +++ b/source/blender/nodes/texture/nodes/node_texture_valToRgb.c @@ -52,28 +52,28 @@ static void valtorgb_colorfn(float *out, TexParams *p, bNode *node, bNodeStack * } } -static void valtorgb_exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void valtorgb_exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &valtorgb_colorfn, data); + tex_output(node, execdata, in, out[0], &valtorgb_colorfn, data); } -static void valtorgb_init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp)) +static void valtorgb_init(bNodeTree *UNUSED(ntree), bNode *node) { node->storage = add_colorband(1); } -void register_node_type_tex_valtorgb(bNodeTreeType *ttype) +void register_node_type_tex_valtorgb() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTOR, NODE_OPTIONS); + tex_node_type_base(&ntype, TEX_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTOR, NODE_OPTIONS); node_type_socket_templates(&ntype, valtorgb_in, valtorgb_out); node_type_size(&ntype, 240, 200, 300); node_type_init(&ntype, valtorgb_init); node_type_storage(&ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage); - node_type_exec(&ntype, valtorgb_exec); + node_type_exec(&ntype, NULL, NULL, valtorgb_exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } /* **************** RGBTOBW ******************** */ @@ -94,19 +94,19 @@ static void rgbtobw_valuefn(float *out, TexParams *p, bNode *UNUSED(node), bNode *out = rgb_to_bw(cin); } -static void rgbtobw_exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out) +static void rgbtobw_exec(void *data, int UNUSED(thread), bNode *node, bNodeExecData *execdata, bNodeStack **in, bNodeStack **out) { - tex_output(node, in, out[0], &rgbtobw_valuefn, data); + tex_output(node, execdata, in, out[0], &rgbtobw_valuefn, data); } -void register_node_type_tex_rgbtobw(bNodeTreeType *ttype) +void register_node_type_tex_rgbtobw() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTOR, 0); + tex_node_type_base(&ntype, TEX_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTOR, 0); node_type_socket_templates(&ntype, rgbtobw_in, rgbtobw_out); node_type_size(&ntype, 80, 40, 120); - node_type_exec(&ntype, rgbtobw_exec); + node_type_exec(&ntype, NULL, NULL, rgbtobw_exec); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } diff --git a/source/blender/nodes/texture/nodes/node_texture_viewer.c b/source/blender/nodes/texture/nodes/node_texture_viewer.c index 5cb8d8c438c..44724c9280f 100644 --- a/source/blender/nodes/texture/nodes/node_texture_viewer.c +++ b/source/blender/nodes/texture/nodes/node_texture_viewer.c @@ -42,7 +42,7 @@ static bNodeSocketTemplate outputs[] = { { -1, 0, "" } }; -static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **UNUSED(out)) +static void exec(void *data, int UNUSED(thread), bNode *UNUSED(node), bNodeExecData *execdata, bNodeStack **in, bNodeStack **UNUSED(out)) { TexCallData *cdata = (TexCallData *)data; @@ -52,21 +52,21 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **UNUSED(o params_from_cdata(¶ms, cdata); tex_input_rgba(col, in[0], ¶ms, cdata->thread); - tex_do_preview(node, params.previewco, col); + tex_do_preview(execdata->preview, params.previewco, col); } } -void register_node_type_tex_viewer(bNodeTreeType *ttype) +void register_node_type_tex_viewer() { static bNodeType ntype; - node_type_base(ttype, &ntype, TEX_NODE_VIEWER, "Viewer", NODE_CLASS_OUTPUT, NODE_PREVIEW); + tex_node_type_base(&ntype, TEX_NODE_VIEWER, "Viewer", NODE_CLASS_OUTPUT, NODE_PREVIEW); node_type_socket_templates(&ntype, inputs, outputs); node_type_size(&ntype, 100, 60, 150); - node_type_exec(&ntype, exec); + node_type_exec(&ntype, NULL, NULL, exec); /* Do not allow muting viewer node. */ node_type_internal_links(&ntype, NULL); - nodeRegisterType(ttype, &ntype); + nodeRegisterType(&ntype); } |