Muting node patch: first part
authorBastien Montagne <montagne29@wanadoo.fr>
Sun, 20 Nov 2011 16:13:27 +0000 (16:13 +0000)
committerBastien Montagne <montagne29@wanadoo.fr>
Sun, 20 Nov 2011 16:13:27 +0000 (16:13 +0000)
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...

141 files changed:
source/blender/blenkernel/BKE_node.h
source/blender/blenkernel/intern/node.c
source/blender/nodes/NOD_composite.h
source/blender/nodes/NOD_shader.h
source/blender/nodes/NOD_texture.h
source/blender/nodes/composite/nodes/node_composite_alphaOver.c
source/blender/nodes/composite/nodes/node_composite_bilateralblur.c
source/blender/nodes/composite/nodes/node_composite_blur.c
source/blender/nodes/composite/nodes/node_composite_brightness.c
source/blender/nodes/composite/nodes/node_composite_channelMatte.c
source/blender/nodes/composite/nodes/node_composite_chromaMatte.c
source/blender/nodes/composite/nodes/node_composite_colorMatte.c
source/blender/nodes/composite/nodes/node_composite_colorSpill.c
source/blender/nodes/composite/nodes/node_composite_colorbalance.c
source/blender/nodes/composite/nodes/node_composite_common.c
source/blender/nodes/composite/nodes/node_composite_composite.c
source/blender/nodes/composite/nodes/node_composite_crop.c
source/blender/nodes/composite/nodes/node_composite_curves.c
source/blender/nodes/composite/nodes/node_composite_defocus.c
source/blender/nodes/composite/nodes/node_composite_diffMatte.c
source/blender/nodes/composite/nodes/node_composite_dilate.c
source/blender/nodes/composite/nodes/node_composite_directionalblur.c
source/blender/nodes/composite/nodes/node_composite_displace.c
source/blender/nodes/composite/nodes/node_composite_distanceMatte.c
source/blender/nodes/composite/nodes/node_composite_filter.c
source/blender/nodes/composite/nodes/node_composite_flip.c
source/blender/nodes/composite/nodes/node_composite_gamma.c
source/blender/nodes/composite/nodes/node_composite_glare.c
source/blender/nodes/composite/nodes/node_composite_hueSatVal.c
source/blender/nodes/composite/nodes/node_composite_huecorrect.c
source/blender/nodes/composite/nodes/node_composite_idMask.c
source/blender/nodes/composite/nodes/node_composite_image.c
source/blender/nodes/composite/nodes/node_composite_invert.c
source/blender/nodes/composite/nodes/node_composite_lensdist.c
source/blender/nodes/composite/nodes/node_composite_levels.c
source/blender/nodes/composite/nodes/node_composite_lummaMatte.c
source/blender/nodes/composite/nodes/node_composite_mapUV.c
source/blender/nodes/composite/nodes/node_composite_mapValue.c
source/blender/nodes/composite/nodes/node_composite_math.c
source/blender/nodes/composite/nodes/node_composite_mixrgb.c
source/blender/nodes/composite/nodes/node_composite_movieclip.c
source/blender/nodes/composite/nodes/node_composite_moviedistortion.c
source/blender/nodes/composite/nodes/node_composite_normal.c
source/blender/nodes/composite/nodes/node_composite_normalize.c
source/blender/nodes/composite/nodes/node_composite_outputFile.c
source/blender/nodes/composite/nodes/node_composite_premulkey.c
source/blender/nodes/composite/nodes/node_composite_rgb.c
source/blender/nodes/composite/nodes/node_composite_rotate.c
source/blender/nodes/composite/nodes/node_composite_scale.c
source/blender/nodes/composite/nodes/node_composite_sepcombHSVA.c
source/blender/nodes/composite/nodes/node_composite_sepcombRGBA.c
source/blender/nodes/composite/nodes/node_composite_sepcombYCCA.c
source/blender/nodes/composite/nodes/node_composite_sepcombYUVA.c
source/blender/nodes/composite/nodes/node_composite_setalpha.c
source/blender/nodes/composite/nodes/node_composite_splitViewer.c
source/blender/nodes/composite/nodes/node_composite_stabilize2d.c
source/blender/nodes/composite/nodes/node_composite_texture.c
source/blender/nodes/composite/nodes/node_composite_tonemap.c
source/blender/nodes/composite/nodes/node_composite_transform.c
source/blender/nodes/composite/nodes/node_composite_translate.c
source/blender/nodes/composite/nodes/node_composite_valToRgb.c
source/blender/nodes/composite/nodes/node_composite_value.c
source/blender/nodes/composite/nodes/node_composite_vecBlur.c
source/blender/nodes/composite/nodes/node_composite_viewer.c
source/blender/nodes/composite/nodes/node_composite_zcombine.c
source/blender/nodes/intern/node_common.c
source/blender/nodes/shader/nodes/node_shader_add_shader.c
source/blender/nodes/shader/nodes/node_shader_attribute.c
source/blender/nodes/shader/nodes/node_shader_background.c
source/blender/nodes/shader/nodes/node_shader_bsdf_anisotropic.c
source/blender/nodes/shader/nodes/node_shader_bsdf_diffuse.c
source/blender/nodes/shader/nodes/node_shader_bsdf_glass.c
source/blender/nodes/shader/nodes/node_shader_bsdf_glossy.c
source/blender/nodes/shader/nodes/node_shader_bsdf_translucent.c
source/blender/nodes/shader/nodes/node_shader_bsdf_transparent.c
source/blender/nodes/shader/nodes/node_shader_bsdf_velvet.c
source/blender/nodes/shader/nodes/node_shader_camera.c
source/blender/nodes/shader/nodes/node_shader_common.c
source/blender/nodes/shader/nodes/node_shader_curves.c
source/blender/nodes/shader/nodes/node_shader_dynamic.c
source/blender/nodes/shader/nodes/node_shader_emission.c
source/blender/nodes/shader/nodes/node_shader_fresnel.c
source/blender/nodes/shader/nodes/node_shader_geom.c
source/blender/nodes/shader/nodes/node_shader_geometry.c
source/blender/nodes/shader/nodes/node_shader_holdout.c
source/blender/nodes/shader/nodes/node_shader_hueSatVal.c
source/blender/nodes/shader/nodes/node_shader_invert.c
source/blender/nodes/shader/nodes/node_shader_layer_weight.c
source/blender/nodes/shader/nodes/node_shader_light_path.c
source/blender/nodes/shader/nodes/node_shader_mapping.c
source/blender/nodes/shader/nodes/node_shader_material.c
source/blender/nodes/shader/nodes/node_shader_math.c
source/blender/nodes/shader/nodes/node_shader_mixRgb.c
source/blender/nodes/shader/nodes/node_shader_mix_shader.c
source/blender/nodes/shader/nodes/node_shader_normal.c
source/blender/nodes/shader/nodes/node_shader_output.c
source/blender/nodes/shader/nodes/node_shader_output_lamp.c
source/blender/nodes/shader/nodes/node_shader_output_material.c
source/blender/nodes/shader/nodes/node_shader_output_world.c
source/blender/nodes/shader/nodes/node_shader_rgb.c
source/blender/nodes/shader/nodes/node_shader_sepcombRGB.c
source/blender/nodes/shader/nodes/node_shader_squeeze.c
source/blender/nodes/shader/nodes/node_shader_tex_coord.c
source/blender/nodes/shader/nodes/node_shader_tex_environment.c
source/blender/nodes/shader/nodes/node_shader_tex_gradient.c
source/blender/nodes/shader/nodes/node_shader_tex_image.c
source/blender/nodes/shader/nodes/node_shader_tex_magic.c
source/blender/nodes/shader/nodes/node_shader_tex_musgrave.c
source/blender/nodes/shader/nodes/node_shader_tex_noise.c
source/blender/nodes/shader/nodes/node_shader_tex_sky.c
source/blender/nodes/shader/nodes/node_shader_tex_voronoi.c
source/blender/nodes/shader/nodes/node_shader_tex_wave.c
source/blender/nodes/shader/nodes/node_shader_texture.c
source/blender/nodes/shader/nodes/node_shader_valToRgb.c
source/blender/nodes/shader/nodes/node_shader_value.c
source/blender/nodes/shader/nodes/node_shader_vectMath.c
source/blender/nodes/shader/nodes/node_shader_volume_isotropic.c
source/blender/nodes/shader/nodes/node_shader_volume_transparent.c
source/blender/nodes/texture/nodes/node_texture_at.c
source/blender/nodes/texture/nodes/node_texture_bricks.c
source/blender/nodes/texture/nodes/node_texture_checker.c
source/blender/nodes/texture/nodes/node_texture_common.c
source/blender/nodes/texture/nodes/node_texture_compose.c
source/blender/nodes/texture/nodes/node_texture_coord.c
source/blender/nodes/texture/nodes/node_texture_curves.c
source/blender/nodes/texture/nodes/node_texture_decompose.c
source/blender/nodes/texture/nodes/node_texture_distance.c
source/blender/nodes/texture/nodes/node_texture_hueSatVal.c
source/blender/nodes/texture/nodes/node_texture_image.c
source/blender/nodes/texture/nodes/node_texture_invert.c
source/blender/nodes/texture/nodes/node_texture_math.c
source/blender/nodes/texture/nodes/node_texture_mixRgb.c
source/blender/nodes/texture/nodes/node_texture_output.c
source/blender/nodes/texture/nodes/node_texture_proc.c
source/blender/nodes/texture/nodes/node_texture_rotate.c
source/blender/nodes/texture/nodes/node_texture_scale.c
source/blender/nodes/texture/nodes/node_texture_texture.c
source/blender/nodes/texture/nodes/node_texture_translate.c
source/blender/nodes/texture/nodes/node_texture_valToNor.c
source/blender/nodes/texture/nodes/node_texture_valToRgb.c
source/blender/nodes/texture/nodes/node_texture_viewer.c

