blender
/
blender
136
406
Fork 588
Code Issues 6.2k Pull Requests 755 Projects 19 Wiki Activity

Shader Nodes: Declare nodes in their own namespace 

Follow up on rB1df8abff257030ba79bc23dc321f35494f4d91c5

This puts all static functions in geometry node files into a new
namespace. This allows using unity build which can improve
compile times significantly

- The namespace name is derived from the file name.
  That makes it possible to write some tooling that checks the names later on.
  The filename extension (cc) is added to the namespace name as well.
  This also possibly simplifies tooling but also makes it more obvious that this namespace is specific to a file.
- In the register function of every node, I added a namespace alias namespace `file_ns = blender::nodes::node_shader_*_cc`;.
  This avoids some duplication of the file name and may also simplify tooling, because this line is easy to detect.
  The name `file_ns` stands for "file namespace" and also indicates that this namespace corresponds to the current file.

In the future some nodes will be split up to separate files and given their own namespace
This will allow function names to be simplified similar to rBfab39440e94

Reviewed By: HooglyBoogly

Differential Revision: https://developer.blender.org/D13480
This commit is contained in:
Aaron Carlisle 2021-12-05 17:46:45 -05:00 committed by Aaron Carlisle
parent 0a8a22fc04
commit 3f7014ecc9
Notes: blender-bot 2023-10-12 12:49:04 +02:00 
Referenced by commit 0f48b37aae, Revert moving all shader nodes to c++
89 changed files with 898 additions and 436 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
source/blender/nodes/shader/nodes/node_shader_add_shader.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_add_shader_cc {
static bNodeSocketTemplate sh_node_add_shader_in[] = {
{SOCK_SHADER, N_("Shader")},
{SOCK_SHADER, N_("Shader")},
@ -41,16 +43,21 @@ static int node_shader_gpu_add_shader(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_add_shader", in, out);
}
} // namespace blender::nodes::node_shader_add_shader_cc
/* node type definition */
void register_node_type_sh_add_shader()
{
namespace file_ns = blender::nodes::node_shader_add_shader_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_ADD_SHADER, "Add Shader", NODE_CLASS_SHADER, 0);
node_type_socket_templates(&ntype, sh_node_add_shader_in, sh_node_add_shader_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_add_shader_in, file_ns::sh_node_add_shader_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_add_shader);
node_type_gpu(&ntype, file_ns::node_shader_gpu_add_shader);
nodeRegisterType(&ntype);
}

13
source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_ambient_occlusion_cc {
static bNodeSocketTemplate sh_node_ambient_occlusion_in[] = {
{SOCK_RGBA, N_("Color"), 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f},
{SOCK_FLOAT, N_("Distance"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
@ -64,16 +66,21 @@ static void node_shader_init_ambient_occlusion(bNodeTree *UNUSED(ntree), bNode *
node->custom2 = 0;
}
} // namespace blender::nodes::node_shader_ambient_occlusion_cc
/* node type definition */
void register_node_type_sh_ambient_occlusion()
{
namespace file_ns = blender::nodes::node_shader_ambient_occlusion_cc;
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_socket_templates(
&ntype, file_ns::sh_node_ambient_occlusion_in, file_ns::sh_node_ambient_occlusion_out);
node_type_init(&ntype, file_ns::node_shader_init_ambient_occlusion);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_ambient_occlusion);
node_type_gpu(&ntype, file_ns::node_shader_gpu_ambient_occlusion);
nodeRegisterType(&ntype);
}

12
source/blender/nodes/shader/nodes/node_shader_attribute.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_attribute_cc {
static bNodeSocketTemplate sh_node_attribute_out[] = {
{SOCK_RGBA, N_("Color")},
{SOCK_VECTOR, N_("Vector"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@ -82,17 +84,21 @@ static int node_shader_gpu_attribute(GPUMaterial *mat,
return 1;
}
} // namespace blender::nodes::node_shader_attribute_cc
/* node type definition */
void register_node_type_sh_attribute()
{
namespace file_ns = blender::nodes::node_shader_attribute_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_ATTRIBUTE, "Attribute", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, nullptr, sh_node_attribute_out);
node_type_init(&ntype, node_shader_init_attribute);
node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_attribute_out);
node_type_init(&ntype, file_ns::node_shader_init_attribute);
node_type_storage(
&ntype, "NodeShaderAttribute", node_free_standard_storage, node_copy_standard_storage);
node_type_gpu(&ntype, node_shader_gpu_attribute);
node_type_gpu(&ntype, file_ns::node_shader_gpu_attribute);
nodeRegisterType(&ntype);
}

11
source/blender/nodes/shader/nodes/node_shader_background.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_background_cc {
static bNodeSocketTemplate sh_node_background_in[] = {
{SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_FLOAT, N_("Strength"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000000.0f},
@ -41,16 +43,21 @@ static int node_shader_gpu_background(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_background", in, out);
}
} // namespace blender::nodes::node_shader_background_cc
/* node type definition */
void register_node_type_sh_background()
{
namespace file_ns = blender::nodes::node_shader_background_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_BACKGROUND, "Background", NODE_CLASS_SHADER, 0);
node_type_socket_templates(&ntype, sh_node_background_in, sh_node_background_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_background_in, file_ns::sh_node_background_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_background);
node_type_gpu(&ntype, file_ns::node_shader_gpu_background);
nodeRegisterType(&ntype);
}

12
source/blender/nodes/shader/nodes/node_shader_bevel.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_bevel_cc {
static bNodeSocketTemplate sh_node_bevel_in[] = {
{SOCK_FLOAT, N_("Radius"), 0.05f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
{SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
@ -54,16 +56,20 @@ static int gpu_shader_bevel(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_bevel", in, out);
}
} // namespace blender::nodes::node_shader_bevel_cc
/* node type definition */
void register_node_type_sh_bevel()
{
namespace file_ns = blender::nodes::node_shader_bevel_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_BEVEL, "Bevel", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, sh_node_bevel_in, sh_node_bevel_out);
node_type_init(&ntype, node_shader_init_bevel);
node_type_socket_templates(&ntype, file_ns::sh_node_bevel_in, file_ns::sh_node_bevel_out);
node_type_init(&ntype, file_ns::node_shader_init_bevel);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, gpu_shader_bevel);
node_type_gpu(&ntype, file_ns::gpu_shader_bevel);
nodeRegisterType(&ntype);
}

12
source/blender/nodes/shader/nodes/node_shader_blackbody.cc
View File

@ -20,6 +20,9 @@
#include "node_shader_util.hh"
/* **************** Blackbody ******************** */
namespace blender::nodes::node_shader_blackbody_cc {
static bNodeSocketTemplate sh_node_blackbody_in[] = {
{SOCK_FLOAT, N_("Temperature"), 1500.0f, 0.0f, 0.0f, 0.0f, 800.0f, 12000.0f},
{-1, ""},
@ -47,17 +50,22 @@ static int node_shader_gpu_blackbody(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_blackbody", in, out, ramp_texture, GPU_constant(&layer));
}
} // namespace blender::nodes::node_shader_blackbody_cc
/* node type definition */
void register_node_type_sh_blackbody()
{
namespace file_ns = blender::nodes::node_shader_blackbody_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_BLACKBODY, "Blackbody", NODE_CLASS_CONVERTER, 0);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_socket_templates(&ntype, sh_node_blackbody_in, sh_node_blackbody_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_blackbody_in, file_ns::sh_node_blackbody_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_blackbody);
node_type_gpu(&ntype, file_ns::node_shader_gpu_blackbody);
nodeRegisterType(&ntype);
}

11
source/blender/nodes/shader/nodes/node_shader_brightness.cc
View File

@ -21,6 +21,8 @@
/* **************** Bright and contrast ******************** */
namespace blender::nodes::node_shader_brightness_cc {
static bNodeSocketTemplate sh_node_brightcontrast_in[] = {
{SOCK_RGBA, N_("Color"), 1.0f, 1.0f, 1.0f, 1.0f},
{SOCK_FLOAT, N_("Bright"), 0.0f, 0.0f, 0.0f, 0.0f, -100.0f, 100.0f, PROP_NONE},
@ -42,15 +44,20 @@ static int gpu_shader_brightcontrast(GPUMaterial *mat,
return GPU_stack_link(mat, node, "brightness_contrast", in, out);
}
} // namespace blender::nodes::node_shader_brightness_cc
void register_node_type_sh_brightcontrast()
{
namespace file_ns = blender::nodes::node_shader_brightness_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_BRIGHTCONTRAST, "Bright/Contrast", NODE_CLASS_OP_COLOR, 0);
node_type_socket_templates(&ntype, sh_node_brightcontrast_in, sh_node_brightcontrast_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_brightcontrast_in, file_ns::sh_node_brightcontrast_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, gpu_shader_brightcontrast);
node_type_gpu(&ntype, file_ns::gpu_shader_brightcontrast);
nodeRegisterType(&ntype);
}

13
source/blender/nodes/shader/nodes/node_shader_bsdf_anisotropic.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_anisotropic_cc {
static bNodeSocketTemplate sh_node_bsdf_anisotropic_in[] = {
{SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_FLOAT, N_("Roughness"), 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
@ -64,17 +66,22 @@ static int node_shader_gpu_bsdf_anisotropic(GPUMaterial *mat,
GPU_constant(&node->ssr_id));
}
} // namespace blender::nodes::node_shader_anisotropic_cc
/* node type definition */
void register_node_type_sh_bsdf_anisotropic()
{
namespace file_ns = blender::nodes::node_shader_anisotropic_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_BSDF_ANISOTROPIC, "Anisotropic BSDF", NODE_CLASS_SHADER, 0);
node_type_socket_templates(&ntype, sh_node_bsdf_anisotropic_in, sh_node_bsdf_anisotropic_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_bsdf_anisotropic_in, file_ns::sh_node_bsdf_anisotropic_out);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_init(&ntype, node_shader_init_anisotropic);
node_type_init(&ntype, file_ns::node_shader_init_anisotropic);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_bsdf_anisotropic);
node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_anisotropic);
nodeRegisterType(&ntype);
}

11
source/blender/nodes/shader/nodes/node_shader_bsdf_diffuse.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_bsdf_diffuse_cc {
static bNodeSocketTemplate sh_node_bsdf_diffuse_in[] = {
{SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_FLOAT, N_("Roughness"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
@ -48,17 +50,22 @@ static int node_shader_gpu_bsdf_diffuse(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_bsdf_diffuse", in, out);
}
} // namespace blender::nodes::node_shader_bsdf_diffuse_cc
/* node type definition */
void register_node_type_sh_bsdf_diffuse()
{
namespace file_ns = blender::nodes::node_shader_bsdf_diffuse_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_BSDF_DIFFUSE, "Diffuse BSDF", NODE_CLASS_SHADER, 0);
node_type_socket_templates(&ntype, sh_node_bsdf_diffuse_in, sh_node_bsdf_diffuse_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_bsdf_diffuse_in, file_ns::sh_node_bsdf_diffuse_out);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_bsdf_diffuse);
node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_diffuse);
nodeRegisterType(&ntype);
}

13
source/blender/nodes/shader/nodes/node_shader_bsdf_glass.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_bsdf_glass_cc {
static bNodeSocketTemplate sh_node_bsdf_glass_in[] = {
{SOCK_RGBA, N_("Color"), 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f},
{SOCK_FLOAT, N_("Roughness"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
@ -66,17 +68,22 @@ static int node_shader_gpu_bsdf_glass(GPUMaterial *mat,
GPU_constant(&node->ssr_id));
}
} // namespace blender::nodes::node_shader_bsdf_glass_cc
/* node type definition */
void register_node_type_sh_bsdf_glass()
{
namespace file_ns = blender::nodes::node_shader_bsdf_glass_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_BSDF_GLASS, "Glass BSDF", NODE_CLASS_SHADER, 0);
node_type_socket_templates(&ntype, sh_node_bsdf_glass_in, sh_node_bsdf_glass_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_bsdf_glass_in, file_ns::sh_node_bsdf_glass_out);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_init(&ntype, node_shader_init_glass);
node_type_init(&ntype, file_ns::node_shader_init_glass);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_bsdf_glass);
node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_glass);
nodeRegisterType(&ntype);
}

13
source/blender/nodes/shader/nodes/node_shader_bsdf_glossy.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_bsdf_glossy_cc {
static bNodeSocketTemplate sh_node_bsdf_glossy_in[] = {
{SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_FLOAT, N_("Roughness"), 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
@ -65,17 +67,22 @@ static int node_shader_gpu_bsdf_glossy(GPUMaterial *mat,
GPU_constant(&node->ssr_id));
}
} // namespace blender::nodes::node_shader_bsdf_glossy_cc
/* node type definition */
void register_node_type_sh_bsdf_glossy()
{
namespace file_ns = blender::nodes::node_shader_bsdf_glossy_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_BSDF_GLOSSY, "Glossy BSDF", NODE_CLASS_SHADER, 0);
node_type_socket_templates(&ntype, sh_node_bsdf_glossy_in, sh_node_bsdf_glossy_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_bsdf_glossy_in, file_ns::sh_node_bsdf_glossy_out);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_init(&ntype, node_shader_init_glossy);
node_type_init(&ntype, file_ns::node_shader_init_glossy);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_bsdf_glossy);
node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_glossy);
nodeRegisterType(&ntype);
}

11
source/blender/nodes/shader/nodes/node_shader_bsdf_hair.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_bsdf_hair_cc {
static bNodeSocketTemplate sh_node_bsdf_hair_in[] = {
{SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_FLOAT, N_("Offset"), 0.0f, 0.0f, 0.0f, 0.0f, -M_PI_2, M_PI_2, PROP_ANGLE},
@ -44,17 +46,22 @@ static int node_shader_gpu_bsdf_hair(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_bsdf_hair", in, out);
}
} // namespace blender::nodes::node_shader_bsdf_hair_cc
/* node type definition */
void register_node_type_sh_bsdf_hair()
{
namespace file_ns = blender::nodes::node_shader_bsdf_hair_cc;
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_socket_templates(
&ntype, file_ns::sh_node_bsdf_hair_in, file_ns::sh_node_bsdf_hair_out);
node_type_size(&ntype, 150, 60, 200);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_bsdf_hair);
node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_hair);
nodeRegisterType(&ntype);
}

12
source/blender/nodes/shader/nodes/node_shader_bsdf_hair_principled.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_bsdf_hair_principled_cc {
/* Color, melanin and absorption coefficient default to approximately same brownish hair. */
static bNodeSocketTemplate sh_node_bsdf_hair_principled_in[] = {
{SOCK_RGBA, N_("Color"), 0.017513f, 0.005763f, 0.002059f, 1.0f, 0.0f, 1.0f},
@ -90,19 +92,23 @@ static void node_shader_update_hair_principled(bNodeTree *ntree, bNode *node)
}
}
} // namespace blender::nodes::node_shader_bsdf_hair_principled_cc
/* node type definition */
void register_node_type_sh_bsdf_hair_principled()
{
namespace file_ns = blender::nodes::node_shader_bsdf_hair_principled_cc;
static bNodeType ntype;
sh_node_type_base(
&ntype, SH_NODE_BSDF_HAIR_PRINCIPLED, "Principled Hair BSDF", NODE_CLASS_SHADER, 0);
node_type_socket_templates(
&ntype, sh_node_bsdf_hair_principled_in, sh_node_bsdf_hair_principled_out);
&ntype, file_ns::sh_node_bsdf_hair_principled_in, file_ns::sh_node_bsdf_hair_principled_out);
node_type_size_preset(&ntype, NODE_SIZE_LARGE);
node_type_init(&ntype, node_shader_init_hair_principled);
node_type_init(&ntype, file_ns::node_shader_init_hair_principled);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_update(&ntype, node_shader_update_hair_principled);
node_type_update(&ntype, file_ns::node_shader_update_hair_principled);
nodeRegisterType(&ntype);
}

