kannonier8/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity

Muting node patch: first part

Browse Source 
This allows node type init code to have access to the nodetree type object (needed to allow generic muting node initialization). Huge and boring edits...
This commit is contained in:
Bastien Montagne 2011-11-20 16:13:27 +00:00
parent af66321f3b
commit ca7d391de8
141 changed files with 843 additions and 1025 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -325,7 +325,7 @@ struct bNode *nodeAddNode(struct bNodeTree *ntree, struct bNodeTemplate *ntemp);
void nodeUnlinkNode(struct bNodeTree *ntree, struct bNode *node);
void nodeUniqueName(struct bNodeTree *ntree, struct bNode *node);
void nodeRegisterType(struct ListBase *typelist, struct bNodeType *ntype) ;
void nodeRegisterType(struct bNodeTreeType *ttype, struct bNodeType *ntype) ;
void nodeMakeDynamicType(struct bNode *node);
int nodeDynamicUnlinkText(struct ID *txtid);
@ -368,7 +368,8 @@ struct bNodeTree *nodeGroupEditSet(struct bNode *node, int edit);
void nodeGroupEditClear(struct bNode *node);
/* Init a new node type struct with default values and callbacks */
void node_type_base(struct bNodeType *ntype, int type, const char *name, short nclass, short flag);
void node_type_base(struct bNodeTreeType *ttype, struct bNodeType *ntype, int type,
const char *name, short nclass, short flag);
void node_type_socket_templates(struct bNodeType *ntype, struct bNodeSocketTemplate *inputs, struct bNodeSocketTemplate *outputs);
void node_type_size(struct bNodeType *ntype, int width, int minwidth, int maxwidth);
void node_type_init(struct bNodeType *ntype, void (*initfunc)(struct bNodeTree *ntree, struct bNode *node, struct bNodeTemplate *ntemp));
@ -421,7 +422,7 @@ struct bNode *node_group_make_from_selected(struct bNodeTree *ntree);
int node_group_ungroup(struct bNodeTree *ntree, struct bNode *gnode);
/* in node_common.c */
void register_node_type_frame(ListBase *lb);
void register_node_type_frame(struct bNodeTreeType *ttype);
/* ************** SHADER NODES *************** */

349
source/blender/blenkernel/intern/node.c
View File

@ -1643,7 +1643,7 @@ struct bNodeTemplate nodeMakeTemplate(struct bNode *node)
}
}
void node_type_base(bNodeType *ntype, int type, const char *name, short nclass, short flag)
void node_type_base(bNodeTreeType *ttype, bNodeType *ntype, int type, const char *name, short nclass, short flag)
{
memset(ntype, 0, sizeof(bNodeType));
@ -1772,211 +1772,212 @@ static bNodeType *is_nodetype_registered(ListBase *typelist, int type)
return NULL;
}
void nodeRegisterType(ListBase *typelist, bNodeType *ntype)
void nodeRegisterType(bNodeTreeType *ttype, bNodeType *ntype)
{
ListBase *typelist = &(ttype->node_types);
bNodeType *found= is_nodetype_registered(typelist, ntype->type);
if(found==NULL)
BLI_addtail(typelist, ntype);
}
static void registerCompositNodes(ListBase *ntypelist)
static void registerCompositNodes(bNodeTreeType *ttype)
{
register_node_type_frame(ntypelist);
register_node_type_frame(ttype);
register_node_type_cmp_group(ntypelist);
// register_node_type_cmp_forloop(ntypelist);
// register_node_type_cmp_whileloop(ntypelist);
register_node_type_cmp_group(ttype);
// register_node_type_cmp_forloop(ttype);
// register_node_type_cmp_whileloop(ttype);
register_node_type_cmp_rlayers(ntypelist);
register_node_type_cmp_image(ntypelist);
register_node_type_cmp_texture(ntypelist);
register_node_type_cmp_value(ntypelist);
register_node_type_cmp_rgb(ntypelist);
register_node_type_cmp_curve_time(ntypelist);
register_node_type_cmp_movieclip(ntypelist);
register_node_type_cmp_rlayers(ttype);
register_node_type_cmp_image(ttype);
register_node_type_cmp_texture(ttype);
register_node_type_cmp_value(ttype);
register_node_type_cmp_rgb(ttype);
register_node_type_cmp_curve_time(ttype);
register_node_type_cmp_movieclip(ttype);
register_node_type_cmp_composite(ntypelist);
register_node_type_cmp_viewer(ntypelist);
register_node_type_cmp_splitviewer(ntypelist);
register_node_type_cmp_output_file(ntypelist);
register_node_type_cmp_view_levels(ntypelist);
register_node_type_cmp_composite(ttype);
register_node_type_cmp_viewer(ttype);
register_node_type_cmp_splitviewer(ttype);
register_node_type_cmp_output_file(ttype);
register_node_type_cmp_view_levels(ttype);
register_node_type_cmp_curve_rgb(ntypelist);
register_node_type_cmp_mix_rgb(ntypelist);
register_node_type_cmp_hue_sat(ntypelist);
register_node_type_cmp_brightcontrast(ntypelist);
register_node_type_cmp_gamma(ntypelist);
register_node_type_cmp_invert(ntypelist);
register_node_type_cmp_alphaover(ntypelist);
register_node_type_cmp_zcombine(ntypelist);
register_node_type_cmp_colorbalance(ntypelist);
register_node_type_cmp_huecorrect(ntypelist);
register_node_type_cmp_curve_rgb(ttype);
register_node_type_cmp_mix_rgb(ttype);
register_node_type_cmp_hue_sat(ttype);
register_node_type_cmp_brightcontrast(ttype);
register_node_type_cmp_gamma(ttype);
register_node_type_cmp_invert(ttype);
register_node_type_cmp_alphaover(ttype);
register_node_type_cmp_zcombine(ttype);
register_node_type_cmp_colorbalance(ttype);
register_node_type_cmp_huecorrect(ttype);
register_node_type_cmp_normal(ntypelist);
register_node_type_cmp_curve_vec(ntypelist);
register_node_type_cmp_map_value(ntypelist);
register_node_type_cmp_normalize(ntypelist);
register_node_type_cmp_normal(ttype);
register_node_type_cmp_curve_vec(ttype);
register_node_type_cmp_map_value(ttype);
register_node_type_cmp_normalize(ttype);
register_node_type_cmp_filter(ntypelist);
register_node_type_cmp_blur(ntypelist);
register_node_type_cmp_dblur(ntypelist);
register_node_type_cmp_bilateralblur(ntypelist);
register_node_type_cmp_vecblur(ntypelist);
register_node_type_cmp_dilateerode(ntypelist);
register_node_type_cmp_defocus(ntypelist);
register_node_type_cmp_filter(ttype);
register_node_type_cmp_blur(ttype);
register_node_type_cmp_dblur(ttype);
register_node_type_cmp_bilateralblur(ttype);
register_node_type_cmp_vecblur(ttype);
register_node_type_cmp_dilateerode(ttype);
register_node_type_cmp_defocus(ttype);
register_node_type_cmp_valtorgb(ntypelist);
register_node_type_cmp_rgbtobw(ntypelist);
register_node_type_cmp_setalpha(ntypelist);
register_node_type_cmp_idmask(ntypelist);
register_node_type_cmp_math(ntypelist);
register_node_type_cmp_seprgba(ntypelist);
register_node_type_cmp_combrgba(ntypelist);
register_node_type_cmp_sephsva(ntypelist);
register_node_type_cmp_combhsva(ntypelist);
register_node_type_cmp_sepyuva(ntypelist);
register_node_type_cmp_combyuva(ntypelist);
register_node_type_cmp_sepycca(ntypelist);
register_node_type_cmp_combycca(ntypelist);
register_node_type_cmp_premulkey(ntypelist);
register_node_type_cmp_valtorgb(ttype);
register_node_type_cmp_rgbtobw(ttype);
register_node_type_cmp_setalpha(ttype);
register_node_type_cmp_idmask(ttype);
register_node_type_cmp_math(ttype);
register_node_type_cmp_seprgba(ttype);
register_node_type_cmp_combrgba(ttype);
register_node_type_cmp_sephsva(ttype);
register_node_type_cmp_combhsva(ttype);
register_node_type_cmp_sepyuva(ttype);
register_node_type_cmp_combyuva(ttype);
register_node_type_cmp_sepycca(ttype);
register_node_type_cmp_combycca(ttype);
register_node_type_cmp_premulkey(ttype);
register_node_type_cmp_diff_matte(ntypelist);
register_node_type_cmp_distance_matte(ntypelist);
register_node_type_cmp_chroma_matte(ntypelist);
register_node_type_cmp_color_matte(ntypelist);
register_node_type_cmp_channel_matte(ntypelist);
register_node_type_cmp_color_spill(ntypelist);
register_node_type_cmp_luma_matte(ntypelist);
register_node_type_cmp_diff_matte(ttype);
register_node_type_cmp_distance_matte(ttype);
register_node_type_cmp_chroma_matte(ttype);
register_node_type_cmp_color_matte(ttype);
register_node_type_cmp_channel_matte(ttype);
register_node_type_cmp_color_spill(ttype);
register_node_type_cmp_luma_matte(ttype);
register_node_type_cmp_translate(ntypelist);
register_node_type_cmp_rotate(ntypelist);
register_node_type_cmp_scale(ntypelist);
register_node_type_cmp_flip(ntypelist);
register_node_type_cmp_crop(ntypelist);
register_node_type_cmp_displace(ntypelist);
register_node_type_cmp_mapuv(ntypelist);
register_node_type_cmp_glare(ntypelist);
register_node_type_cmp_tonemap(ntypelist);
register_node_type_cmp_lensdist(ntypelist);
register_node_type_cmp_transform(ntypelist);
register_node_type_cmp_stabilize2d(ntypelist);
register_node_type_cmp_moviedistortion(ntypelist);
register_node_type_cmp_translate(ttype);
register_node_type_cmp_rotate(ttype);
register_node_type_cmp_scale(ttype);
register_node_type_cmp_flip(ttype);
register_node_type_cmp_crop(ttype);
register_node_type_cmp_displace(ttype);
register_node_type_cmp_mapuv(ttype);
register_node_type_cmp_glare(ttype);
register_node_type_cmp_tonemap(ttype);
register_node_type_cmp_lensdist(ttype);
register_node_type_cmp_transform(ttype);
register_node_type_cmp_stabilize2d(ttype);
register_node_type_cmp_moviedistortion(ttype);
}
static void registerShaderNodes(ListBase *ntypelist)
static void registerShaderNodes(bNodeTreeType *ttype)
{
register_node_type_frame(ntypelist);
register_node_type_frame(ttype);
register_node_type_sh_group(ntypelist);
//register_node_type_sh_forloop(ntypelist);
//register_node_type_sh_whileloop(ntypelist);
register_node_type_sh_group(ttype);
//register_node_type_sh_forloop(ttype);
//register_node_type_sh_whileloop(ttype);
register_node_type_sh_output(ntypelist);
register_node_type_sh_material(ntypelist);
register_node_type_sh_camera(ntypelist);
register_node_type_sh_value(ntypelist);
register_node_type_sh_rgb(ntypelist);
register_node_type_sh_mix_rgb(ntypelist);
register_node_type_sh_valtorgb(ntypelist);
register_node_type_sh_rgbtobw(ntypelist);
register_node_type_sh_texture(ntypelist);
register_node_type_sh_normal(ntypelist);
register_node_type_sh_geom(ntypelist);
register_node_type_sh_mapping(ntypelist);
register_node_type_sh_curve_vec(ntypelist);
register_node_type_sh_curve_rgb(ntypelist);
register_node_type_sh_math(ntypelist);
register_node_type_sh_vect_math(ntypelist);
register_node_type_sh_squeeze(ntypelist);
//register_node_type_sh_dynamic(ntypelist);
register_node_type_sh_material_ext(ntypelist);
register_node_type_sh_invert(ntypelist);
register_node_type_sh_seprgb(ntypelist);
register_node_type_sh_combrgb(ntypelist);
register_node_type_sh_hue_sat(ntypelist);
register_node_type_sh_output(ttype);
register_node_type_sh_material(ttype);
register_node_type_sh_camera(ttype);
register_node_type_sh_value(ttype);
register_node_type_sh_rgb(ttype);
register_node_type_sh_mix_rgb(ttype);
register_node_type_sh_valtorgb(ttype);
register_node_type_sh_rgbtobw(ttype);
register_node_type_sh_texture(ttype);
register_node_type_sh_normal(ttype);
register_node_type_sh_geom(ttype);
register_node_type_sh_mapping(ttype);
register_node_type_sh_curve_vec(ttype);
register_node_type_sh_curve_rgb(ttype);
register_node_type_sh_math(ttype);
register_node_type_sh_vect_math(ttype);
register_node_type_sh_squeeze(ttype);
//register_node_type_sh_dynamic(ttype);
register_node_type_sh_material_ext(ttype);
register_node_type_sh_invert(ttype);
register_node_type_sh_seprgb(ttype);
register_node_type_sh_combrgb(ttype);
register_node_type_sh_hue_sat(ttype);
register_node_type_sh_attribute(ntypelist);
register_node_type_sh_geometry(ntypelist);
register_node_type_sh_light_path(ntypelist);
register_node_type_sh_fresnel(ntypelist);
register_node_type_sh_layer_weight(ntypelist);
register_node_type_sh_tex_coord(ntypelist);
register_node_type_sh_attribute(ttype);
register_node_type_sh_geometry(ttype);
register_node_type_sh_light_path(ttype);
register_node_type_sh_fresnel(ttype);
register_node_type_sh_layer_weight(ttype);
register_node_type_sh_tex_coord(ttype);
register_node_type_sh_background(ntypelist);
register_node_type_sh_bsdf_diffuse(ntypelist);
register_node_type_sh_bsdf_glossy(ntypelist);
register_node_type_sh_bsdf_glass(ntypelist);
register_node_type_sh_bsdf_translucent(ntypelist);
register_node_type_sh_bsdf_transparent(ntypelist);
register_node_type_sh_bsdf_velvet(ntypelist);
register_node_type_sh_emission(ntypelist);
register_node_type_sh_holdout(ntypelist);
//register_node_type_sh_volume_transparent(ntypelist);
//register_node_type_sh_volume_isotropic(ntypelist);
register_node_type_sh_mix_shader(ntypelist);
register_node_type_sh_add_shader(ntypelist);
register_node_type_sh_background(ttype);
register_node_type_sh_bsdf_diffuse(ttype);
register_node_type_sh_bsdf_glossy(ttype);
register_node_type_sh_bsdf_glass(ttype);
register_node_type_sh_bsdf_translucent(ttype);
register_node_type_sh_bsdf_transparent(ttype);
register_node_type_sh_bsdf_velvet(ttype);
register_node_type_sh_emission(ttype);
register_node_type_sh_holdout(ttype);
//register_node_type_sh_volume_transparent(ttype);
//register_node_type_sh_volume_isotropic(ttype);
register_node_type_sh_mix_shader(ttype);
register_node_type_sh_add_shader(ttype);
register_node_type_sh_output_lamp(ntypelist);
register_node_type_sh_output_material(ntypelist);
register_node_type_sh_output_world(ntypelist);
register_node_type_sh_output_lamp(ttype);
register_node_type_sh_output_material(ttype);
register_node_type_sh_output_world(ttype);
register_node_type_sh_tex_image(ntypelist);
register_node_type_sh_tex_environment(ntypelist);
register_node_type_sh_tex_sky(ntypelist);
register_node_type_sh_tex_noise(ntypelist);
register_node_type_sh_tex_wave(ntypelist);
register_node_type_sh_tex_voronoi(ntypelist);
register_node_type_sh_tex_musgrave(ntypelist);
register_node_type_sh_tex_gradient(ntypelist);
register_node_type_sh_tex_magic(ntypelist);
register_node_type_sh_tex_image(ttype);
register_node_type_sh_tex_environment(ttype);
register_node_type_sh_tex_sky(ttype);
register_node_type_sh_tex_noise(ttype);
register_node_type_sh_tex_wave(ttype);
register_node_type_sh_tex_voronoi(ttype);
register_node_type_sh_tex_musgrave(ttype);
register_node_type_sh_tex_gradient(ttype);
register_node_type_sh_tex_magic(ttype);
}
static void registerTextureNodes(ListBase *ntypelist)
static void registerTextureNodes(bNodeTreeType *ttype)
{
register_node_type_frame(ntypelist);
register_node_type_frame(ttype);
register_node_type_tex_group(ntypelist);
// register_node_type_tex_forloop(ntypelist);
// register_node_type_tex_whileloop(ntypelist);
register_node_type_tex_group(ttype);
// register_node_type_tex_forloop(ttype);
// register_node_type_tex_whileloop(ttype);
register_node_type_tex_math(ntypelist);
register_node_type_tex_mix_rgb(ntypelist);
register_node_type_tex_valtorgb(ntypelist);
register_node_type_tex_rgbtobw(ntypelist);
register_node_type_tex_valtonor(ntypelist);
register_node_type_tex_curve_rgb(ntypelist);
register_node_type_tex_curve_time(ntypelist);
register_node_type_tex_invert(ntypelist);
register_node_type_tex_hue_sat(ntypelist);
register_node_type_tex_coord(ntypelist);
register_node_type_tex_distance(ntypelist);
register_node_type_tex_compose(ntypelist);
register_node_type_tex_decompose(ntypelist);
register_node_type_tex_math(ttype);
register_node_type_tex_mix_rgb(ttype);
register_node_type_tex_valtorgb(ttype);
register_node_type_tex_rgbtobw(ttype);
register_node_type_tex_valtonor(ttype);
register_node_type_tex_curve_rgb(ttype);
register_node_type_tex_curve_time(ttype);
register_node_type_tex_invert(ttype);
register_node_type_tex_hue_sat(ttype);
register_node_type_tex_coord(ttype);
register_node_type_tex_distance(ttype);
register_node_type_tex_compose(ttype);
register_node_type_tex_decompose(ttype);
register_node_type_tex_output(ntypelist);
register_node_type_tex_viewer(ntypelist);
register_node_type_tex_output(ttype);
register_node_type_tex_viewer(ttype);
register_node_type_tex_checker(ntypelist);
register_node_type_tex_texture(ntypelist);
register_node_type_tex_bricks(ntypelist);
register_node_type_tex_image(ntypelist);
register_node_type_tex_checker(ttype);
register_node_type_tex_texture(ttype);
register_node_type_tex_bricks(ttype);
register_node_type_tex_image(ttype);
register_node_type_tex_rotate(ntypelist);
register_node_type_tex_translate(ntypelist);
register_node_type_tex_scale(ntypelist);
register_node_type_tex_at(ntypelist);
register_node_type_tex_rotate(ttype);
register_node_type_tex_translate(ttype);
register_node_type_tex_scale(ttype);
register_node_type_tex_at(ttype);
register_node_type_tex_proc_voronoi(ntypelist);
register_node_type_tex_proc_blend(ntypelist);
register_node_type_tex_proc_magic(ntypelist);
register_node_type_tex_proc_marble(ntypelist);
register_node_type_tex_proc_clouds(ntypelist);
register_node_type_tex_proc_wood(ntypelist);
register_node_type_tex_proc_musgrave(ntypelist);
register_node_type_tex_proc_noise(ntypelist);
register_node_type_tex_proc_stucci(ntypelist);
register_node_type_tex_proc_distnoise(ntypelist);
register_node_type_tex_proc_voronoi(ttype);
register_node_type_tex_proc_blend(ttype);
register_node_type_tex_proc_magic(ttype);
register_node_type_tex_proc_marble(ttype);
register_node_type_tex_proc_clouds(ttype);
register_node_type_tex_proc_wood(ttype);
register_node_type_tex_proc_musgrave(ttype);
register_node_type_tex_proc_noise(ttype);
register_node_type_tex_proc_stucci(ttype);
register_node_type_tex_proc_distnoise(ttype);
}
static void free_dynamic_typeinfo(bNodeType *ntype)
@ -2010,9 +2011,9 @@ static void free_typeinfos(ListBase *list)
void init_nodesystem(void)
{
registerCompositNodes(&ntreeGetType(NTREE_COMPOSIT)->node_types);
registerShaderNodes(&ntreeGetType(NTREE_SHADER)->node_types);
registerTextureNodes(&ntreeGetType(NTREE_TEXTURE)->node_types);
registerCompositNodes(ntreeGetType(NTREE_COMPOSIT));
registerShaderNodes(ntreeGetType(NTREE_SHADER));
registerTextureNodes(ntreeGetType(NTREE_TEXTURE));
}
void free_nodesystem(void)