index 580f78d3063bb9e09838ce52ec2ff4ea46524669..32e858bdcb637712296993a4baf468006fe6bd20 100644 (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 *************** */
 
index c4edddf587c8741a4e80681bcd9fac236a991b93..904e0d187f8429f741a472d11c26cbe615f1a205 100644 (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)
-{
-       register_node_type_frame(ntypelist);
-       
-       register_node_type_cmp_group(ntypelist);
-//     register_node_type_cmp_forloop(ntypelist);
-//     register_node_type_cmp_whileloop(ntypelist);
-       
-       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_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_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_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_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_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_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_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);
-}
-
-static void registerShaderNodes(ListBase *ntypelist
-{
-       register_node_type_frame(ntypelist);
-       
-       register_node_type_sh_group(ntypelist);
-       //register_node_type_sh_forloop(ntypelist);
-       //register_node_type_sh_whileloop(ntypelist);
-
-       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_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_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_output_lamp(ntypelist);
-       register_node_type_sh_output_material(ntypelist);
-       register_node_type_sh_output_world(ntypelist);
-
-       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);
-}
-
-static void registerTextureNodes(ListBase *ntypelist)
-{
-       register_node_type_frame(ntypelist);
-       
-       register_node_type_tex_group(ntypelist);
-//     register_node_type_tex_forloop(ntypelist);
-//     register_node_type_tex_whileloop(ntypelist);
-       
-       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_output(ntypelist);
-       register_node_type_tex_viewer(ntypelist);
-       
-       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_rotate(ntypelist);
-       register_node_type_tex_translate(ntypelist);
-       register_node_type_tex_scale(ntypelist);
-       register_node_type_tex_at(ntypelist);
-       
-       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);
+static void registerCompositNodes(bNodeTreeType *ttype)
+{
+       register_node_type_frame(ttype);
+       
+       register_node_type_cmp_group(ttype);
+//     register_node_type_cmp_forloop(ttype);
+//     register_node_type_cmp_whileloop(ttype);
+       
+       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(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(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(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(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(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(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(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(bNodeTreeType *ttype
+{
+       register_node_type_frame(ttype);
+       
+       register_node_type_sh_group(ttype);
+       //register_node_type_sh_forloop(ttype);
+       //register_node_type_sh_whileloop(ttype);
+
+       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(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(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(ttype);
+       register_node_type_sh_output_material(ttype);
+       register_node_type_sh_output_world(ttype);
+
+       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(bNodeTreeType *ttype)
+{
+       register_node_type_frame(ttype);
+       
+       register_node_type_tex_group(ttype);
+//     register_node_type_tex_forloop(ttype);
+//     register_node_type_tex_whileloop(ttype);
+       
+       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(ttype);
+       register_node_type_tex_viewer(ttype);
+       
+       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(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(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) 
index 6deea004417ec1d284ed7b5f080c3a56071ace42..b74342ab516a790d6bab9e3cce7a93852149c411 100644 (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_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_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_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_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_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_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_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_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_glare(ListBase *lb);
-void register_node_type_cmp_tonemap(ListBase *lb);
-void register_node_type_cmp_lensdist(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(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(struct bNodeTreeType *ttype);
+void register_node_type_cmp_viewer(struct bNodeTreeType *ttype);
+void register_node_type_cmp_splitviewer(struct bNodeTreeType *ttype);
+void register_node_type_cmp_output_file(struct bNodeTreeType *ttype);
+void register_node_type_cmp_view_levels(struct bNodeTreeType *ttype);
+
+void register_node_type_cmp_curve_rgb(struct bNodeTreeType *ttype);
+void register_node_type_cmp_mix_rgb(struct bNodeTreeType *ttype);
+void register_node_type_cmp_hue_sat(struct bNodeTreeType *ttype);
+void register_node_type_cmp_brightcontrast(struct bNodeTreeType *ttype);
+void register_node_type_cmp_gamma(struct bNodeTreeType *ttype);
+void register_node_type_cmp_invert(struct bNodeTreeType *ttype);
+void register_node_type_cmp_alphaover(struct bNodeTreeType *ttype);
+void register_node_type_cmp_zcombine(struct bNodeTreeType *ttype);
+void register_node_type_cmp_colorbalance(struct bNodeTreeType *ttype);
+void register_node_type_cmp_huecorrect(struct bNodeTreeType *ttype);
+
+void register_node_type_cmp_normal(struct bNodeTreeType *ttype);
+void register_node_type_cmp_curve_vec(struct bNodeTreeType *ttype);
+void register_node_type_cmp_map_value(struct bNodeTreeType *ttype);
+void register_node_type_cmp_normalize(struct bNodeTreeType *ttype);
+
+void register_node_type_cmp_filter(struct bNodeTreeType *ttype);
+void register_node_type_cmp_blur(struct bNodeTreeType *ttype);
+void register_node_type_cmp_dblur(struct bNodeTreeType *ttype);
+void register_node_type_cmp_bilateralblur(struct bNodeTreeType *ttype);
+void register_node_type_cmp_vecblur(struct bNodeTreeType *ttype);
+void register_node_type_cmp_dilateerode(struct bNodeTreeType *ttype);
+void register_node_type_cmp_defocus(struct bNodeTreeType *ttype);
+
+void register_node_type_cmp_valtorgb(struct bNodeTreeType *ttype);
+void register_node_type_cmp_rgbtobw(struct bNodeTreeType *ttype);
+void register_node_type_cmp_setalpha(struct bNodeTreeType *ttype);
+void register_node_type_cmp_idmask(struct bNodeTreeType *ttype);
+void register_node_type_cmp_math(struct bNodeTreeType *ttype);
+void register_node_type_cmp_seprgba(struct bNodeTreeType *ttype);
+void register_node_type_cmp_combrgba(struct bNodeTreeType *ttype);
+void register_node_type_cmp_sephsva(struct bNodeTreeType *ttype);
+void register_node_type_cmp_combhsva(struct bNodeTreeType *ttype);
+void register_node_type_cmp_sepyuva(struct bNodeTreeType *ttype);
+void register_node_type_cmp_combyuva(struct bNodeTreeType *ttype);
+void register_node_type_cmp_sepycca(struct bNodeTreeType *ttype);
+void register_node_type_cmp_combycca(struct bNodeTreeType *ttype); 
+void register_node_type_cmp_premulkey(struct bNodeTreeType *ttype);
+
+void register_node_type_cmp_diff_matte(struct bNodeTreeType *ttype);
+void register_node_type_cmp_distance_matte(struct bNodeTreeType *ttype);
+void register_node_type_cmp_chroma_matte(struct bNodeTreeType *ttype);
+void register_node_type_cmp_color_matte(struct bNodeTreeType *ttype);
+void register_node_type_cmp_channel_matte(struct bNodeTreeType *ttype);
+void register_node_type_cmp_color_spill(struct bNodeTreeType *ttype);
+void register_node_type_cmp_luma_matte(struct bNodeTreeType *ttype); 
+
+void register_node_type_cmp_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(struct bNodeTreeType *ttype);
+void register_node_type_cmp_tonemap(struct bNodeTreeType *ttype);
+void register_node_type_cmp_lensdist(struct bNodeTreeType *ttype);
 
 #endif
index 996660fcb8b171ee54bde1696cdd85ec53933da5..293ce4665743911e90d909e0ff1ec5dfac11c581 100644 (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
 
index b07c0b22b75310e16a6a3d09a38bf4b3ec61879e..b3fdbf0e2501df65b21714b2b577d8292a7c6a6a 100644 (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
index 4fd4b7501782c5396150dcb9a91c49b15b8e30c6..cad85d33a66f533861f367c93f7021a54b31a09a 100644 (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);
 }
-
-
-
index 0f3413357837dc4c85a14f7423961afe6077b2c6..c6462e2870cf9713141986653da3fe531cb35ac1 100644 (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);
 }
-
index 816aacbe61c1fd2d4b0b476856e8c1ae26ebf0d6..76827f719f520f3a948ce39782d8e879f6a67c5e 100644 (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);
 }
-
-
-
index 9153e3899fccb7ee6c8f66ce1de5c73aad6f6249..d935d9af7f7ab3ca357047970ff3909011b384d4 100644 (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);
 }
-
index 6597ceaeee2dda4e634ce545d60888db6c1d02ad..785786dacbe08b5f34e3b15d4abc2b20a4314e70 100644 (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);
 }
index 0005d9d2cc97a5d4ae4065872f8f2eec0d16ee5c..b6f490a032093fc808f80a65586c39716648aaba 100644 (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);
 }
-
-
-
index 66dc9ff0304eb95789b949d811fe9c2b86c19c86..2d56c9e59737bec14d84b06c10f9f758312623fb 100644 (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);
 }
-
-
-
index c85a81b9bdbdc291ee80dfa57903270e7ae91bbb..af6a295cf7f0d90268bd0df2451b3ddd95be2029 100644 (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);
 }
index f7de5801a5e43157dfb81d8c3d3bb0a90cb067f5..26d7aa0a3a0f9e4c84cb14c379a0b541b4a0f230 100644 (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);
 }
-
-
index 7060971830ed58fa6e81b94db41c2bb7c8a05ffa..1b38609ce24d49011f3bf0f60f2574ff2c375bcb 100644 (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
index 4eb9dd74b2e52d2eb452df8562dfc8e4a71a8d4a..828dd8fcfc7c7962b92a4925f2024800e8e8ba71 100644 (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);
 }
-
index 7847726c68ea6265b5a372fda387bbc05b11674b..3697f3e4c5c979ed03a49fcdd0178ebcb11ca2bf 100644 (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);
 }
-
index 2e54836e042a8022788d8ce1ec964dffa56fa48d..81424586a115b71e001af674eb35d6047f76b57a 100644 (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);
 }
-
-
index f1c2fb321d195a5fa672fe254c282863fa5817ce..1e7c8e8b58c156e741585b929e5e0bf006b3aeca 100644 (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);
 }
-
-
-
index 3b2a23421678d2342c435307847694a2b9b50b45..eae59dea3f493ef4a24f0b4583af96ebfc454a9d 100644 (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);
 }
-
-
-
index 751db6417859c597814941ef7254aa86f9266e46..f8abf96e7420ab021b1b593ef6d503dc9c182fa2 100644 (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);
 }
-
-
index 04610150356a6e112f5abe496a5a0c9233dec29a..d0f7feccf2e4da37bdb338a3dbb29eece5ccd2d5 100644 (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);
 }
-
index a55a6093f1241f8211ea7b5f7ba38cf012e9c405..ad7c1fa589eb0f7909c970e67cefa23ff2a567e3 100644 (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);
 }
-
-
index 27fe66cbe0da81bfc7a7592c041406caaa0ad8e7..292bb66613d27d4e342f8bb9c4cf6efcd37e911b 100644 (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);
 }
-
-
-
index 1a0c51fab530abd8602a2841d6c365b6555bc94e..94a109de8f2110ea81afcedda24dae66d7038196 100644 (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);
 }
-
-
-
index 01f58182227d43c85ebd45143833fbb8980fe630..974a14037eb74ee8e84d53cb2660ed0c856a8f87 100644 (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);
 }