15
source/blender/nodes/shader/nodes/node_shader_bsdf_principled.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_bsdf_principled_cc {
static bNodeSocketTemplate sh_node_bsdf_principled_in[] = {
{SOCK_RGBA, N_("Base Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_FLOAT, N_("Subsurface"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
@ -183,18 +185,23 @@ static void node_shader_update_principled(bNodeTree *ntree, bNode *node)
}
}
} // namespace blender::nodes::node_shader_bsdf_principled_cc
/* node type definition */
void register_node_type_sh_bsdf_principled()
{
namespace file_ns = blender::nodes::node_shader_bsdf_principled_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_BSDF_PRINCIPLED, "Principled BSDF", NODE_CLASS_SHADER, 0);
node_type_socket_templates(&ntype, sh_node_bsdf_principled_in, sh_node_bsdf_principled_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_bsdf_principled_in, file_ns::sh_node_bsdf_principled_out);
node_type_size_preset(&ntype, NODE_SIZE_LARGE);
node_type_init(&ntype, node_shader_init_principled);
node_type_init(&ntype, file_ns::node_shader_init_principled);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_bsdf_principled);
node_type_update(&ntype, node_shader_update_principled);
node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_principled);
node_type_update(&ntype, file_ns::node_shader_update_principled);
nodeRegisterType(&ntype);
}

13
source/blender/nodes/shader/nodes/node_shader_bsdf_refraction.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_bsdf_refraction_cc {
static bNodeSocketTemplate sh_node_bsdf_refraction_in[] = {
{SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_FLOAT, N_("Roughness"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
@ -58,17 +60,22 @@ static int node_shader_gpu_bsdf_refraction(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_bsdf_refraction", in, out);
}
} // namespace blender::nodes::node_shader_bsdf_refraction_cc
/* node type definition */
void register_node_type_sh_bsdf_refraction()
{
namespace file_ns = blender::nodes::node_shader_bsdf_refraction_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_BSDF_REFRACTION, "Refraction BSDF", NODE_CLASS_SHADER, 0);
node_type_socket_templates(&ntype, sh_node_bsdf_refraction_in, sh_node_bsdf_refraction_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_bsdf_refraction_in, file_ns::sh_node_bsdf_refraction_out);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_init(&ntype, node_shader_init_refraction);
node_type_init(&ntype, file_ns::node_shader_init_refraction);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_bsdf_refraction);
node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_refraction);
nodeRegisterType(&ntype);
}

11
source/blender/nodes/shader/nodes/node_shader_bsdf_toon.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_bsdf_toon_cc {
static bNodeSocketTemplate sh_node_bsdf_toon_in[] = {
{SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_FLOAT, N_("Size"), 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
@ -49,17 +51,22 @@ static int node_shader_gpu_bsdf_toon(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_bsdf_toon", in, out);
}
} // namespace blender::nodes::node_shader_bsdf_toon_cc
/* node type definition */
void register_node_type_sh_bsdf_toon()
{
namespace file_ns = blender::nodes::node_shader_bsdf_toon_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_BSDF_TOON, "Toon BSDF", NODE_CLASS_SHADER, 0);
node_type_socket_templates(&ntype, sh_node_bsdf_toon_in, sh_node_bsdf_toon_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_bsdf_toon_in, file_ns::sh_node_bsdf_toon_out);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_bsdf_toon);
node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_toon);
nodeRegisterType(&ntype);
}

11
source/blender/nodes/shader/nodes/node_shader_bsdf_translucent.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_bsdf_translucent_cc {
static bNodeSocketTemplate sh_node_bsdf_translucent_in[] = {
{SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
@ -47,16 +49,21 @@ static int node_shader_gpu_bsdf_translucent(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_bsdf_translucent", in, out);
}
} // namespace blender::nodes::node_shader_bsdf_translucent_cc
/* node type definition */
void register_node_type_sh_bsdf_translucent()
{
namespace file_ns = blender::nodes::node_shader_bsdf_translucent_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_BSDF_TRANSLUCENT, "Translucent BSDF", NODE_CLASS_SHADER, 0);
node_type_socket_templates(&ntype, sh_node_bsdf_translucent_in, sh_node_bsdf_translucent_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_bsdf_translucent_in, file_ns::sh_node_bsdf_translucent_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_bsdf_translucent);
node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_translucent);
nodeRegisterType(&ntype);
}

11
source/blender/nodes/shader/nodes/node_shader_bsdf_transparent.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_bsdf_transparent_cc {
static bNodeSocketTemplate sh_node_bsdf_transparent_in[] = {
{SOCK_RGBA, N_("Color"), 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f},
{-1, ""},
@ -40,16 +42,21 @@ static int node_shader_gpu_bsdf_transparent(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_bsdf_transparent", in, out);
}
} // namespace blender::nodes::node_shader_bsdf_transparent_cc
/* node type definition */
void register_node_type_sh_bsdf_transparent()
{
namespace file_ns = blender::nodes::node_shader_bsdf_transparent_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_BSDF_TRANSPARENT, "Transparent BSDF", NODE_CLASS_SHADER, 0);
node_type_socket_templates(&ntype, sh_node_bsdf_transparent_in, sh_node_bsdf_transparent_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_bsdf_transparent_in, file_ns::sh_node_bsdf_transparent_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_bsdf_transparent);
node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_transparent);
nodeRegisterType(&ntype);
}

11
source/blender/nodes/shader/nodes/node_shader_bsdf_velvet.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_bsdf_velvet_cc {
static bNodeSocketTemplate sh_node_bsdf_velvet_in[] = {
{SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_FLOAT, N_("Sigma"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
@ -48,16 +50,21 @@ static int node_shader_gpu_bsdf_velvet(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_bsdf_velvet", in, out);
}
} // namespace blender::nodes::node_shader_bsdf_velvet_cc
/* node type definition */
void register_node_type_sh_bsdf_velvet()
{
namespace file_ns = blender::nodes::node_shader_bsdf_velvet_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_BSDF_VELVET, "Velvet BSDF", NODE_CLASS_SHADER, 0);
node_type_socket_templates(&ntype, sh_node_bsdf_velvet_in, sh_node_bsdf_velvet_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_bsdf_velvet_in, file_ns::sh_node_bsdf_velvet_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_bsdf_velvet);
node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_velvet);
nodeRegisterType(&ntype);
}

11
source/blender/nodes/shader/nodes/node_shader_bump.cc
View File

@ -24,6 +24,9 @@
#include "node_shader_util.hh"
/* **************** BUMP ******************** */
namespace blender::nodes::node_shader_bump_cc {
/* clang-format off */
static bNodeSocketTemplate sh_node_bump_in[] = {
{SOCK_FLOAT, N_("Strength"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
@ -54,15 +57,19 @@ static int gpu_shader_bump(GPUMaterial *mat,
mat, node, "node_bump", in, out, GPU_builtin(GPU_VIEW_POSITION), GPU_constant(&invert));
}
} // namespace blender::nodes::node_shader_bump_cc
/* node type definition */
void register_node_type_sh_bump()
{
namespace file_ns = blender::nodes::node_shader_bump_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_BUMP, "Bump", NODE_CLASS_OP_VECTOR, 0);
node_type_socket_templates(&ntype, sh_node_bump_in, sh_node_bump_out);
node_type_socket_templates(&ntype, file_ns::sh_node_bump_in, file_ns::sh_node_bump_out);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, gpu_shader_bump);
node_type_gpu(&ntype, file_ns::gpu_shader_bump);
nodeRegisterType(&ntype);
}

11
source/blender/nodes/shader/nodes/node_shader_camera.cc
View File

@ -24,6 +24,9 @@
#include "node_shader_util.hh"
/* **************** CAMERA INFO ******************** */
namespace blender::nodes::node_shader_camera_cc {
static bNodeSocketTemplate sh_node_camera_out[] = {
{SOCK_VECTOR, N_("View Vector")},
{SOCK_FLOAT, N_("View Z Depth")},
@ -44,14 +47,18 @@ static int gpu_shader_camera(GPUMaterial *mat,
return GPU_stack_link(mat, node, "camera", in, out, viewvec);
}
} // namespace blender::nodes::node_shader_camera_cc
void register_node_type_sh_camera()
{
namespace file_ns = blender::nodes::node_shader_camera_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_CAMERA, "Camera Data", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, nullptr, sh_node_camera_out);
node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_camera_out);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, gpu_shader_camera);
node_type_gpu(&ntype, file_ns::gpu_shader_camera);
nodeRegisterType(&ntype);
}

16
source/blender/nodes/shader/nodes/node_shader_clamp.cc
View File

@ -23,7 +23,7 @@
#include "node_shader_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_shader_clamp_cc {
static void sh_node_clamp_declare(NodeDeclarationBuilder &b)
{
@ -34,8 +34,6 @@ static void sh_node_clamp_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Float>(N_("Result"));
};
} // namespace blender::nodes
static void node_shader_init_clamp(bNodeTree *UNUSED(ntree), bNode *node)
{
node->custom1 = NODE_CLAMP_MINMAX; /* clamp type */
@ -75,15 +73,19 @@ static void sh_node_clamp_build_multi_function(blender::nodes::NodeMultiFunction
}
}
} // namespace blender::nodes::node_shader_clamp_cc
void register_node_type_sh_clamp()
{
namespace file_ns = blender::nodes::node_shader_clamp_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_CLAMP, "Clamp", NODE_CLASS_CONVERTER, 0);
ntype.declare = blender::nodes::sh_node_clamp_declare;
node_type_init(&ntype, node_shader_init_clamp);
node_type_gpu(&ntype, gpu_shader_clamp);
ntype.build_multi_function = sh_node_clamp_build_multi_function;
ntype.declare = file_ns::sh_node_clamp_declare;
node_type_init(&ntype, file_ns::node_shader_init_clamp);
node_type_gpu(&ntype, file_ns::gpu_shader_clamp);
ntype.build_multi_function = file_ns::sh_node_clamp_build_multi_function;
nodeRegisterType(&ntype);
}

54
source/blender/nodes/shader/nodes/node_shader_curves.cc
View File

@ -23,7 +23,7 @@
#include "node_shader_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_shader_curve_vec_cc {
static void sh_node_curve_vec_declare(NodeDeclarationBuilder &b)
{
@ -33,8 +33,6 @@ static void sh_node_curve_vec_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Vector>(N_("Vector"));
};
} // namespace blender::nodes
static void node_shader_exec_curve_vec(void *UNUSED(data),
int UNUSED(thread),
bNode *node,
@ -152,25 +150,29 @@ static void sh_node_curve_vec_build_multi_function(
builder.construct_and_set_matching_fn<CurveVecFunction>(*cumap);
}
} // namespace blender::nodes::node_shader_curve_vec_cc
void register_node_type_sh_curve_vec()
{
namespace file_ns = blender::nodes::node_shader_curve_vec_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_CURVE_VEC, "Vector Curves", NODE_CLASS_OP_VECTOR, 0);
ntype.declare = blender::nodes::sh_node_curve_vec_declare;
node_type_init(&ntype, node_shader_init_curve_vec);
ntype.declare = file_ns::sh_node_curve_vec_declare;
node_type_init(&ntype, file_ns::node_shader_init_curve_vec);
node_type_size_preset(&ntype, NODE_SIZE_LARGE);
node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves);
node_type_exec(&ntype, node_initexec_curves, nullptr, node_shader_exec_curve_vec);
node_type_gpu(&ntype, gpu_shader_curve_vec);
ntype.build_multi_function = sh_node_curve_vec_build_multi_function;
node_type_exec(&ntype, node_initexec_curves, nullptr, file_ns::node_shader_exec_curve_vec);
node_type_gpu(&ntype, file_ns::gpu_shader_curve_vec);
ntype.build_multi_function = file_ns::sh_node_curve_vec_build_multi_function;
nodeRegisterType(&ntype);
}
/* **************** CURVE RGB ******************** */
namespace blender::nodes {
namespace blender::nodes::node_shader_curve_rgb_cc {
static void sh_node_curve_rgb_declare(NodeDeclarationBuilder &b)
{
@ -180,8 +182,6 @@ static void sh_node_curve_rgb_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Color>(N_("Color"));
};
} // namespace blender::nodes
static void node_shader_exec_curve_rgb(void *UNUSED(data),
int UNUSED(thread),
bNode *node,
@ -329,25 +329,29 @@ static void sh_node_curve_rgb_build_multi_function(
builder.construct_and_set_matching_fn<CurveRGBFunction>(*cumap);
}
} // namespace blender::nodes::node_shader_curve_rgb_cc
void register_node_type_sh_curve_rgb()
{
namespace file_ns = blender::nodes::node_shader_curve_rgb_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, 0);
ntype.declare = blender::nodes::sh_node_curve_rgb_declare;
node_type_init(&ntype, node_shader_init_curve_rgb);
ntype.declare = file_ns::sh_node_curve_rgb_declare;
node_type_init(&ntype, file_ns::node_shader_init_curve_rgb);
node_type_size_preset(&ntype, NODE_SIZE_LARGE);
node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves);
node_type_exec(&ntype, node_initexec_curves, nullptr, node_shader_exec_curve_rgb);
node_type_gpu(&ntype, gpu_shader_curve_rgb);
ntype.build_multi_function = sh_node_curve_rgb_build_multi_function;
node_type_exec(&ntype, node_initexec_curves, nullptr, file_ns::node_shader_exec_curve_rgb);
node_type_gpu(&ntype, file_ns::gpu_shader_curve_rgb);
ntype.build_multi_function = file_ns::sh_node_curve_rgb_build_multi_function;
nodeRegisterType(&ntype);
}
/* **************** CURVE FLOAT ******************** */
namespace blender::nodes {
namespace blender::nodes::node_shader_curve_float_cc {
static void sh_node_curve_float_declare(NodeDeclarationBuilder &b)
{
@ -361,8 +365,6 @@ static void sh_node_curve_float_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Float>(N_("Value"));
};
} // namespace blender::nodes
static void node_shader_exec_curve_float(void *UNUSED(data),
int UNUSED(thread),
bNode *node,
@ -473,18 +475,22 @@ static void sh_node_curve_float_build_multi_function(
builder.construct_and_set_matching_fn<CurveFloatFunction>(*cumap);
}
} // namespace blender::nodes::node_shader_curve_float_cc
void register_node_type_sh_curve_float()
{
namespace file_ns = blender::nodes::node_shader_curve_float_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_CURVE_FLOAT, "Float Curve", NODE_CLASS_CONVERTER, 0);
ntype.declare = blender::nodes::sh_node_curve_float_declare;
node_type_init(&ntype, node_shader_init_curve_float);
ntype.declare = file_ns::sh_node_curve_float_declare;
node_type_init(&ntype, file_ns::node_shader_init_curve_float);
node_type_size_preset(&ntype, NODE_SIZE_LARGE);
node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves);
node_type_exec(&ntype, node_initexec_curves, nullptr, node_shader_exec_curve_float);
node_type_gpu(&ntype, gpu_shader_curve_float);
ntype.build_multi_function = sh_node_curve_float_build_multi_function;
node_type_exec(&ntype, node_initexec_curves, nullptr, file_ns::node_shader_exec_curve_float);
node_type_gpu(&ntype, file_ns::gpu_shader_curve_float);
ntype.build_multi_function = file_ns::sh_node_curve_float_build_multi_function;
nodeRegisterType(&ntype);
}