140
source/blender/nodes/NOD_composite.h
View File

@ -42,84 +42,84 @@ extern bNodeTreeType ntreeType_Composite;
/* ****************** types array for all composite nodes ****************** */
void register_node_type_cmp_group(ListBase *lb);
void register_node_type_cmp_forloop(ListBase *lb);
void register_node_type_cmp_whileloop(ListBase *lb);
void register_node_type_cmp_group(struct bNodeTreeType *ttype);
void register_node_type_cmp_forloop(struct bNodeTreeType *ttype);
void register_node_type_cmp_whileloop(struct bNodeTreeType *ttype);
void register_node_type_cmp_rlayers(ListBase *lb);
void register_node_type_cmp_image(ListBase *lb);
void register_node_type_cmp_texture(ListBase *lb);
void register_node_type_cmp_value(ListBase *lb);
void register_node_type_cmp_rgb(ListBase *lb);
void register_node_type_cmp_curve_time(ListBase *lb);
void register_node_type_cmp_movieclip(ListBase *lb);
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_composite(ListBase *lb);
void register_node_type_cmp_viewer(ListBase *lb);
void register_node_type_cmp_splitviewer(ListBase *lb);
void register_node_type_cmp_output_file(ListBase *lb);
void register_node_type_cmp_view_levels(ListBase *lb);
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(ListBase *lb);
void register_node_type_cmp_mix_rgb(ListBase *lb);
void register_node_type_cmp_hue_sat(ListBase *lb);
void register_node_type_cmp_brightcontrast(ListBase *lb);
void register_node_type_cmp_gamma(ListBase *lb);
void register_node_type_cmp_invert(ListBase *lb);
void register_node_type_cmp_alphaover(ListBase *lb);
void register_node_type_cmp_zcombine(ListBase *lb);
void register_node_type_cmp_colorbalance(ListBase *lb);
void register_node_type_cmp_huecorrect(ListBase *lb);
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(ListBase *lb);
void register_node_type_cmp_curve_vec(ListBase *lb);
void register_node_type_cmp_map_value(ListBase *lb);
void register_node_type_cmp_normalize(ListBase *lb);
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_normalize(struct bNodeTreeType *ttype);
void register_node_type_cmp_filter(ListBase *lb);
void register_node_type_cmp_blur(ListBase *lb);
void register_node_type_cmp_dblur(ListBase *lb);
void register_node_type_cmp_bilateralblur(ListBase *lb);
void register_node_type_cmp_vecblur(ListBase *lb);
void register_node_type_cmp_dilateerode(ListBase *lb);
void register_node_type_cmp_defocus(ListBase *lb);
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_defocus(struct bNodeTreeType *ttype);
void register_node_type_cmp_valtorgb(ListBase *lb);
void register_node_type_cmp_rgbtobw(ListBase *lb);
void register_node_type_cmp_setalpha(ListBase *lb);
void register_node_type_cmp_idmask(ListBase *lb);
void register_node_type_cmp_math(ListBase *lb);
void register_node_type_cmp_seprgba(ListBase *lb);
void register_node_type_cmp_combrgba(ListBase *lb);
void register_node_type_cmp_sephsva(ListBase *lb);
void register_node_type_cmp_combhsva(ListBase *lb);
void register_node_type_cmp_sepyuva(ListBase *lb);
void register_node_type_cmp_combyuva(ListBase *lb);
void register_node_type_cmp_sepycca(ListBase *lb);
void register_node_type_cmp_combycca(ListBase *lb);
void register_node_type_cmp_premulkey(ListBase *lb);
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(ListBase *lb);
void register_node_type_cmp_distance_matte(ListBase *lb);
void register_node_type_cmp_chroma_matte(ListBase *lb);
void register_node_type_cmp_color_matte(ListBase *lb);
void register_node_type_cmp_channel_matte(ListBase *lb);
void register_node_type_cmp_color_spill(ListBase *lb);
void register_node_type_cmp_luma_matte(ListBase *lb);
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_translate(ListBase *lb);
void register_node_type_cmp_rotate(ListBase *lb);
void register_node_type_cmp_scale(ListBase *lb);
void register_node_type_cmp_flip(ListBase *lb);
void register_node_type_cmp_crop(ListBase *lb);
void register_node_type_cmp_displace(ListBase *lb);
void register_node_type_cmp_mapuv(ListBase *lb);
void register_node_type_cmp_transform(ListBase *lb);
void register_node_type_cmp_stabilize2d(ListBase *lb);
void register_node_type_cmp_moviedistortion(ListBase *lb);
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_glare(ListBase *lb);
void register_node_type_cmp_tonemap(ListBase *lb);
void register_node_type_cmp_lensdist(ListBase *lb);
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);
#endif