-
-
-
index ad377799dead8a5689c6c039221548e1d721397c..90135b5cf357392f350df1ba141cb5d0dca5d936 100644 (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);
 }
index 296ad2e3a5bb1de8703a5fdb60adaba550ee5eba..d4e15f780e5a7f282deb8f7623f73862b7f91d9a 100644 (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);
 }
-
index 711560a0a945d53cf34469f82032c605b174a65a..c4598717e004c5fcba41c226c18d6949f66ec2e2 100644 (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);
 }
-
-
-
index acb70f13ec259674ea6735b7537b64399085dc44..6b0849b23918f1c198df836363ea8ef821140638 100644 (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);
 }
-
-
index 914483bc52fe794113ff0681cbbd6cda1f2cc017..0600e44b0d0b72576ec3c0c5cf40e1cffb771cf2 100644 (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);
 }
-
-
-
index 672d2af06465fcd1c594a9f030557b679421f77f..9920cdab0398d6aafb9e362958c1fa75b764509f 100644 (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);
 }
-
-
-
index d98f5a1c64b398d8397477b00553067001775358..4fda90e0a1e14fc827443dab4d7ef4e1a3086d16 100644 (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);
 }
-
index e57f405ed6804788ebe5d76aa60085a68f91adac..5d3a9323f5285f0247564f9f60de69644cb84835 100644 (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);
 }
-
index f3e4f0db8b62ad0a2855700f0da56350bd8bb9a3..9417e504a1bb8c6753ea77e07c41f91f54d9fc22 100644 (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);
 }
-
-
index 8573849b069a74583016b01939f15e21242003c8..ad5e9d423e55f9e5d94fdc2839891faa3bac61bb 100644 (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);
 }
-
-
index b596f67a886ab9d0c75a034a92017b511e9fd80c..1ca729c839300af7f11c0fcb68c635112be2a0ba 100644 (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);
 }
-
-
-
index 6930fbf0664b67c4220d7417b013ceb8cd2f6173..380aa0b716b23b1bb3ed152b60ff65684d60adfa 100644 (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);
 }
-
-
-
-
index 27fdcfc1d4eba7292d4f0ce4d6b7c95cd7dbc3b9..6c2cbb9a92be9ec1d35faa7d42f300683ce35d31 100644 (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);
 }
-
-
-
-
index 275d949da28b784ab42487b5b8e6375339a6b332..4a303e911e2a3a463f95ab04701ca2fcec77449f 100644 (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);
 }
-
index 8931b8990172558b209a3eeb327ecdc07d28af97..1f449f8c16adf5d23c8ea12d1bce5f9fc6fbf339 100644 (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);
 }
index 05d13f346f30ec1f8d2a28a55aba3db7462bec3a..bc3f648a3747706d8008e0597b0a1d6a4cce78ee 100644 (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);
 }
index 4c43871d8678bc5392d080cd085c214186064b9d..fbbd58932ea68d0da5830e9ea5dc2ff4abd30290 100644 (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);
 }
-
-
index d14f589f3f2e7712fc4744a9909875dcc2657466..455966e4f38d3719ed562c0cc214b18ba6556536 100644 (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);
 }
index 845c5b880202d082e7c4c40cd47e6febbe3d929c..b2177002e822e5da4470dae776c5daf028e3f7a4 100644 (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);
 }
-
-
-
index b188b0dd32379830f01ca8ccfe165bea5605e472..bf934fcd0f7723a175ab0da279d4760df3953331 100644 (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);
 }
-
-
index 12f073a816d0a6f654db2b5bd91d24cd8847ad8e..ca9db716b66711e132ad2f1832a6dbb68a4f518c 100644 (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);
 }
-
-
-
index d02602c7d04698bd636a204ae2421442db34b4fd..826653c6cff4dbf70581e046af87405a76ba3df1 100644 (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);
 }
-
index 37332c9bd7ecd2e5584a250637dbbd90a3b79ecf..188449df5fb837146bab4f5687791d4a17745a66 100644 (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);
 }
-
-
-
-
-
-
-
index bf58d443aecac84ae807a59f4e0301770267833d..d742a916fdffae81ea3b267f5996853e707b0408 100644 (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);
 }
-
-
-
index ade2b22bf35f1f0115185ba0050b4da529415bdc..1f0b504f161908dfc8badbeb1534a53139cadd72 100644 (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);
 }
-
-
index 7944176c5d3f9169e87eadb9a7137005f47eadac..a5f827b094d3ea307e2b401a2578b8cbf581e936 100644 (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);
 }
-
-
-
index aedb5652e61c87f67684108773613563e139337c..2a2f64a5209846a731a0b1d6fe13a2302a65b440 100644 (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);
 }
-
-
index 2b19ebfe5a37b13ae3b8a0b30e56f0f2d7f06ded..6c24185bb8810db72669d25549ea2f6386bc1a9c 100644 (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);
 }
-
index b63b42224e205aca684cb386589dfdd259fee6fc..c801c34e8b57f922069116cf5e517c45e0617f84 100644 (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);
 }
-
-
-
-
-
index c5d60e65530f5aba951ae408753f077b9cbfe892..f41751b3e1501d6132dc5d1b218865ef93edfc22 100644 (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);
 }
index 2f54f27e481baccadbcbe7284527db675f5ac8d5..7f8f14bcfc58202d24ccf91d8b2b19df469371db 100644 (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);
 }
-
-
-
index 36e583a77ff3d694ef90d95a480b6efbdca61646..9b34e117496bacb1dd3a46d87e07a5ddb1738e80 100644 (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);
 }
-
index de9b8fceaeef6b823dad7405b828e336f860df92..7e096bf0545d303277c8de6d6b5a72bf6c62674e 100644 (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);
 }
-
-
index 2b25ef92a1e0e61045b9549f7668c9657bdcc511..073b035add0eb51c2e9ecd8369194027f7ad298b 100644 (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);
 }
-
-
index 014f40a1a480812ee1a7da7c42d10ed1b8cafbf0..30f624641d1e6043213945bba12b1094d9221e9b 100644 (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);
 }
index a38187847fd7eeed4a2839caeccc5efa731e936f..3cecb69bc7ed4d445ab3db8cf14b779dea3c1ade 100644 (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);
 }
-
-
index a0fbcec198ad504dcf65f1c5a245c0d73f639d15..69f896e9bb50d9636e7f54ad85f6fb29f55923ec 100644 (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);
 }
-
-
index fcf7fe530bdaaeb8a5e77f7c900081b57957c9b6..46051caced244dc772d14c2a19c4e8669b7a2bf8 100644 (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);
 }
index 868c0d2b5f32e9092cfc9f85ac1b1cfca29f760c..57b0b7bbf140f7d2d7548ca3b7f0331dbe068ae1 100644 (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);
 }
-
index 11dcf44a288bf7dcb3bdcbfd78118c10df101b4e..5ad84da45d2e4e04533e34c3a8e2140e7bde82ce 100644 (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);
 }
index cddf49dd4d536a2e5e69c5dfcee280fa14358413..c12ff54d24ce8c4cd34eb328d7c2a6af585d148a 100644 (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);
+}
index 6fb21f123fbc92f199f632000f0c354ea673c00b..bd0779ae5b1ade1b2b7c69e9816eaac8c46400cf 100644 (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);
 }
