Ejemplos de node_type_size en C++ (Cpp)

Ejemplo n.º 1

void register_node_type_tex_distance(ListBase *lb)
{
	static bNodeType ntype;
	
	node_type_base(&ntype, TEX_NODE_DISTANCE, "Distance", NODE_CLASS_CONVERTOR, NODE_OPTIONS,
				   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);
}

Ejemplo n.º 2

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

Ejemplo n.º 3

/* 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);
}

Ejemplo n.º 4

Archivo: node_composite_blur.c Proyecto: danielmarg/blender-main

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

Ejemplo n.º 5

/* custom1 = mix type */
void register_node_type_cmp_mix_rgb(ListBase *lb)
{
	static bNodeType ntype;

	node_type_base(&ntype, CMP_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, NODE_PREVIEW|NODE_OPTIONS);
	node_type_socket_templates(&ntype, cmp_node_mix_rgb_in, cmp_node_mix_rgb_out);
	node_type_size(&ntype, 110, 60, 120);
	node_type_label(&ntype, node_blend_label);
	node_type_exec(&ntype, node_composit_exec_mix_rgb);

	nodeRegisterType(lb, &ntype);
}

Ejemplo n.º 6

void register_node_type_cmp_normalize(ListBase *lb)
{
	static bNodeType ntype;
	
	node_type_base(&ntype, CMP_NODE_NORMALIZE, "Normalize", NODE_CLASS_OP_VECTOR, NODE_OPTIONS,
				   cmp_node_normalize_in, cmp_node_normalize_out);
	node_type_size(&ntype, 100, 60, 150);
	node_type_exec(&ntype, node_composit_exec_normalize);
	node_type_storage(&ntype, "TexMapping", NULL, NULL);
	
	nodeRegisterType(lb, &ntype);
}

Ejemplo n.º 7

Archivo: SHD_hueSatVal.c Proyecto: OldBrunet/BGERTPS

void register_node_type_sh_hue_sat(ListBase *lb)
{
	static bNodeType ntype;

	node_type_base(&ntype, SH_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, NODE_OPTIONS,
		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);
}

Ejemplo n.º 8

Archivo: node_composite_valToRgb.c Proyecto: Andrewson3D/blender-for-vray

void register_node_type_cmp_valtorgb(void)
{
	static bNodeType ntype;

	cmp_node_type_base(&ntype, CMP_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTOR, 0);
	node_type_socket_templates(&ntype, cmp_node_valtorgb_in, cmp_node_valtorgb_out);
	node_type_size(&ntype, 240, 200, 320);
	node_type_init(&ntype, node_composit_init_valtorgb);
	node_type_storage(&ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage);

	nodeRegisterType(&ntype);
}

Ejemplo n.º 9

void register_node_type_sh_value(ListBase *lb)
{
	static bNodeType ntype;

	node_type_base(&ntype, SH_NODE_VALUE, "Value", NODE_CLASS_INPUT, NODE_OPTIONS,
		NULL, sh_node_value_out);
	node_type_size(&ntype, 80, 50, 120);
	node_type_exec(&ntype, node_shader_exec_value);
	node_type_gpu(&ntype, gpu_shader_value);

	nodeRegisterType(lb, &ntype);
}

Ejemplo n.º 10

Archivo: node_composite_math.c Proyecto: BHCLL/blendocv

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

Ejemplo n.º 11

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

Ejemplo n.º 12

void register_node_type_sh_seprgb(ListBase *lb)
{
    static bNodeType ntype;

    node_type_base(&ntype, SH_NODE_SEPRGB, "Separate RGB", NODE_CLASS_CONVERTOR, 0,
                   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);
}

Ejemplo n.º 13

Archivo: node_composite_ellipsemask.c Proyecto: 244xiao/blender

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

Ejemplo n.º 14

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

Ejemplo n.º 15

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

Ejemplo n.º 16

void register_node_type_cmp_colorcorrection(void)
{
	static bNodeType ntype;

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

	nodeRegisterType(&ntype);
}