13
source/blender/nodes/shader/nodes/node_shader_displacement.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_displacement_cc {
static bNodeSocketTemplate sh_node_displacement_in[] = {
{SOCK_FLOAT, N_("Height"), 0.00f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
{SOCK_FLOAT, N_("Midlevel"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
@ -68,16 +70,21 @@ static int gpu_shader_displacement(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_displacement_world", in, out);
}
} // namespace blender::nodes::node_shader_displacement_cc
/* node type definition */
void register_node_type_sh_displacement()
{
namespace file_ns = blender::nodes::node_shader_displacement_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_DISPLACEMENT, "Displacement", NODE_CLASS_OP_VECTOR, 0);
node_type_socket_templates(&ntype, sh_node_displacement_in, sh_node_displacement_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_displacement_in, file_ns::sh_node_displacement_out);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_init(&ntype, node_shader_init_displacement);
node_type_gpu(&ntype, gpu_shader_displacement);
node_type_init(&ntype, file_ns::node_shader_init_displacement);
node_type_gpu(&ntype, file_ns::gpu_shader_displacement);
nodeRegisterType(&ntype);
}

11
source/blender/nodes/shader/nodes/node_shader_eevee_specular.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_eevee_specular_cc {
static bNodeSocketTemplate sh_node_eevee_specular_in[] = {
{SOCK_RGBA, N_("Base Color"), 0.8f, 0.8f, 0.8f, 1.0f},
{SOCK_RGBA, N_("Specular"), 0.03f, 0.03f, 0.03f, 1.0f},
@ -86,16 +88,21 @@ static int node_shader_gpu_eevee_specular(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_eevee_specular", in, out, GPU_constant(&node->ssr_id));
}
} // namespace blender::nodes::node_shader_eevee_specular_cc
/* node type definition */
void register_node_type_sh_eevee_specular()
{
namespace file_ns = blender::nodes::node_shader_eevee_specular_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_EEVEE_SPECULAR, "Specular BSDF", NODE_CLASS_SHADER, 0);
node_type_socket_templates(&ntype, sh_node_eevee_specular_in, sh_node_eevee_specular_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_eevee_specular_in, file_ns::sh_node_eevee_specular_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_eevee_specular);
node_type_gpu(&ntype, file_ns::node_shader_gpu_eevee_specular);
nodeRegisterType(&ntype);
}

10
source/blender/nodes/shader/nodes/node_shader_emission.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_emission_cc {
static bNodeSocketTemplate sh_node_emission_in[] = {
{SOCK_RGBA, N_("Color"), 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f},
{SOCK_FLOAT, N_("Strength"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000000.0f},
@ -41,16 +43,20 @@ static int node_shader_gpu_emission(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_emission", in, out, GPU_builtin(GPU_VIEW_NORMAL));
}
} // namespace blender::nodes::node_shader_emission_cc
/* node type definition */
void register_node_type_sh_emission()
{
namespace file_ns = blender::nodes::node_shader_emission_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_EMISSION, "Emission", NODE_CLASS_SHADER, 0);
node_type_socket_templates(&ntype, sh_node_emission_in, sh_node_emission_out);
node_type_socket_templates(&ntype, file_ns::sh_node_emission_in, file_ns::sh_node_emission_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_emission);
node_type_gpu(&ntype, file_ns::node_shader_gpu_emission);
nodeRegisterType(&ntype);
}

13
source/blender/nodes/shader/nodes/node_shader_fresnel.cc
View File

@ -20,6 +20,9 @@
#include "node_shader_util.hh"
/* **************** Fresnel ******************** */
namespace blender::nodes::node_shader_fresnel_cc {
static bNodeSocketTemplate sh_node_fresnel_in[] = {
{SOCK_FLOAT, N_("IOR"), 1.45f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
{SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
@ -57,17 +60,21 @@ static void node_shader_exec_fresnel(void *UNUSED(data),
{
}
} // namespace blender::nodes::node_shader_fresnel_cc
/* node type definition */
void register_node_type_sh_fresnel()
{
namespace file_ns = blender::nodes::node_shader_fresnel_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_FRESNEL, "Fresnel", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, sh_node_fresnel_in, sh_node_fresnel_out);
node_type_socket_templates(&ntype, file_ns::sh_node_fresnel_in, file_ns::sh_node_fresnel_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_fresnel);
node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_fresnel);
node_type_gpu(&ntype, file_ns::node_shader_gpu_fresnel);
node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_fresnel);
nodeRegisterType(&ntype);
}

12
source/blender/nodes/shader/nodes/node_shader_gamma.cc
View File

@ -21,6 +21,8 @@
/* **************** Gamma Tools ******************** */
namespace blender::nodes::node_shader_gamma_cc {
static bNodeSocketTemplate sh_node_gamma_in[] = {
{SOCK_RGBA, N_("Color"), 1.0f, 1.0f, 1.0f, 1.0f},
{SOCK_FLOAT, N_("Gamma"), 1.0f, 0.0f, 0.0f, 0.0f, 0.001f, 10.0f, PROP_UNSIGNED},
@ -58,16 +60,20 @@ static int node_shader_gpu_gamma(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_gamma", in, out);
}
} // namespace blender::nodes::node_shader_gamma_cc
void register_node_type_sh_gamma()
{
namespace file_ns = blender::nodes::node_shader_gamma_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_GAMMA, "Gamma", NODE_CLASS_OP_COLOR, 0);
node_type_socket_templates(&ntype, sh_node_gamma_in, sh_node_gamma_out);
node_type_socket_templates(&ntype, file_ns::sh_node_gamma_in, file_ns::sh_node_gamma_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_gamma);
node_type_gpu(&ntype, node_shader_gpu_gamma);
node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_gamma);
node_type_gpu(&ntype, file_ns::node_shader_gpu_gamma);
nodeRegisterType(&ntype);
}

10
source/blender/nodes/shader/nodes/node_shader_geometry.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_geometry_cc {
static bNodeSocketTemplate sh_node_geometry_out[] = {
{SOCK_VECTOR, N_("Position"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@ -86,16 +88,20 @@ static int node_shader_gpu_geometry(GPUMaterial *mat,
return success;
}
} // namespace blender::nodes::node_shader_geometry_cc
/* node type definition */
void register_node_type_sh_geometry()
{
namespace file_ns = blender::nodes::node_shader_geometry_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_NEW_GEOMETRY, "Geometry", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, nullptr, sh_node_geometry_out);
node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_geometry_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_geometry);
node_type_gpu(&ntype, file_ns::node_shader_gpu_geometry);
nodeRegisterType(&ntype);
}

10
source/blender/nodes/shader/nodes/node_shader_hair_info.cc
View File

@ -19,6 +19,8 @@
#include "node_shader_util.hh"
namespace blender::nodes::node_shader_hair_info_cc {
static bNodeSocketTemplate outputs[] = {
{SOCK_FLOAT, N_("Is Strand"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{SOCK_FLOAT, N_("Intercept"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@ -43,16 +45,20 @@ static int node_shader_gpu_hair_info(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_hair_info", in, out, length_link);
}
} // namespace blender::nodes::node_shader_hair_info_cc
/* node type definition */
void register_node_type_sh_hair_info()
{
namespace file_ns = blender::nodes::node_shader_hair_info_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_HAIR_INFO, "Hair Info", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, nullptr, outputs);
node_type_socket_templates(&ntype, nullptr, file_ns::outputs);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_hair_info);
node_type_gpu(&ntype, file_ns::node_shader_gpu_hair_info);
nodeRegisterType(&ntype);
}

10
source/blender/nodes/shader/nodes/node_shader_holdout.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_holdout_cc {
static bNodeSocketTemplate sh_node_holdout_in[] = {
{-1, ""},
};
@ -39,16 +41,20 @@ static int gpu_shader_rgb(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_holdout", in, out);
}
} // namespace blender::nodes::node_shader_holdout_cc
/* node type definition */
void register_node_type_sh_holdout()
{
namespace file_ns = blender::nodes::node_shader_holdout_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_HOLDOUT, "Holdout", NODE_CLASS_SHADER, 0);
node_type_socket_templates(&ntype, sh_node_holdout_in, sh_node_holdout_out);
node_type_socket_templates(&ntype, file_ns::sh_node_holdout_in, file_ns::sh_node_holdout_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, gpu_shader_rgb);
node_type_gpu(&ntype, file_ns::gpu_shader_rgb);
nodeRegisterType(&ntype);
}

13
source/blender/nodes/shader/nodes/node_shader_hueSatVal.cc
View File

@ -24,6 +24,9 @@
#include "node_shader_util.hh"
/* **************** Hue Saturation ******************** */
namespace blender::nodes::node_shader_hueSatVal_cc {
static bNodeSocketTemplate sh_node_hue_sat_in[] = {
{SOCK_FLOAT, N_("Hue"), 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_NONE},
{SOCK_FLOAT, N_("Saturation"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 2.0f, PROP_NONE},
@ -85,15 +88,19 @@ static int gpu_shader_hue_sat(GPUMaterial *mat,
return GPU_stack_link(mat, node, "hue_sat", in, out);
}
} // namespace blender::nodes::node_shader_hueSatVal_cc
void register_node_type_sh_hue_sat()
{
namespace file_ns = blender::nodes::node_shader_hueSatVal_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, 0);
node_type_socket_templates(&ntype, sh_node_hue_sat_in, sh_node_hue_sat_out);
node_type_socket_templates(&ntype, file_ns::sh_node_hue_sat_in, file_ns::sh_node_hue_sat_out);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_hue_sat);
node_type_gpu(&ntype, gpu_shader_hue_sat);
node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_hue_sat);
node_type_gpu(&ntype, file_ns::gpu_shader_hue_sat);
nodeRegisterType(&ntype);
}

10
source/blender/nodes/shader/nodes/node_shader_ies_light.cc
View File

@ -21,6 +21,8 @@
/* **************** IES Light ******************** */
namespace blender::nodes::node_shader_ies_light_cc {
static bNodeSocketTemplate sh_node_tex_ies_in[] = {
{SOCK_VECTOR, N_("Vector"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
{SOCK_FLOAT, N_("Strength"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000000.0f, PROP_NONE},
@ -39,14 +41,18 @@ static void node_shader_init_tex_ies(bNodeTree *UNUSED(ntree), bNode *node)
node->storage = tex;
}
} // namespace blender::nodes::node_shader_ies_light_cc
/* node type definition */
void register_node_type_sh_tex_ies()
{
namespace file_ns = blender::nodes::node_shader_ies_light_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_TEX_IES, "IES Texture", NODE_CLASS_TEXTURE, 0);
node_type_socket_templates(&ntype, sh_node_tex_ies_in, sh_node_tex_ies_out);
node_type_init(&ntype, node_shader_init_tex_ies);
node_type_socket_templates(&ntype, file_ns::sh_node_tex_ies_in, file_ns::sh_node_tex_ies_out);
node_type_init(&ntype, file_ns::node_shader_init_tex_ies);
node_type_storage(
&ntype, "NodeShaderTexIES", node_free_standard_storage, node_copy_standard_storage);

13
source/blender/nodes/shader/nodes/node_shader_invert.cc
View File

@ -24,6 +24,9 @@
#include "node_shader_util.hh"
/* **************** INVERT ******************** */
namespace blender::nodes::node_shader_invert_cc {
static bNodeSocketTemplate sh_node_invert_in[] = {
{SOCK_FLOAT, N_("Fac"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
{SOCK_RGBA, N_("Color"), 0.0f, 0.0f, 0.0f, 1.0f},
@ -65,14 +68,18 @@ static int gpu_shader_invert(GPUMaterial *mat,
return GPU_stack_link(mat, node, "invert", in, out);
}
} // namespace blender::nodes::node_shader_invert_cc
void register_node_type_sh_invert()
{
namespace file_ns = blender::nodes::node_shader_invert_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, 0);
node_type_socket_templates(&ntype, sh_node_invert_in, sh_node_invert_out);
node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_invert);
node_type_gpu(&ntype, gpu_shader_invert);
node_type_socket_templates(&ntype, file_ns::sh_node_invert_in, file_ns::sh_node_invert_out);
node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_invert);
node_type_gpu(&ntype, file_ns::gpu_shader_invert);
nodeRegisterType(&ntype);
}

13
source/blender/nodes/shader/nodes/node_shader_layer_weight.cc
View File

@ -21,6 +21,8 @@
/* **************** Layer Weight ******************** */
namespace blender::nodes::node_shader_layer_weight_cc {
static bNodeSocketTemplate sh_node_layer_weight_in[] = {
{SOCK_FLOAT, N_("Blend"), 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
@ -59,17 +61,22 @@ static void node_shader_exec_layer_weight(void *UNUSED(data),
{
}
} // namespace blender::nodes::node_shader_layer_weight_cc
/* node type definition */
void register_node_type_sh_layer_weight()
{
namespace file_ns = blender::nodes::node_shader_layer_weight_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_LAYER_WEIGHT, "Layer Weight", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, sh_node_layer_weight_in, sh_node_layer_weight_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_layer_weight_in, file_ns::sh_node_layer_weight_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_layer_weight);
node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_layer_weight);
node_type_gpu(&ntype, file_ns::node_shader_gpu_layer_weight);
node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_layer_weight);
nodeRegisterType(&ntype);
}

11
source/blender/nodes/shader/nodes/node_shader_light_falloff.cc
View File

@ -21,6 +21,8 @@
/* **************** INPUT ********************* */
namespace blender::nodes::node_shader_light_falloff_cc {
static bNodeSocketTemplate sh_node_light_falloff_in[] = {
{SOCK_FLOAT, N_("Strength"), 100.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000000.0f},
{SOCK_FLOAT, N_("Smooth"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
@ -45,17 +47,22 @@ static int node_shader_gpu_light_falloff(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_light_falloff", in, out);
}
} // namespace blender::nodes::node_shader_light_falloff_cc
/* node type definition */
void register_node_type_sh_light_falloff()
{
namespace file_ns = blender::nodes::node_shader_light_falloff_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_LIGHT_FALLOFF, "Light Falloff", NODE_CLASS_OP_COLOR, 0);
node_type_socket_templates(&ntype, sh_node_light_falloff_in, sh_node_light_falloff_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_light_falloff_in, file_ns::sh_node_light_falloff_out);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_light_falloff);
node_type_gpu(&ntype, file_ns::node_shader_gpu_light_falloff);
nodeRegisterType(&ntype);
}

10
source/blender/nodes/shader/nodes/node_shader_light_path.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_light_path_cc {
static bNodeSocketTemplate sh_node_light_path_out[] = {
{SOCK_FLOAT, N_("Is Camera Ray"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{SOCK_FLOAT, N_("Is Shadow Ray"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@ -47,16 +49,20 @@ static int node_shader_gpu_light_path(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_light_path", in, out);
}
} // namespace blender::nodes::node_shader_light_path_cc
/* node type definition */
void register_node_type_sh_light_path()
{
namespace file_ns = blender::nodes::node_shader_light_path_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_LIGHT_PATH, "Light Path", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, nullptr, sh_node_light_path_out);
node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_light_path_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_light_path);
node_type_gpu(&ntype, file_ns::node_shader_gpu_light_path);
nodeRegisterType(&ntype);
}

18
source/blender/nodes/shader/nodes/node_shader_map_range.cc
View File

@ -25,7 +25,7 @@
#include "BLI_math_base_safe.h"
namespace blender::nodes {
namespace blender::nodes::node_shader_map_range_cc {
static void sh_node_map_range_declare(NodeDeclarationBuilder &b)
{
@ -39,8 +39,6 @@ static void sh_node_map_range_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Float>(N_("Result"));
};
} // namespace blender::nodes
static void node_shader_update_map_range(bNodeTree *ntree, bNode *node)
{
bNodeSocket *sockSteps = nodeFindSocket(node, SOCK_IN, "Steps");
@ -307,16 +305,20 @@ static void sh_node_map_range_build_multi_function(
}
}
} // namespace blender::nodes::node_shader_map_range_cc
void register_node_type_sh_map_range()
{
namespace file_ns = blender::nodes::node_shader_map_range_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_MAP_RANGE, "Map Range", NODE_CLASS_CONVERTER, 0);
ntype.declare = blender::nodes::sh_node_map_range_declare;
node_type_init(&ntype, node_shader_init_map_range);
node_type_update(&ntype, node_shader_update_map_range);
node_type_gpu(&ntype, gpu_shader_map_range);
ntype.build_multi_function = sh_node_map_range_build_multi_function;
ntype.declare = file_ns::sh_node_map_range_declare;
node_type_init(&ntype, file_ns::node_shader_init_map_range);
node_type_update(&ntype, file_ns::node_shader_update_map_range);
node_type_gpu(&ntype, file_ns::gpu_shader_map_range);
ntype.build_multi_function = file_ns::sh_node_map_range_build_multi_function;
nodeRegisterType(&ntype);
}

13
source/blender/nodes/shader/nodes/node_shader_mapping.cc
View File

@ -24,6 +24,9 @@
#include "node_shader_util.hh"
/* **************** MAPPING ******************** */
namespace blender::nodes::node_shader_mapping_cc {
static bNodeSocketTemplate sh_node_mapping_in[] = {
{SOCK_VECTOR, N_("Vector"), 0.0f, 0.0f, 0.0f, 1.0f, -FLT_MAX, FLT_MAX, PROP_NONE},
{SOCK_VECTOR, N_("Location"), 0.0f, 0.0f, 0.0f, 1.0f, -FLT_MAX, FLT_MAX, PROP_TRANSLATION},
@ -64,14 +67,18 @@ static void node_shader_update_mapping(bNodeTree *ntree, bNode *node)
ntree, sock, ELEM(node->custom1, NODE_MAPPING_TYPE_POINT, NODE_MAPPING_TYPE_TEXTURE));
}
} // namespace blender::nodes::node_shader_mapping_cc
void register_node_type_sh_mapping()
{
namespace file_ns = blender::nodes::node_shader_mapping_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_MAPPING, "Mapping", NODE_CLASS_OP_VECTOR, 0);
node_type_socket_templates(&ntype, sh_node_mapping_in, sh_node_mapping_out);
node_type_gpu(&ntype, gpu_shader_mapping);
node_type_update(&ntype, node_shader_update_mapping);
node_type_socket_templates(&ntype, file_ns::sh_node_mapping_in, file_ns::sh_node_mapping_out);
node_type_gpu(&ntype, file_ns::gpu_shader_mapping);
node_type_update(&ntype, file_ns::node_shader_update_mapping);
nodeRegisterType(&ntype);
}

14
source/blender/nodes/shader/nodes/node_shader_math.cc
View File

@ -27,7 +27,7 @@
/* **************** SCALAR MATH ******************** */
namespace blender::nodes {
namespace blender::nodes::node_shader_math_cc {
static void sh_node_math_declare(NodeDeclarationBuilder &b)
{
@ -44,8 +44,6 @@ static void sh_node_math_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Float>(N_("Value"));
};
} // namespace blender::nodes
static const char *gpu_shader_get_name(int mode)
{
const blender::nodes::FloatMathOperationInfo *info =
@ -161,16 +159,20 @@ static void sh_node_math_build_multi_function(blender::nodes::NodeMultiFunctionB
}
}
} // namespace blender::nodes::node_shader_math_cc
void register_node_type_sh_math()
{
namespace file_ns = blender::nodes::node_shader_math_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_MATH, "Math", NODE_CLASS_CONVERTER, 0);
ntype.declare = blender::nodes::sh_node_math_declare;
ntype.declare = file_ns::sh_node_math_declare;
node_type_label(&ntype, node_math_label);
node_type_gpu(&ntype, gpu_shader_math);
node_type_gpu(&ntype, file_ns::gpu_shader_math);
node_type_update(&ntype, node_math_update);
ntype.build_multi_function = sh_node_math_build_multi_function;
ntype.build_multi_function = file_ns::sh_node_math_build_multi_function;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/shader/nodes/node_shader_mixRgb.cc
View File

@ -23,7 +23,7 @@
#include "node_shader_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_shader_mixRgb_cc {
static void sh_node_mix_rgb_declare(NodeDeclarationBuilder &b)
{
@ -34,8 +34,6 @@ static void sh_node_mix_rgb_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Color>(N_("Color"));
};
} // namespace blender::nodes
static void node_shader_exec_mix_rgb(void *UNUSED(data),
int UNUSED(thread),
bNode *node,
@ -183,16 +181,20 @@ static void sh_node_mix_rgb_build_multi_function(blender::nodes::NodeMultiFuncti
builder.construct_and_set_matching_fn<MixRGBFunction>(clamp, mix_type);
}
} // namespace blender::nodes::node_shader_mixRgb_cc
void register_node_type_sh_mix_rgb()
{
namespace file_ns = blender::nodes::node_shader_mixRgb_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, 0);
ntype.declare = blender::nodes::sh_node_mix_rgb_declare;
ntype.declare = file_ns::sh_node_mix_rgb_declare;
node_type_label(&ntype, node_blend_label);
node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_mix_rgb);
node_type_gpu(&ntype, gpu_shader_mix_rgb);
ntype.build_multi_function = sh_node_mix_rgb_build_multi_function;
node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_mix_rgb);
node_type_gpu(&ntype, file_ns::gpu_shader_mix_rgb);
ntype.build_multi_function = file_ns::sh_node_mix_rgb_build_multi_function;
nodeRegisterType(&ntype);
}

11
source/blender/nodes/shader/nodes/node_shader_mix_shader.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_mix_shader_cc {
static bNodeSocketTemplate sh_node_mix_shader_in[] = {
{SOCK_FLOAT, N_("Fac"), 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
{SOCK_SHADER, N_("Shader")},
@ -42,16 +44,21 @@ static int node_shader_gpu_mix_shader(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_mix_shader", in, out);
}
} // namespace blender::nodes::node_shader_mix_shader_cc
/* node type definition */
void register_node_type_sh_mix_shader()
{
namespace file_ns = blender::nodes::node_shader_mix_shader_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_MIX_SHADER, "Mix Shader", NODE_CLASS_SHADER, 0);
node_type_socket_templates(&ntype, sh_node_mix_shader_in, sh_node_mix_shader_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_mix_shader_in, file_ns::sh_node_mix_shader_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_mix_shader);
node_type_gpu(&ntype, file_ns::node_shader_gpu_mix_shader);
nodeRegisterType(&ntype);
}

13
source/blender/nodes/shader/nodes/node_shader_normal.cc
View File

@ -24,6 +24,9 @@
#include "node_shader_util.hh"
/* **************** NORMAL ******************** */
namespace blender::nodes::node_shader_normal_cc {
static bNodeSocketTemplate sh_node_normal_in[] = {
{SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 1.0f, 0.0f, -1.0f, 1.0f, PROP_DIRECTION},
{-1, ""},
@ -64,14 +67,18 @@ static int gpu_shader_normal(GPUMaterial *mat,
return GPU_stack_link(mat, node, "normal_new_shading", in, out, vec);
}
} // namespace blender::nodes::node_shader_normal_cc
void register_node_type_sh_normal()
{
namespace file_ns = blender::nodes::node_shader_normal_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_NORMAL, "Normal", NODE_CLASS_OP_VECTOR, 0);
node_type_socket_templates(&ntype, sh_node_normal_in, sh_node_normal_out);
node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_normal);
node_type_gpu(&ntype, gpu_shader_normal);
node_type_socket_templates(&ntype, file_ns::sh_node_normal_in, file_ns::sh_node_normal_out);
node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_normal);
node_type_gpu(&ntype, file_ns::gpu_shader_normal);
nodeRegisterType(&ntype);
}

15
source/blender/nodes/shader/nodes/node_shader_normal_map.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_normal_map_cc {
static bNodeSocketTemplate sh_node_normal_map_in[] = {
{SOCK_FLOAT, N_("Strength"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 10.0f},
{SOCK_RGBA, N_("Color"), 0.5f, 0.5f, 1.0f, 1.0f, 0.0f, 1.0f},
@ -115,19 +117,24 @@ static int gpu_shader_normal_map(GPUMaterial *mat,
return true;
}
} // namespace blender::nodes::node_shader_normal_map_cc
/* node type definition */
void register_node_type_sh_normal_map()
{
namespace file_ns = blender::nodes::node_shader_normal_map_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_NORMAL_MAP, "Normal Map", NODE_CLASS_OP_VECTOR, 0);
node_type_socket_templates(&ntype, sh_node_normal_map_in, sh_node_normal_map_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_normal_map_in, file_ns::sh_node_normal_map_out);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_init(&ntype, node_shader_init_normal_map);
node_type_init(&ntype, file_ns::node_shader_init_normal_map);
node_type_storage(
&ntype, "NodeShaderNormalMap", node_free_standard_storage, node_copy_standard_storage);
node_type_gpu(&ntype, gpu_shader_normal_map);
node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_normal_map);
node_type_gpu(&ntype, file_ns::gpu_shader_normal_map);
node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_normal_map);
nodeRegisterType(&ntype);
}

10
source/blender/nodes/shader/nodes/node_shader_object_info.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_object_info_cc {
static bNodeSocketTemplate sh_node_object_info_out[] = {
{SOCK_VECTOR, N_("Location"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{SOCK_RGBA, N_("Color"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@ -49,13 +51,17 @@ static int node_shader_gpu_object_info(GPUMaterial *mat,
GPU_constant(&index));
}
} // namespace blender::nodes::node_shader_object_info_cc
void register_node_type_sh_object_info()
{
namespace file_ns = blender::nodes::node_shader_object_info_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_OBJECT_INFO, "Object Info", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, nullptr, sh_node_object_info_out);
node_type_gpu(&ntype, node_shader_gpu_object_info);
node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_object_info_out);
node_type_gpu(&ntype, file_ns::node_shader_gpu_object_info);
nodeRegisterType(&ntype);
}

12
source/blender/nodes/shader/nodes/node_shader_output_aov.cc
View File

@ -23,6 +23,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_output_aov_cc {
static bNodeSocketTemplate sh_node_output_aov_in[] = {
{SOCK_RGBA, N_("Color"), 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{SOCK_FLOAT, N_("Value"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@ -53,17 +55,21 @@ static int node_shader_gpu_output_aov(GPUMaterial *mat,
return true;
}
} // namespace blender::nodes::node_shader_output_aov_cc
/* node type definition */
void register_node_type_sh_output_aov()
{
namespace file_ns = blender::nodes::node_shader_output_aov_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_OUTPUT_AOV, "AOV Output", NODE_CLASS_OUTPUT, 0);
node_type_socket_templates(&ntype, sh_node_output_aov_in, nullptr);
node_type_init(&ntype, node_shader_init_output_aov);
node_type_socket_templates(&ntype, file_ns::sh_node_output_aov_in, nullptr);
node_type_init(&ntype, file_ns::node_shader_init_output_aov);
node_type_storage(
&ntype, "NodeShaderOutputAOV", node_free_standard_storage, node_copy_standard_storage);
node_type_gpu(&ntype, node_shader_gpu_output_aov);
node_type_gpu(&ntype, file_ns::node_shader_gpu_output_aov);
ntype.no_muting = true;

8
source/blender/nodes/shader/nodes/node_shader_output_light.cc
View File

@ -21,18 +21,24 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_output_light_cc {
static bNodeSocketTemplate sh_node_output_light_in[] = {
{SOCK_SHADER, N_("Surface"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{-1, ""},
};
} // namespace blender::nodes::node_shader_output_light_cc
/* node type definition */
void register_node_type_sh_output_light()
{
namespace file_ns = blender::nodes::node_shader_output_light_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_OUTPUT_LIGHT, "Light Output", NODE_CLASS_OUTPUT, 0);
node_type_socket_templates(&ntype, sh_node_output_light_in, nullptr);
node_type_socket_templates(&ntype, file_ns::sh_node_output_light_in, nullptr);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);

8
source/blender/nodes/shader/nodes/node_shader_output_linestyle.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_output_linestyle_cc {
static bNodeSocketTemplate sh_node_output_linestyle_in[] = {
{SOCK_RGBA, N_("Color"), 1.0f, 0.0f, 1.0f, 1.0f},
{SOCK_FLOAT, N_("Color Fac"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
@ -29,13 +31,17 @@ static bNodeSocketTemplate sh_node_output_linestyle_in[] = {
{-1, ""},
};
} // namespace blender::nodes::node_shader_output_linestyle_cc
/* node type definition */
void register_node_type_sh_output_linestyle()
{
namespace file_ns = blender::nodes::node_shader_output_linestyle_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_OUTPUT_LINESTYLE, "Line Style Output", NODE_CLASS_OUTPUT, 0);
node_type_socket_templates(&ntype, sh_node_output_linestyle_in, nullptr);
node_type_socket_templates(&ntype, file_ns::sh_node_output_linestyle_in, nullptr);
node_type_init(&ntype, nullptr);
ntype.no_muting = true;

10
source/blender/nodes/shader/nodes/node_shader_output_material.cc
View File

@ -23,6 +23,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_output_material_cc {
static bNodeSocketTemplate sh_node_output_material_in[] = {
{SOCK_SHADER, N_("Surface")},
{SOCK_SHADER, N_("Volume")},
@ -73,16 +75,20 @@ static int node_shader_gpu_output_material(GPUMaterial *mat,
return true;
}
} // namespace blender::nodes::node_shader_output_material_cc
/* node type definition */
void register_node_type_sh_output_material()
{
namespace file_ns = blender::nodes::node_shader_output_material_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_OUTPUT_MATERIAL, "Material Output", NODE_CLASS_OUTPUT, 0);
node_type_socket_templates(&ntype, sh_node_output_material_in, nullptr);
node_type_socket_templates(&ntype, file_ns::sh_node_output_material_in, nullptr);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_output_material);
node_type_gpu(&ntype, file_ns::node_shader_gpu_output_material);
ntype.no_muting = true;

10
source/blender/nodes/shader/nodes/node_shader_output_world.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_output_world_cc {
static bNodeSocketTemplate sh_node_output_world_in[] = {
{SOCK_SHADER, N_("Surface"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{SOCK_SHADER, N_("Volume"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@ -41,16 +43,20 @@ static int node_shader_gpu_output_world(GPUMaterial *mat,
return true;
}
} // namespace blender::nodes::node_shader_output_world_cc
/* node type definition */
void register_node_type_sh_output_world()
{
namespace file_ns = blender::nodes::node_shader_output_world_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_OUTPUT_WORLD, "World Output", NODE_CLASS_OUTPUT, 0);
node_type_socket_templates(&ntype, sh_node_output_world_in, nullptr);
node_type_socket_templates(&ntype, file_ns::sh_node_output_world_in, nullptr);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_output_world);
node_type_gpu(&ntype, file_ns::node_shader_gpu_output_world);
ntype.no_muting = true;

12
source/blender/nodes/shader/nodes/node_shader_particle_info.cc
View File

@ -21,6 +21,8 @@
#include "node_shader_util.hh"
namespace blender::nodes::node_shader_particle_info_cc {
static bNodeSocketTemplate outputs[] = {
{SOCK_FLOAT, "Index"},
{SOCK_FLOAT, "Random"},
@ -62,15 +64,19 @@ static int gpu_shader_particle_info(GPUMaterial *mat,
GPU_builtin(GPU_PARTICLE_ANG_VELOCITY));
}
} // namespace blender::nodes::node_shader_particle_info_cc
/* node type definition */
void register_node_type_sh_particle_info()
{
namespace file_ns = blender::nodes::node_shader_particle_info_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_PARTICLE_INFO, "Particle Info", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, nullptr, outputs);
node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_particle_info);
node_type_gpu(&ntype, gpu_shader_particle_info);
node_type_socket_templates(&ntype, nullptr, file_ns::outputs);
node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_particle_info);
node_type_gpu(&ntype, file_ns::gpu_shader_particle_info);
nodeRegisterType(&ntype);
}

11
source/blender/nodes/shader/nodes/node_shader_rgb.cc
View File

@ -24,6 +24,9 @@
#include "node_shader_util.hh"
/* **************** RGB ******************** */
namespace blender::nodes::node_shader_rgb_cc {
static bNodeSocketTemplate sh_node_rgb_out[] = {
{SOCK_RGBA, N_("Color"), 0.5f, 0.5f, 0.5f, 1.0f},
{-1, ""},
@ -39,13 +42,17 @@ static int gpu_shader_rgb(GPUMaterial *mat,
return GPU_stack_link(mat, node, "set_rgba", in, out, link);
}
} // namespace blender::nodes::node_shader_rgb_cc
void register_node_type_sh_rgb()
{
namespace file_ns = blender::nodes::node_shader_rgb_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_RGB, "RGB", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, nullptr, sh_node_rgb_out);
node_type_gpu(&ntype, gpu_shader_rgb);
node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_rgb_out);
node_type_gpu(&ntype, file_ns::gpu_shader_rgb);
nodeRegisterType(&ntype);
}

11
source/blender/nodes/shader/nodes/node_shader_script.cc
View File

@ -25,6 +25,8 @@
/* **************** Script ******************** */
namespace blender::nodes::node_shader_script_cc {
static void init(bNodeTree *UNUSED(ntree), bNode *node)
{
NodeShaderScript *nss = (NodeShaderScript *)MEM_callocN(sizeof(NodeShaderScript),
@ -59,13 +61,18 @@ static void node_copy_script(bNodeTree *UNUSED(dest_ntree),
dest_node->storage = dest_nss;
}
} // namespace blender::nodes::node_shader_script_cc
void register_node_type_sh_script()
{
namespace file_ns = blender::nodes::node_shader_script_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_SCRIPT, "Script", NODE_CLASS_SCRIPT, 0);
node_type_init(&ntype, init);
node_type_storage(&ntype, "NodeShaderScript", node_free_script, node_copy_script);
node_type_init(&ntype, file_ns::init);
node_type_storage(
&ntype, "NodeShaderScript", file_ns::node_free_script, file_ns::node_copy_script);
nodeRegisterType(&ntype);
}

44
source/blender/nodes/shader/nodes/node_shader_sepcombHSV.cc
View File

@ -24,6 +24,9 @@
#include "node_shader_util.hh"
/* **************** SEPARATE HSV ******************** */
namespace blender::nodes::node_shader_sepcombHSV_cc {
static bNodeSocketTemplate sh_node_sephsv_in[] = {
{SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f},
{-1, ""},
@ -57,19 +60,8 @@ static int gpu_shader_sephsv(GPUMaterial *mat,
return GPU_stack_link(mat, node, "separate_hsv", in, out);
}
void register_node_type_sh_sephsv()
{
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_SEPHSV, "Separate HSV", NODE_CLASS_CONVERTER, 0);
node_type_socket_templates(&ntype, sh_node_sephsv_in, sh_node_sephsv_out);
node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_sephsv);
node_type_gpu(&ntype, gpu_shader_sephsv);
nodeRegisterType(&ntype);
}
/* **************** COMBINE HSV ******************** */
static bNodeSocketTemplate sh_node_combhsv_in[] = {
{SOCK_FLOAT, N_("H"), 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_UNSIGNED},
{SOCK_FLOAT, N_("S"), 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_UNSIGNED},
@ -105,14 +97,32 @@ static int gpu_shader_combhsv(GPUMaterial *mat,
return GPU_stack_link(mat, node, "combine_hsv", in, out);
}
void register_node_type_sh_combhsv()
} // namespace blender::nodes::node_shader_sepcombHSV_cc
void register_node_type_sh_sephsv()
{
namespace file_ns = blender::nodes::node_shader_sepcombHSV_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_COMBHSV, "Combine HSV", NODE_CLASS_CONVERTER, 0);
node_type_socket_templates(&ntype, sh_node_combhsv_in, sh_node_combhsv_out);
node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_combhsv);
node_type_gpu(&ntype, gpu_shader_combhsv);
sh_node_type_base(&ntype, SH_NODE_SEPHSV, "Separate HSV", NODE_CLASS_CONVERTER, 0);
node_type_socket_templates(&ntype, file_ns::sh_node_sephsv_in, file_ns::sh_node_sephsv_out);
node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_sephsv);
node_type_gpu(&ntype, file_ns::gpu_shader_sephsv);
nodeRegisterType(&ntype);
}
void register_node_type_sh_combhsv()
{
namespace file_ns = blender::nodes::node_shader_sepcombHSV_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_COMBHSV, "Combine HSV", NODE_CLASS_CONVERTER, 0);
node_type_socket_templates(&ntype, file_ns::sh_node_combhsv_in, file_ns::sh_node_combhsv_out);
node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_combhsv);
node_type_gpu(&ntype, file_ns::gpu_shader_combhsv);
nodeRegisterType(&ntype);
}

52
source/blender/nodes/shader/nodes/node_shader_sepcombRGB.cc
View File

@ -23,7 +23,7 @@
#include "node_shader_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_shader_sepcombRGB_cc {
static void sh_node_seprgb_declare(NodeDeclarationBuilder &b)
{
@ -34,8 +34,6 @@ static void sh_node_seprgb_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Float>(N_("B"));
};
} // namespace blender::nodes
static void node_shader_exec_seprgb(void *UNUSED(data),
int UNUSED(thread),
bNode *UNUSED(node),
@ -103,21 +101,6 @@ static void sh_node_seprgb_build_multi_function(blender::nodes::NodeMultiFunctio
builder.set_matching_fn(fn);
}
void register_node_type_sh_seprgb()
{
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_SEPRGB, "Separate RGB", NODE_CLASS_CONVERTER, 0);
ntype.declare = blender::nodes::sh_node_seprgb_declare;
node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_seprgb);
node_type_gpu(&ntype, gpu_shader_seprgb);
ntype.build_multi_function = sh_node_seprgb_build_multi_function;
nodeRegisterType(&ntype);
}
namespace blender::nodes {
static void sh_node_combrgb_declare(NodeDeclarationBuilder &b)
{
b.is_function_node();
@ -127,8 +110,6 @@ static void sh_node_combrgb_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Color>(N_("Image"));
};
} // namespace blender::nodes
static void node_shader_exec_combrgb(void *UNUSED(data),
int UNUSED(thread),
bNode *UNUSED(node),
@ -163,15 +144,34 @@ static void sh_node_combrgb_build_multi_function(blender::nodes::NodeMultiFuncti
builder.set_matching_fn(fn);
}
void register_node_type_sh_combrgb()
} // namespace blender::nodes::node_shader_sepcombRGB_cc
void register_node_type_sh_seprgb()
{
namespace file_ns = blender::nodes::node_shader_sepcombRGB_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_COMBRGB, "Combine RGB", NODE_CLASS_CONVERTER, 0);
ntype.declare = blender::nodes::sh_node_combrgb_declare;
node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_combrgb);
node_type_gpu(&ntype, gpu_shader_combrgb);
ntype.build_multi_function = sh_node_combrgb_build_multi_function;
sh_fn_node_type_base(&ntype, SH_NODE_SEPRGB, "Separate RGB", NODE_CLASS_CONVERTER, 0);
ntype.declare = file_ns::sh_node_seprgb_declare;
node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_seprgb);
node_type_gpu(&ntype, file_ns::gpu_shader_seprgb);
ntype.build_multi_function = file_ns::sh_node_seprgb_build_multi_function;
nodeRegisterType(&ntype);
}
void register_node_type_sh_combrgb()
{
namespace file_ns = blender::nodes::node_shader_sepcombRGB_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_COMBRGB, "Combine RGB", NODE_CLASS_CONVERTER, 0);
ntype.declare = file_ns::sh_node_combrgb_declare;
node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_combrgb);
node_type_gpu(&ntype, file_ns::gpu_shader_combrgb);
ntype.build_multi_function = file_ns::sh_node_combrgb_build_multi_function;
nodeRegisterType(&ntype);
}

48
source/blender/nodes/shader/nodes/node_shader_sepcombXYZ.cc
View File

@ -23,7 +23,7 @@
#include "node_shader_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_shader_sepcombXYZ_cc {
static void sh_node_sepxyz_declare(NodeDeclarationBuilder &b)
{
@ -34,8 +34,6 @@ static void sh_node_sepxyz_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Float>(N_("Z"));
};
} // namespace blender::nodes
static int gpu_shader_sepxyz(GPUMaterial *mat,
bNode *node,
bNodeExecData *UNUSED(execdata),
@ -88,20 +86,6 @@ static void sh_node_sepxyz_build_multi_function(blender::nodes::NodeMultiFunctio
builder.set_matching_fn(separate_fn);
}
void register_node_type_sh_sepxyz()
{
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_SEPXYZ, "Separate XYZ", NODE_CLASS_CONVERTER, 0);
ntype.declare = blender::nodes::sh_node_sepxyz_declare;
node_type_gpu(&ntype, gpu_shader_sepxyz);
ntype.build_multi_function = sh_node_sepxyz_build_multi_function;
nodeRegisterType(&ntype);
}
namespace blender::nodes {
static void sh_node_combxyz_declare(NodeDeclarationBuilder &b)
{
b.is_function_node();
@ -111,8 +95,6 @@ static void sh_node_combxyz_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Vector>(N_("Vector"));
};
} // namespace blender::nodes
static int gpu_shader_combxyz(GPUMaterial *mat,
bNode *node,
bNodeExecData *UNUSED(execdata),
@ -129,14 +111,32 @@ static void sh_node_combxyz_build_multi_function(blender::nodes::NodeMultiFuncti
builder.set_matching_fn(fn);
}
void register_node_type_sh_combxyz()
} // namespace blender::nodes::node_shader_sepcombXYZ_cc
void register_node_type_sh_sepxyz()
{
namespace file_ns = blender::nodes::node_shader_sepcombXYZ_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_COMBXYZ, "Combine XYZ", NODE_CLASS_CONVERTER, 0);
ntype.declare = blender::nodes::sh_node_combxyz_declare;
node_type_gpu(&ntype, gpu_shader_combxyz);
ntype.build_multi_function = sh_node_combxyz_build_multi_function;
sh_fn_node_type_base(&ntype, SH_NODE_SEPXYZ, "Separate XYZ", NODE_CLASS_CONVERTER, 0);
ntype.declare = file_ns::sh_node_sepxyz_declare;
node_type_gpu(&ntype, file_ns::gpu_shader_sepxyz);
ntype.build_multi_function = file_ns::sh_node_sepxyz_build_multi_function;
nodeRegisterType(&ntype);
}
void register_node_type_sh_combxyz()
{
namespace file_ns = blender::nodes::node_shader_sepcombXYZ_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_COMBXYZ, "Combine XYZ", NODE_CLASS_CONVERTER, 0);
ntype.declare = file_ns::sh_node_combxyz_declare;
node_type_gpu(&ntype, file_ns::gpu_shader_combxyz);
ntype.build_multi_function = file_ns::sh_node_combxyz_build_multi_function;
nodeRegisterType(&ntype);
}

