diff options
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); } |