-
index 2cdd99da65cae013c123c8283e6b9d5d92953745..6acdc5baa59f9796da9d8b07e1b0ca1908c553da 100644 (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);
+}
index e19d867a0574fc32765138bdfff512fee25e9624..2fd41fed92f5184c8a548c2612a4e0cc28424425 100644 (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);
+}
index cbc8296958808388ee714e81241a9ec07169db14..114581f8a20c84122c061188d57863c400b9712a 100644 (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);
+}
index 2652385e27345d7eed2a10add2d116a4fccebe06..89d469a6a4d1afaa159d61061ff44c53c4ebebbe 100644 (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);
+}
index 03c1ca29de1dba0b58ae04c6b39307187a92f505..000a211805bde0a055db0a9b3610f2364d6c6ae7 100644 (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);
+}
index 74db25f3b13eb8dbe6a60d08c52d53b27077c865..60fe847ac11c0fce544f5a6785d66d1e3e0fa9ce 100644 (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);
+}
index c74786441f08f284c8dc0f12759ab31926487e45..301e6dfababe3636c3b26f9668a53d8a650e842c 100644 (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);
+}
index 7ca38fc0af7aec1f900dd9fc0c319c30facec925..fefcf4caeaf6f84c342eb658b0dbd76f2f200539 100644 (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);
+}
index 02efbd63abaac6dac8faace4d000c0e3eb6364a4..d95cc1460df7dc154d3390ad5468df37e8602e8e 100644 (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);
 }
-
-
index ff995e02ca68a05ea24ca4a330352901adfdbc5c..f75cecfe83b29ed76f717950269b85e77aeeab98 100644 (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
index 7ac05bb28bfd638103169e43be05c8abed29979c..d30434f4e3244778c078e8d8ccef75a48286655e 100644 (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);
 }
-
index 51ddb865c540a2187068ab19e93f710b3beb8acb..5e7c99f7276c2161b0a2fb5d47e3e7ebde61c917 100644 (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
-
-
index 9b9d95086ce28229539513c0506ac1daac6f194f..9eb8fc98c69ab2cdb107cdbcabe6ec02fc5bb21c 100644 (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);
+}
index b98fa191bebd0a9ab946c877355cb756b6907de5..8e5350c2167f2814b064b5ee498eb441c8d02413 100644 (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);
+}
index 6547194b33ab957c90d12ab43f41bf321ab2680b..2b28eae4085e2a48b27dea94efdf0904b4ffe64c 100644 (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);
 }
-
index 2bbdf3c23bb8ad39b343a25470b5ed17a3ec1c92..6b576b0c0d1ba0d83519e04900afa8a7980358ce 100644 (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);
+}
index f08217f3a92ed25207a976981907caf3eaea4ea0..81dceafe21f8b8faeb621c152d8587fb9a084166 100644 (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);
+}
index 1207196381df2acdb7f83ea3285cc4c2637740f9..bfdcb5d0917e9e39b2376d0e1970d19575c72a38 100644 (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);
 }
-
-
-
index e3dacefbcf235f177d90cd2f6b0cc21d0283dd91..6d21b93fb6570a912cbe067524cdc93b24731dbe 100644 (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);
 }
-
-
index 39c7173bd16c76a3989b348ffd403ccc5c74ef44..bcd7fb8639d7e356e5d9f719215dd3820e9f27a3 100644 (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);
+}
index b64b9bf8b1125b6cf93923074ce4e936858b0d2c..5d7a3014682e83ca8b7fa682919bf19b72506603 100644 (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);
+}
index 2fa885dcdd3a3bf9f540775d4db48d37fa329824..c2a58d4916137b3deebebb916c4fb9bca9033863 100644 (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);
 }
index a74a2567844d92704cced8cc9e6b3db0bb603953..decd3bb225faf76662b0b32393caf40551703afd 100644 (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);
 }
-
-
index 1c15c49a7da7e8911d1c573b28028bbe4243130a..c9234c626aa06d68d1c92d6fa85a6dfaccabe5b3 100644 (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);
 }
-
-
index 5d7ec9a23abc328f7ff51c5eb2359f27e2a7d7f9..e7350612b5b7cf43c745ae5ef7a11910a510e58a 100644 (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);
 }
-
index bf44d26024c78e63e37192a8b8174a4eb62c9ca6..43dde9e5b91c295258aec04fe951fa0ddf5147d9 100644 (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);
+}
index 40f2f65a193bcaa43358d145b63a64065a4fce80..f699268e939bfe7b33ca4ce1738c3303141b8909 100644 (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);
 }
index 22e3cab532dba4dae105268da970ec512aacc39f..8be634367a5a6cbce9e6ccb487a61c8cabf5b1d8 100644 (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);
 }
-
-
index 8aa9de15eb497cb310f6027606945571a1d4ac00..3fe4862e8c8a816c7519215e01a99c0e69a11f10 100644 (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);
+}
index 58d8bc039722e2a78c83b367bc09300789437764..15a201f9f216c3a90d13c2a5e36d3d5f76afbc58 100644 (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);
+}
index 98cecd0d04b5d0a228058a01b11e5cc79e91d25d..6283c28c485ec0028176609738136067c7838aa0 100644 (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);
+}
index 58a00ed92e50893334710a1217288dc512b649fe..d0c52035f96470b6df6b1e1712aa143c4f75586b 100644 (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);
 }
-
index 4f409bb3ec114119c35f1158298bf8c8f771da9f..09371a8a5ae03cd80ee4eef4a91301c6e505805e 100644 (file)
@@ -56,18 +56,18 @@ static int gpu_shader_seprgb(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack
        return GPU_stack_link(mat, "separate_rgb", in, out);
 }
 
