C++ (Cpp) node_type_compatibility示例

示例#1

void register_node_type_sh_invert(void)
{
	static bNodeType ntype;

	sh_node_type_base(&ntype, SH_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
	node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING);
	node_type_socket_templates(&ntype, sh_node_invert_in, sh_node_invert_out);
	node_type_size(&ntype, 90, 80, 100);
	node_type_exec(&ntype, NULL, NULL, node_shader_exec_invert);
	node_type_gpu(&ntype, gpu_shader_invert);

	nodeRegisterType(&ntype);
}

示例#2

文件： node_shader_emission.c 项目： 244xiao/blender

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

	sh_node_type_base(&ntype, SH_NODE_EMISSION, "Emission", NODE_CLASS_SHADER, 0);
	node_type_compatibility(&ntype, NODE_NEW_SHADING);
	node_type_socket_templates(&ntype, sh_node_emission_in, sh_node_emission_out);
	node_type_init(&ntype, NULL);
	node_type_storage(&ntype, "", NULL, NULL);
	node_type_gpu(&ntype, node_shader_gpu_emission);

	nodeRegisterType(&ntype);
}

示例#3

文件： node_shader_bsdf_velvet.c 项目： DarkDefender/blender-npr-tess2

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

	sh_node_type_base(&ntype, SH_NODE_BSDF_VELVET, "Velvet BSDF", NODE_CLASS_SHADER, 0);
	node_type_compatibility(&ntype, NODE_NEW_SHADING);
	node_type_socket_templates(&ntype, sh_node_bsdf_velvet_in, sh_node_bsdf_velvet_out);
	node_type_init(&ntype, NULL);
	node_type_storage(&ntype, "", NULL, NULL);
	node_type_gpu(&ntype, node_shader_gpu_bsdf_velvet);

	nodeRegisterType(&ntype);
}

示例#4

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

    sh_node_type_base(&ntype, SH_NODE_WIREFRAME, "Wireframe", NODE_CLASS_INPUT, NODE_OPTIONS);
    node_type_compatibility(&ntype, NODE_NEW_SHADING);
    node_type_socket_templates(&ntype, sh_node_wireframe_in, sh_node_wireframe_out);
    node_type_size(&ntype, 150, 60, 200);
    node_type_init(&ntype, NULL);
    node_type_storage(&ntype, "", NULL, NULL);

    nodeRegisterType(&ntype);
}

示例#5

文件： node_oct_transform_rotation.c 项目： JimStar/OctaneBlender

void register_node_type_transform_oct_rotation(void) {
	static bNodeType ntype;
	
	if(ntype.type != SH_NODE_OCT_ROTATE_TRN) node_type_base(&ntype, SH_NODE_OCT_ROTATE_TRN, "Octane Rotation Transform", NODE_CLASS_OCT_TRANSFORM, NODE_OPTIONS);
    node_type_compatibility(&ntype, NODE_NEW_SHADING);
	node_type_socket_templates(&ntype, sh_node_in, sh_node_out);
	node_type_size(&ntype, 160, 160, 200);
	node_type_init(&ntype, 0);
	node_type_exec(&ntype, 0, 0, 0);
    ntype.update_internal_links = node_update_internal_links_default;
	
	nodeRegisterType(&ntype);
} /* register_node_type_transform_oct_rotation() */

示例#6

文件： node_shader_tex_gradient.c 项目： DarkDefender/blender-npr-tess2

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

	sh_node_type_base(&ntype, SH_NODE_TEX_GRADIENT, "Gradient Texture", NODE_CLASS_TEXTURE, 0);
	node_type_compatibility(&ntype, NODE_NEW_SHADING);
	node_type_socket_templates(&ntype, sh_node_tex_gradient_in, sh_node_tex_gradient_out);
	node_type_init(&ntype, node_shader_init_tex_gradient);
	node_type_storage(&ntype, "NodeTexGradient", node_free_standard_storage, node_copy_standard_storage);
	node_type_gpu(&ntype, node_shader_gpu_tex_gradient);

	nodeRegisterType(&ntype);
}

示例#7

文件： node_shader_texture.c 项目： vanangamudi/blender-main

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

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