11
source/blender/nodes/shader/nodes/node_shader_shaderToRgb.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_shaderToRgb_cc {
static bNodeSocketTemplate sh_node_shadertorgb_in[] = {
{SOCK_SHADER, N_("Shader")},
{-1, ""},
@ -45,16 +47,21 @@ static int node_shader_gpu_shadertorgb(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_shader_to_rgba", in, out);
}
} // namespace blender::nodes::node_shader_shaderToRgb_cc
/* node type definition */
void register_node_type_sh_shadertorgb()
{
namespace file_ns = blender::nodes::node_shader_shaderToRgb_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_SHADERTORGB, "Shader to RGB", NODE_CLASS_CONVERTER, 0);
node_type_socket_templates(&ntype, sh_node_shadertorgb_in, sh_node_shadertorgb_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_shadertorgb_in, file_ns::sh_node_shadertorgb_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_shadertorgb);
node_type_gpu(&ntype, file_ns::node_shader_gpu_shadertorgb);
nodeRegisterType(&ntype);
}

13
source/blender/nodes/shader/nodes/node_shader_squeeze.cc
View File

@ -24,6 +24,9 @@
#include "node_shader_util.hh"
/* **************** VALUE SQUEEZE ******************** */
namespace blender::nodes::node_shader_squeeze_cc {
static bNodeSocketTemplate sh_node_squeeze_in[] = {
{SOCK_FLOAT, N_("Value"), 0.0f, 0.0f, 0.0f, 0.0f, -100.0f, 100.0f, PROP_NONE},
{SOCK_FLOAT, N_("Width"), 1.0f, 0.0f, 0.0f, 0.0f, -100.0f, 100.0f, PROP_NONE},
@ -57,15 +60,19 @@ static int gpu_shader_squeeze(GPUMaterial *mat,
return GPU_stack_link(mat, node, "squeeze", in, out);
}
} // namespace blender::nodes::node_shader_squeeze_cc
void register_node_type_sh_squeeze()
{
namespace file_ns = blender::nodes::node_shader_squeeze_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_SQUEEZE, "Squeeze Value", NODE_CLASS_CONVERTER, 0);
node_type_socket_templates(&ntype, sh_node_squeeze_in, sh_node_squeeze_out);
node_type_socket_templates(&ntype, file_ns::sh_node_squeeze_in, file_ns::sh_node_squeeze_out);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_squeeze);
node_type_gpu(&ntype, gpu_shader_squeeze);
node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_squeeze);
node_type_gpu(&ntype, file_ns::gpu_shader_squeeze);
nodeRegisterType(&ntype);
}