-void register_node_type_sh_seprgb(ListBase *lb)
+void register_node_type_sh_seprgb(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
 
-       node_type_base(&ntype, SH_NODE_SEPRGB, "Separate RGB", NODE_CLASS_CONVERTOR, 0);
+       node_type_base(ttype, &ntype, SH_NODE_SEPRGB, "Separate RGB", NODE_CLASS_CONVERTOR, 0);
        node_type_compatibility(&ntype, NODE_OLD_SHADING);
        node_type_socket_templates(&ntype, sh_node_seprgb_in, sh_node_seprgb_out);
        node_type_size(&ntype, 80, 40, 140);
        node_type_exec(&ntype, node_shader_exec_seprgb);
        node_type_gpu(&ntype, gpu_shader_seprgb);
 
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
 
 
@@ -96,17 +96,16 @@ static int gpu_shader_combrgb(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStac
        return GPU_stack_link(mat, "combine_rgb", in, out);
 }
 
-void register_node_type_sh_combrgb(ListBase *lb)
+void register_node_type_sh_combrgb(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
 
-       node_type_base(&ntype, SH_NODE_COMBRGB, "Combine RGB", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, SH_NODE_COMBRGB, "Combine RGB", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
        node_type_compatibility(&ntype, NODE_OLD_SHADING);
        node_type_socket_templates(&ntype, sh_node_combrgb_in, sh_node_combrgb_out);
        node_type_size(&ntype, 80, 40, 140);
        node_type_exec(&ntype, node_shader_exec_combrgb);
        node_type_gpu(&ntype, gpu_shader_combrgb);
 
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
-
index 16a9ae8aedc4d0e7127662271a9a2dc32ca21f42..ded930659e5bed3383014645c8fc3b3ea3860ac9 100644 (file)
@@ -62,11 +62,11 @@ static int gpu_shader_squeeze(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStac
        return GPU_stack_link(mat, "squeeze", in, out);
 }
 
-void register_node_type_sh_squeeze(ListBase *lb)
+void register_node_type_sh_squeeze(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
 
-       node_type_base(&ntype, SH_NODE_SQUEEZE, "Squeeze Value", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, SH_NODE_SQUEEZE, "Squeeze Value", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
        node_type_compatibility(&ntype, NODE_OLD_SHADING);
        node_type_socket_templates(&ntype, sh_node_squeeze_in, sh_node_squeeze_out);
        node_type_size(&ntype, 120, 110, 160);
@@ -74,7 +74,5 @@ void register_node_type_sh_squeeze(ListBase *lb)
        node_type_exec(&ntype, node_shader_exec_squeeze);
        node_type_gpu(&ntype, gpu_shader_squeeze);
 
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
-
-
index 0982c0fe90d990419056ce0b0307a9c32392ed7f..8f67fb585c9e905989a4716602484b90baa96f2a 100644 (file)
@@ -52,11 +52,11 @@ static int node_shader_gpu_tex_coord(GPUMaterial *mat, bNode *UNUSED(node), GPUN
 }
 
 /* node type definition */
-void register_node_type_sh_tex_coord(ListBase *lb)
+void register_node_type_sh_tex_coord(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
 
-       node_type_base(&ntype, SH_NODE_TEX_COORD, "Texture Coordinate", NODE_CLASS_INPUT, 0);
+       node_type_base(ttype, &ntype, SH_NODE_TEX_COORD, "Texture Coordinate", NODE_CLASS_INPUT, 0);
        node_type_compatibility(&ntype, NODE_NEW_SHADING);
        node_type_socket_templates(&ntype, NULL, sh_node_tex_coord_out);
        node_type_size(&ntype, 150, 60, 200);
@@ -65,6 +65,5 @@ void register_node_type_sh_tex_coord(ListBase *lb)
        node_type_exec(&ntype, NULL);
        node_type_gpu(&ntype, node_shader_gpu_tex_coord);
 
-       nodeRegisterType(lb, &ntype);
-};
-
+       nodeRegisterType(ttype, &ntype);
+}
index 5639e82ddb828e5035382ef592ef2da0de85a156..dbdd6a8619b36879b2073fb4fc9e36e9b41d3ce8 100644 (file)
@@ -69,11 +69,11 @@ static int node_shader_gpu_tex_environment(GPUMaterial *mat, bNode *node, GPUNod
 }
 
 /* node type definition */
-void register_node_type_sh_tex_environment(ListBase *lb)
+void register_node_type_sh_tex_environment(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
 
-       node_type_base(&ntype, SH_NODE_TEX_ENVIRONMENT, "Environment Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, SH_NODE_TEX_ENVIRONMENT, "Environment Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS);
        node_type_compatibility(&ntype, NODE_NEW_SHADING);
        node_type_socket_templates(&ntype, sh_node_tex_environment_in, sh_node_tex_environment_out);
        node_type_size(&ntype, 150, 60, 200);
@@ -82,6 +82,5 @@ void register_node_type_sh_tex_environment(ListBase *lb)
        node_type_exec(&ntype, NULL);
        node_type_gpu(&ntype, node_shader_gpu_tex_environment);
 
-       nodeRegisterType(lb, &ntype);
-};
-
+       nodeRegisterType(ttype, &ntype);
+}
index f93507e29976a9fe914e763b706059eac228abc9..a2403b6bdec3a4c0c3bab35c378d76a0b3f3cc27 100644 (file)
@@ -61,11 +61,11 @@ static int node_shader_gpu_tex_gradient(GPUMaterial *mat, bNode *node, GPUNodeSt
 }
 
 /* node type definition */
-void register_node_type_sh_tex_gradient(ListBase *lb)
+void register_node_type_sh_tex_gradient(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
 
-       node_type_base(&ntype, SH_NODE_TEX_GRADIENT, "Gradient Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, SH_NODE_TEX_GRADIENT, "Gradient Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS);
        node_type_compatibility(&ntype, NODE_NEW_SHADING);
        node_type_socket_templates(&ntype, sh_node_tex_gradient_in, sh_node_tex_gradient_out);
        node_type_size(&ntype, 150, 60, 200);
@@ -74,6 +74,5 @@ void register_node_type_sh_tex_gradient(ListBase *lb)
        node_type_exec(&ntype, NULL);
        node_type_gpu(&ntype, node_shader_gpu_tex_gradient);
 
-       nodeRegisterType(lb, &ntype);
-};
-
+       nodeRegisterType(ttype, &ntype);
+}
index ce614d6117d0391a9edbeee5474ed01ed7b7979a..aa679b4e04ea6dd260622ed137298ba6ace51c9d 100644 (file)
@@ -69,11 +69,11 @@ static int node_shader_gpu_tex_image(GPUMaterial *mat, bNode *node, GPUNodeStack
 }
 
 /* node type definition */
-void register_node_type_sh_tex_image(ListBase *lb)
+void register_node_type_sh_tex_image(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
 
-       node_type_base(&ntype, SH_NODE_TEX_IMAGE, "Image Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, SH_NODE_TEX_IMAGE, "Image Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS);
        node_type_compatibility(&ntype, NODE_NEW_SHADING);
        node_type_socket_templates(&ntype, sh_node_tex_image_in, sh_node_tex_image_out);
        node_type_size(&ntype, 150, 60, 200);
@@ -82,6 +82,5 @@ void register_node_type_sh_tex_image(ListBase *lb)
        node_type_exec(&ntype, NULL);
        node_type_gpu(&ntype, node_shader_gpu_tex_image);
 
-       nodeRegisterType(lb, &ntype);
-};
-
+       nodeRegisterType(ttype, &ntype);
+}
index 73a66c94193284764c3db353fe38a9609a741909..3a270220667738f717e78c7ae9e1181e1694a6b1 100644 (file)
@@ -66,11 +66,11 @@ static int node_shader_gpu_tex_magic(GPUMaterial *mat, bNode *node, GPUNodeStack
 }
 
 /* node type definition */
-void register_node_type_sh_tex_magic(ListBase *lb)
+void register_node_type_sh_tex_magic(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
 
-       node_type_base(&ntype, SH_NODE_TEX_MAGIC, "Magic Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, SH_NODE_TEX_MAGIC, "Magic Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS);
        node_type_compatibility(&ntype, NODE_NEW_SHADING);
        node_type_socket_templates(&ntype, sh_node_tex_magic_in, sh_node_tex_magic_out);
        node_type_size(&ntype, 150, 60, 200);
@@ -79,6 +79,5 @@ void register_node_type_sh_tex_magic(ListBase *lb)
        node_type_exec(&ntype, NULL);
        node_type_gpu(&ntype, node_shader_gpu_tex_magic);
 
-       nodeRegisterType(lb, &ntype);
-};
-
+       nodeRegisterType(ttype, &ntype);
+}
index 00cde10ccea9ad3dd32ae1047eb433725246411d..015b78687fd9dfbadeb193b3503dc9232d57c4c2 100644 (file)
@@ -67,11 +67,11 @@ static int node_shader_gpu_tex_musgrave(GPUMaterial *mat, bNode *node, GPUNodeSt
 }
 
 /* node type definition */
-void register_node_type_sh_tex_musgrave(ListBase *lb)
+void register_node_type_sh_tex_musgrave(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
 
-       node_type_base(&ntype, SH_NODE_TEX_MUSGRAVE, "Musgrave Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, SH_NODE_TEX_MUSGRAVE, "Musgrave Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS);
        node_type_compatibility(&ntype, NODE_NEW_SHADING);
        node_type_socket_templates(&ntype, sh_node_tex_musgrave_in, sh_node_tex_musgrave_out);
        node_type_size(&ntype, 150, 60, 200);
@@ -80,6 +80,5 @@ void register_node_type_sh_tex_musgrave(ListBase *lb)
        node_type_exec(&ntype, NULL);
        node_type_gpu(&ntype, node_shader_gpu_tex_musgrave);
 
-       nodeRegisterType(lb, &ntype);
-};
-
+       nodeRegisterType(ttype, &ntype);
+}
index f767fb6f36d3b46eaa0656f9e95fdea18ee9830e..bb365cf5a3398e3f590770ec96f6e3dcee487f13 100644 (file)
@@ -63,11 +63,11 @@ static int node_shader_gpu_tex_noise(GPUMaterial *mat, bNode *node, GPUNodeStack
 }
 
 /* node type definition */
-void register_node_type_sh_tex_noise(ListBase *lb)
+void register_node_type_sh_tex_noise(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
 
-       node_type_base(&ntype, SH_NODE_TEX_NOISE, "Noise Texture", NODE_CLASS_TEXTURE, 0);
+       node_type_base(ttype, &ntype, SH_NODE_TEX_NOISE, "Noise Texture", NODE_CLASS_TEXTURE, 0);
        node_type_compatibility(&ntype, NODE_NEW_SHADING);
        node_type_socket_templates(&ntype, sh_node_tex_noise_in, sh_node_tex_noise_out);
        node_type_size(&ntype, 150, 60, 200);
@@ -76,6 +76,5 @@ void register_node_type_sh_tex_noise(ListBase *lb)
        node_type_exec(&ntype, NULL);
        node_type_gpu(&ntype, node_shader_gpu_tex_noise);
 
-       nodeRegisterType(lb, &ntype);
-};
-
+       nodeRegisterType(ttype, &ntype);
+}
index 72bcccee5c708582d43ddad8459c3a99e7302209..a4131f3ca6c10d30719ec1c6e883ae2d880c7917 100644 (file)
@@ -63,11 +63,11 @@ static int node_shader_gpu_tex_sky(GPUMaterial *mat, bNode *node, GPUNodeStack *
 }
 
 /* node type definition */
-void register_node_type_sh_tex_sky(ListBase *lb)
+void register_node_type_sh_tex_sky(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
 
-       node_type_base(&ntype, SH_NODE_TEX_SKY, "Sky Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, SH_NODE_TEX_SKY, "Sky Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS);
        node_type_compatibility(&ntype, NODE_NEW_SHADING);
        node_type_socket_templates(&ntype, sh_node_tex_sky_in, sh_node_tex_sky_out);
        node_type_size(&ntype, 150, 60, 200);
@@ -76,6 +76,5 @@ void register_node_type_sh_tex_sky(ListBase *lb)
        node_type_exec(&ntype, NULL);
        node_type_gpu(&ntype, node_shader_gpu_tex_sky);
 
-       nodeRegisterType(lb, &ntype);
-};
-
+       nodeRegisterType(ttype, &ntype);
+}
index 563774d83383b074ff9cd7d5ec7410076da3473c..9adaab22b0359695552b7e2101235844581c5de5 100644 (file)
@@ -62,11 +62,11 @@ static int node_shader_gpu_tex_voronoi(GPUMaterial *mat, bNode *node, GPUNodeSta
 }
 
 /* node type definition */