示例#8

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

	sh_node_type_base(&ntype, SH_NODE_HOLDOUT, "Holdout", NODE_CLASS_SHADER, 0);
	node_type_compatibility(&ntype, NODE_NEW_SHADING);
	node_type_socket_templates(&ntype, sh_node_holdout_in, sh_node_holdout_out);
	node_type_size(&ntype, 150, 60, 200);
	node_type_init(&ntype, NULL);
	node_type_storage(&ntype, "", NULL, NULL);

	nodeRegisterType(&ntype);
}

示例#9

文件： node_shader_fresnel.c 项目： 244xiao/blender

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

	sh_node_type_base(&ntype, SH_NODE_FRESNEL, "Fresnel", NODE_CLASS_INPUT, 0);
	node_type_compatibility(&ntype, NODE_NEW_SHADING);
	node_type_socket_templates(&ntype, sh_node_fresnel_in, sh_node_fresnel_out);
	node_type_init(&ntype, NULL);
	node_type_storage(&ntype, "", NULL, NULL);
	node_type_gpu(&ntype, node_shader_gpu_fresnel);

	nodeRegisterType(&ntype);
}

示例#10

文件： node_oct_medium_absorption.c 项目： JimStar/OctaneBlender

void register_node_type_medium_oct_absorption(void) {
    static bNodeType ntype;

    if(ntype.type != SH_NODE_OCT_ABSORP_MED) node_type_base(&ntype, SH_NODE_OCT_ABSORP_MED, "Octane Absorption Medium", NODE_CLASS_OCT_MEDIUM, NODE_OPTIONS);
    node_type_compatibility(&ntype, NODE_NEW_SHADING);
    node_type_socket_templates(&ntype, sh_node_in, sh_node_out);
    node_type_size(&ntype, 160, 160, 200);
    node_type_init(&ntype, 0);
    node_type_exec(&ntype, 0, 0, 0);
    ntype.update_internal_links = node_update_internal_links_default;

    nodeRegisterType(&ntype);
} /* register_node_type_medium_oct_absorption() */

示例#11

文件： node_shader_valToRgb.c 项目： mik0001/Blender

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

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

示例#12

文件： node_shader_tex_coord.c 项目： 244xiao/blender

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

	sh_node_type_base(&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_init(&ntype, NULL);
	node_type_storage(&ntype, "", NULL, NULL);
	node_type_gpu(&ntype, node_shader_gpu_tex_coord);

	nodeRegisterType(&ntype);
}

示例#13

文件： node_oct_texture_marble.c 项目： JimStar/OctaneBlender

void register_node_type_tex_oct_marble(void) {
	static bNodeType ntype;
	
	if(ntype.type != SH_NODE_OCT_MARBLE_TEX) node_type_base(&ntype, SH_NODE_OCT_MARBLE_TEX, "Octane Marble Tex", NODE_CLASS_OCT_TEXTURE, NODE_OPTIONS);
    node_type_compatibility(&ntype, NODE_NEW_SHADING);
	node_type_socket_templates(&ntype, sh_node_in, sh_node_out);
	node_type_size(&ntype, 160, 160, 200);
	node_type_init(&ntype, 0);
	node_type_exec(&ntype, 0, 0, 0);
    ntype.update_internal_links = node_update_internal_links_default;
	
	nodeRegisterType(&ntype);
} /* register_node_type_tex_oct_marble() */

示例#14

文件： node_shader_material.c 项目： jonntd/blender

void register_node_type_sh_material(void)
{
	static bNodeType ntype;

	sh_node_type_base(&ntype, SH_NODE_MATERIAL, "Material", NODE_CLASS_INPUT, NODE_PREVIEW);
	node_type_compatibility(&ntype, NODE_OLD_SHADING);
	node_type_socket_templates(&ntype, sh_node_material_in, sh_node_material_out);
	node_type_init(&ntype, node_shader_init_material);
	node_type_exec(&ntype, NULL, NULL, node_shader_exec_material);
	node_type_gpu(&ntype, gpu_shader_material);

	nodeRegisterType(&ntype);
}

示例#15

文件： node_shader_squeeze.c 项目： 244xiao/blender