114
source/blender/nodes/NOD_shader.h
View File

@ -43,68 +43,68 @@ extern struct bNodeTreeType ntreeType_Shader;
/* the type definitions array */
/* ****************** types array for all shaders ****************** */
void register_node_type_sh_group(ListBase *lb);
void register_node_type_sh_forloop(ListBase *lb);
void register_node_type_sh_whileloop(ListBase *lb);
void register_node_type_sh_group(struct bNodeTreeType *ttype);
void register_node_type_sh_forloop(struct bNodeTreeType *ttype);
void register_node_type_sh_whileloop(struct bNodeTreeType *ttype);
void register_node_type_sh_output(ListBase *lb);
void register_node_type_sh_material(ListBase *lb);
void register_node_type_sh_camera(ListBase *lb);
void register_node_type_sh_value(ListBase *lb);
void register_node_type_sh_rgb(ListBase *lb);
void register_node_type_sh_mix_rgb(ListBase *lb);
void register_node_type_sh_valtorgb(ListBase *lb);
void register_node_type_sh_rgbtobw(ListBase *lb);
void register_node_type_sh_texture(ListBase *lb);
void register_node_type_sh_normal(ListBase *lb);
void register_node_type_sh_geom(ListBase *lb);
void register_node_type_sh_mapping(ListBase *lb);
void register_node_type_sh_curve_vec(ListBase *lb);
void register_node_type_sh_curve_rgb(ListBase *lb);
void register_node_type_sh_math(ListBase *lb);
void register_node_type_sh_vect_math(ListBase *lb);
void register_node_type_sh_squeeze(ListBase *lb);
void register_node_type_sh_dynamic(ListBase *lb);
void register_node_type_sh_material_ext(ListBase *lb);
void register_node_type_sh_invert(ListBase *lb);
void register_node_type_sh_seprgb(ListBase *lb);
void register_node_type_sh_combrgb(ListBase *lb);
void register_node_type_sh_hue_sat(ListBase *lb);
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_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_attribute(ListBase *lb);
void register_node_type_sh_geometry(ListBase *lb);
void register_node_type_sh_light_path(ListBase *lb);
void register_node_type_sh_fresnel(ListBase *lb);
void register_node_type_sh_layer_weight(ListBase *lb);
void register_node_type_sh_tex_coord(ListBase *lb);
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_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_background(ListBase *lb);
void register_node_type_sh_bsdf_diffuse(ListBase *lb);
void register_node_type_sh_bsdf_glossy(ListBase *lb);
void register_node_type_sh_bsdf_glass(ListBase *lb);
void register_node_type_sh_bsdf_translucent(ListBase *lb);
void register_node_type_sh_bsdf_transparent(ListBase *lb);
void register_node_type_sh_bsdf_velvet(ListBase *lb);
void register_node_type_sh_emission(ListBase *lb);
void register_node_type_sh_holdout(ListBase *lb);
void register_node_type_sh_volume_transparent(ListBase *lb);
void register_node_type_sh_volume_isotropic(ListBase *lb);
void register_node_type_sh_mix_shader(ListBase *lb);
void register_node_type_sh_add_shader(ListBase *lb);
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_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_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(ListBase *lb);
void register_node_type_sh_output_material(ListBase *lb);
void register_node_type_sh_output_world(ListBase *lb);
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(ListBase *lb);
void register_node_type_sh_tex_environment(ListBase *lb);
void register_node_type_sh_tex_sky(ListBase *lb);
void register_node_type_sh_tex_voronoi(ListBase *lb);
void register_node_type_sh_tex_gradient(ListBase *lb);
void register_node_type_sh_tex_magic(ListBase *lb);
void register_node_type_sh_tex_wave(ListBase *lb);
void register_node_type_sh_tex_musgrave(ListBase *lb);
void register_node_type_sh_tex_noise(ListBase *lb);
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);
#endif

72
source/blender/nodes/NOD_texture.h
View File

@ -42,45 +42,45 @@ extern bNodeTreeType ntreeType_Texture;
/* ****************** types array for all texture nodes ****************** */
void register_node_type_tex_group(ListBase *lb);
void register_node_type_tex_forloop(ListBase *lb);
void register_node_type_tex_whileloop(ListBase *lb);
void register_node_type_tex_group(struct bNodeTreeType *ttype);
void register_node_type_tex_forloop(struct bNodeTreeType *ttype);
void register_node_type_tex_whileloop(struct bNodeTreeType *ttype);
void register_node_type_tex_math(ListBase *lb);
void register_node_type_tex_mix_rgb(ListBase *lb);
void register_node_type_tex_valtorgb(ListBase *lb);
void register_node_type_tex_valtonor(ListBase *lb);
void register_node_type_tex_rgbtobw(ListBase *lb);
void register_node_type_tex_output(ListBase *lb);
void register_node_type_tex_viewer(ListBase *lb);
void register_node_type_tex_checker(ListBase *lb);
void register_node_type_tex_texture(ListBase *lb);
void register_node_type_tex_bricks(ListBase *lb);
void register_node_type_tex_image(ListBase *lb);
void register_node_type_tex_curve_rgb(ListBase *lb);
void register_node_type_tex_curve_time(ListBase *lb);
void register_node_type_tex_invert(ListBase *lb);
void register_node_type_tex_hue_sat(ListBase *lb);
void register_node_type_tex_coord(ListBase *lb);
void register_node_type_tex_distance(ListBase *lb);
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_rotate(ListBase *lb);
void register_node_type_tex_translate(ListBase *lb);
void register_node_type_tex_scale(ListBase *lb);
void register_node_type_tex_at(ListBase *lb);
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_compose(ListBase *lb);
void register_node_type_tex_decompose(ListBase *lb);
void register_node_type_tex_compose(struct bNodeTreeType *ttype);
void register_node_type_tex_decompose(struct bNodeTreeType *ttype);
void register_node_type_tex_proc_voronoi(ListBase *lb);
void register_node_type_tex_proc_blend(ListBase *lb);
void register_node_type_tex_proc_magic(ListBase *lb);
void register_node_type_tex_proc_marble(ListBase *lb);
void register_node_type_tex_proc_clouds(ListBase *lb);
void register_node_type_tex_proc_wood(ListBase *lb);
void register_node_type_tex_proc_musgrave(ListBase *lb);
void register_node_type_tex_proc_noise(ListBase *lb);
void register_node_type_tex_proc_stucci(ListBase *lb);
void register_node_type_tex_proc_distnoise(ListBase *lb);
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);
#endif

9
source/blender/nodes/composite/nodes/node_composite_alphaOver.c
View File

@ -143,19 +143,16 @@ static void node_alphaover_init(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemp
node->storage= MEM_callocN(sizeof(NodeTwoFloats), "NodeTwoFloats");
}
void register_node_type_cmp_alphaover(ListBase *lb)
void register_node_type_cmp_alphaover(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_ALPHAOVER, "AlphaOver", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_base(ttype, &ntype, CMP_NODE_ALPHAOVER, "AlphaOver", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_alphaover_in, cmp_node_alphaover_out);
node_type_size(&ntype, 80, 40, 120);
node_type_init(&ntype, node_alphaover_init);
node_type_storage(&ntype, "NodeTwoFloats", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_alphaover);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

7
source/blender/nodes/composite/nodes/node_composite_bilateralblur.c
View File

@ -258,17 +258,16 @@ static void node_composit_init_bilateralblur(bNodeTree *UNUSED(ntree), bNode* no
nbbd->sigma_space= 5.0;
}
void register_node_type_cmp_bilateralblur(ListBase *lb)
void register_node_type_cmp_bilateralblur(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_BILATERALBLUR, "Bilateral Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 150, 120, 200);
node_type_init(&ntype, node_composit_init_bilateralblur);
node_type_storage(&ntype, "NodeBilateralBlurData", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_bilateralblur);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/composite/nodes/node_composite_blur.c
View File

@ -716,19 +716,16 @@ static void node_composit_init_blur(bNodeTree *UNUSED(ntree), bNode* node, bNode
node->storage= MEM_callocN(sizeof(NodeBlurData), "node blur data");
}
void register_node_type_cmp_blur(ListBase *lb)
void register_node_type_cmp_blur(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_BLUR, "Blur", NODE_CLASS_OP_FILTER, NODE_PREVIEW|NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 120, 80, 200);
node_type_init(&ntype, node_composit_init_blur);
node_type_storage(&ntype, "NodeBlurData", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_blur);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

7
source/blender/nodes/composite/nodes/node_composite_brightness.c
View File

@ -94,15 +94,14 @@ static void node_composit_exec_brightcontrast(void *UNUSED(data), bNode *node, b
}
}
void register_node_type_cmp_brightcontrast(ListBase *lb)
void register_node_type_cmp_brightcontrast(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_BRIGHTCONTRAST, "Bright/Contrast", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_base(ttype, &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);
node_type_size(&ntype, 140, 100, 320);
node_type_exec(&ntype, node_composit_exec_brightcontrast);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

6
source/blender/nodes/composite/nodes/node_composite_channelMatte.c
View File

@ -200,16 +200,16 @@ static void node_composit_init_channel_matte(bNodeTree *UNUSED(ntree), bNode* no
node->custom2= 2; /* Green Channel */
}
void register_node_type_cmp_channel_matte(ListBase *lb)
void register_node_type_cmp_channel_matte(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_CHANNEL_MATTE, "Channel Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 200, 80, 250);
node_type_init(&ntype, node_composit_init_channel_matte);
node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_channel_matte);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/composite/nodes/node_composite_chromaMatte.c
View File

@ -187,19 +187,16 @@ static void node_composit_init_chroma_matte(bNodeTree *UNUSED(ntree), bNode* nod
c->fstrength= 1.0f;
}
void register_node_type_cmp_chroma_matte(ListBase *lb)
void register_node_type_cmp_chroma_matte(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_CHROMA_MATTE, "Chroma Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 200, 80, 300);
node_type_init(&ntype, node_composit_init_chroma_matte);
node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_chroma_matte);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/composite/nodes/node_composite_colorMatte.c
View File

@ -123,19 +123,16 @@ static void node_composit_init_color_matte(bNodeTree *UNUSED(ntree), bNode* node
c->fstrength= 1.0f;
}
void register_node_type_cmp_color_matte(ListBase *lb)
void register_node_type_cmp_color_matte(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_COLOR_MATTE, "Color Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 200, 80, 300);
node_type_init(&ntype, node_composit_init_color_matte);
node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_color_matte);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

6
source/blender/nodes/composite/nodes/node_composite_colorSpill.c
View File

@ -324,16 +324,16 @@ 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(ListBase *lb)
void register_node_type_cmp_color_spill(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_COLOR_SPILL, "Color Spill", NODE_CLASS_MATTE, NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 140, 80, 200);
node_type_init(&ntype, node_composit_init_color_spill);
node_type_storage(&ntype, "NodeColorspill", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_color_spill);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

8
source/blender/nodes/composite/nodes/node_composite_colorbalance.c
View File

@ -182,18 +182,16 @@ 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(ListBase *lb)
void register_node_type_cmp_colorbalance(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_COLORBALANCE, "Color Balance", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_base(ttype, &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);
node_type_exec(&ntype, node_composit_exec_colorbalance);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

18
source/blender/nodes/composite/nodes/node_composite_common.c
View File

@ -206,11 +206,11 @@ static void group_execute(void *data, int thread, struct bNode *node, void *node
group_move_outputs(node, out, exec->stack);
}
void register_node_type_cmp_group(ListBase *lb)
void register_node_type_cmp_group(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, NODE_GROUP, "Group", NODE_CLASS_GROUP, NODE_OPTIONS|NODE_CONST_OUTPUT);
node_type_base(ttype, &ntype, NODE_GROUP, "Group", NODE_CLASS_GROUP, NODE_OPTIONS|NODE_CONST_OUTPUT);
node_type_socket_templates(&ntype, NULL, NULL);
node_type_size(&ntype, 120, 60, 200);
node_type_label(&ntype, node_group_label);
@ -221,7 +221,7 @@ void register_node_type_cmp_group(ListBase *lb)
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);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}
@ -290,11 +290,11 @@ static void forloop_execute(void *data, int thread, struct bNode *node, void *no
group_move_outputs(node, out, exec->stack);
}
void register_node_type_cmp_forloop(ListBase *lb)
void register_node_type_cmp_forloop(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, NODE_FORLOOP, "For", NODE_CLASS_GROUP, NODE_OPTIONS);
node_type_base(ttype, &ntype, NODE_FORLOOP, "For", NODE_CLASS_GROUP, NODE_OPTIONS);
node_type_socket_templates(&ntype, NULL, NULL);
node_type_size(&ntype, 120, 60, 200);
node_type_label(&ntype, node_group_label);
@ -306,7 +306,7 @@ void register_node_type_cmp_forloop(ListBase *lb)
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, forloop_execute);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}
#endif
@ -351,11 +351,11 @@ static void whileloop_execute(void *data, int thread, struct bNode *node, void *
group_move_outputs(node, out, exec->stack);
}
void register_node_type_cmp_whileloop(ListBase *lb)
void register_node_type_cmp_whileloop(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, NODE_WHILELOOP, "While", NODE_CLASS_GROUP, NODE_OPTIONS);
node_type_base(ttype, &ntype, NODE_WHILELOOP, "While", NODE_CLASS_GROUP, NODE_OPTIONS);
node_type_socket_templates(&ntype, NULL, NULL);
node_type_size(&ntype, 120, 60, 200);
node_type_label(&ntype, node_group_label);
@ -367,6 +367,6 @@ void register_node_type_cmp_whileloop(ListBase *lb)
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, whileloop_execute);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}
#endif