-void register_node_type_sh_tex_voronoi(ListBase *lb)
+void register_node_type_sh_tex_voronoi(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
 
-       node_type_base(&ntype, SH_NODE_TEX_VORONOI, "Voronoi Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, SH_NODE_TEX_VORONOI, "Voronoi Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS);
        node_type_compatibility(&ntype, NODE_NEW_SHADING);
        node_type_socket_templates(&ntype, sh_node_tex_voronoi_in, sh_node_tex_voronoi_out);
        node_type_size(&ntype, 150, 60, 200);
@@ -75,6 +75,5 @@ void register_node_type_sh_tex_voronoi(ListBase *lb)
        node_type_exec(&ntype, NULL);
        node_type_gpu(&ntype, node_shader_gpu_tex_voronoi);
 
-       nodeRegisterType(lb, &ntype);
-};
-
+       nodeRegisterType(ttype, &ntype);
+}
index 059a41c2b0c36c413002d13eaa444e4141983a70..d359a407bc050dbf27f12a3f821645f07ccb60c8 100644 (file)
@@ -65,11 +65,11 @@ static int node_shader_gpu_tex_wave(GPUMaterial *mat, bNode *node, GPUNodeStack
 }
 
 /* node type definition */
-void register_node_type_sh_tex_wave(ListBase *lb)
+void register_node_type_sh_tex_wave(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
 
-       node_type_base(&ntype, SH_NODE_TEX_WAVE, "Wave Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, SH_NODE_TEX_WAVE, "Wave Texture", NODE_CLASS_TEXTURE, NODE_OPTIONS);
        node_type_compatibility(&ntype, NODE_NEW_SHADING);
        node_type_socket_templates(&ntype, sh_node_tex_wave_in, sh_node_tex_wave_out);
        node_type_size(&ntype, 150, 60, 200);
@@ -78,6 +78,5 @@ void register_node_type_sh_tex_wave(ListBase *lb)
        node_type_exec(&ntype, NULL);
        node_type_gpu(&ntype, node_shader_gpu_tex_wave);
 
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
-
index c26cf2451df481a9ebafc31d3f52befa1eb30b3b..02818496dabbf1197f12da0beb3f4657790db33e 100644 (file)
@@ -133,18 +133,16 @@ static int gpu_shader_texture(GPUMaterial *mat, bNode *node, GPUNodeStack *in, G
                return 0;
 }
 
-void register_node_type_sh_texture(ListBase *lb)
+void register_node_type_sh_texture(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
 
-       node_type_base(&ntype, SH_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW);
+       node_type_base(ttype, &ntype, SH_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW);
        node_type_compatibility(&ntype, NODE_OLD_SHADING);
        node_type_socket_templates(&ntype, sh_node_texture_in, sh_node_texture_out);
        node_type_size(&ntype, 120, 80, 240);
        node_type_exec(&ntype, node_shader_exec_texture);
        node_type_gpu(&ntype, gpu_shader_texture);
 
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
-
-
index 94afd09274af75da6ead61d5fea0e7d1f24fc531..f0a94928985da0def13faf3315754ae7f91c7900 100644 (file)
@@ -71,11 +71,11 @@ static int gpu_shader_valtorgb(GPUMaterial *mat, bNode *node, GPUNodeStack *in,
        return GPU_stack_link(mat, "valtorgb", in, out, GPU_texture(size, array));
 }
 
-void register_node_type_sh_valtorgb(ListBase *lb)
+void register_node_type_sh_valtorgb(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
 
-       node_type_base(&ntype, SH_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, SH_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
        node_type_compatibility(&ntype, NODE_OLD_SHADING);
        node_type_socket_templates(&ntype, sh_node_valtorgb_in, sh_node_valtorgb_out);
        node_type_size(&ntype, 240, 200, 300);
@@ -84,7 +84,7 @@ void register_node_type_sh_valtorgb(ListBase *lb)
        node_type_exec(&ntype, node_shader_exec_valtorgb);
        node_type_gpu(&ntype, gpu_shader_valtorgb);
 
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
 
 
@@ -112,18 +112,16 @@ static int gpu_shader_rgbtobw(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStac
        return GPU_stack_link(mat, "rgbtobw", in, out);
 }
 
-void register_node_type_sh_rgbtobw(ListBase *lb)
+void register_node_type_sh_rgbtobw(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
 
-       node_type_base(&ntype, SH_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTOR, 0);
+       node_type_base(ttype, &ntype, SH_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTOR, 0);
        node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING);
        node_type_socket_templates(&ntype, sh_node_rgbtobw_in, sh_node_rgbtobw_out);
        node_type_size(&ntype, 80, 40, 120);
        node_type_exec(&ntype, node_shader_exec_rgbtobw);
        node_type_gpu(&ntype, gpu_shader_rgbtobw);
 
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
-
-
index 8f490f4953b3096432b075da23a608d6dff95240..3196ce5cbe4cd65076b0149e66e2555f907c2528 100644 (file)
@@ -66,11 +66,11 @@ static int gpu_shader_value(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPU
        return GPU_stack_link(mat, "set_value", in, out, vec);
 }
 
-void register_node_type_sh_value(ListBase *lb)
+void register_node_type_sh_value(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
 
-       node_type_base(&ntype, SH_NODE_VALUE, "Value", NODE_CLASS_INPUT, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, SH_NODE_VALUE, "Value", NODE_CLASS_INPUT, NODE_OPTIONS);
        node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING);
        node_type_socket_templates(&ntype, NULL, sh_node_value_out);
        node_type_init(&ntype, node_shader_init_value);
@@ -78,7 +78,5 @@ void register_node_type_sh_value(ListBase *lb)
        node_type_exec(&ntype, node_shader_exec_value);
        node_type_gpu(&ntype, gpu_shader_value);
 
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
-
-
index bb56037b4d45356f203f870874bac1d8eda7f2b7..75dbff11b6eba5b04996970e46e7fd8253f243ba 100644 (file)
@@ -130,11 +130,11 @@ static int gpu_shader_vect_math(GPUMaterial *mat, bNode *node, GPUNodeStack *in,
        return 1;
 }
 
-void register_node_type_sh_vect_math(ListBase *lb)
+void register_node_type_sh_vect_math(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
 
-       node_type_base(&ntype, SH_NODE_VECT_MATH, "Vector Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, SH_NODE_VECT_MATH, "Vector Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
        node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING);
        node_type_socket_templates(&ntype, sh_node_vect_math_in, sh_node_vect_math_out);
        node_type_size(&ntype, 80, 75, 140);
@@ -143,7 +143,5 @@ void register_node_type_sh_vect_math(ListBase *lb)
        node_type_exec(&ntype, node_shader_exec_vect_math);
        node_type_gpu(&ntype, gpu_shader_vect_math);
 
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
-
-
index 1ce975eae8f182eddd9af0c1e51211b6e9386ebb..6eb3178709f48eff9205d3d0107fa561bc002e7a 100644 (file)
@@ -46,11 +46,11 @@ static int node_shader_gpu_volume_isotropic(GPUMaterial *UNUSED(mat), bNode *UNU
 }
 
 /* node type definition */
-void register_node_type_sh_volume_isotropic(ListBase *lb)
+void register_node_type_sh_volume_isotropic(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
 
-       node_type_base(&ntype, SH_NODE_VOLUME_ISOTROPIC, "Isotropic Volume", NODE_CLASS_SHADER, 0);
+       node_type_base(ttype, &ntype, SH_NODE_VOLUME_ISOTROPIC, "Isotropic Volume", NODE_CLASS_SHADER, 0);
        node_type_compatibility(&ntype, NODE_NEW_SHADING);
        node_type_socket_templates(&ntype, sh_node_volume_isotropic_in, sh_node_volume_isotropic_out);
        node_type_size(&ntype, 150, 60, 200);
@@ -59,6 +59,5 @@ void register_node_type_sh_volume_isotropic(ListBase *lb)
        node_type_exec(&ntype, NULL);
        node_type_gpu(&ntype, node_shader_gpu_volume_isotropic);
 
-       nodeRegisterType(lb, &ntype);
-};
-
+       nodeRegisterType(ttype, &ntype);
+}
index 5c557aee45da5aa8301735a92765ecb41efdc410..3d2d4fc689e3a1ca05831a6c68f5b8b25f9a8823 100644 (file)
@@ -46,11 +46,11 @@ static int node_shader_gpu_volume_transparent(GPUMaterial *UNUSED(mat), bNode *U
 }
 
 /* node type definition */
-void register_node_type_sh_volume_transparent(ListBase *lb)
+void register_node_type_sh_volume_transparent(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
 
-       node_type_base(&ntype, SH_NODE_VOLUME_TRANSPARENT, "Transparent Volume", NODE_CLASS_SHADER, 0);
+       node_type_base(ttype, &ntype, SH_NODE_VOLUME_TRANSPARENT, "Transparent Volume", NODE_CLASS_SHADER, 0);
        node_type_compatibility(&ntype, NODE_NEW_SHADING);
        node_type_socket_templates(&ntype, sh_node_volume_transparent_in, sh_node_volume_transparent_out);
        node_type_size(&ntype, 150, 60, 200);
@@ -59,6 +59,5 @@ void register_node_type_sh_volume_transparent(ListBase *lb)
        node_type_exec(&ntype, NULL);
        node_type_gpu(&ntype, node_shader_gpu_volume_transparent);
 
-       nodeRegisterType(lb, &ntype);
-};
-
+       nodeRegisterType(ttype, &ntype);
+}
index 657878916029c680975999000fb5f1b843f37548..33548be3208b8cba054727bc515084d7c98f5d45 100644 (file)
@@ -58,14 +58,14 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
        tex_output(node, in, out[0], &colorfn, data);
 }
 
-void register_node_type_tex_at(ListBase *lb)
+void register_node_type_tex_at(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_AT, "At", NODE_CLASS_DISTORT, 0);
+       node_type_base(ttype, &ntype, TEX_NODE_AT, "At", NODE_CLASS_DISTORT, 0);
        node_type_socket_templates(&ntype, inputs, outputs);
        node_type_size(&ntype, 140, 100, 320);
        node_type_exec(&ntype, exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
index 0700085a787161144797182ca71a5881707c8a86..b4b25a10537b81215c6be66ed276e0a966c09a47 100644 (file)
@@ -119,15 +119,15 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
        tex_output(node, in, out[0], &colorfn, data);
 }
 
-void register_node_type_tex_bricks(ListBase *lb)
+void register_node_type_tex_bricks(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_BRICKS, "Bricks", NODE_CLASS_PATTERN, NODE_PREVIEW|NODE_OPTIONS);
+       node_type_base(ttype, &ntype, TEX_NODE_BRICKS, "Bricks", NODE_CLASS_PATTERN, NODE_PREVIEW|NODE_OPTIONS);
        node_type_socket_templates(&ntype, inputs, outputs);
        node_type_size(&ntype, 150, 60, 150);
        node_type_init(&ntype, init);
        node_type_exec(&ntype, exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
index aebd3f2a05c1f3a928bc0a740480e2fd95d0bf3c..6b5848270ba344fee4d1cae0848aa6f3bbef40f7 100644 (file)
@@ -69,14 +69,14 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
        tex_output(node, in, out[0], &colorfn, data);
 }
 
-void register_node_type_tex_checker(ListBase *lb)
+void register_node_type_tex_checker(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_CHECKER, "Checker", NODE_CLASS_PATTERN, NODE_PREVIEW|NODE_OPTIONS);
+       node_type_base(ttype, &ntype, TEX_NODE_CHECKER, "Checker", NODE_CLASS_PATTERN, NODE_PREVIEW|NODE_OPTIONS);
        node_type_socket_templates(&ntype, inputs, outputs);
        node_type_size(&ntype, 100, 60, 150);
        node_type_exec(&ntype, exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
index 0b8ee031d4fcf58de7220a3174e3b11730bf7854..9a66ecb5ffb5b507f515a2a1c22e46dd7311dcef 100644 (file)
@@ -125,11 +125,11 @@ static void group_execute(void *data, int thread, struct bNode *node, void *node
        ntreeReleaseThreadStack(nts);
 }
 
-void register_node_type_tex_group(ListBase *lb)
+void register_node_type_tex_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);
@@ -140,7 +140,7 @@ void register_node_type_tex_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);
 }
 
 
@@ -186,11 +186,11 @@ static void forloop_execute(void *data, int thread, struct bNode *node, void *no
        ntreeReleaseThreadStack(nts);
 }
 
-void register_node_type_tex_forloop(ListBase *lb)
+void register_node_type_tex_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);
@@ -202,7 +202,7 @@ void register_node_type_tex_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
 
