void register_node_type_cmp_colorbalance(void)
{
	static bNodeType ntype;

	cmp_node_type_base(&ntype, CMP_NODE_COLORBALANCE, "Color Balance", NODE_CLASS_OP_COLOR, 0);
	node_type_socket_templates(&ntype, cmp_node_colorbalance_in, cmp_node_colorbalance_out);
	node_type_size(&ntype, 400, 200, 400);
	node_type_init(&ntype, node_composit_init_colorbalance);
	node_type_storage(&ntype, "NodeColorBalance", node_free_standard_storage, node_copy_standard_storage);

	nodeRegisterType(&ntype);
}
void register_node_type_cmp_huecorrect(void)
{
	static bNodeType ntype;

	cmp_node_type_base(&ntype, CMP_NODE_HUECORRECT, "Hue Correct", NODE_CLASS_OP_COLOR, 0);
	node_type_socket_templates(&ntype, cmp_node_huecorrect_in, cmp_node_huecorrect_out);
	node_type_size(&ntype, 320, 140, 500);
	node_type_init(&ntype, node_composit_init_huecorrect);
	node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves);

	nodeRegisterType(&ntype);
}
void register_node_type_sh_texture(void)
{
	static bNodeType ntype;

	sh_node_type_base(&ntype, SH_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_PREVIEW);
	node_type_compatibility(&ntype, NODE_OLD_SHADING);
	node_type_socket_templates(&ntype, sh_node_texture_in, sh_node_texture_out);
	node_type_exec(&ntype, NULL, NULL, node_shader_exec_texture);
	node_type_gpu(&ntype, gpu_shader_texture);

	nodeRegisterType(&ntype);
}
void register_node_type_cmp_valtorgb(bNodeTreeType *ttype)
{
	static bNodeType ntype;

	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);

	nodeRegisterType(ttype, &ntype);
}
Exemplo n.º 5
0
void register_node_type_cmp_filter(ListBase *lb)
{
	static bNodeType ntype;

	node_type_base(&ntype, CMP_NODE_FILTER, "Filter", NODE_CLASS_OP_FILTER, NODE_PREVIEW|NODE_OPTIONS);
	node_type_socket_templates(&ntype, cmp_node_filter_in, cmp_node_filter_out);
	node_type_size(&ntype, 80, 40, 120);
	node_type_label(&ntype, node_filter_label);
	node_type_exec(&ntype, node_composit_exec_filter);

	nodeRegisterType(lb, &ntype);
}
Exemplo n.º 6
0
/* node type definition */
void register_node_type_sh_hair_info(void)
{
  static bNodeType ntype;

  sh_node_type_base(&ntype, SH_NODE_HAIR_INFO, "Hair Info", NODE_CLASS_INPUT, 0);
  node_type_socket_templates(&ntype, NULL, outputs);
  node_type_init(&ntype, NULL);
  node_type_storage(&ntype, "", NULL, NULL);
  node_type_gpu(&ntype, node_shader_gpu_hair_info);

  nodeRegisterType(&ntype);
}
Exemplo n.º 7
0
void register_node_type_cmp_blur(bNodeTreeType *ttype)
{
	static bNodeType ntype;

	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);

	nodeRegisterType(ttype, &ntype);
}
void register_node_type_cmp_colorcorrection(void)
{
	static bNodeType ntype;

	cmp_node_type_base(&ntype, CMP_NODE_COLORCORRECTION, "Color Correction", NODE_CLASS_OP_COLOR, 0);
	node_type_socket_templates(&ntype, cmp_node_colorcorrection_in, cmp_node_colorcorrection_out);
	node_type_size(&ntype, 400, 200, 600);
	node_type_init(&ntype, node_composit_init_colorcorrection);
	node_type_storage(&ntype, "NodeColorCorrection", node_free_standard_storage, node_copy_standard_storage);

	nodeRegisterType(&ntype);
}
Exemplo n.º 9
0
void register_node_type_tex_distance(void)
{
	static bNodeType ntype;
	
	tex_node_type_base(&ntype, TEX_NODE_DISTANCE, "Distance", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
	node_type_socket_templates(&ntype, inputs, outputs);
	node_type_size(&ntype, 120, 110, 160);
	node_type_storage(&ntype, "node_distance", NULL, NULL);
	node_type_exec(&ntype, NULL, NULL, exec);
	
	nodeRegisterType(&ntype);
}
Exemplo n.º 10
0
void register_node_type_cmp_ellipsemask(void)
{
	static bNodeType ntype;

	cmp_node_type_base(&ntype, CMP_NODE_MASK_ELLIPSE, "Ellipse Mask", NODE_CLASS_MATTE, 0);
	node_type_socket_templates(&ntype, cmp_node_ellipsemask_in, cmp_node_ellipsemask_out);
	node_type_size(&ntype, 260, 110, 320);
	node_type_init(&ntype, node_composit_init_ellipsemask);
	node_type_storage(&ntype, "NodeEllipseMask", node_free_standard_storage, node_copy_standard_storage);

	nodeRegisterType(&ntype);
}
Exemplo n.º 11
0
void register_node_type_cmp_diff_matte(void)
{
  static bNodeType ntype;

  cmp_node_type_base(
      &ntype, CMP_NODE_DIFF_MATTE, "Difference Key", NODE_CLASS_MATTE, NODE_PREVIEW);
  node_type_socket_templates(&ntype, cmp_node_diff_matte_in, cmp_node_diff_matte_out);
  node_type_init(&ntype, node_composit_init_diff_matte);
  node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage);

  nodeRegisterType(&ntype);
}
Exemplo n.º 12
0
void register_node_type_sh_value(void)
{
	static bNodeType ntype;

	sh_node_type_base(&ntype, SH_NODE_VALUE, "Value", NODE_CLASS_INPUT, NODE_OPTIONS);
	node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING);
	node_type_socket_templates(&ntype, NULL, sh_node_value_out);
	node_type_size(&ntype, 80, 50, 120);
	node_type_gpu(&ntype, gpu_shader_value);

	nodeRegisterType(&ntype);
}
Exemplo n.º 13
0
void register_node_type_sh_combrgb(ListBase *lb)
{
	static bNodeType ntype;

	node_type_base(&ntype, SH_NODE_COMBRGB, "Combine RGB", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
	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);
}
Exemplo n.º 14
0
void register_node_type_sh_seprgb(ListBase *lb)
{
	static bNodeType ntype;

	node_type_base(&ntype, SH_NODE_SEPRGB, "Separate RGB", NODE_CLASS_CONVERTOR, 0);
	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);
}
Exemplo n.º 15
0
/* node type definition */
void register_node_type_sh_bump(void)
{
	static bNodeType ntype;

	sh_node_type_base(&ntype, SH_NODE_BUMP, "Bump", NODE_CLASS_OP_VECTOR, 0);
	node_type_compatibility(&ntype, NODE_NEW_SHADING);
	node_type_socket_templates(&ntype, sh_node_bump_in, sh_node_bump_out);
	node_type_storage(&ntype, "BumpNode", node_free_standard_storage, node_copy_standard_storage);
	node_type_gpu(&ntype, gpu_shader_bump);

	nodeRegisterType(&ntype);
}
Exemplo n.º 16
0
void register_node_type_sh_normal(void)
{
	static bNodeType ntype;
	
	sh_node_type_base(&ntype, SH_NODE_NORMAL, "Normal", NODE_CLASS_OP_VECTOR, 0);
	node_type_compatibility(&ntype, NODE_OLD_SHADING | NODE_NEW_SHADING);
	node_type_socket_templates(&ntype, sh_node_normal_in, sh_node_normal_out);
	node_type_exec(&ntype, NULL, NULL, node_shader_exec_normal);
	node_type_gpu(&ntype, gpu_shader_normal);
	
	nodeRegisterType(&ntype);
}
Exemplo n.º 17
0
void register_node_type_cmp_rgb(ListBase *lb)
{
	static bNodeType ntype;

	node_type_base(&ntype, CMP_NODE_RGB, "RGB", NODE_CLASS_INPUT, NODE_OPTIONS);
	node_type_socket_templates(&ntype, NULL, cmp_node_rgb_out);
	node_type_init(&ntype, node_composit_init_rgb);
	node_type_size(&ntype, 140, 80, 140);
	node_type_exec(&ntype, node_composit_exec_rgb);

	nodeRegisterType(lb, &ntype);
}
Exemplo n.º 18
0
void register_node_type_cmp_mask(void)
{
	static bNodeType ntype;

	cmp_node_type_base(&ntype, CMP_NODE_MASK, "Mask", NODE_CLASS_INPUT, 0);
	node_type_socket_templates(&ntype, NULL, cmp_node_mask_out);
	node_type_init(&ntype, node_composit_init_mask);

	node_type_storage(&ntype, "NodeMask", node_free_standard_storage, node_copy_standard_storage);

	nodeRegisterType(&ntype);
}
Exemplo n.º 19
0
/* custom1 = mix type */
void register_node_type_cmp_invert(ListBase *lb)
{
	static bNodeType ntype;

	node_type_base(&ntype, CMP_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
	node_type_socket_templates(&ntype, cmp_node_invert_in, cmp_node_invert_out);
	node_type_size(&ntype, 120, 120, 140);
	node_type_init(&ntype, node_composit_init_invert);
	node_type_exec(&ntype, node_composit_exec_invert);

	nodeRegisterType(lb, &ntype);
}
Exemplo n.º 20
0
void register_node_type_cmp_math(ListBase *lb)
{
	static bNodeType ntype;

	node_type_base(&ntype, CMP_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
	node_type_socket_templates(&ntype, cmp_node_math_in, cmp_node_math_out);
	node_type_size(&ntype, 120, 110, 160);
	node_type_label(&ntype, node_math_label);
	node_type_exec(&ntype, node_composit_exec_math);

	nodeRegisterType(lb, &ntype);
}
Exemplo n.º 21
0
void register_node_type_cmp_rotate(ListBase *lb)
{
	static bNodeType ntype;

	node_type_base(&ntype, CMP_NODE_ROTATE, "Rotate", NODE_CLASS_DISTORT, NODE_OPTIONS);
	node_type_socket_templates(&ntype, cmp_node_rotate_in, cmp_node_rotate_out);
	node_type_size(&ntype, 140, 100, 320);
	node_type_init(&ntype, node_composit_init_rotate);
	node_type_exec(&ntype, node_composit_exec_rotate);

	nodeRegisterType(lb, &ntype);
}
Exemplo n.º 22
0
void register_node_type_cmp_output_file(void)
{
	static bNodeType ntype;

	cmp_node_type_base(&ntype, CMP_NODE_OUTPUT_FILE, "File Output", NODE_CLASS_OUTPUT, NODE_PREVIEW);
	node_type_socket_templates(&ntype, NULL, NULL);
	ntype.initfunc_api = init_output_file;
	node_type_storage(&ntype, "NodeImageMultiFile", free_output_file, copy_output_file);
	node_type_update(&ntype, update_output_file, NULL);

	nodeRegisterType(&ntype);
}
Exemplo n.º 23
0
/* node type definition */
void register_node_type_sh_volume_scatter(void)
{
  static bNodeType ntype;

  sh_node_type_base(&ntype, SH_NODE_VOLUME_SCATTER, "Volume Scatter", NODE_CLASS_SHADER, 0);
  node_type_socket_templates(&ntype, sh_node_volume_scatter_in, sh_node_volume_scatter_out);
  node_type_init(&ntype, NULL);
  node_type_storage(&ntype, "", NULL, NULL);
  node_type_gpu(&ntype, node_shader_gpu_volume_scatter);

  nodeRegisterType(&ntype);
}
Exemplo n.º 24
0
void register_node_type_sh_rgbtobw(void)
{
	static bNodeType ntype;

	sh_node_type_base(&ntype, SH_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTOR, 0);
	node_type_compatibility(&ntype, NODE_OLD_SHADING | NODE_NEW_SHADING);
	node_type_socket_templates(&ntype, sh_node_rgbtobw_in, sh_node_rgbtobw_out);
	node_type_exec(&ntype, NULL, NULL, node_shader_exec_rgbtobw);
	node_type_gpu(&ntype, gpu_shader_rgbtobw);

	nodeRegisterType(&ntype);
}
/* node type definition */
void register_node_type_sh_ambient_occlusion(void)
{
  static bNodeType ntype;

  sh_node_type_base(&ntype, SH_NODE_AMBIENT_OCCLUSION, "Ambient Occlusion", NODE_CLASS_INPUT, 0);
  node_type_socket_templates(&ntype, sh_node_ambient_occlusion_in, sh_node_ambient_occlusion_out);
  node_type_init(&ntype, node_shader_init_ambient_occlusion);
  node_type_storage(&ntype, "", NULL, NULL);
  node_type_gpu(&ntype, node_shader_gpu_ambient_occlusion);

  nodeRegisterType(&ntype);
}
Exemplo n.º 26
0
void register_node_type_cmp_normal(ListBase *lb)
{
	static bNodeType ntype;

	node_type_base(&ntype, CMP_NODE_NORMAL, "Normal", NODE_CLASS_OP_VECTOR, NODE_OPTIONS);
	node_type_socket_templates(&ntype, cmp_node_normal_in, cmp_node_normal_out);
	node_type_init(&ntype, init);
	node_type_size(&ntype, 100, 60, 200);
	node_type_exec(&ntype, node_composit_exec_normal);

	nodeRegisterType(lb, &ntype);
}
/* node type definition */
void register_node_type_sh_particle_info(void)
{
	static bNodeType ntype;

	sh_node_type_base(&ntype, SH_NODE_PARTICLE_INFO, "Particle Info", NODE_CLASS_INPUT, 0);
	node_type_compatibility(&ntype, NODE_NEW_SHADING | NODE_OLD_SHADING);
	node_type_socket_templates(&ntype, NULL, outputs);
	node_type_exec(&ntype, NULL, NULL, node_shader_exec_particle_info);
	node_type_gpu(&ntype, gpu_shader_particle_info);

	nodeRegisterType(&ntype);
}
Exemplo n.º 28
0
void register_node_type_tex_curve_time(void)
{
	static bNodeType ntype;
	
	tex_node_type_base(&ntype, TEX_NODE_CURVE_TIME, "Time", NODE_CLASS_INPUT, 0);
	node_type_socket_templates(&ntype, NULL, time_outputs);
	node_type_size_preset(&ntype, NODE_SIZE_LARGE);
	node_type_init(&ntype, time_init);
	node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves);
	node_type_exec(&ntype, node_initexec_curves, NULL, time_exec);
	
	nodeRegisterType(&ntype);
}
Exemplo n.º 29
0
void register_node_type_reroute(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(ttype, ntype, NODE_REROUTE, "Reroute", NODE_CLASS_LAYOUT, 0);
	node_type_socket_templates(ntype, node_reroute_in, node_reroute_out);
	node_type_internal_connect(ntype, node_reroute_internal_connect);
	node_type_update(ntype, node_reroute_update, NULL);
	
	ntype->needs_free = 1;
	nodeRegisterType(ttype, ntype);
}
Exemplo n.º 30
0
void register_node_type_tex_curve_rgb(void)
{
	static bNodeType ntype;
	
	tex_node_type_base(&ntype, TEX_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, 0);
	node_type_socket_templates(&ntype, rgb_inputs, rgb_outputs);
	node_type_size_preset(&ntype, NODE_SIZE_LARGE);
	node_type_init(&ntype, rgb_init);
	node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves);
	node_type_exec(&ntype, node_initexec_curves, NULL, rgb_exec);
	
	nodeRegisterType(&ntype);
}