17
source/blender/nodes/shader/nodes/node_shader_subsurface_scattering.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_subsurface_scattering_cc {
static bNodeSocketTemplate sh_node_subsurface_scattering_in[] = {
{SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_FLOAT, N_("Scale"), 1.0, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
@ -78,20 +80,25 @@ static void node_shader_update_subsurface_scattering(bNodeTree *ntree, bNode *no
}
}
} // namespace blender::nodes::node_shader_subsurface_scattering_cc
/* node type definition */
void register_node_type_sh_subsurface_scattering()
{
namespace file_ns = blender::nodes::node_shader_subsurface_scattering_cc;
static bNodeType ntype;
sh_node_type_base(
&ntype, SH_NODE_SUBSURFACE_SCATTERING, "Subsurface Scattering", NODE_CLASS_SHADER, 0);
node_type_socket_templates(
&ntype, sh_node_subsurface_scattering_in, sh_node_subsurface_scattering_out);
node_type_socket_templates(&ntype,
file_ns::sh_node_subsurface_scattering_in,
file_ns::sh_node_subsurface_scattering_out);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_init(&ntype, node_shader_init_subsurface_scattering);
node_type_init(&ntype, file_ns::node_shader_init_subsurface_scattering);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_subsurface_scattering);
node_type_update(&ntype, node_shader_update_subsurface_scattering);
node_type_gpu(&ntype, file_ns::node_shader_gpu_subsurface_scattering);
node_type_update(&ntype, file_ns::node_shader_update_subsurface_scattering);
nodeRegisterType(&ntype);
}