7
source/blender/nodes/composite/nodes/node_composite_composite.c
View File

@ -97,15 +97,14 @@ static void node_composit_exec_composite(void *data, bNode *node, bNodeStack **i
generate_preview(data, node, in[0]->data);
}
void register_node_type_cmp_composite(ListBase *lb)
void register_node_type_cmp_composite(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_COMPOSITE, "Composite", NODE_CLASS_OUTPUT, NODE_PREVIEW);
node_type_base(ttype, &ntype, CMP_NODE_COMPOSITE, "Composite", NODE_CLASS_OUTPUT, NODE_PREVIEW);
node_type_socket_templates(&ntype, cmp_node_composite_in, NULL);
node_type_size(&ntype, 80, 60, 200);
node_type_exec(&ntype, node_composit_exec_composite);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

7
source/blender/nodes/composite/nodes/node_composite_crop.c
View File

@ -111,17 +111,16 @@ static void node_composit_init_crop(bNodeTree *UNUSED(ntree), bNode* node, bNode
nxy->y2= 0;
}
void register_node_type_cmp_crop(ListBase *lb)
void register_node_type_cmp_crop(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_CROP, "Crop", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 140, 100, 320);
node_type_init(&ntype, node_composit_init_crop);
node_type_storage(&ntype, "NodeTwoXYs", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_crop);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

21
source/blender/nodes/composite/nodes/node_composite_curves.c
View File

@ -62,23 +62,22 @@ static void node_composit_init_curves_time(bNodeTree *UNUSED(ntree), bNode* node
node->storage= curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
}
void register_node_type_cmp_curve_time(ListBase *lb)
void register_node_type_cmp_curve_time(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_TIME, "Time", NODE_CLASS_INPUT, NODE_OPTIONS);
node_type_base(ttype, &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);
node_type_exec(&ntype, node_composit_exec_curves_time);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}
/* **************** CURVE VEC ******************** */
static bNodeSocketTemplate cmp_node_curve_vec_in[]= {
{ SOCK_VECTOR, 1, "Vector", 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE},
@ -103,18 +102,18 @@ 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(ListBase *lb)
void register_node_type_cmp_curve_vec(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_CURVE_VEC, "Vector Curves", NODE_CLASS_OP_VECTOR, NODE_OPTIONS);
node_type_base(ttype, &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);
node_type_exec(&ntype, node_composit_exec_curve_vec);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}
@ -190,18 +189,16 @@ 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(ListBase *lb)
void register_node_type_cmp_curve_rgb(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_base(ttype, &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);
node_type_exec(&ntype, node_composit_exec_curve_rgb);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/composite/nodes/node_composite_defocus.c
View File

@ -875,19 +875,16 @@ static void node_composit_init_defocus(bNodeTree *UNUSED(ntree), bNode* node, bN
node->storage = nbd;
}
void register_node_type_cmp_defocus(ListBase *lb)
void register_node_type_cmp_defocus(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_DEFOCUS, "Defocus", NODE_CLASS_OP_FILTER, NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 150, 120, 200);
node_type_init(&ntype, node_composit_init_defocus);
node_type_storage(&ntype, "NodeDefocus", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_defocus);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/composite/nodes/node_composite_diffMatte.c
View File

@ -131,19 +131,16 @@ static void node_composit_init_diff_matte(bNodeTree *UNUSED(ntree), bNode* node,
c->t2= 0.1f;
}
void register_node_type_cmp_diff_matte(ListBase *lb)
void register_node_type_cmp_diff_matte(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_DIFF_MATTE, "Difference Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 200, 80, 250);
node_type_init(&ntype, node_composit_init_diff_matte);
node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_diff_matte);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

8
source/blender/nodes/composite/nodes/node_composite_dilate.c
View File

@ -146,16 +146,14 @@ static void node_composit_exec_dilateerode(void *UNUSED(data), bNode *node, bNod
}
}
void register_node_type_cmp_dilateerode(ListBase *lb)
void register_node_type_cmp_dilateerode(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_DILATEERODE, "Dilate/Erode", NODE_CLASS_OP_FILTER, NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 130, 100, 320);
node_type_exec(&ntype, node_composit_exec_dilateerode);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

7
source/blender/nodes/composite/nodes/node_composite_directionalblur.c
View File

@ -130,17 +130,16 @@ static void node_composit_init_dblur(bNodeTree *UNUSED(ntree), bNode* node, bNod
ndbd->center_y= 0.5;
}
void register_node_type_cmp_dblur(ListBase *lb)
void register_node_type_cmp_dblur(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_DBLUR, "Directional Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 150, 120, 200);
node_type_init(&ntype, node_composit_init_dblur);
node_type_storage(&ntype, "NodeDBlurData", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_dblur);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

8
source/blender/nodes/composite/nodes/node_composite_displace.c
View File

@ -182,16 +182,14 @@ static void node_composit_exec_displace(void *UNUSED(data), bNode *node, bNodeSt
}
}
void register_node_type_cmp_displace(ListBase *lb)
void register_node_type_cmp_displace(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_DISPLACE, "Displace", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_base(ttype, &ntype, CMP_NODE_DISPLACE, "Displace", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_displace_in, cmp_node_displace_out);
node_type_size(&ntype, 140, 100, 320);
node_type_exec(&ntype, node_composit_exec_displace);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/composite/nodes/node_composite_distanceMatte.c
View File

@ -128,19 +128,16 @@ static void node_composit_init_distance_matte(bNodeTree *UNUSED(ntree), bNode* n
c->t2= 0.1f;
}
void register_node_type_cmp_distance_matte(ListBase *lb)
void register_node_type_cmp_distance_matte(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_DIST_MATTE, "Distance Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 200, 80, 250);
node_type_init(&ntype, node_composit_init_distance_matte);
node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_distance_matte);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/composite/nodes/node_composite_filter.c
View File

@ -220,18 +220,15 @@ static void node_composit_exec_filter(void *data, bNode *node, bNodeStack **in,
}
void register_node_type_cmp_filter(ListBase *lb)
void register_node_type_cmp_filter(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_FILTER, "Filter", NODE_CLASS_OP_FILTER, NODE_PREVIEW|NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 80, 40, 120);
node_type_label(&ntype, node_filter_label);
node_type_exec(&ntype, node_composit_exec_filter);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/composite/nodes/node_composite_flip.c
View File

@ -88,17 +88,14 @@ static void node_composit_exec_flip(void *UNUSED(data), bNode *node, bNodeStack
}
}
void register_node_type_cmp_flip(ListBase *lb)
void register_node_type_cmp_flip(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_FLIP, "Flip", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_base(ttype, &ntype, CMP_NODE_FLIP, "Flip", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_flip_in, cmp_node_flip_out);
node_type_size(&ntype, 140, 100, 320);
node_type_exec(&ntype, node_composit_exec_flip);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

6
source/blender/nodes/composite/nodes/node_composite_gamma.c
View File

@ -75,14 +75,14 @@ static void node_composit_exec_gamma(void *UNUSED(data), bNode *node, bNodeStack
}
}
void register_node_type_cmp_gamma(ListBase *lb)
void register_node_type_cmp_gamma(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_GAMMA, "Gamma", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_base(ttype, &ntype, CMP_NODE_GAMMA, "Gamma", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_gamma_in, cmp_node_gamma_out);
node_type_size(&ntype, 140, 100, 320);
node_type_exec(&ntype, node_composit_exec_gamma);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

7
source/blender/nodes/composite/nodes/node_composite_glare.c
View File

@ -489,17 +489,16 @@ static void node_composit_init_glare(bNodeTree *UNUSED(ntree), bNode* node, bNod
node->storage = ndg;
}
void register_node_type_cmp_glare(ListBase *lb)
void register_node_type_cmp_glare(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_GLARE, "Glare", NODE_CLASS_OP_FILTER, NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 150, 120, 200);
node_type_init(&ntype, node_composit_init_glare);
node_type_storage(&ntype, "NodeGlare", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_glare);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/composite/nodes/node_composite_hueSatVal.c
View File

@ -102,19 +102,16 @@ static void node_composit_init_hue_sat(bNodeTree *UNUSED(ntree), bNode* node, bN
nhs->val= 1.0f;
}
void register_node_type_cmp_hue_sat(ListBase *lb)
void register_node_type_cmp_hue_sat(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 150, 80, 250);
node_type_init(&ntype, node_composit_init_hue_sat);
node_type_storage(&ntype, "NodeHueSat", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_hue_sat);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

8
source/blender/nodes/composite/nodes/node_composite_huecorrect.c
View File

@ -151,18 +151,16 @@ static void node_composit_init_huecorrect(bNodeTree *UNUSED(ntree), bNode* node,
cumapping->cur = 1;
}
void register_node_type_cmp_huecorrect(ListBase *lb)
void register_node_type_cmp_huecorrect(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_HUECORRECT, "Hue Correct", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_base(ttype, &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, 400);
node_type_init(&ntype, node_composit_init_huecorrect);
node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves);
node_type_exec(&ntype, node_composit_exec_huecorrect);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/composite/nodes/node_composite_idMask.c
View File

@ -107,17 +107,14 @@ static void node_composit_exec_idmask(void *data, bNode *node, bNodeStack **in,
}
void register_node_type_cmp_idmask(ListBase *lb)
void register_node_type_cmp_idmask(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_ID_MASK, "ID Mask", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_base(ttype, &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);
node_type_size(&ntype, 140, 100, 320);
node_type_exec(&ntype, node_composit_exec_idmask);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

15
source/blender/nodes/composite/nodes/node_composite_image.c
View File

@ -314,18 +314,18 @@ static void node_composit_init_image(bNodeTree *UNUSED(ntree), bNode* node, bNod
iuser->ok= 1;
}
void register_node_type_cmp_image(ListBase *lb)
void register_node_type_cmp_image(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_IMAGE, "Image", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS);
node_type_base(ttype, &ntype, CMP_NODE_IMAGE, "Image", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS);
node_type_socket_templates(&ntype, NULL, cmp_node_rlayers_out);
node_type_size(&ntype, 120, 80, 300);
node_type_init(&ntype, node_composit_init_image);
node_type_storage(&ntype, "ImageUser", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_image);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}
@ -445,17 +445,14 @@ static void node_composit_exec_rlayers(void *data, bNode *node, bNodeStack **UNU
}
void register_node_type_cmp_rlayers(ListBase *lb)
void register_node_type_cmp_rlayers(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_R_LAYERS, "Render Layers", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS);
node_type_base(ttype, &ntype, CMP_NODE_R_LAYERS, "Render Layers", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS);
node_type_socket_templates(&ntype, NULL, cmp_node_rlayers_out);
node_type_size(&ntype, 150, 100, 300);
node_type_exec(&ntype, node_composit_exec_rlayers);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

7
source/blender/nodes/composite/nodes/node_composite_invert.c
View File

@ -118,16 +118,15 @@ static void node_composit_init_invert(bNodeTree *UNUSED(ntree), bNode* node, bNo
}
/* custom1 = mix type */
void register_node_type_cmp_invert(ListBase *lb)
void register_node_type_cmp_invert(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 120, 120, 140);
node_type_init(&ntype, node_composit_init_invert);
node_type_exec(&ntype, node_composit_exec_invert);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

7
source/blender/nodes/composite/nodes/node_composite_lensdist.c
View File

@ -190,17 +190,16 @@ static void node_composit_init_lensdist(bNodeTree *UNUSED(ntree), bNode* node, b
}
void register_node_type_cmp_lensdist(ListBase *lb)
void register_node_type_cmp_lensdist(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_LENSDIST, "Lens Distortion", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 150, 120, 200);
node_type_init(&ntype, node_composit_init_lensdist);
node_type_storage(&ntype, "NodeLensDist", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_lensdist);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

8
source/blender/nodes/composite/nodes/node_composite_levels.c
View File

@ -320,18 +320,16 @@ static void node_composit_init_view_levels(bNodeTree *UNUSED(ntree), bNode* node
node->custom1=1; /*All channels*/
}
void register_node_type_cmp_view_levels(ListBase *lb)
void register_node_type_cmp_view_levels(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_VIEW_LEVELS, "Levels", NODE_CLASS_OUTPUT, NODE_OPTIONS|NODE_PREVIEW);
node_type_base(ttype, &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_size(&ntype, 140, 100, 320);
node_type_init(&ntype, node_composit_init_view_levels);
node_type_storage(&ntype, "ImageUser", NULL, NULL);
node_type_exec(&ntype, node_composit_exec_view_levels);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

8
source/blender/nodes/composite/nodes/node_composite_lummaMatte.c
View File

@ -104,18 +104,16 @@ static void node_composit_init_luma_matte(bNodeTree *UNUSED(ntree), bNode* node,
c->t2= 0.0f;
}
void register_node_type_cmp_luma_matte(ListBase *lb)
void register_node_type_cmp_luma_matte(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_LUMA_MATTE, "Luminance Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 200, 80, 250);
node_type_init(&ntype, node_composit_init_luma_matte);
node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_luma_matte);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/composite/nodes/node_composite_mapUV.c
View File

@ -162,17 +162,14 @@ static void node_composit_exec_mapuv(void *UNUSED(data), bNode *node, bNodeStack
}
}
void register_node_type_cmp_mapuv(ListBase *lb)
void register_node_type_cmp_mapuv(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_MAP_UV, "Map UV", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_base(ttype, &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);
node_type_size(&ntype, 140, 100, 320);
node_type_exec(&ntype, node_composit_exec_mapuv);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

10
source/blender/nodes/composite/nodes/node_composite_mapValue.c
View File

@ -82,20 +82,16 @@ static void node_composit_init_map_value(bNodeTree *UNUSED(ntree), bNode* node,
node->storage= add_tex_mapping();
}
void register_node_type_cmp_map_value(ListBase *lb)
void register_node_type_cmp_map_value(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_MAP_VALUE, "Map Value", NODE_CLASS_OP_VECTOR, NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 100, 60, 150);
node_type_init(&ntype, node_composit_init_map_value);
node_type_storage(&ntype, "TexMapping", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_map_value);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

10
source/blender/nodes/composite/nodes/node_composite_math.c
View File

@ -194,19 +194,15 @@ static void node_composit_exec_math(void *UNUSED(data), bNode *node, bNodeStack
out[0]->data= stackbuf;
}
void register_node_type_cmp_math(ListBase *lb)
void register_node_type_cmp_math(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 120, 110, 160);
node_type_label(&ntype, node_math_label);
node_type_exec(&ntype, node_composit_exec_math);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

7
source/blender/nodes/composite/nodes/node_composite_mixrgb.c
View File

@ -82,16 +82,15 @@ static void node_composit_exec_mix_rgb(void *data, bNode *node, bNodeStack **in,
}
/* custom1 = mix type */
void register_node_type_cmp_mix_rgb(ListBase *lb)
void register_node_type_cmp_mix_rgb(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, NODE_PREVIEW|NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 110, 60, 120);
node_type_label(&ntype, node_blend_label);
node_type_exec(&ntype, node_composit_exec_mix_rgb);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

6
source/blender/nodes/composite/nodes/node_composite_movieclip.c
View File

@ -142,16 +142,16 @@ static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(nt
user->framenr= 1;
}
void register_node_type_cmp_movieclip(ListBase *lb)
void register_node_type_cmp_movieclip(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_MOVIECLIP, "Movie Clip", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 120, 80, 300);
node_type_init(&ntype, init);
node_type_storage(&ntype, "MovieClipUser", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_movieclip);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

6
source/blender/nodes/composite/nodes/node_composite_moviedistortion.c
View File

@ -124,16 +124,16 @@ static void storage_copy(bNode *orig_node, bNode *new_node)
new_node->storage= BKE_tracking_distortion_copy(orig_node->storage);
}
void register_node_type_cmp_moviedistortion(ListBase *lb)
void register_node_type_cmp_moviedistortion(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_MOVIEDISTORTION, "Movie Distortion", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 140, 100, 320);
node_type_label(&ntype, label);
node_type_exec(&ntype, exec);
node_type_storage(&ntype, NULL, storage_free, storage_copy);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

8
source/blender/nodes/composite/nodes/node_composite_normal.c
View File

@ -91,17 +91,15 @@ static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(nt
nor[2] = 1.0f;
}
void register_node_type_cmp_normal(ListBase *lb)
void register_node_type_cmp_normal(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_NORMAL, "Normal", NODE_CLASS_OP_VECTOR, NODE_OPTIONS);
node_type_base(ttype, &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);
node_type_size(&ntype, 100, 60, 200);
node_type_exec(&ntype, node_composit_exec_normal);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

6
source/blender/nodes/composite/nodes/node_composite_normalize.c
View File

@ -101,14 +101,14 @@ static void node_composit_exec_normalize(void *UNUSED(data), bNode *node, bNodeS
}
}
void register_node_type_cmp_normalize(ListBase *lb)
void register_node_type_cmp_normalize(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_NORMALIZE, "Normalize", NODE_CLASS_OP_VECTOR, NODE_OPTIONS);
node_type_base(ttype, &ntype, CMP_NODE_NORMALIZE, "Normalize", NODE_CLASS_OP_VECTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_normalize_in, cmp_node_normalize_out);
node_type_size(&ntype, 100, 60, 150);
node_type_exec(&ntype, node_composit_exec_normalize);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/composite/nodes/node_composite_outputFile.c
View File