void register_node_type_sh_squeeze(void)
{
	static bNodeType ntype;

	sh_node_type_base(&ntype, SH_NODE_SQUEEZE, "Squeeze Value", NODE_CLASS_CONVERTOR, 0);
	node_type_compatibility(&ntype, NODE_OLD_SHADING);
	node_type_socket_templates(&ntype, sh_node_squeeze_in, sh_node_squeeze_out);
	node_type_storage(&ntype, "node_squeeze", NULL, NULL);
	node_type_exec(&ntype, NULL, NULL, node_shader_exec_squeeze);
	node_type_gpu(&ntype, gpu_shader_squeeze);

	nodeRegisterType(&ntype);
}

示例#16

文件： node_shader_dynamic.c 项目： mik0001/Blender

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

示例#17

文件： node_oct_texture_gaussian_spectrum.c 项目： JimStar/OctaneBlender

void register_node_type_tex_oct_gaussian_spectrum(void) {
	static bNodeType ntype;
	
	if(ntype.type != SH_NODE_OCT_GAUSSIAN_SPECTRUM_TEX) node_type_base(&ntype, SH_NODE_OCT_GAUSSIAN_SPECTRUM_TEX, "Octane Gaussian Spectrum Tex", NODE_CLASS_OCT_TEXTURE, NODE_OPTIONS);
    node_type_compatibility(&ntype, NODE_NEW_SHADING);
	node_type_socket_templates(&ntype, sh_node_in, sh_node_out);
	node_type_size(&ntype, 160, 160, 200);
	node_type_init(&ntype, 0);
	node_type_exec(&ntype, 0, 0, 0);
    ntype.update_internal_links = node_update_internal_links_default;
	
	nodeRegisterType(&ntype);
} /* register_node_type_tex_oct_gaussian_spectrum() */

示例#18

文件： node_shader_ambient_occlusion.c 项目： Ichthyostega/blender

/* 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_compatibility(&ntype, NODE_NEW_SHADING);
	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);
}

示例#19

文件： node_shader_tex_checker.c 项目： Andrewson3D/blender-for-vray

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

	sh_node_type_base(&ntype, SH_NODE_TEX_CHECKER, "Checker Texture", NODE_CLASS_TEXTURE, 0);
	node_type_compatibility(&ntype, NODE_NEW_SHADING);
	node_type_socket_templates(&ntype, sh_node_tex_checker_in, sh_node_tex_checker_out);
	node_type_init(&ntype, node_shader_init_tex_checker);
	node_type_storage(&ntype, "NodeTexChecker", node_free_standard_storage, node_copy_standard_storage);
	node_type_gpu(&ntype, node_shader_gpu_tex_checker);

	nodeRegisterType(&ntype);
}

示例#20

文件： node_shader_light_path.c 项目： DarkDefender/blender-npr-tess2

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

	sh_node_type_base(&ntype, SH_NODE_LIGHT_PATH, "Light Path", NODE_CLASS_INPUT, 0);
	node_type_compatibility(&ntype, NODE_NEW_SHADING);
	node_type_socket_templates(&ntype, NULL, sh_node_light_path_out);
	node_type_init(&ntype, NULL);
	node_type_storage(&ntype, "", NULL, NULL);
	node_type_gpu(&ntype, node_shader_gpu_light_path);

	nodeRegisterType(&ntype);
}

示例#21

文件： node_common.c 项目： diekev/blender

void register_node_type_group_output(void)
{
	/* used for all tree types, needs dynamic allocation */
	bNodeType *ntype = MEM_callocN(sizeof(bNodeType), "node type");
	
	node_type_base(ntype, NODE_GROUP_OUTPUT, "Group Output", NODE_CLASS_INTERFACE, 0);
	node_type_size(ntype, 140, 80, 400);
	node_type_init(ntype, node_group_output_init);
	node_type_update(ntype, node_group_output_update, node_group_output_verify);
	node_type_compatibility(ntype, NODE_OLD_SHADING | NODE_NEW_SHADING);
	
	ntype->needs_free = 1;
	nodeRegisterType(ntype);
}

示例#22

文件： node_shader_bsdf_hair.c 项目： Andrewson3D/blender-for-vray