12
source/blender/nodes/shader/nodes/node_shader_tangent.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_tangent_cc {
static bNodeSocketTemplate sh_node_tangent_out[] = {
{SOCK_VECTOR, N_("Tangent"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{-1, ""},
@ -69,16 +71,20 @@ static int node_shader_gpu_tangent(GPUMaterial *mat,
GPU_builtin(GPU_OBJECT_MATRIX));
}
} // namespace blender::nodes::node_shader_tangent_cc
/* node type definition */
void register_node_type_sh_tangent()
{
namespace file_ns = blender::nodes::node_shader_tangent_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_TANGENT, "Tangent", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, nullptr, sh_node_tangent_out);
node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_tangent_out);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_init(&ntype, node_shader_init_tangent);
node_type_gpu(&ntype, node_shader_gpu_tangent);
node_type_init(&ntype, file_ns::node_shader_init_tangent);
node_type_gpu(&ntype, file_ns::node_shader_gpu_tangent);
node_type_storage(
&ntype, "NodeShaderTangent", node_free_standard_storage, node_copy_standard_storage);

18
source/blender/nodes/shader/nodes/node_shader_tex_brick.cc
View File

@ -22,7 +22,7 @@
#include "BLI_float2.hh"
#include "BLI_float4.hh"
namespace blender::nodes {
namespace blender::nodes::node_shader_tex_brick_cc {
static void sh_node_tex_brick_declare(NodeDeclarationBuilder &b)
{
@ -57,8 +57,6 @@ static void sh_node_tex_brick_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Float>(N_("Fac"));
};
} // namespace blender::nodes
static void node_shader_init_tex_brick(bNodeTree *UNUSED(ntree), bNode *node)
{
NodeTexBrick *tex = (NodeTexBrick *)MEM_callocN(sizeof(NodeTexBrick), "NodeTexBrick");
@ -101,8 +99,6 @@ static int node_shader_gpu_tex_brick(GPUMaterial *mat,
GPU_constant(&squash_freq));
}
namespace blender::nodes {
class BrickFunction : public fn::MultiFunction {
private:
const float offset_;
@ -266,20 +262,22 @@ static void sh_node_brick_build_multi_function(blender::nodes::NodeMultiFunction
tex->offset, tex->offset_freq, tex->squash, tex->squash_freq);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_shader_tex_brick_cc
void register_node_type_sh_tex_brick()
{
namespace file_ns = blender::nodes::node_shader_tex_brick_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_TEX_BRICK, "Brick Texture", NODE_CLASS_TEXTURE, 0);
ntype.declare = blender::nodes::sh_node_tex_brick_declare;
ntype.declare = file_ns::sh_node_tex_brick_declare;
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_init(&ntype, node_shader_init_tex_brick);
node_type_init(&ntype, file_ns::node_shader_init_tex_brick);
node_type_storage(
&ntype, "NodeTexBrick", node_free_standard_storage, node_copy_standard_storage);
node_type_gpu(&ntype, node_shader_gpu_tex_brick);
ntype.build_multi_function = blender::nodes::sh_node_brick_build_multi_function;
node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_brick);
ntype.build_multi_function = file_ns::sh_node_brick_build_multi_function;
nodeRegisterType(&ntype);
}

18
source/blender/nodes/shader/nodes/node_shader_tex_checker.cc
View File

@ -19,7 +19,7 @@
#include "node_shader_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_shader_tex_checker_cc {
static void sh_node_tex_checker_declare(NodeDeclarationBuilder &b)
{
@ -36,8 +36,6 @@ static void sh_node_tex_checker_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Float>(N_("Fac"));
};
} // namespace blender::nodes
static void node_shader_init_tex_checker(bNodeTree *UNUSED(ntree), bNode *node)
{
NodeTexChecker *tex = (NodeTexChecker *)MEM_callocN(sizeof(NodeTexChecker), "NodeTexChecker");
@ -59,8 +57,6 @@ static int node_shader_gpu_tex_checker(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_tex_checker", in, out);
}
namespace blender::nodes {
class NodeTexChecker : public fn::MultiFunction {
public:
NodeTexChecker()
@ -121,19 +117,21 @@ static void sh_node_tex_checker_build_multi_function(
builder.set_matching_fn(fn);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_shader_tex_checker_cc
void register_node_type_sh_tex_checker()
{
namespace file_ns = blender::nodes::node_shader_tex_checker_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_TEX_CHECKER, "Checker Texture", NODE_CLASS_TEXTURE, 0);
ntype.declare = blender::nodes::sh_node_tex_checker_declare;
node_type_init(&ntype, node_shader_init_tex_checker);
ntype.declare = file_ns::sh_node_tex_checker_declare;
node_type_init(&ntype, file_ns::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);
ntype.build_multi_function = blender::nodes::sh_node_tex_checker_build_multi_function;
node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_checker);
ntype.build_multi_function = file_ns::sh_node_tex_checker_build_multi_function;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/shader/nodes/node_shader_tex_coord.cc
View File

@ -23,6 +23,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_tex_coord_cc {
static bNodeSocketTemplate sh_node_tex_coord_out[] = {
{SOCK_VECTOR, N_("Generated"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@ -83,16 +85,20 @@ static int node_shader_gpu_tex_coord(GPUMaterial *mat,
return 1;
}
} // namespace blender::nodes::node_shader_tex_coord_cc
/* node type definition */
void register_node_type_sh_tex_coord()
{
namespace file_ns = blender::nodes::node_shader_tex_coord_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_TEX_COORD, "Texture Coordinate", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, nullptr, sh_node_tex_coord_out);
node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_tex_coord_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_tex_coord);
node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_coord);
nodeRegisterType(&ntype);
}

13
source/blender/nodes/shader/nodes/node_shader_tex_environment.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_tex_environment_cc {
static bNodeSocketTemplate sh_node_tex_environment_in[] = {
{SOCK_VECTOR, N_("Vector"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
{-1, ""},
@ -133,17 +135,22 @@ static int node_shader_gpu_tex_environment(GPUMaterial *mat,
return true;
}
} // namespace blender::nodes::node_shader_tex_environment_cc
/* node type definition */
void register_node_type_sh_tex_environment()
{
namespace file_ns = blender::nodes::node_shader_tex_environment_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_TEX_ENVIRONMENT, "Environment Texture", NODE_CLASS_TEXTURE, 0);
node_type_socket_templates(&ntype, sh_node_tex_environment_in, sh_node_tex_environment_out);
node_type_init(&ntype, node_shader_init_tex_environment);
node_type_socket_templates(
&ntype, file_ns::sh_node_tex_environment_in, file_ns::sh_node_tex_environment_out);
node_type_init(&ntype, file_ns::node_shader_init_tex_environment);
node_type_storage(
&ntype, "NodeTexEnvironment", node_free_standard_storage, node_copy_standard_storage);
node_type_gpu(&ntype, node_shader_gpu_tex_environment);
node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_environment);
node_type_label(&ntype, node_image_label);
node_type_size_preset(&ntype, NODE_SIZE_LARGE);

18
source/blender/nodes/shader/nodes/node_shader_tex_gradient.cc
View File

@ -19,7 +19,7 @@
#include "node_shader_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_shader_tex_gradient_cc {
static void sh_node_tex_gradient_declare(NodeDeclarationBuilder &b)
{
@ -29,8 +29,6 @@ static void sh_node_tex_gradient_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Float>(N_("Fac")).no_muted_links();
};
} // namespace blender::nodes
static void node_shader_init_tex_gradient(bNodeTree *UNUSED(ntree), bNode *node)
{
NodeTexGradient *tex = (NodeTexGradient *)MEM_callocN(sizeof(NodeTexGradient),
@ -56,8 +54,6 @@ static int node_shader_gpu_tex_gradient(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_tex_gradient", in, out, GPU_constant(&gradient_type));
}
namespace blender::nodes {
class GradientFunction : public fn::MultiFunction {
private:
int gradient_type_;
@ -158,19 +154,21 @@ static void sh_node_gradient_tex_build_multi_function(
builder.construct_and_set_matching_fn<GradientFunction>(tex->gradient_type);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_shader_tex_gradient_cc
void register_node_type_sh_tex_gradient()
{
namespace file_ns = blender::nodes::node_shader_tex_gradient_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_TEX_GRADIENT, "Gradient Texture", NODE_CLASS_TEXTURE, 0);
ntype.declare = blender::nodes::sh_node_tex_gradient_declare;
node_type_init(&ntype, node_shader_init_tex_gradient);
ntype.declare = file_ns::sh_node_tex_gradient_declare;
node_type_init(&ntype, file_ns::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);
ntype.build_multi_function = blender::nodes::sh_node_gradient_tex_build_multi_function;
node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_gradient);
ntype.build_multi_function = file_ns::sh_node_gradient_tex_build_multi_function;
nodeRegisterType(&ntype);
}

14
source/blender/nodes/shader/nodes/node_shader_tex_image.cc
View File

@ -19,7 +19,7 @@
#include "node_shader_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_shader_tex_image_cc {
static void sh_node_tex_image_declare(NodeDeclarationBuilder &b)
{
@ -29,8 +29,6 @@ static void sh_node_tex_image_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Float>(N_("Alpha")).no_muted_links();
};
}; // namespace blender::nodes
static void node_shader_init_tex_image(bNodeTree *UNUSED(ntree), bNode *node)
{
NodeTexImage *tex = (NodeTexImage *)MEM_callocN(sizeof(NodeTexImage), "NodeTexImage");
@ -173,17 +171,21 @@ static int node_shader_gpu_tex_image(GPUMaterial *mat,
return true;
}
} // namespace blender::nodes::node_shader_tex_image_cc
/* node type definition */
void register_node_type_sh_tex_image()
{
namespace file_ns = blender::nodes::node_shader_tex_image_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_TEX_IMAGE, "Image Texture", NODE_CLASS_TEXTURE, 0);
ntype.declare = blender::nodes::sh_node_tex_image_declare;
node_type_init(&ntype, node_shader_init_tex_image);
ntype.declare = file_ns::sh_node_tex_image_declare;
node_type_init(&ntype, file_ns::node_shader_init_tex_image);
node_type_storage(
&ntype, "NodeTexImage", node_free_standard_storage, node_copy_standard_storage);
node_type_gpu(&ntype, node_shader_gpu_tex_image);
node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_image);
node_type_label(&ntype, node_image_label);
node_type_size_preset(&ntype, NODE_SIZE_LARGE);

18
source/blender/nodes/shader/nodes/node_shader_tex_magic.cc
View File

@ -19,7 +19,7 @@
#include "node_shader_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_shader_tex_magic_cc {
static void sh_node_tex_magic_declare(NodeDeclarationBuilder &b)
{
@ -31,8 +31,6 @@ static void sh_node_tex_magic_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Float>(N_("Fac")).no_muted_links();
};
} // namespace blender::nodes
static void node_shader_init_tex_magic(bNodeTree *UNUSED(ntree), bNode *node)
{
NodeTexMagic *tex = (NodeTexMagic *)MEM_callocN(sizeof(NodeTexMagic), "NodeTexMagic");
@ -58,8 +56,6 @@ static int node_shader_gpu_tex_magic(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_tex_magic", in, out, GPU_constant(&depth));
}
namespace blender::nodes {
class MagicFunction : public fn::MultiFunction {
private:
int depth_;
@ -179,19 +175,21 @@ static void sh_node_magic_tex_build_multi_function(
builder.construct_and_set_matching_fn<MagicFunction>(tex->depth);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_shader_tex_magic_cc
void register_node_type_sh_tex_magic()
{
namespace file_ns = blender::nodes::node_shader_tex_magic_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_TEX_MAGIC, "Magic Texture", NODE_CLASS_TEXTURE, 0);
ntype.declare = blender::nodes::sh_node_tex_magic_declare;
node_type_init(&ntype, node_shader_init_tex_magic);
ntype.declare = file_ns::sh_node_tex_magic_declare;
node_type_init(&ntype, file_ns::node_shader_init_tex_magic);
node_type_storage(
&ntype, "NodeTexMagic", node_free_standard_storage, node_copy_standard_storage);
node_type_gpu(&ntype, node_shader_gpu_tex_magic);
ntype.build_multi_function = blender::nodes::sh_node_magic_tex_build_multi_function;
node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_magic);
ntype.build_multi_function = file_ns::sh_node_magic_tex_build_multi_function;
nodeRegisterType(&ntype);
}

20
source/blender/nodes/shader/nodes/node_shader_tex_musgrave.cc
View File

@ -21,7 +21,7 @@
#include "BLI_noise.hh"
namespace blender::nodes {
namespace blender::nodes::node_shader_tex_musgrave_cc {
static void sh_node_tex_musgrave_declare(NodeDeclarationBuilder &b)
{
@ -37,8 +37,6 @@ static void sh_node_tex_musgrave_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Float>(N_("Fac")).no_muted_links();
};
} // namespace blender::nodes
static void node_shader_init_tex_musgrave(bNodeTree *UNUSED(ntree), bNode *node)
{
NodeTexMusgrave *tex = (NodeTexMusgrave *)MEM_callocN(sizeof(NodeTexMusgrave),
@ -128,8 +126,6 @@ static void node_shader_update_tex_musgrave(bNodeTree *ntree, bNode *node)
node_sock_label(outFacSock, "Height");
}
namespace blender::nodes {
class MusgraveFunction : public fn::MultiFunction {
private:
const int dimensions_;
@ -529,21 +525,23 @@ static void sh_node_musgrave_build_multi_function(
builder.construct_and_set_matching_fn<MusgraveFunction>(tex->dimensions, tex->musgrave_type);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_shader_tex_musgrave_cc
void register_node_type_sh_tex_musgrave()
{
namespace file_ns = blender::nodes::node_shader_tex_musgrave_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_TEX_MUSGRAVE, "Musgrave Texture", NODE_CLASS_TEXTURE, 0);
ntype.declare = blender::nodes::sh_node_tex_musgrave_declare;
ntype.declare = file_ns::sh_node_tex_musgrave_declare;
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_init(&ntype, node_shader_init_tex_musgrave);
node_type_init(&ntype, file_ns::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);
node_type_update(&ntype, node_shader_update_tex_musgrave);
ntype.build_multi_function = blender::nodes::sh_node_musgrave_build_multi_function;
node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_musgrave);
node_type_update(&ntype, file_ns::node_shader_update_tex_musgrave);
ntype.build_multi_function = file_ns::sh_node_musgrave_build_multi_function;
nodeRegisterType(&ntype);
}

20
source/blender/nodes/shader/nodes/node_shader_tex_noise.cc
View File

@ -21,7 +21,7 @@
#include "BLI_noise.hh"
namespace blender::nodes {
namespace blender::nodes::node_shader_tex_noise_cc {
static void sh_node_tex_noise_declare(NodeDeclarationBuilder &b)
{
@ -40,8 +40,6 @@ static void sh_node_tex_noise_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Color>(N_("Color")).no_muted_links();
};
} // namespace blender::nodes
static void node_shader_init_tex_noise(bNodeTree *UNUSED(ntree), bNode *node)
{
NodeTexNoise *tex = (NodeTexNoise *)MEM_callocN(sizeof(NodeTexNoise), "NodeTexNoise");
@ -86,8 +84,6 @@ static void node_shader_update_tex_noise(bNodeTree *ntree, bNode *node)
nodeSetSocketAvailability(ntree, sockW, tex->dimensions == 1 || tex->dimensions == 4);
}
namespace blender::nodes {
class NoiseFunction : public fn::MultiFunction {
private:
int dimensions_;
@ -246,21 +242,23 @@ static void sh_node_noise_build_multi_function(blender::nodes::NodeMultiFunction
builder.construct_and_set_matching_fn<NoiseFunction>(tex->dimensions);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_shader_tex_noise_cc
/* node type definition */
void register_node_type_sh_tex_noise()
{
namespace file_ns = blender::nodes::node_shader_tex_noise_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_TEX_NOISE, "Noise Texture", NODE_CLASS_TEXTURE, 0);
ntype.declare = blender::nodes::sh_node_tex_noise_declare;
node_type_init(&ntype, node_shader_init_tex_noise);
ntype.declare = file_ns::sh_node_tex_noise_declare;
node_type_init(&ntype, file_ns::node_shader_init_tex_noise);
node_type_storage(
&ntype, "NodeTexNoise", node_free_standard_storage, node_copy_standard_storage);
node_type_gpu(&ntype, node_shader_gpu_tex_noise);
node_type_update(&ntype, node_shader_update_tex_noise);
ntype.build_multi_function = blender::nodes::sh_node_noise_build_multi_function;
node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_noise);
node_type_update(&ntype, file_ns::node_shader_update_tex_noise);
ntype.build_multi_function = file_ns::sh_node_noise_build_multi_function;
nodeRegisterType(&ntype);
}

15
source/blender/nodes/shader/nodes/node_shader_tex_pointdensity.cc
View File

@ -23,6 +23,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_tex_pointdensity_cc {
static bNodeSocketTemplate sh_node_tex_pointdensity_in[] = {
{SOCK_VECTOR, N_("Vector"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
{-1, ""},
@ -65,18 +67,23 @@ static void node_shader_copy_tex_pointdensity(bNodeTree *UNUSED(dest_ntree),
memset(pd, 0, sizeof(*pd));
}
} // namespace blender::nodes::node_shader_tex_pointdensity_cc
/* node type definition */
void register_node_type_sh_tex_pointdensity()
{
namespace file_ns = blender::nodes::node_shader_tex_pointdensity_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_TEX_POINTDENSITY, "Point Density", NODE_CLASS_TEXTURE, 0);
node_type_socket_templates(&ntype, sh_node_tex_pointdensity_in, sh_node_tex_pointdensity_out);
node_type_init(&ntype, node_shader_init_tex_pointdensity);
node_type_socket_templates(
&ntype, file_ns::sh_node_tex_pointdensity_in, file_ns::sh_node_tex_pointdensity_out);
node_type_init(&ntype, file_ns::node_shader_init_tex_pointdensity);
node_type_storage(&ntype,
"NodeShaderTexPointDensity",
node_shader_free_tex_pointdensity,
node_shader_copy_tex_pointdensity);
file_ns::node_shader_free_tex_pointdensity,
file_ns::node_shader_copy_tex_pointdensity);
nodeRegisterType(&ntype);
}

14
source/blender/nodes/shader/nodes/node_shader_tex_sky.cc
View File

@ -22,6 +22,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_tex_sky_cc {
static bNodeSocketTemplate sh_node_tex_sky_in[] = {
{SOCK_VECTOR, N_("Vector"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
{-1, ""},
@ -203,19 +205,23 @@ static void node_shader_update_sky(bNodeTree *ntree, bNode *node)
nodeSetSocketAvailability(ntree, sockVector, !(tex->sky_model == 2 && tex->sun_disc == 1));
}
} // namespace blender::nodes::node_shader_tex_sky_cc
/* node type definition */
void register_node_type_sh_tex_sky()
{
namespace file_ns = blender::nodes::node_shader_tex_sky_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_TEX_SKY, "Sky Texture", NODE_CLASS_TEXTURE, 0);
node_type_socket_templates(&ntype, sh_node_tex_sky_in, sh_node_tex_sky_out);
node_type_socket_templates(&ntype, file_ns::sh_node_tex_sky_in, file_ns::sh_node_tex_sky_out);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_init(&ntype, node_shader_init_tex_sky);
node_type_init(&ntype, file_ns::node_shader_init_tex_sky);
node_type_storage(&ntype, "NodeTexSky", node_free_standard_storage, node_copy_standard_storage);
node_type_gpu(&ntype, node_shader_gpu_tex_sky);
node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_sky);
/* remove Vector input for Nishita */
node_type_update(&ntype, node_shader_update_sky);
node_type_update(&ntype, file_ns::node_shader_update_sky);
nodeRegisterType(&ntype);
}

20
source/blender/nodes/shader/nodes/node_shader_tex_voronoi.cc
View File

@ -21,7 +21,7 @@
#include "BLI_noise.hh"
namespace blender::nodes {
namespace blender::nodes::node_shader_tex_voronoi_cc {
static void sh_node_tex_voronoi_declare(NodeDeclarationBuilder &b)
{
@ -47,8 +47,6 @@ static void sh_node_tex_voronoi_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Float>(N_("Radius")).no_muted_links();
};
} // namespace blender::nodes
static void node_shader_init_tex_voronoi(bNodeTree *UNUSED(ntree), bNode *node)
{
NodeTexVoronoi *tex = (NodeTexVoronoi *)MEM_callocN(sizeof(NodeTexVoronoi), "NodeTexVoronoi");
@ -165,8 +163,6 @@ static void node_shader_update_tex_voronoi(bNodeTree *ntree, bNode *node)
nodeSetSocketAvailability(ntree, outRadiusSock, tex->feature == SHD_VORONOI_N_SPHERE_RADIUS);
}
namespace blender::nodes {
static MultiFunction::ExecutionHints voronoi_execution_hints{50, false};
class VoronoiMinowskiFunction : public fn::MultiFunction {
@ -1321,20 +1317,22 @@ static void sh_node_voronoi_build_multi_function(blender::nodes::NodeMultiFuncti
}
}
} // namespace blender::nodes
} // namespace blender::nodes::node_shader_tex_voronoi_cc
void register_node_type_sh_tex_voronoi()
{
namespace file_ns = blender::nodes::node_shader_tex_voronoi_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_TEX_VORONOI, "Voronoi Texture", NODE_CLASS_TEXTURE, 0);
ntype.declare = blender::nodes::sh_node_tex_voronoi_declare;
node_type_init(&ntype, node_shader_init_tex_voronoi);
ntype.declare = file_ns::sh_node_tex_voronoi_declare;
node_type_init(&ntype, file_ns::node_shader_init_tex_voronoi);
node_type_storage(
&ntype, "NodeTexVoronoi", node_free_standard_storage, node_copy_standard_storage);
node_type_gpu(&ntype, node_shader_gpu_tex_voronoi);
node_type_update(&ntype, node_shader_update_tex_voronoi);
ntype.build_multi_function = blender::nodes::sh_node_voronoi_build_multi_function;
node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_voronoi);
node_type_update(&ntype, file_ns::node_shader_update_tex_voronoi);
ntype.build_multi_function = file_ns::sh_node_voronoi_build_multi_function;
nodeRegisterType(&ntype);
}

18
source/blender/nodes/shader/nodes/node_shader_tex_wave.cc
View File

@ -21,7 +21,7 @@
#include "BLI_noise.hh"
namespace blender::nodes {
namespace blender::nodes::node_shader_tex_wave_cc {
static void sh_node_tex_wave_declare(NodeDeclarationBuilder &b)
{
@ -41,8 +41,6 @@ static void sh_node_tex_wave_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Float>(N_("Fac")).no_muted_links();
};
} // namespace blender::nodes
static void node_shader_init_tex_wave(bNodeTree *UNUSED(ntree), bNode *node)
{
NodeTexWave *tex = (NodeTexWave *)MEM_callocN(sizeof(NodeTexWave), "NodeTexWave");
@ -81,8 +79,6 @@ static int node_shader_gpu_tex_wave(GPUMaterial *mat,
GPU_constant(&wave_profile));
}
namespace blender::nodes {
class WaveFunction : public fn::MultiFunction {
private:
int wave_type_;
@ -216,19 +212,21 @@ static void sh_node_wave_tex_build_multi_function(
tex->wave_type, tex->bands_direction, tex->rings_direction, tex->wave_profile);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_shader_tex_wave_cc
void register_node_type_sh_tex_wave()
{
namespace file_ns = blender::nodes::node_shader_tex_wave_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_TEX_WAVE, "Wave Texture", NODE_CLASS_TEXTURE, 0);
ntype.declare = blender::nodes::sh_node_tex_wave_declare;
ntype.declare = file_ns::sh_node_tex_wave_declare;
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_init(&ntype, node_shader_init_tex_wave);
node_type_init(&ntype, file_ns::node_shader_init_tex_wave);
node_type_storage(&ntype, "NodeTexWave", node_free_standard_storage, node_copy_standard_storage);
node_type_gpu(&ntype, node_shader_gpu_tex_wave);
ntype.build_multi_function = blender::nodes::sh_node_wave_tex_build_multi_function;
node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_wave);
ntype.build_multi_function = file_ns::sh_node_wave_tex_build_multi_function;
nodeRegisterType(&ntype);
}

20
source/blender/nodes/shader/nodes/node_shader_tex_white_noise.cc
View File

@ -21,7 +21,7 @@
#include "BLI_noise.hh"
namespace blender::nodes {
namespace blender::nodes::node_shader_tex_white_noise_cc {
static void sh_node_tex_white_noise_declare(NodeDeclarationBuilder &b)
{
@ -32,8 +32,6 @@ static void sh_node_tex_white_noise_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Color>(N_("Color"));
};
} // namespace blender::nodes
static void node_shader_init_tex_white_noise(bNodeTree *UNUSED(ntree), bNode *node)
{
node->custom1 = 3;
@ -67,8 +65,6 @@ static void node_shader_update_tex_white_noise(bNodeTree *ntree, bNode *node)
nodeSetSocketAvailability(ntree, sockW, node->custom1 == 1 || node->custom1 == 4);
}
namespace blender::nodes {
class WhiteNoiseFunction : public fn::MultiFunction {
private:
int dimensions_;
@ -189,19 +185,21 @@ static void sh_node_noise_build_multi_function(blender::nodes::NodeMultiFunction
builder.construct_and_set_matching_fn<WhiteNoiseFunction>((int)node.custom1);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_shader_tex_white_noise_cc
void register_node_type_sh_tex_white_noise()
{
namespace file_ns = blender::nodes::node_shader_tex_white_noise_cc;
static bNodeType ntype;
sh_fn_node_type_base(
&ntype, SH_NODE_TEX_WHITE_NOISE, "White Noise Texture", NODE_CLASS_TEXTURE, 0);
ntype.declare = blender::nodes::sh_node_tex_white_noise_declare;
node_type_init(&ntype, node_shader_init_tex_white_noise);
node_type_gpu(&ntype, gpu_shader_tex_white_noise);
node_type_update(&ntype, node_shader_update_tex_white_noise);
ntype.build_multi_function = blender::nodes::sh_node_noise_build_multi_function;
ntype.declare = file_ns::sh_node_tex_white_noise_declare;
node_type_init(&ntype, file_ns::node_shader_init_tex_white_noise);
node_type_gpu(&ntype, file_ns::gpu_shader_tex_white_noise);
node_type_update(&ntype, file_ns::node_shader_update_tex_white_noise);
ntype.build_multi_function = file_ns::sh_node_noise_build_multi_function;
nodeRegisterType(&ntype);
}

8
source/blender/nodes/shader/nodes/node_shader_uvAlongStroke.cc
View File

@ -21,18 +21,24 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_uvAlongStroke_cc {
static bNodeSocketTemplate sh_node_uvalongstroke_out[] = {
{SOCK_VECTOR, N_("UV"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{-1, ""},
};
} // namespace blender::nodes::node_shader_uvAlongStroke_cc
/* node type definition */
void register_node_type_sh_uvalongstroke()
{
namespace file_ns = blender::nodes::node_shader_uvAlongStroke_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_UVALONGSTROKE, "UV Along Stroke", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, nullptr, sh_node_uvalongstroke_out);
node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_uvalongstroke_out);
node_type_init(&ntype, nullptr);
nodeRegisterType(&ntype);

12
source/blender/nodes/shader/nodes/node_shader_uvmap.cc
View File

@ -23,6 +23,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_uvmap_cc {
static bNodeSocketTemplate sh_node_uvmap_out[] = {
{SOCK_VECTOR, N_("UV"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{-1, ""},
@ -51,18 +53,22 @@ static int node_shader_gpu_uvmap(GPUMaterial *mat,
return 1;
}
} // namespace blender::nodes::node_shader_uvmap_cc
/* node type definition */
void register_node_type_sh_uvmap()
{
namespace file_ns = blender::nodes::node_shader_uvmap_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_UVMAP, "UV Map", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, nullptr, sh_node_uvmap_out);
node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_uvmap_out);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_init(&ntype, node_shader_init_uvmap);
node_type_init(&ntype, file_ns::node_shader_init_uvmap);
node_type_storage(
&ntype, "NodeShaderUVMap", node_free_standard_storage, node_copy_standard_storage);
node_type_gpu(&ntype, node_shader_gpu_uvmap);
node_type_gpu(&ntype, file_ns::node_shader_gpu_uvmap);
nodeRegisterType(&ntype);
}

56
source/blender/nodes/shader/nodes/node_shader_valToRgb.cc
View File

@ -29,7 +29,7 @@
#include "node_shader_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_shader_valToRgb_cc {
static void sh_node_valtorgb_declare(NodeDeclarationBuilder &b)
{
@ -39,8 +39,6 @@ static void sh_node_valtorgb_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Float>(N_("Alpha"));
};
} // namespace blender::nodes
static void node_shader_exec_valtorgb(void *UNUSED(data),
int UNUSED(thread),
bNode *node,
@ -172,32 +170,12 @@ static void sh_node_valtorgb_build_multi_function(
builder.construct_and_set_matching_fn<ColorBandFunction>(*color_band);
}
void register_node_type_sh_valtorgb()
{
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTER, 0);
ntype.declare = blender::nodes::sh_node_valtorgb_declare;
node_type_init(&ntype, node_shader_init_valtorgb);
node_type_size_preset(&ntype, NODE_SIZE_LARGE);
node_type_storage(&ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_valtorgb);
node_type_gpu(&ntype, gpu_shader_valtorgb);
ntype.build_multi_function = sh_node_valtorgb_build_multi_function;
nodeRegisterType(&ntype);
}
namespace blender::nodes {
static void sh_node_rgbtobw_declare(NodeDeclarationBuilder &b)
{
b.add_input<decl::Color>(N_("Color")).default_value({0.5f, 0.5f, 0.5f, 1.0f});
b.add_output<decl::Float>(N_("Val"));
};
} // namespace blender::nodes
static void node_shader_exec_rgbtobw(void *UNUSED(data),
int UNUSED(thread),
bNode *UNUSED(node),
@ -222,14 +200,36 @@ static int gpu_shader_rgbtobw(GPUMaterial *mat,
return GPU_stack_link(mat, node, "rgbtobw", in, out);
}
void register_node_type_sh_rgbtobw()
} // namespace blender::nodes::node_shader_valToRgb_cc
void register_node_type_sh_valtorgb()
{
namespace file_ns = blender::nodes::node_shader_valToRgb_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTER, 0);
ntype.declare = blender::nodes::sh_node_rgbtobw_declare;
node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_rgbtobw);
node_type_gpu(&ntype, gpu_shader_rgbtobw);
sh_fn_node_type_base(&ntype, SH_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTER, 0);
ntype.declare = file_ns::sh_node_valtorgb_declare;
node_type_init(&ntype, file_ns::node_shader_init_valtorgb);
node_type_size_preset(&ntype, NODE_SIZE_LARGE);
node_type_storage(&ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_valtorgb);
node_type_gpu(&ntype, file_ns::gpu_shader_valtorgb);
ntype.build_multi_function = file_ns::sh_node_valtorgb_build_multi_function;
nodeRegisterType(&ntype);
}
void register_node_type_sh_rgbtobw()
{
namespace file_ns = blender::nodes::node_shader_valToRgb_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTER, 0);
ntype.declare = file_ns::sh_node_rgbtobw_declare;
node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_rgbtobw);
node_type_gpu(&ntype, file_ns::gpu_shader_rgbtobw);
nodeRegisterType(&ntype);
}

14
source/blender/nodes/shader/nodes/node_shader_value.cc
View File

@ -23,15 +23,13 @@
#include "node_shader_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_shader_value_cc {
static void sh_node_value_declare(NodeDeclarationBuilder &b)
{
b.add_output<decl::Float>(N_("Value"));
};
} // namespace blender::nodes
static int gpu_shader_value(GPUMaterial *mat,
bNode *node,
bNodeExecData *UNUSED(execdata),
@ -49,14 +47,18 @@ static void sh_node_value_build_multi_function(blender::nodes::NodeMultiFunction
builder.construct_and_set_matching_fn<blender::fn::CustomMF_Constant<float>>(value->value);
}
} // namespace blender::nodes::node_shader_value_cc
void register_node_type_sh_value()
{
namespace file_ns = blender::nodes::node_shader_value_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_VALUE, "Value", NODE_CLASS_INPUT, 0);
ntype.declare = blender::nodes::sh_node_value_declare;
node_type_gpu(&ntype, gpu_shader_value);
ntype.build_multi_function = sh_node_value_build_multi_function;
ntype.declare = file_ns::sh_node_value_declare;
node_type_gpu(&ntype, file_ns::gpu_shader_value);
ntype.build_multi_function = file_ns::sh_node_value_build_multi_function;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/shader/nodes/node_shader_vectTransform.cc
View File

@ -24,6 +24,9 @@
#include "node_shader_util.hh"
/* **************** Vector Transform ******************** */
namespace blender::nodes::node_shader_vectTransform_cc {
static bNodeSocketTemplate sh_node_vect_transform_in[] = {
{SOCK_VECTOR, N_("Vector"), 0.5f, 0.5f, 0.5f, 1.0f, -10000.0f, 10000.0f, PROP_NONE}, {-1, ""}};
@ -137,17 +140,22 @@ static int gpu_shader_vect_transform(GPUMaterial *mat,
return true;
}
} // namespace blender::nodes::node_shader_vectTransform_cc
void register_node_type_sh_vect_transform()
{
namespace file_ns = blender::nodes::node_shader_vectTransform_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_VECT_TRANSFORM, "Vector Transform", NODE_CLASS_OP_VECTOR, 0);
node_type_init(&ntype, node_shader_init_vect_transform);
node_type_socket_templates(&ntype, sh_node_vect_transform_in, sh_node_vect_transform_out);
node_type_init(&ntype, file_ns::node_shader_init_vect_transform);
node_type_socket_templates(
&ntype, file_ns::sh_node_vect_transform_in, file_ns::sh_node_vect_transform_out);
node_type_storage(
&ntype, "NodeShaderVectTransform", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_vect_transform);
node_type_gpu(&ntype, gpu_shader_vect_transform);
node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_vect_transform);
node_type_gpu(&ntype, file_ns::gpu_shader_vect_transform);
nodeRegisterType(&ntype);
}

12
source/blender/nodes/shader/nodes/node_shader_vector_displacement.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_vector_displacement_cc {
static bNodeSocketTemplate sh_node_vector_displacement_in[] = {
{SOCK_RGBA, N_("Vector"), 0.00f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f, PROP_NONE, SOCK_HIDE_VALUE},
{SOCK_FLOAT, N_("Midlevel"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
@ -63,18 +65,22 @@ static int gpu_shader_vector_displacement(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_vector_displacement_world", in, out);
}
} // namespace blender::nodes::node_shader_vector_displacement_cc
/* node type definition */
void register_node_type_sh_vector_displacement()
{
namespace file_ns = blender::nodes::node_shader_vector_displacement_cc;
static bNodeType ntype;
sh_node_type_base(
&ntype, SH_NODE_VECTOR_DISPLACEMENT, "Vector Displacement", NODE_CLASS_OP_VECTOR, 0);
node_type_socket_templates(
&ntype, sh_node_vector_displacement_in, sh_node_vector_displacement_out);
&ntype, file_ns::sh_node_vector_displacement_in, file_ns::sh_node_vector_displacement_out);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_init(&ntype, node_shader_init_vector_displacement);
node_type_gpu(&ntype, gpu_shader_vector_displacement);
node_type_init(&ntype, file_ns::node_shader_init_vector_displacement);
node_type_gpu(&ntype, file_ns::gpu_shader_vector_displacement);
nodeRegisterType(&ntype);
}

16
source/blender/nodes/shader/nodes/node_shader_vector_math.cc
View File

@ -25,7 +25,7 @@
#include "NOD_math_functions.hh"
namespace blender::nodes {
namespace blender::nodes::node_vector_math_shader_cc {
static void sh_node_vector_math_declare(NodeDeclarationBuilder &b)
{
@ -38,8 +38,6 @@ static void sh_node_vector_math_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Float>(N_("Value"));
};
} // namespace blender::nodes
static const char *gpu_shader_get_name(int mode)
{
switch (mode) {
@ -279,16 +277,20 @@ static void sh_node_vector_math_build_multi_function(
builder.set_matching_fn(fn);
}
} // namespace blender::nodes::node_vector_math_shader_cc
void register_node_type_sh_vect_math()
{
namespace file_ns = blender::nodes::node_vector_math_shader_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_VECTOR_MATH, "Vector Math", NODE_CLASS_OP_VECTOR, 0);
ntype.declare = blender::nodes::sh_node_vector_math_declare;
ntype.declare = file_ns::sh_node_vector_math_declare;
node_type_label(&ntype, node_vector_math_label);
node_type_gpu(&ntype, gpu_shader_vector_math);
node_type_update(&ntype, node_shader_update_vector_math);
ntype.build_multi_function = sh_node_vector_math_build_multi_function;
node_type_gpu(&ntype, file_ns::gpu_shader_vector_math);
node_type_update(&ntype, file_ns::node_shader_update_vector_math);
ntype.build_multi_function = file_ns::sh_node_vector_math_build_multi_function;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/shader/nodes/node_shader_vector_rotate.cc
View File

@ -23,7 +23,7 @@
#include "node_shader_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_shader_vector_rotate_cc {
static void sh_node_vector_rotate_declare(NodeDeclarationBuilder &b)
{
@ -36,8 +36,6 @@ static void sh_node_vector_rotate_declare(NodeDeclarationBuilder &b)
b.add_output<decl::Vector>(N_("Vector"));
};
} // namespace blender::nodes
static const char *gpu_shader_get_name(int mode)
{
switch (mode) {
@ -205,15 +203,19 @@ static void node_shader_update_vector_rotate(bNodeTree *ntree, bNode *node)
ntree, sock_angle, !ELEM(node->custom1, NODE_VECTOR_ROTATE_TYPE_EULER_XYZ));
}
} // namespace blender::nodes::node_shader_vector_rotate_cc
void register_node_type_sh_vector_rotate()
{
namespace file_ns = blender::nodes::node_shader_vector_rotate_cc;
static bNodeType ntype;
sh_fn_node_type_base(&ntype, SH_NODE_VECTOR_ROTATE, "Vector Rotate", NODE_CLASS_OP_VECTOR, 0);
ntype.declare = blender::nodes::sh_node_vector_rotate_declare;
node_type_gpu(&ntype, gpu_shader_vector_rotate);
node_type_update(&ntype, node_shader_update_vector_rotate);
ntype.build_multi_function = sh_node_vector_rotate_build_multi_function;
ntype.declare = file_ns::sh_node_vector_rotate_declare;
node_type_gpu(&ntype, file_ns::gpu_shader_vector_rotate);
node_type_update(&ntype, file_ns::node_shader_update_vector_rotate);
ntype.build_multi_function = file_ns::sh_node_vector_rotate_build_multi_function;
nodeRegisterType(&ntype);
}

12
source/blender/nodes/shader/nodes/node_shader_vertex_color.cc
View File

@ -19,6 +19,8 @@
#include "node_shader_util.hh"
namespace blender::nodes::node_shader_vertex_color_cc {
static bNodeSocketTemplate sh_node_vertex_color_out[] = {
{SOCK_RGBA, N_("Color")},
{SOCK_FLOAT, N_("Alpha")},
@ -47,16 +49,20 @@ static int node_shader_gpu_vertex_color(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_vertex_color", in, out, vertexColorLink);
}
} // namespace blender::nodes::node_shader_vertex_color_cc
void register_node_type_sh_vertex_color()
{
namespace file_ns = blender::nodes::node_shader_vertex_color_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_VERTEX_COLOR, "Vertex Color", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, nullptr, sh_node_vertex_color_out);
node_type_init(&ntype, node_shader_init_vertex_color);
node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_vertex_color_out);
node_type_init(&ntype, file_ns::node_shader_init_vertex_color);
node_type_storage(
&ntype, "NodeShaderVertexColor", node_free_standard_storage, node_copy_standard_storage);
node_type_gpu(&ntype, node_shader_gpu_vertex_color);
node_type_gpu(&ntype, file_ns::node_shader_gpu_vertex_color);
nodeRegisterType(&ntype);
}

11
source/blender/nodes/shader/nodes/node_shader_volume_absorption.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_volume_absorption_cc {
static bNodeSocketTemplate sh_node_volume_absorption_in[] = {
{SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_FLOAT, N_("Density"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
@ -41,16 +43,21 @@ static int node_shader_gpu_volume_absorption(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_volume_absorption", in, out);
}
} // namespace blender::nodes::node_shader_volume_absorption_cc
/* node type definition */
void register_node_type_sh_volume_absorption()
{
namespace file_ns = blender::nodes::node_shader_volume_absorption_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_VOLUME_ABSORPTION, "Volume Absorption", NODE_CLASS_SHADER, 0);
node_type_socket_templates(&ntype, sh_node_volume_absorption_in, sh_node_volume_absorption_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_volume_absorption_in, file_ns::sh_node_volume_absorption_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_volume_absorption);
node_type_gpu(&ntype, file_ns::node_shader_gpu_volume_absorption);
nodeRegisterType(&ntype);
}

10
source/blender/nodes/shader/nodes/node_shader_volume_info.cc
View File

@ -19,6 +19,8 @@
#include "node_shader_util.hh"
namespace blender::nodes::node_shader_volume_info_cc {
static bNodeSocketTemplate sh_node_volume_info_out[] = {
{SOCK_RGBA, N_("Color")},
{SOCK_FLOAT, N_("Density")},
@ -49,13 +51,17 @@ static int node_shader_gpu_volume_info(GPUMaterial *mat,
return true;
}
} // namespace blender::nodes::node_shader_volume_info_cc
void register_node_type_sh_volume_info()
{
namespace file_ns = blender::nodes::node_shader_volume_info_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_VOLUME_INFO, "Volume Info", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, nullptr, sh_node_volume_info_out);
node_type_gpu(&ntype, node_shader_gpu_volume_info);
node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_volume_info_out);
node_type_gpu(&ntype, file_ns::node_shader_gpu_volume_info);
nodeRegisterType(&ntype);
}

13
source/blender/nodes/shader/nodes/node_shader_volume_principled.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_volume_principled_cc {
static bNodeSocketTemplate sh_node_volume_principled_in[] = {
{SOCK_RGBA, N_("Color"), 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 1.0f},
{SOCK_STRING, N_("Color Attribute"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@ -126,17 +128,22 @@ static int node_shader_gpu_volume_principled(GPUMaterial *mat,
GPU_constant(&layer));
}
} // namespace blender::nodes::node_shader_volume_principled_cc
/* node type definition */
void register_node_type_sh_volume_principled()
{
namespace file_ns = blender::nodes::node_shader_volume_principled_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_VOLUME_PRINCIPLED, "Principled Volume", NODE_CLASS_SHADER, 0);
node_type_socket_templates(&ntype, sh_node_volume_principled_in, sh_node_volume_principled_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_volume_principled_in, file_ns::sh_node_volume_principled_out);
node_type_size_preset(&ntype, NODE_SIZE_LARGE);
node_type_init(&ntype, node_shader_init_volume_principled);
node_type_init(&ntype, file_ns::node_shader_init_volume_principled);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_volume_principled);
node_type_gpu(&ntype, file_ns::node_shader_gpu_volume_principled);
nodeRegisterType(&ntype);
}

11
source/blender/nodes/shader/nodes/node_shader_volume_scatter.cc
View File

@ -21,6 +21,8 @@
/* **************** OUTPUT ******************** */
namespace blender::nodes::node_shader_volume_scatter_cc {
static bNodeSocketTemplate sh_node_volume_scatter_in[] = {
{SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_FLOAT, N_("Density"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
@ -42,16 +44,21 @@ static int node_shader_gpu_volume_scatter(GPUMaterial *mat,
return GPU_stack_link(mat, node, "node_volume_scatter", in, out);
}
} // namespace blender::nodes::node_shader_volume_scatter_cc
/* node type definition */
void register_node_type_sh_volume_scatter()
{
namespace file_ns = blender::nodes::node_shader_volume_scatter_cc;
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_socket_templates(
&ntype, file_ns::sh_node_volume_scatter_in, file_ns::sh_node_volume_scatter_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_volume_scatter);
node_type_gpu(&ntype, file_ns::node_shader_gpu_volume_scatter);
nodeRegisterType(&ntype);
}

12
source/blender/nodes/shader/nodes/node_shader_wavelength.cc
View File

@ -20,6 +20,9 @@
#include "node_shader_util.hh"
/* **************** Wavelength ******************** */
namespace blender::nodes::node_shader_wavelength_cc {
static bNodeSocketTemplate sh_node_wavelength_in[] = {
{SOCK_FLOAT, N_("Wavelength"), 500.0f, 0.0f, 0.0f, 0.0f, 380.0f, 780.0f},
{-1, ""},
@ -57,17 +60,22 @@ static int node_shader_gpu_wavelength(GPUMaterial *mat,
GPU_uniform(xyz_to_rgb.b));
}
} // namespace blender::nodes::node_shader_wavelength_cc
/* node type definition */
void register_node_type_sh_wavelength()
{
namespace file_ns = blender::nodes::node_shader_wavelength_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_WAVELENGTH, "Wavelength", NODE_CLASS_CONVERTER, 0);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_socket_templates(&ntype, sh_node_wavelength_in, sh_node_wavelength_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_wavelength_in, file_ns::sh_node_wavelength_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_wavelength);
node_type_gpu(&ntype, file_ns::node_shader_gpu_wavelength);
nodeRegisterType(&ntype);
}

12
source/blender/nodes/shader/nodes/node_shader_wireframe.cc
View File

@ -20,6 +20,9 @@
#include "node_shader_util.hh"
/* **************** Wireframe ******************** */
namespace blender::nodes::node_shader_wireframe_cc {
static bNodeSocketTemplate sh_node_wireframe_in[] = {
{SOCK_FLOAT, N_("Size"), 0.01f, 0.0f, 0.0f, 0.0f, 0.0f, 100.0f},
{-1, ""},
@ -52,16 +55,21 @@ static int node_shader_gpu_wireframe(GPUMaterial *mat,
GPU_builtin(GPU_BARYCENTRIC_DIST));
}
} // namespace blender::nodes::node_shader_wireframe_cc
/* node type definition */
void register_node_type_sh_wireframe()
{
namespace file_ns = blender::nodes::node_shader_wireframe_cc;
static bNodeType ntype;
sh_node_type_base(&ntype, SH_NODE_WIREFRAME, "Wireframe", NODE_CLASS_INPUT, 0);
node_type_socket_templates(&ntype, sh_node_wireframe_in, sh_node_wireframe_out);
node_type_socket_templates(
&ntype, file_ns::sh_node_wireframe_in, file_ns::sh_node_wireframe_out);
node_type_init(&ntype, nullptr);
node_type_storage(&ntype, "", nullptr, nullptr);
node_type_gpu(&ntype, node_shader_gpu_wireframe);
node_type_gpu(&ntype, file_ns::node_shader_gpu_wireframe);
nodeRegisterType(&ntype);
}