@ -108,19 +108,16 @@ static void node_composit_init_output_file(bNodeTree *UNUSED(ntree), bNode* node
}
}
void register_node_type_cmp_output_file(ListBase *lb)
void register_node_type_cmp_output_file(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_OUTPUT_FILE, "File Output", NODE_CLASS_OUTPUT, NODE_PREVIEW|NODE_OPTIONS);
node_type_base(ttype, &ntype, CMP_NODE_OUTPUT_FILE, "File Output", NODE_CLASS_OUTPUT, NODE_PREVIEW|NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_output_file_in, NULL);
node_type_size(&ntype, 140, 80, 300);
node_type_init(&ntype, node_composit_init_output_file);
node_type_storage(&ntype, "NodeImageFile", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_output_file);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

8
source/blender/nodes/composite/nodes/node_composite_premulkey.c
View File

@ -61,16 +61,14 @@ static void node_composit_exec_premulkey(void *UNUSED(data), bNode *node, bNodeS
}
}
void register_node_type_cmp_premulkey(ListBase *lb)
void register_node_type_cmp_premulkey(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_PREMULKEY, "Alpha Convert", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_base(ttype, &ntype, CMP_NODE_PREMULKEY, "Alpha Convert", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_premulkey_in, cmp_node_premulkey_out);
node_type_size(&ntype, 140, 100, 320);
node_type_exec(&ntype, node_composit_exec_premulkey);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/composite/nodes/node_composite_rgb.c
View File

@ -58,18 +58,15 @@ static void node_composit_exec_rgb(void *UNUSED(data), bNode *node, bNodeStack *
copy_v4_v4(out[0]->vec, col);
}
void register_node_type_cmp_rgb(ListBase *lb)
void register_node_type_cmp_rgb(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_RGB, "RGB", NODE_CLASS_INPUT, NODE_OPTIONS);
node_type_base(ttype, &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(&ntype, 140, 80, 140);
node_type_exec(&ntype, node_composit_exec_rgb);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

7
source/blender/nodes/composite/nodes/node_composite_rotate.c
View File

@ -126,16 +126,15 @@ static void node_composit_init_rotate(bNodeTree *UNUSED(ntree), bNode* node, bNo
node->custom1= 1; /* Bilinear Filter*/
}
void register_node_type_cmp_rotate(ListBase *lb)
void register_node_type_cmp_rotate(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_ROTATE, "Rotate", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 140, 100, 320);
node_type_init(&ntype, node_composit_init_rotate);
node_type_exec(&ntype, node_composit_exec_rotate);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

13
source/blender/nodes/composite/nodes/node_composite_scale.c
View File

@ -129,21 +129,14 @@ static void node_composit_exec_scale(void *data, bNode *node, bNodeStack **in, b
}
}
void register_node_type_cmp_scale(ListBase *lb)
void register_node_type_cmp_scale(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_SCALE, "Scale", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_base(ttype, &ntype, CMP_NODE_SCALE, "Scale", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_scale_in, cmp_node_scale_out);
node_type_size(&ntype, 140, 100, 320);
node_type_exec(&ntype, node_composit_exec_scale);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

15
source/blender/nodes/composite/nodes/node_composite_sepcombHSVA.c
View File

@ -99,16 +99,16 @@ static void node_composit_exec_sephsva(void *UNUSED(data), bNode *node, bNodeSta
}
}
void register_node_type_cmp_sephsva(ListBase *lb)
void register_node_type_cmp_sephsva(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_SEPHSVA, "Separate HSVA", NODE_CLASS_CONVERTOR, 0);
node_type_base(ttype, &ntype, CMP_NODE_SEPHSVA, "Separate HSVA", NODE_CLASS_CONVERTOR, 0);
node_type_socket_templates(&ntype, cmp_node_sephsva_in, cmp_node_sephsva_out);
node_type_size(&ntype, 80, 40, 140);
node_type_exec(&ntype, node_composit_exec_sephsva);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}
@ -169,17 +169,14 @@ static void node_composit_exec_combhsva(void *UNUSED(data), bNode *node, bNodeSt
}
}
void register_node_type_cmp_combhsva(ListBase *lb)
void register_node_type_cmp_combhsva(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_COMBHSVA, "Combine HSVA", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_base(ttype, &ntype, CMP_NODE_COMBHSVA, "Combine HSVA", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_combhsva_in, cmp_node_combhsva_out);
node_type_size(&ntype, 80, 40, 140);
node_type_exec(&ntype, node_composit_exec_combhsva);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

14
source/blender/nodes/composite/nodes/node_composite_sepcombRGBA.c
View File

@ -77,16 +77,16 @@ static void node_composit_exec_seprgba(void *UNUSED(data), bNode *UNUSED(node),
}
}
void register_node_type_cmp_seprgba(ListBase *lb)
void register_node_type_cmp_seprgba(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_SEPRGBA, "Separate RGBA", NODE_CLASS_CONVERTOR, 0);
node_type_base(ttype, &ntype, CMP_NODE_SEPRGBA, "Separate RGBA", NODE_CLASS_CONVERTOR, 0);
node_type_socket_templates(&ntype, cmp_node_seprgba_in, cmp_node_seprgba_out);
node_type_size(&ntype, 80, 40, 140);
node_type_exec(&ntype, node_composit_exec_seprgba);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}
@ -145,16 +145,14 @@ static void node_composit_exec_combrgba(void *UNUSED(data), bNode *node, bNodeSt
}
}
void register_node_type_cmp_combrgba(ListBase *lb)
void register_node_type_cmp_combrgba(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_COMBRGBA, "Combine RGBA", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_base(ttype, &ntype, CMP_NODE_COMBRGBA, "Combine RGBA", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_combrgba_in, cmp_node_combrgba_out);
node_type_size(&ntype, 80, 40, 140);
node_type_exec(&ntype, node_composit_exec_combrgba);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

15
source/blender/nodes/composite/nodes/node_composite_sepcombYCCA.c
View File

@ -148,16 +148,16 @@ static void node_composit_exec_sepycca(void *UNUSED(data), bNode *node, bNodeSta
}
}
void register_node_type_cmp_sepycca(ListBase *lb)
void register_node_type_cmp_sepycca(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_SEPYCCA, "Separate YCbCrA", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_base(ttype, &ntype, CMP_NODE_SEPYCCA, "Separate YCbCrA", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_sepycca_in, cmp_node_sepycca_out);
node_type_size(&ntype, 80, 40, 140);
node_type_exec(&ntype, node_composit_exec_sepycca);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}
@ -295,17 +295,14 @@ static void node_composit_exec_combycca(void *UNUSED(data), bNode *node, bNodeSt
}
}
void register_node_type_cmp_combycca(ListBase *lb)
void register_node_type_cmp_combycca(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_COMBYCCA, "Combine YCbCrA", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_base(ttype, &ntype, CMP_NODE_COMBYCCA, "Combine YCbCrA", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_combycca_in, cmp_node_combycca_out);
node_type_size(&ntype, 80, 40, 140);
node_type_exec(&ntype, node_composit_exec_combycca);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

14
source/blender/nodes/composite/nodes/node_composite_sepcombYUVA.c
View File

@ -99,16 +99,16 @@ static void node_composit_exec_sepyuva(void *UNUSED(data), bNode *node, bNodeSta
}
}
void register_node_type_cmp_sepyuva(ListBase *lb)
void register_node_type_cmp_sepyuva(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_SEPYUVA, "Separate YUVA", NODE_CLASS_CONVERTOR, 0);
node_type_base(ttype, &ntype, CMP_NODE_SEPYUVA, "Separate YUVA", NODE_CLASS_CONVERTOR, 0);
node_type_socket_templates(&ntype, cmp_node_sepyuva_in, cmp_node_sepyuva_out);
node_type_size(&ntype, 80, 40, 140);
node_type_exec(&ntype, node_composit_exec_sepyuva);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}
@ -170,16 +170,14 @@ static void node_composit_exec_combyuva(void *UNUSED(data), bNode *node, bNodeSt
}
}
void register_node_type_cmp_combyuva(ListBase *lb)
void register_node_type_cmp_combyuva(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_COMBYUVA, "Combine YUVA", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_base(ttype, &ntype, CMP_NODE_COMBYUVA, "Combine YUVA", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_combyuva_in, cmp_node_combyuva_out);
node_type_size(&ntype, 80, 40, 140);
node_type_exec(&ntype, node_composit_exec_combyuva);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

7
source/blender/nodes/composite/nodes/node_composite_setalpha.c
View File

@ -73,15 +73,14 @@ static void node_composit_exec_setalpha(void *UNUSED(data), bNode *node, bNodeSt
}
}
void register_node_type_cmp_setalpha(ListBase *lb)
void register_node_type_cmp_setalpha(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_SETALPHA, "Set Alpha", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_base(ttype, &ntype, CMP_NODE_SETALPHA, "Set Alpha", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_setalpha_in, cmp_node_setalpha_out);
node_type_size(&ntype, 120, 40, 140);
node_type_exec(&ntype, node_composit_exec_setalpha);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

11
source/blender/nodes/composite/nodes/node_composite_splitViewer.c
View File

@ -149,21 +149,16 @@ static void node_composit_init_splitviewer(bNodeTree *UNUSED(ntree), bNode* node
node->custom1= 50; /* default 50% split */
}
void register_node_type_cmp_splitviewer(ListBase *lb)
void register_node_type_cmp_splitviewer(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_SPLITVIEWER, "SplitViewer", NODE_CLASS_OUTPUT, NODE_PREVIEW|NODE_OPTIONS);
node_type_base(ttype, &ntype, CMP_NODE_SPLITVIEWER, "SplitViewer", NODE_CLASS_OUTPUT, NODE_PREVIEW|NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_splitviewer_in, NULL);
node_type_size(&ntype, 140, 100, 320);
node_type_init(&ntype, node_composit_init_splitviewer);
node_type_storage(&ntype, "ImageUser", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_splitviewer);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

6
source/blender/nodes/composite/nodes/node_composite_stabilize2d.c
View File

@ -66,14 +66,14 @@ static void node_composit_exec_stabilize2d(void *data, bNode *node, bNodeStack *
}
}
void register_node_type_cmp_stabilize2d(ListBase *lb)
void register_node_type_cmp_stabilize2d(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_STABILIZE2D, "Stabilize 2D", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_base(ttype, &ntype, CMP_NODE_STABILIZE2D, "Stabilize 2D", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_stabilize2d_in, cmp_node_stabilize2d_out);
node_type_size(&ntype, 140, 100, 320);
node_type_exec(&ntype, node_composit_exec_stabilize2d);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/composite/nodes/node_composite_texture.c
View File

@ -142,17 +142,14 @@ static void node_composit_exec_texture(void *data, bNode *node, bNodeStack **in,
}
}
void register_node_type_cmp_texture(ListBase *lb)
void register_node_type_cmp_texture(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW);
node_type_base(ttype, &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);
node_type_size(&ntype, 120, 80, 240);
node_type_exec(&ntype, node_composit_exec_texture);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