/* 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_compatibility(&ntype, NODE_NEW_SHADING);
	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);
}

示例#23

文件： node_shader_math.c 项目： SuriyaaKudoIsc/blender-git

void register_node_type_sh_math(void)
{
	static bNodeType ntype;

	sh_node_type_base(&ntype, SH_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, 0);
	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_label(&ntype, node_math_label);
	node_type_storage(&ntype, "", NULL, NULL);
	node_type_exec(&ntype, NULL, NULL, node_shader_exec_math);
	node_type_gpu(&ntype, gpu_shader_math);

	nodeRegisterType(&ntype);
}

示例#24

文件： node_shader_material.c 项目： danielmarg/blender-main

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

	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);
	node_type_init(&ntype, node_shader_init_material);
	node_type_exec(&ntype, node_shader_exec_material);
	node_type_gpu(&ntype, gpu_shader_material);

	nodeRegisterType(ttype, &ntype);
}

示例#25

文件： node_shader_bsdf_glass.c 项目： ilent2/Blender-Billboard-Modifier

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

	sh_node_type_base(&ntype, SH_NODE_BSDF_GLASS, "Glass BSDF", NODE_CLASS_SHADER, 0);
	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_preset(&ntype, NODE_SIZE_MIDDLE);
	node_type_init(&ntype, NULL);
	node_type_storage(&ntype, "", NULL, NULL);
	node_type_gpu(&ntype, node_shader_gpu_bsdf_glass);

	nodeRegisterType(&ntype);
}

示例#26

文件： node_shader_rgb.c 项目： danielmarg/blender-main

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

	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);
	node_type_size(&ntype, 140, 80, 140);
	node_type_exec(&ntype, node_shader_exec_rgb);
	node_type_gpu(&ntype, gpu_shader_rgb);

	nodeRegisterType(ttype, &ntype);
}

示例#27

文件： node_shader_tex_musgrave.c 项目： caomw/blender-ui

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

    sh_node_type_base(&ntype, SH_NODE_TEX_MUSGRAVE, "Musgrave Texture", NODE_CLASS_TEXTURE, 0);
    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_preset(&ntype, NODE_SIZE_MIDDLE);
    node_type_init(&ntype, node_shader_init_tex_musgrave);
    node_type_storage(&ntype, "NodeTexMusgrave", node_free_standard_storage, node_copy_standard_storage);
    node_type_gpu(&ntype, node_shader_gpu_tex_musgrave);

    nodeRegisterType(&ntype);
}

示例#28

文件： node_shader_material.c 项目： jonntd/blender

void register_node_type_sh_material_ext(void)
{
	static bNodeType ntype;

	sh_node_type_base(&ntype, SH_NODE_MATERIAL_EXT, "Extended Material", NODE_CLASS_INPUT, 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_init(&ntype, node_shader_init_material);
	node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
	node_type_exec(&ntype, NULL, NULL, node_shader_exec_material);
	node_type_gpu(&ntype, gpu_shader_material);

	nodeRegisterType(&ntype);
}

示例#29

文件： node_common.c 项目： vanangamudi/blender-main

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(ttype, ntype, NODE_FRAME, "Frame", NODE_CLASS_LAYOUT, NODE_BACKGROUND|NODE_OPTIONS);
	node_type_init(ntype, node_frame_init);
	node_type_storage(ntype, "NodeFrame", node_free_standard_storage, node_copy_standard_storage);
	node_type_size(ntype, 150, 100, 0);
	node_type_compatibility(ntype, NODE_OLD_SHADING|NODE_NEW_SHADING);
	
	ntype->needs_free = 1;
	nodeRegisterType(ttype, ntype);
}

示例#30

文件： node_shader_volume_principled.c 项目： mgschwan/blensor

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

	sh_node_type_base(&ntype, SH_NODE_VOLUME_PRINCIPLED, "Principled Volume", NODE_CLASS_SHADER, 0);
	node_type_compatibility(&ntype, NODE_NEW_SHADING);
	node_type_socket_templates(&ntype, sh_node_volume_principled_in, sh_node_volume_principled_out);
	node_type_size_preset(&ntype, NODE_SIZE_LARGE);
	node_type_init(&ntype, node_shader_init_volume_principled);
	node_type_storage(&ntype, "", NULL, NULL);
	node_type_gpu(&ntype, node_shader_gpu_volume_principled);

	nodeRegisterType(&ntype);
}