@@ -248,11 +248,11 @@ static void whileloop_execute(void *data, int thread, struct bNode *node, void *
        ntreeReleaseThreadStack(nts);
 }
 
-void register_node_type_tex_whileloop(ListBase *lb)
+void register_node_type_tex_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);
@@ -264,6 +264,6 @@ void register_node_type_tex_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
index d2a6cd0cb428a647825c4ce2ac60b531855fe50c..5256db98d7897d5a7294afde7bb2e4e6ede09d5e 100644 (file)
@@ -57,14 +57,14 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
        tex_output(node, in, out[0], &colorfn, data);
 }
 
-void register_node_type_tex_compose(ListBase *lb)
+void register_node_type_tex_compose(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_COMPOSE, "Compose RGBA", NODE_CLASS_OP_COLOR, 0);
+       node_type_base(ttype, &ntype, TEX_NODE_COMPOSE, "Compose RGBA", NODE_CLASS_OP_COLOR, 0);
        node_type_socket_templates(&ntype, inputs, outputs);
        node_type_size(&ntype, 100, 60, 150);
        node_type_exec(&ntype, exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
index a86324e9f7dee1191f473f7ad2634648b298b131..6d6f31d6aaa134bc68eedd9c3ecfe0e2ed7a5593 100644 (file)
@@ -50,15 +50,15 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
        tex_output(node, in, out[0], &vectorfn, data);
 }
 