7
source/blender/nodes/composite/nodes/node_composite_tonemap.c
View File

@ -162,17 +162,16 @@ static void node_composit_init_tonemap(bNodeTree *UNUSED(ntree), bNode* node, bN
node->storage = ntm;
}
void register_node_type_cmp_tonemap(ListBase *lb)
void register_node_type_cmp_tonemap(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_TONEMAP, "Tonemap", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 150, 120, 200);
node_type_init(&ntype, node_composit_init_tonemap);
node_type_storage(&ntype, "NodeTonemap", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_tonemap);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

8
source/blender/nodes/composite/nodes/node_composite_transform.c
View File

@ -127,16 +127,14 @@ static void node_composit_exec_transform(void *UNUSED(data), bNode *node, bNodeS
}
}
void register_node_type_cmp_transform(ListBase *lb)
void register_node_type_cmp_transform(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_TRANSFORM, "Transform", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_base(ttype, &ntype, CMP_NODE_TRANSFORM, "Transform", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_transform_in, cmp_node_transform_out);
node_type_size(&ntype, 140, 100, 320);
node_type_exec(&ntype, node_composit_exec_transform);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

8
source/blender/nodes/composite/nodes/node_composite_translate.c
View File

@ -59,16 +59,14 @@ static void node_composit_exec_translate(void *UNUSED(data), bNode *UNUSED(node)
}
}
void register_node_type_cmp_translate(ListBase *lb)
void register_node_type_cmp_translate(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_TRANSLATE, "Translate", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 140, 100, 320);
node_type_exec(&ntype, node_composit_exec_translate);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

12
source/blender/nodes/composite/nodes/node_composite_valToRgb.c
View File

@ -83,18 +83,18 @@ static void node_composit_init_valtorgb(bNodeTree *UNUSED(ntree), bNode* node, b
node->storage= add_colorband(1);
}
void register_node_type_cmp_valtorgb(ListBase *lb)
void register_node_type_cmp_valtorgb(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_base(ttype, &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, 300);
node_type_init(&ntype, node_composit_init_valtorgb);
node_type_storage(&ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_valtorgb);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}
@ -137,14 +137,14 @@ static void node_composit_exec_rgbtobw(void *UNUSED(data), bNode *node, bNodeSta
}
}
void register_node_type_cmp_rgbtobw(ListBase *lb)
void register_node_type_cmp_rgbtobw(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTOR, 0);
node_type_base(ttype, &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(&ntype, 80, 40, 120);
node_type_exec(&ntype, node_composit_exec_rgbtobw);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

8
source/blender/nodes/composite/nodes/node_composite_value.c
View File

@ -57,17 +57,15 @@ static void node_composit_exec_value(void *UNUSED(data), bNode *node, bNodeStack
out[0]->vec[0]= val;
}
void register_node_type_cmp_value(ListBase *lb)
void register_node_type_cmp_value(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_VALUE, "Value", NODE_CLASS_INPUT, NODE_OPTIONS);
node_type_base(ttype, &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(&ntype, 80, 40, 120);
node_type_exec(&ntype, node_composit_exec_value);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

8
source/blender/nodes/composite/nodes/node_composite_vecBlur.c
View File

@ -94,18 +94,16 @@ static void node_composit_init_vecblur(bNodeTree *UNUSED(ntree), bNode* node, bN
}
/* custom1: itterations, custom2: maxspeed (0 = nolimit) */
void register_node_type_cmp_vecblur(ListBase *lb)
void register_node_type_cmp_vecblur(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_VECBLUR, "Vector Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS);
node_type_base(ttype, &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_size(&ntype, 120, 80, 200);
node_type_init(&ntype, node_composit_init_vecblur);
node_type_storage(&ntype, "NodeBlurData", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_vecblur);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

6
source/blender/nodes/composite/nodes/node_composite_viewer.c
View File

@ -131,16 +131,16 @@ static void node_composit_init_viewer(bNodeTree *UNUSED(ntree), bNode* node, bNo
iuser->ok= 1;
}
void register_node_type_cmp_viewer(ListBase *lb)
void register_node_type_cmp_viewer(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_VIEWER, "Viewer", NODE_CLASS_OUTPUT, NODE_PREVIEW);
node_type_base(ttype, &ntype, CMP_NODE_VIEWER, "Viewer", NODE_CLASS_OUTPUT, NODE_PREVIEW);
node_type_socket_templates(&ntype, cmp_node_viewer_in, NULL);
node_type_size(&ntype, 80, 60, 200);
node_type_init(&ntype, node_composit_init_viewer);
node_type_storage(&ntype, "ImageUser", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_composit_exec_viewer);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

7
source/blender/nodes/composite/nodes/node_composite_zcombine.c
View File

@ -222,15 +222,14 @@ static void node_composit_exec_zcombine(void *data, bNode *node, bNodeStack **in
}
void register_node_type_cmp_zcombine(ListBase *lb)
void register_node_type_cmp_zcombine(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_ZCOMBINE, "Z Combine", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_base(ttype, &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);
node_type_size(&ntype, 80, 40, 120);
node_type_exec(&ntype, node_composit_exec_zcombine);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

6
source/blender/nodes/intern/node_common.c
View File

@ -973,15 +973,15 @@ bNodeTemplate node_whileloop_template(bNode *node)
/**** FRAME ****/
void register_node_type_frame(ListBase *lb)
void register_node_type_frame(bNodeTreeType *ttype)
{
/* frame type is used for all tree types, needs dynamic allocation */
bNodeType *ntype= MEM_callocN(sizeof(bNodeType), "frame node type");
node_type_base(ntype, NODE_FRAME, "Frame", NODE_CLASS_LAYOUT, NODE_BACKGROUND);
node_type_base(ttype, ntype, NODE_FRAME, "Frame", NODE_CLASS_LAYOUT, NODE_BACKGROUND);
node_type_size(ntype, 150, 100, 0);
node_type_compatibility(ntype, NODE_OLD_SHADING|NODE_NEW_SHADING);
ntype->needs_free = 1;
nodeRegisterType(lb, ntype);
nodeRegisterType(ttype, ntype);
}

9
source/blender/nodes/shader/nodes/node_shader_add_shader.c
View File

@ -46,11 +46,11 @@ static int node_shader_gpu_add_shader(GPUMaterial *mat, bNode *UNUSED(node), GPU
}
/* node type definition */
void register_node_type_sh_add_shader(ListBase *lb)
void register_node_type_sh_add_shader(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_ADD_SHADER, "Add Shader", NODE_CLASS_SHADER, 0);
node_type_base(ttype, &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);
@ -59,6 +59,5 @@ void register_node_type_sh_add_shader(ListBase *lb)
node_type_exec(&ntype, NULL);
node_type_gpu(&ntype, node_shader_gpu_add_shader);
nodeRegisterType(lb, &ntype);
};
nodeRegisterType(ttype, &ntype);
}

7
source/blender/nodes/shader/nodes/node_shader_attribute.c
View File

@ -43,11 +43,11 @@ static void node_shader_init_attribute(bNodeTree *UNUSED(ntree), bNode* node, bN
}
/* node type definition */
void register_node_type_sh_attribute(ListBase *lb)
void register_node_type_sh_attribute(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_ATTRIBUTE, "Attribute", NODE_CLASS_INPUT, NODE_OPTIONS);
node_type_base(ttype, &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);
@ -56,6 +56,5 @@ void register_node_type_sh_attribute(ListBase *lb)
node_type_exec(&ntype, NULL);
node_type_gpu(&ntype, NULL);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/shader/nodes/node_shader_background.c
View File

@ -41,11 +41,11 @@ static bNodeSocketTemplate sh_node_background_out[]= {
};
/* node type definition */
void register_node_type_sh_background(ListBase *lb)
void register_node_type_sh_background(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_BACKGROUND, "Background", NODE_CLASS_SHADER, 0);
node_type_base(ttype, &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);
@ -54,6 +54,5 @@ void register_node_type_sh_background(ListBase *lb)
node_type_exec(&ntype, NULL);
node_type_gpu(&ntype, NULL);
nodeRegisterType(lb, &ntype);
};
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/shader/nodes/node_shader_bsdf_anisotropic.c
View File

@ -47,11 +47,11 @@ static int node_shader_gpu_bsdf_anisotropic(GPUMaterial *mat, bNode *UNUSED(node
}
/* node type definition */
void register_node_type_sh_bsdf_anisotropic(ListBase *lb)
void register_node_type_sh_bsdf_anisotropic(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_BSDF_ANISOTROPIC, "Glossy Anisotropic BSDF", NODE_CLASS_SHADER, 0);
node_type_base(ttype, &ntype, SH_NODE_BSDF_ANISOTROPIC, "Glossy 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);
@ -60,6 +60,5 @@ void register_node_type_sh_bsdf_anisotropic(ListBase *lb)
node_type_exec(&ntype, NULL);
node_type_gpu(&ntype, node_shader_gpu_bsdf_anisotropic);
nodeRegisterType(lb, &ntype);
};
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/shader/nodes/node_shader_bsdf_diffuse.c
View File

@ -46,11 +46,11 @@ static int node_shader_gpu_bsdf_diffuse(GPUMaterial *mat, bNode *UNUSED(node), G
}
/* node type definition */
void register_node_type_sh_bsdf_diffuse(ListBase *lb)
void register_node_type_sh_bsdf_diffuse(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_BSDF_DIFFUSE, "Diffuse BSDF", NODE_CLASS_SHADER, 0);
node_type_base(ttype, &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);
@ -59,6 +59,5 @@ void register_node_type_sh_bsdf_diffuse(ListBase *lb)
node_type_exec(&ntype, NULL);
node_type_gpu(&ntype, node_shader_gpu_bsdf_diffuse);
nodeRegisterType(lb, &ntype);
};
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/shader/nodes/node_shader_bsdf_glass.c
View File

@ -47,11 +47,11 @@ static int node_shader_gpu_bsdf_glass(GPUMaterial *mat, bNode *UNUSED(node), GPU
}
/* node type definition */
void register_node_type_sh_bsdf_glass(ListBase *lb)
void register_node_type_sh_bsdf_glass(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_BSDF_GLASS, "Glass BSDF", NODE_CLASS_SHADER, NODE_OPTIONS);
node_type_base(ttype, &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);
@ -60,6 +60,5 @@ void register_node_type_sh_bsdf_glass(ListBase *lb)
node_type_exec(&ntype, NULL);
node_type_gpu(&ntype, node_shader_gpu_bsdf_glass);
nodeRegisterType(lb, &ntype);
};
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/shader/nodes/node_shader_bsdf_glossy.c
View File

@ -47,11 +47,11 @@ static int node_shader_gpu_bsdf_glossy(GPUMaterial *mat, bNode *UNUSED(node), GP
}
/* node type definition */
void register_node_type_sh_bsdf_glossy(ListBase *lb)
void register_node_type_sh_bsdf_glossy(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_BSDF_GLOSSY, "Glossy BSDF", NODE_CLASS_SHADER, NODE_OPTIONS);
node_type_base(ttype, &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);
@ -60,6 +60,5 @@ void register_node_type_sh_bsdf_glossy(ListBase *lb)
node_type_exec(&ntype, NULL);
node_type_gpu(&ntype, node_shader_gpu_bsdf_glossy);
nodeRegisterType(lb, &ntype);
};
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/shader/nodes/node_shader_bsdf_translucent.c
View File