Ejemplo n.º 17

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

Ejemplo n.º 18

void register_node_type_sh_texture(ListBase *lb)
{
	static bNodeType ntype;

	node_type_base(&ntype, SH_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW);
	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);
}

Ejemplo n.º 19

Archivo: node_composite_huecorrect.c Proyecto: Andrewson3D/blender-for-vray

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

Ejemplo n.º 20

Archivo: node_composite_colorbalance.c Proyecto: SuriyaaKudoIsc/blender-git

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

Ejemplo n.º 21

Archivo: node_texture_distance.c Proyecto: mik0001/Blender

void register_node_type_tex_distance(bNodeTreeType *ttype)
{
	static bNodeType ntype;
	
	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(ttype, &ntype);
}

Ejemplo n.º 22

void register_node_type_sh_rgbtobw(ListBase *lb)
{
	static bNodeType ntype;

	node_type_base(&ntype, SH_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTOR, 0,
		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);
}

Ejemplo n.º 23

Archivo: node_composite_rotate.c Proyecto: BHCLL/blendocv

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

Ejemplo n.º 24

Archivo: node_composite_value.c Proyecto: vanangamudi/blender-main

void register_node_type_cmp_value(bNodeTreeType *ttype)
{
	static bNodeType ntype;

	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(ttype, &ntype);
}

Ejemplo n.º 25

Archivo: node_shader_bsdf_hair.c Proyecto: dfelinto/blender

/* node type definition */
void register_node_type_sh_bsdf_hair(void)
{
  static bNodeType ntype;

  sh_node_type_base(&ntype, SH_NODE_BSDF_HAIR, "Hair BSDF", NODE_CLASS_SHADER, 0);
  node_type_socket_templates(&ntype, sh_node_bsdf_hair_in, sh_node_bsdf_hair_out);
  node_type_size(&ntype, 150, 60, 200);
  node_type_init(&ntype, NULL);
  node_type_storage(&ntype, "", NULL, NULL);
  node_type_gpu(&ntype, node_shader_gpu_bsdf_hair);

  nodeRegisterType(&ntype);
}

Ejemplo n.º 26

Archivo: node_texture_valToRgb.c Proyecto: BHCLL/blendocv

void register_node_type_tex_valtorgb(ListBase *lb)
{
	static bNodeType ntype;
	
	node_type_base(&ntype, TEX_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
	node_type_socket_templates(&ntype, valtorgb_in, valtorgb_out);
	node_type_size(&ntype, 240, 200, 300);
	node_type_init(&ntype, valtorgb_init);
	node_type_storage(&ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage);
	node_type_exec(&ntype, valtorgb_exec);
	
	nodeRegisterType(lb, &ntype);
}

Ejemplo n.º 27

void register_node_type_cmp_moviedistortion(bNodeTreeType *ttype)
{
	static bNodeType ntype;

	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(ttype, &ntype);
}

Ejemplo n.º 28

Archivo: node_composite_colorSpill.c Proyecto: mik0001/Blender

void register_node_type_cmp_color_spill(bNodeTreeType *ttype)
{
	static bNodeType ntype;
	
	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(ttype, &ntype);
}

Ejemplo n.º 29

Archivo: CMP_splitViewer.c Proyecto: OldBrunet/BGERTPS

void register_node_type_cmp_splitviewer(ListBase *lb)
{
	static bNodeType ntype;

	node_type_base(&ntype, CMP_NODE_SPLITVIEWER, "SplitViewer", NODE_CLASS_OUTPUT, NODE_PREVIEW|NODE_OPTIONS,
		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);
}

Ejemplo n.º 30

void register_node_type_cmp_distance_matte(ListBase *lb)
{
	static bNodeType ntype;

	node_type_base(&ntype, CMP_NODE_DIST_MATTE, "Distance Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS);
	node_type_socket_templates(&ntype, cmp_node_distance_matte_in, cmp_node_distance_matte_out);
	node_type_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);
}