-void register_node_type_tex_coord(ListBase *lb)
+void register_node_type_tex_coord(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_COORD, "Coordinates", NODE_CLASS_INPUT, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, TEX_NODE_COORD, "Coordinates", NODE_CLASS_INPUT, NODE_OPTIONS);
        node_type_socket_templates(&ntype, NULL, outputs);
        node_type_size(&ntype, 120, 110, 160);
        node_type_storage(&ntype, "node_coord", NULL, NULL);
        node_type_exec(&ntype, exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
index b14036ace5b6fdf3454029c5785b5518c1ba6eba..08e7efc1606a527d32e1379802cae564a56460b1 100644 (file)
@@ -66,18 +66,18 @@ static void time_init(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUS
        node->storage= curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
 }
 
-void register_node_type_tex_curve_time(ListBase *lb)
+void register_node_type_tex_curve_time(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_CURVE_TIME, "Time", NODE_CLASS_INPUT, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, TEX_NODE_CURVE_TIME, "Time", NODE_CLASS_INPUT, NODE_OPTIONS);
        node_type_socket_templates(&ntype, NULL, time_outputs);
        node_type_size(&ntype, 140, 100, 320);
        node_type_init(&ntype, time_init);
        node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves);
        node_type_exec(&ntype, time_exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
 
 /* **************** CURVE RGB  ******************** */
@@ -110,17 +110,16 @@ static void rgb_init(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSE
        node->storage= curvemapping_add(4, 0.0f, 0.0f, 1.0f, 1.0f);
 }
 
-void register_node_type_tex_curve_rgb(ListBase *lb)
+void register_node_type_tex_curve_rgb(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, TEX_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
        node_type_socket_templates(&ntype, rgb_inputs, rgb_outputs);
        node_type_size(&ntype, 200, 140, 320);
        node_type_init(&ntype, rgb_init);
        node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves);
        node_type_exec(&ntype, rgb_exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
-
index e83e6a718ef8b71f80726f83f052b1ca84532bd4..435b87164c4dec59060ce392b8339f94265aa732 100644 (file)
@@ -78,14 +78,14 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
        tex_output(node, in, out[3], &valuefn_a, data);
 }
 
-void register_node_type_tex_decompose(ListBase *lb)
+void register_node_type_tex_decompose(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_DECOMPOSE, "Decompose RGBA", NODE_CLASS_OP_COLOR, 0);
+       node_type_base(ttype, &ntype, TEX_NODE_DECOMPOSE, "Decompose RGBA", NODE_CLASS_OP_COLOR, 0);
        node_type_socket_templates(&ntype, inputs, outputs);
        node_type_size(&ntype, 100, 60, 150);
        node_type_exec(&ntype, exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
index c0a9950e76194b2b3aa8d343d9cabe8d066b81e6..a2c1f41c0de68a258c26e7f40da54131f5777d1b 100644 (file)
@@ -61,15 +61,15 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
        tex_output(node, in, out[0], &valuefn, data);
 }
 
-void register_node_type_tex_distance(ListBase *lb)
+void register_node_type_tex_distance(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_DISTANCE, "Distance", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, TEX_NODE_DISTANCE, "Distance", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
        node_type_socket_templates(&ntype, inputs, outputs);
        node_type_size(&ntype, 120, 110, 160);
        node_type_storage(&ntype, "node_distance", NULL, NULL);
        node_type_exec(&ntype, exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
index 3346592f7d3141c2be8bceafb09819c052125010..e566fb0298a481721caa3ecac34d577911a9cbc2 100644 (file)
@@ -92,14 +92,14 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
        tex_output(node, in, out[0], &colorfn, data);
 }
 
-void register_node_type_tex_hue_sat(ListBase *lb)
+void register_node_type_tex_hue_sat(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, TEX_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
        node_type_socket_templates(&ntype, inputs, outputs);
        node_type_size(&ntype, 150, 80, 250);
        node_type_exec(&ntype, exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
index 0ead3a3dec24fa5321308eaf3c017e8496ad891d..0acfe62ed82131d9d692e89f71d2013aff71db36 100644 (file)
@@ -95,16 +95,16 @@ static void init(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(nt
        iuser->ok= 1;
 }
 
-void register_node_type_tex_image(ListBase *lb)
+void register_node_type_tex_image(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_IMAGE, "Image", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS);
+       node_type_base(ttype, &ntype, TEX_NODE_IMAGE, "Image", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS);
        node_type_socket_templates(&ntype, NULL, outputs);
        node_type_size(&ntype, 120, 80, 300);
        node_type_init(&ntype, init);
        node_type_storage(&ntype, "ImageUser", node_free_standard_storage, node_copy_standard_storage);
        node_type_exec(&ntype, exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
index 5ee60d02e32bb00471e569241918a179ee38c740..297675f498c6cf05dda9fb61682d74f13b8e23a8 100644 (file)
@@ -63,15 +63,14 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
        tex_output(node, in, out[0], &colorfn, data);
 }
 
-void register_node_type_tex_invert(ListBase *lb)
+void register_node_type_tex_invert(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, TEX_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
        node_type_socket_templates(&ntype, inputs, outputs);
        node_type_size(&ntype, 90, 80, 100);
        node_type_exec(&ntype, exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
-
index 74b9dcdd30a6ff8d2c7b5ec8450f80c7a1109e6f..4659aa2b6c06a55f3295d8a3e5fc41e37a88b993 100644 (file)
@@ -184,17 +184,16 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
        tex_output(node, in, out[0], &valuefn, data);
 }
 
-void register_node_type_tex_math(ListBase *lb)
+void register_node_type_tex_math(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, TEX_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
        node_type_socket_templates(&ntype, inputs, outputs);
        node_type_size(&ntype, 120, 110, 160);
        node_type_label(&ntype, node_math_label);
        node_type_storage(&ntype, "node_math", NULL, NULL);
        node_type_exec(&ntype, exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
-
index e3b5119c797c2a65137f55760738868fdf6b3e07..13816088ea70f975f016c0c5812a5cebb845b167 100644 (file)
@@ -64,15 +64,15 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
        tex_output(node, in, out[0], &colorfn, data);
 }
 
-void register_node_type_tex_mix_rgb(ListBase *lb)
+void register_node_type_tex_mix_rgb(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, TEX_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
        node_type_socket_templates(&ntype, inputs, outputs);
        node_type_size(&ntype, 100, 60, 150);
        node_type_label(&ntype, node_blend_label);
        node_type_exec(&ntype, exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
index 42ee2847d06a16d73da8aa4344d2bc9a1546b4e1..dc96f5abcb5c00b144e1b7a86cd81c098712d440 100644 (file)
@@ -157,16 +157,16 @@ static void copy(bNode *orig, bNode *new)
        assign_index(new);
 }
 
-void register_node_type_tex_output(ListBase *lb)
+void register_node_type_tex_output(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_OUTPUT, "Output", NODE_CLASS_OUTPUT, NODE_PREVIEW|NODE_OPTIONS);
+       node_type_base(ttype, &ntype, TEX_NODE_OUTPUT, "Output", NODE_CLASS_OUTPUT, NODE_PREVIEW|NODE_OPTIONS);
        node_type_socket_templates(&ntype, inputs, NULL);
        node_type_size(&ntype, 150, 60, 200);
        node_type_init(&ntype, init);
        node_type_storage(&ntype, "TexNodeOutput", node_free_standard_storage, copy);
        node_type_exec(&ntype, exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
index 3012d313db5b0f1e28dbeb319375c41f0d9b222b..fac8b02fb85391d875d02c83bbac0902b330b1e2 100644 (file)
@@ -296,18 +296,18 @@ static void init(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(nt
 
 /* Node type definitions */
 #define TexDef(TEXTYPE, outputs, name, Name) \
-void register_node_type_tex_proc_##name(ListBase *lb) \
+void register_node_type_tex_proc_##name(bNodeTreeType *ttype) \
 { \
        static bNodeType ntype; \
        \
-       node_type_base(&ntype, TEX_NODE_PROC+TEXTYPE, Name, NODE_CLASS_TEXTURE, NODE_PREVIEW|NODE_OPTIONS); \
+       node_type_base(ttype, &ntype, TEX_NODE_PROC+TEXTYPE, Name, NODE_CLASS_TEXTURE, NODE_PREVIEW|NODE_OPTIONS); \
        node_type_socket_templates(&ntype, name##_inputs, outputs); \
        node_type_size(&ntype, 140, 80, 140); \
        node_type_init(&ntype, init); \
        node_type_storage(&ntype, "Tex", node_free_standard_storage, node_copy_standard_storage); \
        node_type_exec(&ntype, name##_exec); \
        \
-       nodeRegisterType(lb, &ntype); \
+       nodeRegisterType(ttype, &ntype); \
 }
        
 #define C outputs_color_only
index a3f692862698382d4e1288324fc1ce2f8d8eb46e..d1c9cca3f3cea93d84a75b95912c90648d605545 100644 (file)
@@ -95,14 +95,14 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
        tex_output(node, in, out[0], &colorfn, data);
 }
 
-void register_node_type_tex_rotate(ListBase *lb)
+void register_node_type_tex_rotate(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_ROTATE, "Rotate", NODE_CLASS_DISTORT, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, TEX_NODE_ROTATE, "Rotate", NODE_CLASS_DISTORT, NODE_OPTIONS);
        node_type_socket_templates(&ntype, inputs, outputs);
        node_type_size(&ntype, 140, 100, 320);
        node_type_exec(&ntype, exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
index f42b3addc91f08ecea024f75f730cdc406745464..f8790d414c934446aeafe283570c2a8bcf374c6e 100644 (file)
@@ -68,14 +68,14 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
        tex_output(node, in, out[0], &colorfn, data);
 }
 
-void register_node_type_tex_scale(ListBase *lb)
+void register_node_type_tex_scale(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_SCALE, "Scale", NODE_CLASS_DISTORT, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, TEX_NODE_SCALE, "Scale", NODE_CLASS_DISTORT, NODE_OPTIONS);
        node_type_socket_templates(&ntype, inputs, outputs);
        node_type_size(&ntype, 90, 80, 100);
        node_type_exec(&ntype, exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
index 667570582feb206e4b3c13b0c19d33db68d0d540..3a0f11d5417b5312817e586fcf80d462c04b7fa6 100644 (file)
@@ -95,14 +95,14 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
        tex_output(node, in, out[0], &colorfn, data);
 }
 
-void register_node_type_tex_texture(ListBase *lb)
+void register_node_type_tex_texture(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS);
+       node_type_base(ttype, &ntype, TEX_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS);
        node_type_socket_templates(&ntype, inputs, outputs);
        node_type_size(&ntype, 120, 80, 240);
        node_type_exec(&ntype, exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
index 8d09b4363f8e839ef03c35d74107c2d51a55a5db..61b0702b333beb9f9415ca28cc065a464c1d7a19 100644 (file)
@@ -64,14 +64,14 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
        tex_output(node, in, out[0], &colorfn, data);
 }
 
-void register_node_type_tex_translate(ListBase *lb)
+void register_node_type_tex_translate(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_TRANSLATE, "Translate", NODE_CLASS_DISTORT, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, TEX_NODE_TRANSLATE, "Translate", NODE_CLASS_DISTORT, NODE_OPTIONS);
        node_type_socket_templates(&ntype, inputs, outputs);
        node_type_size(&ntype, 90, 80, 100);
        node_type_exec(&ntype, exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
index 28b0a19c5a99320fc2049e4891a0a9f5240a1bcd..c81590604338c8684e2aa8ba18b6b6d1c3781256 100644 (file)
@@ -80,14 +80,14 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
        tex_output(node, in, out[0], &normalfn, data);
 }
 
-void register_node_type_tex_valtonor(ListBase *lb)
+void register_node_type_tex_valtonor(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_VALTONOR, "Value to Normal", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, TEX_NODE_VALTONOR, "Value to Normal", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
        node_type_socket_templates(&ntype, inputs, outputs);
        node_type_size(&ntype, 90, 80, 100);
        node_type_exec(&ntype, exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
index 0a6cdbd202405a32722487051c1806827e6c59ef..c0efa43c14f37630d34a2d5547409a14f79e39c9 100644 (file)
@@ -62,18 +62,18 @@ static void valtorgb_init(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *
        node->storage = add_colorband(1);
 }
 
-void register_node_type_tex_valtorgb(ListBase *lb)
+void register_node_type_tex_valtorgb(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
+       node_type_base(ttype, &ntype, TEX_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
        node_type_socket_templates(&ntype, valtorgb_in, valtorgb_out);
        node_type_size(&ntype, 240, 200, 300);
        node_type_init(&ntype, valtorgb_init);
        node_type_storage(&ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage);
        node_type_exec(&ntype, valtorgb_exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
 
 /* **************** RGBTOBW ******************** */
@@ -100,15 +100,14 @@ static void rgbtobw_exec(void *data, bNode *node, bNodeStack **in, bNodeStack **
        tex_output(node, in, out[0], &rgbtobw_valuefn, data);
 }
 
-void register_node_type_tex_rgbtobw(ListBase *lb)
+void register_node_type_tex_rgbtobw(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTOR, 0);
+       node_type_base(ttype, &ntype, TEX_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTOR, 0);
        node_type_socket_templates(&ntype, rgbtobw_in, rgbtobw_out);
        node_type_size(&ntype, 80, 40, 120);
        node_type_exec(&ntype, rgbtobw_exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }
-
index a9670bfa78bf7fb521e9f94b18b23135d915f81c..4b4a9fdb4ebcbf1d5d38374d3a741b70f32623b7 100644 (file)
@@ -56,14 +56,14 @@ static void exec(void *data, bNode *node, bNodeStack **in, bNodeStack **UNUSED(o
        }
 }
 
-void register_node_type_tex_viewer(ListBase *lb)
+void register_node_type_tex_viewer(bNodeTreeType *ttype)
 {
        static bNodeType ntype;
        
-       node_type_base(&ntype, TEX_NODE_VIEWER, "Viewer", NODE_CLASS_OUTPUT, NODE_PREVIEW);
+       node_type_base(ttype, &ntype, TEX_NODE_VIEWER, "Viewer", NODE_CLASS_OUTPUT, NODE_PREVIEW);
        node_type_socket_templates(&ntype, inputs, outputs);
        node_type_size(&ntype, 100, 60, 150);
        node_type_exec(&ntype, exec);
        
-       nodeRegisterType(lb, &ntype);
+       nodeRegisterType(ttype, &ntype);
 }