@ -45,11 +45,11 @@ static int node_shader_gpu_bsdf_translucent(GPUMaterial *mat, bNode *UNUSED(node
}
/* node type definition */
void register_node_type_sh_bsdf_translucent(ListBase *lb)
void register_node_type_sh_bsdf_translucent(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_BSDF_TRANSLUCENT, "Translucent BSDF", NODE_CLASS_SHADER, 0);
node_type_base(ttype, &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);
@ -58,6 +58,5 @@ void register_node_type_sh_bsdf_translucent(ListBase *lb)
node_type_exec(&ntype, NULL);
node_type_gpu(&ntype, node_shader_gpu_bsdf_translucent);
nodeRegisterType(lb, &ntype);
};
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/shader/nodes/node_shader_bsdf_transparent.c
View File

@ -45,11 +45,11 @@ static int node_shader_gpu_bsdf_transparent(GPUMaterial *mat, bNode *UNUSED(node
}
/* node type definition */
void register_node_type_sh_bsdf_transparent(ListBase *lb)
void register_node_type_sh_bsdf_transparent(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_BSDF_TRANSPARENT, "Transparent BSDF", NODE_CLASS_SHADER, 0);
node_type_base(ttype, &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);
@ -58,6 +58,5 @@ void register_node_type_sh_bsdf_transparent(ListBase *lb)
node_type_exec(&ntype, NULL);
node_type_gpu(&ntype, node_shader_gpu_bsdf_transparent);
nodeRegisterType(lb, &ntype);
};
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/shader/nodes/node_shader_bsdf_velvet.c
View File

@ -46,11 +46,11 @@ static int node_shader_gpu_bsdf_velvet(GPUMaterial *mat, bNode *UNUSED(node), GP
}
/* node type definition */
void register_node_type_sh_bsdf_velvet(ListBase *lb)
void register_node_type_sh_bsdf_velvet(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_BSDF_VELVET, "Velvet BSDF", NODE_CLASS_SHADER, 0);
node_type_base(ttype, &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);
@ -59,6 +59,5 @@ void register_node_type_sh_bsdf_velvet(ListBase *lb)
node_type_exec(&ntype, NULL);
node_type_gpu(&ntype, node_shader_gpu_bsdf_velvet);
nodeRegisterType(lb, &ntype);
};
nodeRegisterType(ttype, &ntype);
}

8
source/blender/nodes/shader/nodes/node_shader_camera.c
View File

@ -57,11 +57,11 @@ static int gpu_shader_camera(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack
return GPU_stack_link(mat, "camera", in, out, GPU_builtin(GPU_VIEW_POSITION));
}
void register_node_type_sh_camera(ListBase *lb)
void register_node_type_sh_camera(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_CAMERA, "Camera Data", NODE_CLASS_INPUT, 0);
node_type_base(ttype, &ntype, SH_NODE_CAMERA, "Camera Data", NODE_CLASS_INPUT, 0);
node_type_compatibility(&ntype, NODE_OLD_SHADING);
node_type_socket_templates(&ntype, NULL, sh_node_camera_out);
node_type_size(&ntype, 95, 95, 120);
@ -69,7 +69,5 @@ void register_node_type_sh_camera(ListBase *lb)
node_type_exec(&ntype, node_shader_exec_camera);
node_type_gpu(&ntype, gpu_shader_camera);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

18
source/blender/nodes/shader/nodes/node_shader_common.c
View File

@ -180,11 +180,11 @@ static int gpu_group_execute(GPUMaterial *mat, bNode *node, void *nodedata, GPUN
return 1;
}
void register_node_type_sh_group(ListBase *lb)
void register_node_type_sh_group(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, NODE_GROUP, "Group", NODE_CLASS_GROUP, NODE_OPTIONS|NODE_CONST_OUTPUT);
node_type_base(ttype, &ntype, NODE_GROUP, "Group", NODE_CLASS_GROUP, NODE_OPTIONS|NODE_CONST_OUTPUT);
node_type_socket_templates(&ntype, NULL, NULL);
node_type_size(&ntype, 120, 60, 200);
node_type_label(&ntype, node_group_label);
@ -196,7 +196,7 @@ void register_node_type_sh_group(ListBase *lb)
node_type_exec_new(&ntype, group_initexec, group_freeexec, group_execute);
node_type_gpu_ext(&ntype, gpu_group_execute);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}
@ -242,11 +242,11 @@ static void forloop_execute(void *data, int thread, struct bNode *node, void *no
ntreeReleaseThreadStack(nts);
}
void register_node_type_sh_forloop(ListBase *lb)
void register_node_type_sh_forloop(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, NODE_FORLOOP, "For", NODE_CLASS_GROUP, NODE_OPTIONS);
node_type_base(ttype, &ntype, NODE_FORLOOP, "For", NODE_CLASS_GROUP, NODE_OPTIONS);
node_type_socket_templates(&ntype, NULL, NULL);
node_type_size(&ntype, 120, 60, 200);
node_type_label(&ntype, node_group_label);
@ -258,7 +258,7 @@ void register_node_type_sh_forloop(ListBase *lb)
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, forloop_execute);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}
#endif
@ -304,11 +304,11 @@ static void whileloop_execute(void *data, int thread, struct bNode *node, void *
ntreeReleaseThreadStack(nts);
}
void register_node_type_sh_whileloop(ListBase *lb)
void register_node_type_sh_whileloop(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, NODE_WHILELOOP, "While", NODE_CLASS_GROUP, NODE_OPTIONS);
node_type_base(ttype, &ntype, NODE_WHILELOOP, "While", NODE_CLASS_GROUP, NODE_OPTIONS);
node_type_socket_templates(&ntype, NULL, NULL);
node_type_size(&ntype, 120, 60, 200);
node_type_label(&ntype, node_group_label);
@ -320,6 +320,6 @@ void register_node_type_sh_whileloop(ListBase *lb)
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, whileloop_execute);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}
#endif

13
source/blender/nodes/shader/nodes/node_shader_curves.c
View File

@ -69,11 +69,11 @@ 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(ListBase *lb)
void register_node_type_sh_curve_vec(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_CURVE_VEC, "Vector Curves", NODE_CLASS_OP_VECTOR, NODE_OPTIONS);
node_type_base(ttype, &ntype, SH_NODE_CURVE_VEC, "Vector Curves", NODE_CLASS_OP_VECTOR, NODE_OPTIONS);
node_type_compatibility(&ntype, NODE_OLD_SHADING);
node_type_socket_templates(&ntype, sh_node_curve_vec_in, sh_node_curve_vec_out);
node_type_size(&ntype, 200, 140, 320);
@ -82,7 +82,7 @@ void register_node_type_sh_curve_vec(ListBase *lb)
node_type_exec(&ntype, node_shader_exec_curve_vec);
node_type_gpu(&ntype, gpu_shader_curve_vec);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}
@ -124,11 +124,11 @@ 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(ListBase *lb)
void register_node_type_sh_curve_rgb(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_base(ttype, &ntype, SH_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_compatibility(&ntype, NODE_OLD_SHADING);
node_type_socket_templates(&ntype, sh_node_curve_rgb_in, sh_node_curve_rgb_out);
node_type_size(&ntype, 200, 140, 320);
@ -137,6 +137,5 @@ void register_node_type_sh_curve_rgb(ListBase *lb)
node_type_exec(&ntype, node_shader_exec_curve_rgb);
node_type_gpu(&ntype, gpu_shader_curve_rgb);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

14
source/blender/nodes/shader/nodes/node_shader_dynamic.c
View File

@ -761,32 +761,30 @@ static void node_dynamic_exec_cb(void *data, bNode *node, bNodeStack **in, bNode
#endif
}
void register_node_type_sh_dynamic(ListBase *lb)
void register_node_type_sh_dynamic(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, NODE_DYNAMIC, "Dynamic", NODE_CLASS_OP_DYNAMIC, NODE_OPTIONS, NULL, NULL);
node_type_base(ttype, &ntype, NODE_DYNAMIC, "Dynamic", NODE_CLASS_OP_DYNAMIC, NODE_OPTIONS, NULL, NULL);
node_type_compatibility(&ntype, NODE_OLD_SHADING);
node_type_size(&ntype, 150, 60, 300);
node_type_init(&ntype, node_dynamic_init_cb);
node_type_storage(&ntype, "NodeScriptDict", node_dynamic_free_storage_cb, node_dynamic_copy_cb);
node_type_exec(&ntype, node_dynamic_exec_cb);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}
#else
void register_node_type_sh_dynamic(ListBase *lb)
void register_node_type_sh_dynamic(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, NODE_DYNAMIC, "Dynamic", NODE_CLASS_OP_DYNAMIC, 0);
node_type_base(ttype, &ntype, NODE_DYNAMIC, "Dynamic", NODE_CLASS_OP_DYNAMIC, 0);
node_type_compatibility(&ntype, NODE_OLD_SHADING);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}
#endif

9
source/blender/nodes/shader/nodes/node_shader_emission.c
View File

@ -46,11 +46,11 @@ static int node_shader_gpu_emission(GPUMaterial *mat, bNode *UNUSED(node), GPUNo
}
/* node type definition */
void register_node_type_sh_emission(ListBase *lb)
void register_node_type_sh_emission(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_EMISSION, "Emission", NODE_CLASS_SHADER, 0);
node_type_base(ttype, &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);
@ -59,6 +59,5 @@ void register_node_type_sh_emission(ListBase *lb)
node_type_exec(&ntype, NULL);
node_type_gpu(&ntype, node_shader_gpu_emission);
nodeRegisterType(lb, &ntype);
};
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/shader/nodes/node_shader_fresnel.c
View File

@ -45,11 +45,11 @@ static int node_shader_gpu_fresnel(GPUMaterial *mat, bNode *UNUSED(node), GPUNod
}
/* node type definition */
void register_node_type_sh_fresnel(ListBase *lb)
void register_node_type_sh_fresnel(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_FRESNEL, "Fresnel", NODE_CLASS_INPUT, 0);
node_type_base(ttype, &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);
@ -58,6 +58,5 @@ void register_node_type_sh_fresnel(ListBase *lb)
node_type_exec(&ntype, NULL);
node_type_gpu(&ntype, node_shader_gpu_fresnel);
nodeRegisterType(lb, &ntype);
};
nodeRegisterType(ttype, &ntype);
}

7
source/blender/nodes/shader/nodes/node_shader_geom.c
View File

@ -138,11 +138,11 @@ static int gpu_shader_geom(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUN
}
/* node type definition */
void register_node_type_sh_geom(ListBase *lb)
void register_node_type_sh_geom(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_GEOMETRY, "Geometry", NODE_CLASS_INPUT, NODE_OPTIONS);
node_type_base(ttype, &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);
@ -151,6 +151,5 @@ void register_node_type_sh_geom(ListBase *lb)
node_type_exec(&ntype, node_shader_exec_geom);
node_type_gpu(&ntype, gpu_shader_geom);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/shader/nodes/node_shader_geometry.c
View File

@ -48,11 +48,11 @@ static int node_shader_gpu_geometry(GPUMaterial *mat, bNode *UNUSED(node), GPUNo
}
/* node type definition */
void register_node_type_sh_geometry(ListBase *lb)
void register_node_type_sh_geometry(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_NEW_GEOMETRY, "Geometry", NODE_CLASS_INPUT, 0);
node_type_base(ttype, &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);
@ -61,6 +61,5 @@ void register_node_type_sh_geometry(ListBase *lb)
node_type_exec(&ntype, NULL);
node_type_gpu(&ntype, node_shader_gpu_geometry);
nodeRegisterType(lb, &ntype);
};
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/shader/nodes/node_shader_holdout.c
View File

@ -40,11 +40,11 @@ static bNodeSocketTemplate sh_node_holdout_out[]= {
/* node type definition */
void register_node_type_sh_holdout(ListBase *lb)
void register_node_type_sh_holdout(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_HOLDOUT, "Holdout", NODE_CLASS_SHADER, 0);
node_type_base(ttype, &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);
@ -53,6 +53,5 @@ void register_node_type_sh_holdout(ListBase *lb)
node_type_exec(&ntype, NULL);
node_type_gpu(&ntype, NULL);
nodeRegisterType(lb, &ntype);
};
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/shader/nodes/node_shader_hueSatVal.c
View File

@ -80,19 +80,16 @@ static int gpu_shader_hue_sat(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStac
return GPU_stack_link(mat, "hue_sat", in, out);
}
void register_node_type_sh_hue_sat(ListBase *lb)
void register_node_type_sh_hue_sat(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_base(ttype, &ntype, SH_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_compatibility(&ntype, NODE_OLD_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_gpu(&ntype, gpu_shader_hue_sat);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

8
source/blender/nodes/shader/nodes/node_shader_invert.c
View File

@ -72,18 +72,16 @@ static int gpu_shader_invert(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack
return GPU_stack_link(mat, "invert", in, out);
}
void register_node_type_sh_invert(ListBase *lb)
void register_node_type_sh_invert(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_base(ttype, &ntype, SH_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_compatibility(&ntype, NODE_OLD_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_gpu(&ntype, gpu_shader_invert);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/shader/nodes/node_shader_layer_weight.c
View File

@ -46,11 +46,11 @@ static int node_shader_gpu_layer_weight(GPUMaterial *UNUSED(mat), bNode *UNUSED(
}
/* node type definition */
void register_node_type_sh_layer_weight(ListBase *lb)
void register_node_type_sh_layer_weight(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_LAYER_WEIGHT, "Layer Weight", NODE_CLASS_INPUT, 0);
node_type_base(ttype, &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);
@ -59,6 +59,5 @@ void register_node_type_sh_layer_weight(ListBase *lb)
node_type_exec(&ntype, NULL);
node_type_gpu(&ntype, node_shader_gpu_layer_weight);
nodeRegisterType(lb, &ntype);
};
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/shader/nodes/node_shader_light_path.c
View File

@ -46,11 +46,11 @@ static int node_shader_gpu_light_path(GPUMaterial *mat, bNode *UNUSED(node), GPU
}
/* node type definition */
void register_node_type_sh_light_path(ListBase *lb)
void register_node_type_sh_light_path(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_LIGHT_PATH, "Light Path", NODE_CLASS_INPUT, 0);
node_type_base(ttype, &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);
@ -59,6 +59,5 @@ void register_node_type_sh_light_path(ListBase *lb)
node_type_exec(&ntype, NULL);
node_type_gpu(&ntype, node_shader_gpu_light_path);
nodeRegisterType(lb, &ntype);
};
nodeRegisterType(ttype, &ntype);
}

6
source/blender/nodes/shader/nodes/node_shader_mapping.c
View File

@ -86,11 +86,11 @@ 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(ListBase *lb)
void register_node_type_sh_mapping(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_MAPPING, "Mapping", NODE_CLASS_OP_VECTOR, NODE_OPTIONS);
node_type_base(ttype, &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);
@ -99,5 +99,5 @@ void register_node_type_sh_mapping(ListBase *lb)
node_type_exec(&ntype, node_shader_exec_mapping);
node_type_gpu(&ntype, gpu_shader_mapping);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

14
source/blender/nodes/shader/nodes/node_shader_material.c
View File

@ -300,11 +300,11 @@ static int gpu_shader_material(GPUMaterial *mat, bNode *node, GPUNodeStack *in,
return 0;
}
void register_node_type_sh_material(ListBase *lb)
void register_node_type_sh_material(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_MATERIAL, "Material", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW);
node_type_base(ttype, &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);
@ -312,15 +312,15 @@ void register_node_type_sh_material(ListBase *lb)
node_type_exec(&ntype, node_shader_exec_material);
node_type_gpu(&ntype, gpu_shader_material);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}
void register_node_type_sh_material_ext(ListBase *lb)
void register_node_type_sh_material_ext(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_MATERIAL_EXT, "Extended Material", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW);
node_type_base(ttype, &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);
@ -328,7 +328,5 @@ void register_node_type_sh_material_ext(ListBase *lb)
node_type_exec(&ntype, node_shader_exec_material);
node_type_gpu(&ntype, gpu_shader_material);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

8
source/blender/nodes/shader/nodes/node_shader_math.c
View File

@ -236,11 +236,11 @@ static int gpu_shader_math(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUN
return 1;
}
void register_node_type_sh_math(ListBase *lb)
void register_node_type_sh_math(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_base(ttype, &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);
@ -249,7 +249,5 @@ void register_node_type_sh_math(ListBase *lb)
node_type_exec(&ntype, node_shader_exec_math);
node_type_gpu(&ntype, gpu_shader_math);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

7
source/blender/nodes/shader/nodes/node_shader_mixRgb.c
View File

@ -73,11 +73,11 @@ static int gpu_shader_mix_rgb(GPUMaterial *mat, bNode *node, GPUNodeStack *in, G
}
void register_node_type_sh_mix_rgb(ListBase *lb)
void register_node_type_sh_mix_rgb(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_base(ttype, &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);
@ -85,6 +85,5 @@ void register_node_type_sh_mix_rgb(ListBase *lb)
node_type_exec(&ntype, node_shader_exec_mix_rgb);
node_type_gpu(&ntype, gpu_shader_mix_rgb);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/shader/nodes/node_shader_mix_shader.c
View File

@ -47,11 +47,11 @@ static int node_shader_gpu_mix_shader(GPUMaterial *mat, bNode *UNUSED(node), GPU
}
/* node type definition */
void register_node_type_sh_mix_shader(ListBase *lb)
void register_node_type_sh_mix_shader(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_MIX_SHADER, "Mix Shader", NODE_CLASS_SHADER, 0);
node_type_base(ttype, &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);
@ -60,6 +60,5 @@ void register_node_type_sh_mix_shader(ListBase *lb)
node_type_exec(&ntype, NULL);
node_type_gpu(&ntype, node_shader_gpu_mix_shader);
nodeRegisterType(lb, &ntype);
};
nodeRegisterType(ttype, &ntype);
}

6
source/blender/nodes/shader/nodes/node_shader_normal.c
View File

@ -79,16 +79,16 @@ static int gpu_shader_normal(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GP
return GPU_stack_link(mat, "normal", in, out, vec);
}
void register_node_type_sh_normal(ListBase *lb)
void register_node_type_sh_normal(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_NORMAL, "Normal", NODE_CLASS_OP_VECTOR, NODE_OPTIONS);
node_type_base(ttype, &ntype, SH_NODE_NORMAL, "Normal", NODE_CLASS_OP_VECTOR, NODE_OPTIONS);
node_type_compatibility(&ntype, NODE_OLD_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_gpu(&ntype, gpu_shader_normal);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

8
source/blender/nodes/shader/nodes/node_shader_output.c
View File

@ -78,18 +78,16 @@ static int gpu_shader_output(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack
return 1;
}
void register_node_type_sh_output(ListBase *lb)
void register_node_type_sh_output(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_OUTPUT, "Output", NODE_CLASS_OUTPUT, NODE_PREVIEW);
node_type_base(ttype, &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_gpu(&ntype, gpu_shader_output);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/shader/nodes/node_shader_output_lamp.c
View File

@ -35,11 +35,11 @@ static bNodeSocketTemplate sh_node_output_lamp_in[]= {
};
/* node type definition */
void register_node_type_sh_output_lamp(ListBase *lb)
void register_node_type_sh_output_lamp(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_OUTPUT_LAMP, "Lamp Output", NODE_CLASS_OUTPUT, 0);
node_type_base(ttype, &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);
@ -48,6 +48,5 @@ void register_node_type_sh_output_lamp(ListBase *lb)
node_type_exec(&ntype, NULL);
node_type_gpu(&ntype, NULL);
nodeRegisterType(lb, &ntype);
};
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/shader/nodes/node_shader_output_material.c
View File

@ -48,11 +48,11 @@ static int node_shader_gpu_output_material(GPUMaterial *mat, bNode *UNUSED(node)
/* node type definition */
void register_node_type_sh_output_material(ListBase *lb)
void register_node_type_sh_output_material(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_OUTPUT_MATERIAL, "Material Output", NODE_CLASS_OUTPUT, 0);
node_type_base(ttype, &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);
@ -61,6 +61,5 @@ void register_node_type_sh_output_material(ListBase *lb)
node_type_exec(&ntype, NULL);
node_type_gpu(&ntype, node_shader_gpu_output_material);
nodeRegisterType(lb, &ntype);
};
nodeRegisterType(ttype, &ntype);
}

9
source/blender/nodes/shader/nodes/node_shader_output_world.c
View File

@ -36,11 +36,11 @@ static bNodeSocketTemplate sh_node_output_world_in[]= {
};
/* node type definition */
void register_node_type_sh_output_world(ListBase *lb)
void register_node_type_sh_output_world(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_OUTPUT_WORLD, "World Output", NODE_CLASS_OUTPUT, 0);
node_type_base(ttype, &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);
@ -49,6 +49,5 @@ void register_node_type_sh_output_world(ListBase *lb)
node_type_exec(&ntype, NULL);
node_type_gpu(&ntype, NULL);
nodeRegisterType(lb, &ntype);
};
nodeRegisterType(ttype, &ntype);
}

7
source/blender/nodes/shader/nodes/node_shader_rgb.c
View File

@ -66,11 +66,11 @@ static int gpu_shader_rgb(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNo
return GPU_stack_link(mat, "set_rgba", in, out, vec);
}
void register_node_type_sh_rgb(ListBase *lb)
void register_node_type_sh_rgb(bNodeTreeType *ttype)
{
static bNodeType ntype;
node_type_base(&ntype, SH_NODE_RGB, "RGB", NODE_CLASS_INPUT, NODE_OPTIONS);
node_type_base(ttype, &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);
@ -78,6 +78,5 @@ void register_node_type_sh_rgb(ListBase *lb)
node_type_exec(&ntype, node_shader_exec_rgb);
node_type_gpu(&ntype, gpu_shader_rgb);
nodeRegisterType(lb, &ntype);
nodeRegisterType(ttype, &ntype);
}

Some files were not shown because too many files have changed in this diff Show More