tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity

Geometry Nodes: add namespace for every file 

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

* The name space name is derived from the file name. That makes
  it possible to write some tooling that checks the names later on.
  The file name 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_geo_*_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 beginning I used `node_ns` but `file_ns` is more
  generic which may make it more suitable when we want to use unity
  builds outside of the nodes modules in the future.
* Some node files contain code that is actually shared between
  different nodes. For now I left that code in the `blender::nodes`
  namespace and moved it to the top of the file (couldn't move it to
  the bottom in all cases, so I just moved it to the top everywhere).
  As a separate cleanup step, this shared code should actually be
  moved to a separate file.

Differential Revision: https://developer.blender.org/D13330
This commit is contained in:
Jacques Lucke 2021-11-23 14:56:01 +01:00
parent 47276b8470
commit 1df8abff25
135 changed files with 1353 additions and 1046 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_align_rotation_to_vector.cc
View File

@ -22,7 +22,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_align_rotation_to_vector_cc {
static void geo_node_align_rotation_to_vector_declare(NodeDeclarationBuilder &b)
{
@ -219,10 +219,12 @@ static void geo_node_align_rotation_to_vector_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_align_rotation_to_vector_cc
void register_node_type_geo_align_rotation_to_vector()
{
namespace file_ns = blender::nodes::node_geo_legacy_align_rotation_to_vector_cc;
static bNodeType ntype;
geo_node_type_base(&ntype,
@ -230,14 +232,14 @@ void register_node_type_geo_align_rotation_to_vector()
"Align Rotation to Vector",
NODE_CLASS_GEOMETRY,
0);
node_type_init(&ntype, blender::nodes::geo_node_align_rotation_to_vector_init);
node_type_update(&ntype, blender::nodes::geo_node_align_rotation_to_vector_update);
node_type_init(&ntype, file_ns::geo_node_align_rotation_to_vector_init);
node_type_update(&ntype, file_ns::geo_node_align_rotation_to_vector_update);
node_type_storage(&ntype,
"NodeGeometryAlignRotationToVector",
node_free_standard_storage,
node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_align_rotation_to_vector_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_align_rotation_to_vector_exec;
ntype.draw_buttons = blender::nodes::geo_node_align_rotation_to_vector_layout;
ntype.declare = file_ns::geo_node_align_rotation_to_vector_declare;
ntype.geometry_node_execute = file_ns::geo_node_align_rotation_to_vector_exec;
ntype.draw_buttons = file_ns::geo_node_align_rotation_to_vector_layout;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_clamp.cc
View File

@ -20,7 +20,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_attribute_clamp_cc {
static void geo_node_attribute_clamp_declare(NodeDeclarationBuilder &b)
{
@ -262,19 +262,21 @@ static void geo_node_attribute_clamp_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_attribute_clamp_cc
void register_node_type_geo_attribute_clamp()
{
namespace file_ns = blender::nodes::node_geo_legacy_attribute_clamp_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_ATTRIBUTE_CLAMP, "Attribute Clamp", NODE_CLASS_ATTRIBUTE, 0);
node_type_init(&ntype, blender::nodes::geo_node_attribute_clamp_init);
node_type_update(&ntype, blender::nodes::geo_node_attribute_clamp_update);
ntype.declare = blender::nodes::geo_node_attribute_clamp_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_clamp_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_clamp_layout;
node_type_init(&ntype, file_ns::geo_node_attribute_clamp_init);
node_type_update(&ntype, file_ns::geo_node_attribute_clamp_update);
ntype.declare = file_ns::geo_node_attribute_clamp_declare;
ntype.geometry_node_execute = file_ns::geo_node_attribute_clamp_exec;
ntype.draw_buttons = file_ns::geo_node_attribute_clamp_layout;
node_type_storage(
&ntype, "NodeAttributeClamp", node_free_standard_storage, node_copy_standard_storage);
nodeRegisterType(&ntype);

14
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_color_ramp.cc
View File

@ -23,7 +23,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_attributes_color_ramp_cc {
static void geo_node_attribute_color_ramp_declare(NodeDeclarationBuilder &b)
{
@ -119,10 +119,12 @@ static void geo_node_attribute_color_ramp_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_attributes_color_ramp_cc
void register_node_type_geo_attribute_color_ramp()
{
namespace file_ns = blender::nodes::node_geo_legacy_attributes_color_ramp_cc;
static bNodeType ntype;
geo_node_type_base(&ntype,
@ -132,10 +134,10 @@ void register_node_type_geo_attribute_color_ramp()
0);
node_type_storage(
&ntype, "NodeAttributeColorRamp", node_free_standard_storage, node_copy_standard_storage);
node_type_init(&ntype, blender::nodes::geo_node_attribute_color_ramp_init);
node_type_init(&ntype, file_ns::geo_node_attribute_color_ramp_init);
node_type_size_preset(&ntype, NODE_SIZE_LARGE);
ntype.declare = blender::nodes::geo_node_attribute_color_ramp_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_color_ramp_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_color_ramp_layout;
ntype.declare = file_ns::geo_node_attribute_color_ramp_declare;
ntype.geometry_node_execute = file_ns::geo_node_attribute_color_ramp_exec;
ntype.draw_buttons = file_ns::geo_node_attribute_color_ramp_layout;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_combine_xyz.cc
View File

@ -19,7 +19,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_attribute_combine_xyz_cc {
static void geo_node_attribute_combine_xyz_declare(NodeDeclarationBuilder &b)
{
@ -130,10 +130,12 @@ static void geo_node_attribute_combine_xyz_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_attribute_combine_xyz_cc
void register_node_type_geo_attribute_combine_xyz()
{
namespace file_ns = blender::nodes::node_geo_legacy_attribute_combine_xyz_cc;
static bNodeType ntype;
geo_node_type_base(&ntype,
@ -141,13 +143,13 @@ void register_node_type_geo_attribute_combine_xyz()
"Attribute Combine XYZ",
NODE_CLASS_ATTRIBUTE,
0);
node_type_init(&ntype, blender::nodes::geo_node_attribute_combine_xyz_init);
node_type_update(&ntype, blender::nodes::geo_node_attribute_combine_xyz_update);
node_type_init(&ntype, file_ns::geo_node_attribute_combine_xyz_init);
node_type_update(&ntype, file_ns::geo_node_attribute_combine_xyz_update);
node_type_storage(
&ntype, "NodeAttributeCombineXYZ", node_free_standard_storage, node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_attribute_combine_xyz_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_combine_xyz_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_combine_xyz_layout;
ntype.declare = file_ns::geo_node_attribute_combine_xyz_declare;
ntype.geometry_node_execute = file_ns::geo_node_attribute_combine_xyz_exec;
ntype.draw_buttons = file_ns::geo_node_attribute_combine_xyz_layout;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_compare.cc
View File

@ -21,7 +21,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_attribute_compare_cc {
static void geo_node_attribute_compare_declare(NodeDeclarationBuilder &b)
{
@ -341,20 +341,22 @@ static void geo_node_attribute_compare_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_attribute_compare_cc
void register_node_type_geo_attribute_compare()
{
namespace file_ns = blender::nodes::node_geo_legacy_attribute_compare_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_ATTRIBUTE_COMPARE, "Attribute Compare", NODE_CLASS_ATTRIBUTE, 0);
ntype.declare = blender::nodes::geo_node_attribute_compare_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_compare_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_compare_layout;
node_type_update(&ntype, blender::nodes::geo_node_attribute_compare_update);
ntype.declare = file_ns::geo_node_attribute_compare_declare;
ntype.geometry_node_execute = file_ns::geo_node_attribute_compare_exec;
ntype.draw_buttons = file_ns::geo_node_attribute_compare_layout;
node_type_update(&ntype, file_ns::geo_node_attribute_compare_update);
node_type_storage(
&ntype, "NodeAttributeCompare", node_free_standard_storage, node_copy_standard_storage);
node_type_init(&ntype, blender::nodes::geo_node_attribute_compare_init);
node_type_init(&ntype, file_ns::geo_node_attribute_compare_init);
nodeRegisterType(&ntype);
}

14
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_convert.cc
View File

@ -19,7 +19,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_attribute_convert_cc {
static void geo_node_attribute_convert_declare(NodeDeclarationBuilder &b)
{
@ -175,18 +175,20 @@ static void geo_node_attribute_convert_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_attribute_convert_cc
void register_node_type_geo_attribute_convert()
{
namespace file_ns = blender::nodes::node_geo_legacy_attribute_convert_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_ATTRIBUTE_CONVERT, "Attribute Convert", NODE_CLASS_ATTRIBUTE, 0);
ntype.declare = blender::nodes::geo_node_attribute_convert_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_convert_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_convert_layout;
node_type_init(&ntype, blender::nodes::geo_node_attribute_convert_init);
ntype.declare = file_ns::geo_node_attribute_convert_declare;
ntype.geometry_node_execute = file_ns::geo_node_attribute_convert_exec;
ntype.draw_buttons = file_ns::geo_node_attribute_convert_layout;
node_type_init(&ntype, file_ns::geo_node_attribute_convert_init);
node_type_storage(
&ntype, "NodeAttributeConvert", node_free_standard_storage, node_copy_standard_storage);

20
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_curve_map.cc
View File

@ -24,7 +24,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_attribute_curve_map_cc {
static void geo_node_attribute_curve_map_declare(NodeDeclarationBuilder &b)
{
@ -203,23 +203,25 @@ static void geo_node_attribute_curve_map_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_attribute_curve_map_cc
void register_node_type_geo_attribute_curve_map()
{
namespace file_ns = blender::nodes::node_geo_legacy_attribute_curve_map_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_ATTRIBUTE_CURVE_MAP, "Attribute Curve Map", NODE_CLASS_ATTRIBUTE, 0);
node_type_update(&ntype, blender::nodes::geo_node_attribute_curve_map_update);
node_type_init(&ntype, blender::nodes::geo_node_attribute_curve_map_init);
node_type_update(&ntype, file_ns::geo_node_attribute_curve_map_update);
node_type_init(&ntype, file_ns::geo_node_attribute_curve_map_init);
node_type_size_preset(&ntype, NODE_SIZE_LARGE);
node_type_storage(&ntype,
"NodeAttributeCurveMap",
blender::nodes::geo_node_attribute_curve_map_free_storage,
blender::nodes::geo_node_attribute_curve_map_copy_storage);
ntype.declare = blender::nodes::geo_node_attribute_curve_map_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_curve_map_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_curve_map_layout;
file_ns::geo_node_attribute_curve_map_free_storage,
file_ns::geo_node_attribute_curve_map_copy_storage);
ntype.declare = file_ns::geo_node_attribute_curve_map_declare;
ntype.geometry_node_execute = file_ns::geo_node_attribute_curve_map_exec;
ntype.draw_buttons = file_ns::geo_node_attribute_curve_map_layout;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_fill.cc
View File

@ -19,7 +19,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_attribute_fill_cc {
static void geo_node_attribute_fill_declare(NodeDeclarationBuilder &b)
{
@ -146,18 +146,20 @@ static void geo_node_attribute_fill_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_attribute_fill_cc
void register_node_type_geo_attribute_fill()
{
namespace file_ns = blender::nodes::node_geo_legacy_attribute_fill_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_ATTRIBUTE_FILL, "Attribute Fill", NODE_CLASS_ATTRIBUTE, 0);
node_type_init(&ntype, blender::nodes::geo_node_attribute_fill_init);
node_type_update(&ntype, blender::nodes::geo_node_attribute_fill_update);
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_fill_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_fill_layout;
ntype.declare = blender::nodes::geo_node_attribute_fill_declare;
node_type_init(&ntype, file_ns::geo_node_attribute_fill_init);
node_type_update(&ntype, file_ns::geo_node_attribute_fill_update);
ntype.geometry_node_execute = file_ns::geo_node_attribute_fill_exec;
ntype.draw_buttons = file_ns::geo_node_attribute_fill_layout;
ntype.declare = file_ns::geo_node_attribute_fill_declare;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_map_range.cc
View File

@ -22,7 +22,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_attribute_map_range_cc {
static void geo_node_attribute_map_range_declare(NodeDeclarationBuilder &b)
{
@ -416,20 +416,22 @@ static void geo_node_attribute_map_range_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_attribute_map_range_cc
void register_node_type_geo_attribute_map_range()
{
namespace file_ns = blender::nodes::node_geo_legacy_attribute_map_range_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_ATTRIBUTE_MAP_RANGE, "Attribute Map Range", NODE_CLASS_ATTRIBUTE, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_map_range_exec;
node_type_init(&ntype, blender::nodes::geo_node_attribute_map_range_init);
node_type_update(&ntype, blender::nodes::geo_node_attribute_map_range_update);
ntype.geometry_node_execute = file_ns::geo_node_attribute_map_range_exec;
node_type_init(&ntype, file_ns::geo_node_attribute_map_range_init);
node_type_update(&ntype, file_ns::geo_node_attribute_map_range_update);
node_type_storage(
&ntype, "NodeAttributeMapRange", node_free_standard_storage, node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_attribute_map_range_declare;
ntype.draw_buttons = blender::nodes::fn_attribute_map_range_layout;
ntype.declare = file_ns::geo_node_attribute_map_range_declare;
ntype.draw_buttons = file_ns::fn_attribute_map_range_layout;
nodeRegisterType(&ntype);
}

18
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_math.cc
View File

@ -25,7 +25,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_attribute_math_cc {
static void geo_node_attribute_math_declare(NodeDeclarationBuilder &b)
{
@ -297,20 +297,22 @@ static void geo_node_attribute_math_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_attribute_math_cc
void register_node_type_geo_attribute_math()
{
namespace file_ns = blender::nodes::node_geo_legacy_attribute_math_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_ATTRIBUTE_MATH, "Attribute Math", NODE_CLASS_ATTRIBUTE, 0);
ntype.declare = blender::nodes::geo_node_attribute_math_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_math_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_math_layout;
node_type_label(&ntype, blender::nodes::geo_node_math_label);
node_type_update(&ntype, blender::nodes::geo_node_attribute_math_update);
node_type_init(&ntype, blender::nodes::geo_node_attribute_math_init);
ntype.declare = file_ns::geo_node_attribute_math_declare;
ntype.geometry_node_execute = file_ns::geo_node_attribute_math_exec;
ntype.draw_buttons = file_ns::geo_node_attribute_math_layout;
node_type_label(&ntype, file_ns::geo_node_math_label);
node_type_update(&ntype, file_ns::geo_node_attribute_math_update);
node_type_init(&ntype, file_ns::geo_node_attribute_math_init);
node_type_storage(
&ntype, "NodeAttributeMath", node_free_standard_storage, node_copy_standard_storage);
nodeRegisterType(&ntype);

16
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_mix.cc
View File

@ -25,7 +25,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_attribute_mix_cc {
static void geo_node_mix_attribute_declare(NodeDeclarationBuilder &b)
{
@ -241,19 +241,21 @@ static void geo_node_attribute_mix_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_attribute_mix_cc
void register_node_type_geo_attribute_mix()
{
namespace file_ns = blender::nodes::node_geo_legacy_attribute_mix_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_ATTRIBUTE_MIX, "Attribute Mix", NODE_CLASS_ATTRIBUTE, 0);
node_type_init(&ntype, blender::nodes::geo_node_attribute_mix_init);
node_type_update(&ntype, blender::nodes::geo_node_attribute_mix_update);
ntype.declare = blender::nodes::geo_node_mix_attribute_declare;
ntype.draw_buttons = blender::nodes::geo_node_attribute_mix_layout;
node_type_init(&ntype, file_ns::geo_node_attribute_mix_init);
node_type_update(&ntype, file_ns::geo_node_attribute_mix_update);
ntype.declare = file_ns::geo_node_mix_attribute_declare;
ntype.draw_buttons = file_ns::geo_node_attribute_mix_layout;
node_type_storage(
&ntype, "NodeAttributeMix", node_free_standard_storage, node_copy_standard_storage);
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_mix_exec;
ntype.geometry_node_execute = file_ns::geo_node_attribute_mix_exec;
nodeRegisterType(&ntype);
}

14
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_proximity.cc
View File

@ -26,7 +26,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_attribute_proximity_cc {
static void geo_node_attribute_proximity_declare(NodeDeclarationBuilder &b)
{
@ -230,22 +230,24 @@ static void geo_node_attribute_proximity_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_attribute_proximity_cc
void register_node_type_geo_legacy_attribute_proximity()
{
namespace file_ns = blender::nodes::node_geo_legacy_attribute_proximity_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_ATTRIBUTE_PROXIMITY, "Attribute Proximity", NODE_CLASS_ATTRIBUTE, 0);
node_type_init(&ntype, blender::nodes::geo_attribute_proximity_init);
node_type_init(&ntype, file_ns::geo_attribute_proximity_init);
node_type_storage(&ntype,
"NodeGeometryAttributeProximity",
node_free_standard_storage,
node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_attribute_proximity_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_proximity_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_proximity_layout;
ntype.declare = file_ns::geo_node_attribute_proximity_declare;
ntype.geometry_node_execute = file_ns::geo_node_attribute_proximity_exec;
ntype.draw_buttons = file_ns::geo_node_attribute_proximity_layout;
nodeRegisterType(&ntype);
}

78
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_randomize.cc
View File

@ -25,6 +25,40 @@
namespace blender::nodes {
Array<uint32_t> get_geometry_element_ids_as_uints(const GeometryComponent &component,
const AttributeDomain domain)
{
const int domain_size = component.attribute_domain_size(domain);
/* Hash the reserved name attribute "id" as a (hopefully) stable seed for each point. */
GVArray hash_attribute = component.attribute_try_get_for_read("id", domain);
Array<uint32_t> hashes(domain_size);
if (hash_attribute) {
BLI_assert(hashes.size() == hash_attribute.size());
const CPPType &cpp_type = hash_attribute.type();
BLI_assert(cpp_type.is_hashable());
GVArray_GSpan items{hash_attribute};
threading::parallel_for(hashes.index_range(), 512, [&](IndexRange range) {
for (const int i : range) {
hashes[i] = cpp_type.hash(items[i]);
}
});
}
else {
/* If there is no "id" attribute for per-point variation, just create it here. */
RandomNumberGenerator rng(0);
for (const int i : hashes.index_range()) {
hashes[i] = rng.get_uint32();
}
}
return hashes;
}
} // namespace blender::nodes
namespace blender::nodes::node_geo_legacy_attribute_randomize_cc {
static void geo_node_legacy_attribute_randomize_declare(NodeDeclarationBuilder &b)
{
b.add_input<decl::Geometry>(N_("Geometry"));
@ -174,36 +208,6 @@ static void randomize_attribute_bool(MutableSpan<bool> span,
});
}
Array<uint32_t> get_geometry_element_ids_as_uints(const GeometryComponent &component,
const AttributeDomain domain)
{
const int domain_size = component.attribute_domain_size(domain);
/* Hash the reserved name attribute "id" as a (hopefully) stable seed for each point. */
GVArray hash_attribute = component.attribute_try_get_for_read("id", domain);
Array<uint32_t> hashes(domain_size);
if (hash_attribute) {
BLI_assert(hashes.size() == hash_attribute.size());
const CPPType &cpp_type = hash_attribute.type();
BLI_assert(cpp_type.is_hashable());
GVArray_GSpan items{hash_attribute};
threading::parallel_for(hashes.index_range(), 512, [&](IndexRange range) {
for (const int i : range) {
hashes[i] = cpp_type.hash(items[i]);
}
});
}
else {
/* If there is no "id" attribute for per-point variation, just create it here. */
RandomNumberGenerator rng(0);
for (const int i : hashes.index_range()) {
hashes[i] = rng.get_uint32();
}
}
return hashes;
}
static AttributeDomain get_result_domain(const GeometryComponent &component,
const GeoNodeExecParams &params,
const StringRef name)
@ -324,20 +328,22 @@ static void geo_node_legacy_random_attribute_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_attribute_randomize_cc
void register_node_type_geo_legacy_attribute_randomize()
{
namespace file_ns = blender::nodes::node_geo_legacy_attribute_randomize_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_ATTRIBUTE_RANDOMIZE, "Attribute Randomize", NODE_CLASS_ATTRIBUTE, 0);
node_type_init(&ntype, blender::nodes::geo_node_legacy_attribute_randomize_init);
node_type_update(&ntype, blender::nodes::geo_node_legacy_attribute_randomize_update);
node_type_init(&ntype, file_ns::geo_node_legacy_attribute_randomize_init);
node_type_update(&ntype, file_ns::geo_node_legacy_attribute_randomize_update);
ntype.declare = blender::nodes::geo_node_legacy_attribute_randomize_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_legacy_random_attribute_exec;
ntype.draw_buttons = blender::nodes::geo_node_legacy_attribute_random_layout;
ntype.declare = file_ns::geo_node_legacy_attribute_randomize_declare;
ntype.geometry_node_execute = file_ns::geo_node_legacy_random_attribute_exec;
ntype.draw_buttons = file_ns::geo_node_legacy_attribute_random_layout;
node_type_storage(
&ntype, "NodeAttributeRandomize", node_free_standard_storage, node_copy_standard_storage);
nodeRegisterType(&ntype);

10
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_sample_texture.cc
View File

@ -28,7 +28,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_attribute_sample_texture_cc {
static void geo_node_attribute_sample_texture_declare(NodeDeclarationBuilder &b)
{
@ -119,10 +119,12 @@ static void geo_node_attribute_sample_texture_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_attribute_sample_texture_cc
void register_node_type_geo_sample_texture()
{
namespace file_ns = blender::nodes::node_geo_legacy_attribute_sample_texture_cc;
static bNodeType ntype;
geo_node_type_base(&ntype,
@ -131,7 +133,7 @@ void register_node_type_geo_sample_texture()
NODE_CLASS_ATTRIBUTE,
0);
node_type_size_preset(&ntype, NODE_SIZE_LARGE);
ntype.declare = blender::nodes::geo_node_attribute_sample_texture_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_sample_texture_exec;
ntype.declare = file_ns::geo_node_attribute_sample_texture_declare;
ntype.geometry_node_execute = file_ns::geo_node_attribute_sample_texture_exec;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_separate_xyz.cc
View File

@ -19,7 +19,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_attribute_separate_xyz_cc {
static void geo_node_attribute_separate_xyz_declare(NodeDeclarationBuilder &b)
{
@ -151,10 +151,12 @@ static void geo_node_attribute_separate_xyz_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_attribute_separate_xyz_cc
void register_node_type_geo_attribute_separate_xyz()
{
namespace file_ns = blender::nodes::node_geo_legacy_attribute_separate_xyz_cc;
static bNodeType ntype;
geo_node_type_base(&ntype,
@ -162,12 +164,12 @@ void register_node_type_geo_attribute_separate_xyz()
"Attribute Separate XYZ",
NODE_CLASS_ATTRIBUTE,
0);
ntype.declare = blender::nodes::geo_node_attribute_separate_xyz_declare;
node_type_init(&ntype, blender::nodes::geo_node_attribute_separate_xyz_init);
node_type_update(&ntype, blender::nodes::geo_node_attribute_separate_xyz_update);
ntype.declare = file_ns::geo_node_attribute_separate_xyz_declare;
node_type_init(&ntype, file_ns::geo_node_attribute_separate_xyz_init);
node_type_update(&ntype, file_ns::geo_node_attribute_separate_xyz_update);
node_type_storage(
&ntype, "NodeAttributeSeparateXYZ", node_free_standard_storage, node_copy_standard_storage);
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_separate_xyz_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_separate_xyz_layout;
ntype.geometry_node_execute = file_ns::geo_node_attribute_separate_xyz_exec;
ntype.draw_buttons = file_ns::geo_node_attribute_separate_xyz_layout;
nodeRegisterType(&ntype);
}

14
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_transfer.cc
View File

@ -29,7 +29,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_attribute_transfer_cc {
static void geo_node_attribute_transfer_declare(NodeDeclarationBuilder &b)
{
@ -510,21 +510,23 @@ static void geo_node_attribute_transfer_exec(GeoNodeExecParams params)
params.set_output("Geometry", dst_geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_attribute_transfer_cc
void register_node_type_geo_legacy_attribute_transfer()
{
namespace file_ns = blender::nodes::node_geo_legacy_attribute_transfer_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_ATTRIBUTE_TRANSFER, "Attribute Transfer", NODE_CLASS_ATTRIBUTE, 0);
node_type_init(&ntype, blender::nodes::geo_node_attribute_transfer_init);
node_type_init(&ntype, file_ns::geo_node_attribute_transfer_init);
node_type_storage(&ntype,
"NodeGeometryAttributeTransfer",
node_free_standard_storage,
node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_attribute_transfer_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_transfer_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_transfer_layout;
ntype.declare = file_ns::geo_node_attribute_transfer_declare;
ntype.geometry_node_execute = file_ns::geo_node_attribute_transfer_exec;
ntype.draw_buttons = file_ns::geo_node_attribute_transfer_layout;
nodeRegisterType(&ntype);
}

18
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_vector_math.cc
View File

@ -26,7 +26,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_attribute_vector_math_cc {
static void geo_node_attribute_vector_math_declare(NodeDeclarationBuilder &b)
{
@ -551,10 +551,12 @@ static void geo_node_attribute_vector_math_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_attribute_vector_math_cc
void register_node_type_geo_attribute_vector_math()
{
namespace file_ns = blender::nodes::node_geo_legacy_attribute_vector_math_cc;
static bNodeType ntype;
geo_node_type_base(&ntype,
@ -562,12 +564,12 @@ void register_node_type_geo_attribute_vector_math()
"Attribute Vector Math",
NODE_CLASS_ATTRIBUTE,
0);
ntype.declare = blender::nodes::geo_node_attribute_vector_math_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_vector_math_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_vector_math_layout;
node_type_label(&ntype, blender::nodes::geo_node_vector_math_label);
node_type_update(&ntype, blender::nodes::geo_node_attribute_vector_math_update);
node_type_init(&ntype, blender::nodes::geo_node_attribute_vector_math_init);
ntype.declare = file_ns::geo_node_attribute_vector_math_declare;
ntype.geometry_node_execute = file_ns::geo_node_attribute_vector_math_exec;
ntype.draw_buttons = file_ns::geo_node_attribute_vector_math_layout;
node_type_label(&ntype, file_ns::geo_node_vector_math_label);
node_type_update(&ntype, file_ns::geo_node_attribute_vector_math_update);
node_type_init(&ntype, file_ns::geo_node_attribute_vector_math_init);
node_type_storage(
&ntype, "NodeAttributeVectorMath", node_free_standard_storage, node_copy_standard_storage);

16
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_vector_rotate.cc
View File

@ -21,7 +21,7 @@
#include "UI_interface.h"
#include "UI_resources.h"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_attribute_vector_rotate_cc {
static void geo_node_attribute_vector_rotate_declare(NodeDeclarationBuilder &b)
{
@ -328,10 +328,12 @@ static void geo_node_attribute_vector_rotate_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_attribute_vector_rotate_cc
void register_node_type_geo_attribute_vector_rotate()
{
namespace file_ns = blender::nodes::node_geo_legacy_attribute_vector_rotate_cc;
static bNodeType ntype;
geo_node_type_base(&ntype,
@ -339,13 +341,13 @@ void register_node_type_geo_attribute_vector_rotate()
"Attribute Vector Rotate",
NODE_CLASS_ATTRIBUTE,
0);
node_type_update(&ntype, blender::nodes::geo_node_attribute_vector_rotate_update);
node_type_init(&ntype, blender::nodes::geo_node_attribute_vector_rotate_init);
node_type_update(&ntype, file_ns::geo_node_attribute_vector_rotate_update);
node_type_init(&ntype, file_ns::geo_node_attribute_vector_rotate_init);
node_type_size(&ntype, 165, 100, 600);
node_type_storage(
&ntype, "NodeAttributeVectorRotate", node_free_standard_storage, node_copy_standard_storage);
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_vector_rotate_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_vector_rotate_layout;
ntype.declare = blender::nodes::geo_node_attribute_vector_rotate_declare;
ntype.geometry_node_execute = file_ns::geo_node_attribute_vector_rotate_exec;
ntype.draw_buttons = file_ns::geo_node_attribute_vector_rotate_layout;
ntype.declare = file_ns::geo_node_attribute_vector_rotate_declare;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_endpoints.cc
View File

@ -25,7 +25,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_curve_endpoints_cc {
static void geo_node_curve_endpoints_declare(NodeDeclarationBuilder &b)
{
@ -206,16 +206,18 @@ static void geo_node_curve_endpoints_exec(GeoNodeExecParams params)
params.set_output("End Points", std::move(end_result));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_curve_endpoints_cc
void register_node_type_geo_legacy_curve_endpoints()
{
namespace file_ns = blender::nodes::node_geo_legacy_curve_endpoints_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_CURVE_ENDPOINTS, "Curve Endpoints", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_endpoints_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_endpoints_exec;
ntype.declare = file_ns::geo_node_curve_endpoints_declare;
ntype.geometry_node_execute = file_ns::geo_node_curve_endpoints_exec;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_reverse.cc
View File

@ -20,7 +20,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_curve_reverse_cc {
static void geo_node_curve_reverse_declare(NodeDeclarationBuilder &b)
{
@ -58,14 +58,16 @@ static void geo_node_curve_reverse_exec(GeoNodeExecParams params)
params.set_output("Curve", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_curve_reverse_cc
void register_node_type_geo_legacy_curve_reverse()
{
namespace file_ns = blender::nodes::node_geo_legacy_curve_reverse_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_CURVE_REVERSE, "Curve Reverse", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_reverse_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_reverse_exec;
ntype.declare = file_ns::geo_node_curve_reverse_declare;
ntype.geometry_node_execute = file_ns::geo_node_curve_reverse_exec;
nodeRegisterType(&ntype);
}

14
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_select_by_handle_type.cc
View File

@ -23,7 +23,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_curve_select_by_handle_type_cc {
static void geo_node_select_by_handle_type_declare(NodeDeclarationBuilder &b)
{
@ -121,10 +121,12 @@ static void geo_node_select_by_handle_type_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_curve_select_by_handle_type_cc
void register_node_type_geo_legacy_select_by_handle_type()
{
namespace file_ns = blender::nodes::node_geo_legacy_curve_select_by_handle_type_cc;
static bNodeType ntype;
geo_node_type_base(&ntype,
@ -132,14 +134,14 @@ void register_node_type_geo_legacy_select_by_handle_type()
"Select by Handle Type",
NODE_CLASS_GEOMETRY,
0);
ntype.declare = blender::nodes::geo_node_select_by_handle_type_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_select_by_handle_type_exec;
node_type_init(&ntype, blender::nodes::geo_node_curve_select_by_handle_type_init);
ntype.declare = file_ns::geo_node_select_by_handle_type_declare;
ntype.geometry_node_execute = file_ns::geo_node_select_by_handle_type_exec;
node_type_init(&ntype, file_ns::geo_node_curve_select_by_handle_type_init);
node_type_storage(&ntype,
"NodeGeometryCurveSelectHandles",
node_free_standard_storage,
node_copy_standard_storage);
ntype.draw_buttons = blender::nodes::geo_node_curve_select_by_handle_type_layout;
ntype.draw_buttons = file_ns::geo_node_curve_select_by_handle_type_layout;
nodeRegisterType(&ntype);
}

14
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_set_handles.cc
View File

@ -21,7 +21,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_curve_set_handles_cc {
static void geo_node_curve_set_handles_decalre(NodeDeclarationBuilder &b)
{
@ -124,21 +124,23 @@ static void geo_node_curve_set_handles_exec(GeoNodeExecParams params)
params.set_output("Curve", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_curve_set_handles_cc
void register_node_type_geo_legacy_curve_set_handles()
{
namespace file_ns = blender::nodes::node_geo_legacy_curve_set_handles_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_CURVE_SET_HANDLES, "Set Handle Type", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_set_handles_decalre;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_set_handles_exec;
node_type_init(&ntype, blender::nodes::geo_node_curve_set_handles_init);
ntype.declare = file_ns::geo_node_curve_set_handles_decalre;
ntype.geometry_node_execute = file_ns::geo_node_curve_set_handles_exec;
node_type_init(&ntype, file_ns::geo_node_curve_set_handles_init);
node_type_storage(&ntype,
"NodeGeometryCurveSetHandles",
node_free_standard_storage,
node_copy_standard_storage);
ntype.draw_buttons = blender::nodes::geo_node_curve_set_handles_layout;
ntype.draw_buttons = file_ns::geo_node_curve_set_handles_layout;
nodeRegisterType(&ntype);
}

14
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_spline_type.cc
View File

@ -23,7 +23,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_curve_spline_type_cc {
static void geo_node_legacy_curve_spline_type_declare(NodeDeclarationBuilder &b)
{
@ -282,21 +282,23 @@ static void geo_node_legacy_curve_spline_type_exec(GeoNodeExecParams params)
params.set_output("Curve", GeometrySet::create_with_curve(new_curve.release()));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_curve_spline_type_cc
void register_node_type_geo_legacy_curve_spline_type()
{
namespace file_ns = blender::nodes::node_geo_legacy_curve_spline_type_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_CURVE_SPLINE_TYPE, "Set Spline Type", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_legacy_curve_spline_type_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_legacy_curve_spline_type_exec;
node_type_init(&ntype, blender::nodes::geo_node_legacy_curve_spline_type_init);
ntype.declare = file_ns::geo_node_legacy_curve_spline_type_declare;
ntype.geometry_node_execute = file_ns::geo_node_legacy_curve_spline_type_exec;
node_type_init(&ntype, file_ns::geo_node_legacy_curve_spline_type_init);
node_type_storage(&ntype,
"NodeGeometryCurveSplineType",
node_free_standard_storage,
node_copy_standard_storage);
ntype.draw_buttons = blender::nodes::geo_node_legacy_curve_spline_type_layout;
ntype.draw_buttons = file_ns::geo_node_legacy_curve_spline_type_layout;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_subdivide.cc
View File

@ -25,7 +25,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_curve_subdivide_cc {
static void geo_node_curve_subdivide_declare(NodeDeclarationBuilder &b)
{
@ -370,22 +370,24 @@ static void geo_node_subdivide_exec(GeoNodeExecParams params)
params.set_output("Geometry", GeometrySet::create_with_curve(output_curve.release()));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_curve_subdivide_cc
void register_node_type_geo_legacy_curve_subdivide()
{
namespace file_ns = blender::nodes::node_geo_legacy_curve_subdivide_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_CURVE_SUBDIVIDE, "Curve Subdivide", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_subdivide_declare;
ntype.draw_buttons = blender::nodes::geo_node_curve_subdivide_layout;
ntype.declare = file_ns::geo_node_curve_subdivide_declare;
ntype.draw_buttons = file_ns::geo_node_curve_subdivide_layout;
node_type_storage(&ntype,
"NodeGeometryCurveSubdivide",
node_free_standard_storage,
node_copy_standard_storage);
node_type_init(&ntype, blender::nodes::geo_node_curve_subdivide_init);
node_type_update(&ntype, blender::nodes::geo_node_curve_subdivide_update);
ntype.geometry_node_execute = blender::nodes::geo_node_subdivide_exec;
node_type_init(&ntype, file_ns::geo_node_curve_subdivide_init);
node_type_update(&ntype, file_ns::geo_node_curve_subdivide_update);
ntype.geometry_node_execute = file_ns::geo_node_subdivide_exec;
nodeRegisterType(&ntype);
}

114
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_to_points.cc
View File

@ -28,6 +28,58 @@
namespace blender::nodes {
static GMutableSpan create_attribute_and_retrieve_span(PointCloudComponent &points,
const AttributeIDRef &attribute_id,
const CustomDataType data_type)
{
points.attribute_try_create(attribute_id, ATTR_DOMAIN_POINT, data_type, AttributeInitDefault());
WriteAttributeLookup attribute = points.attribute_try_get_for_write(attribute_id);
BLI_assert(attribute);
return attribute.varray.get_internal_span();
}
template<typename T>
static MutableSpan<T> create_attribute_and_retrieve_span(PointCloudComponent &points,
const AttributeIDRef &attribute_id)
{
GMutableSpan attribute = create_attribute_and_retrieve_span(
points, attribute_id, bke::cpp_type_to_custom_data_type(CPPType::get<T>()));
return attribute.typed<T>();
}
CurveToPointsResults curve_to_points_create_result_attributes(PointCloudComponent &points,
const CurveEval &curve)
{
CurveToPointsResults attributes;
attributes.result_size = points.attribute_domain_size(ATTR_DOMAIN_POINT);
attributes.positions = create_attribute_and_retrieve_span<float3>(points, "position");
attributes.radii = create_attribute_and_retrieve_span<float>(points, "radius");
attributes.tilts = create_attribute_and_retrieve_span<float>(points, "tilt");
/* Because of the invariants of the curve component, we use the attributes of the
* first spline as a representative for the attribute meta data all splines. */
curve.splines().first()->attributes.foreach_attribute(
[&](const AttributeIDRef &attribute_id, const AttributeMetaData &meta_data) {
attributes.point_attributes.add_new(
attribute_id,
create_attribute_and_retrieve_span(points, attribute_id, meta_data.data_type));
return true;
},
ATTR_DOMAIN_POINT);
attributes.tangents = create_attribute_and_retrieve_span<float3>(points, "tangent");
attributes.normals = create_attribute_and_retrieve_span<float3>(points, "normal");
attributes.rotations = create_attribute_and_retrieve_span<float3>(points, "rotation");
return attributes;
}
} // namespace blender::nodes
namespace blender::nodes::node_geo_legacy_curve_to_points_cc {
static void geo_node_curve_to_points_declare(NodeDeclarationBuilder &b)
{
b.add_input<decl::Geometry>(N_("Geometry"));
@ -114,54 +166,6 @@ static Array<int> calculate_spline_point_offsets(GeoNodeExecParams &params,
return {0};
}
static GMutableSpan create_attribute_and_retrieve_span(PointCloudComponent &points,
const AttributeIDRef &attribute_id,
const CustomDataType data_type)
{
points.attribute_try_create(attribute_id, ATTR_DOMAIN_POINT, data_type, AttributeInitDefault());
WriteAttributeLookup attribute = points.attribute_try_get_for_write(attribute_id);
BLI_assert(attribute);
return attribute.varray.get_internal_span();
}
template<typename T>
static MutableSpan<T> create_attribute_and_retrieve_span(PointCloudComponent &points,
const AttributeIDRef &attribute_id)
{
GMutableSpan attribute = create_attribute_and_retrieve_span(
points, attribute_id, bke::cpp_type_to_custom_data_type(CPPType::get<T>()));
return attribute.typed<T>();
}
CurveToPointsResults curve_to_points_create_result_attributes(PointCloudComponent &points,
const CurveEval &curve)
{
CurveToPointsResults attributes;
attributes.result_size = points.attribute_domain_size(ATTR_DOMAIN_POINT);
attributes.positions = create_attribute_and_retrieve_span<float3>(points, "position");
attributes.radii = create_attribute_and_retrieve_span<float>(points, "radius");
attributes.tilts = create_attribute_and_retrieve_span<float>(points, "tilt");
/* Because of the invariants of the curve component, we use the attributes of the
* first spline as a representative for the attribute meta data all splines. */
curve.splines().first()->attributes.foreach_attribute(
[&](const AttributeIDRef &attribute_id, const AttributeMetaData &meta_data) {
attributes.point_attributes.add_new(
attribute_id,
create_attribute_and_retrieve_span(points, attribute_id, meta_data.data_type));
return true;
},
ATTR_DOMAIN_POINT);
attributes.tangents = create_attribute_and_retrieve_span<float3>(points, "tangent");
attributes.normals = create_attribute_and_retrieve_span<float3>(points, "normal");
attributes.rotations = create_attribute_and_retrieve_span<float3>(points, "rotation");
return attributes;
}
/**
* TODO: For non-poly splines, this has double copies that could be avoided as part
* of a general look at optimizing uses of #Spline::interpolate_to_evaluated.
@ -340,21 +344,23 @@ static void geo_node_curve_to_points_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(result));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_curve_to_points_cc
void register_node_type_geo_legacy_curve_to_points()
{
namespace file_ns = blender::nodes::node_geo_legacy_curve_to_points_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_CURVE_TO_POINTS, "Curve to Points", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_to_points_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_to_points_exec;
ntype.draw_buttons = blender::nodes::geo_node_curve_to_points_layout;
ntype.declare = file_ns::geo_node_curve_to_points_declare;
ntype.geometry_node_execute = file_ns::geo_node_curve_to_points_exec;
ntype.draw_buttons = file_ns::geo_node_curve_to_points_layout;
node_type_storage(
&ntype, "NodeGeometryCurveToPoints", node_free_standard_storage, node_copy_standard_storage);
node_type_init(&ntype, blender::nodes::geo_node_curve_to_points_init);
node_type_update(&ntype, blender::nodes::geo_node_curve_to_points_update);
node_type_init(&ntype, file_ns::geo_node_curve_to_points_init);
node_type_update(&ntype, file_ns::geo_node_curve_to_points_update);
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_delete_geometry.cc
View File

@ -43,7 +43,7 @@ void copy_masked_polys_to_new_mesh(const Mesh &src_mesh,
blender::Span<int> masked_poly_indices,
blender::Span<int> new_loop_starts);
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_delete_geometry_cc {
static void geo_node_delete_geometry_declare(NodeDeclarationBuilder &b)
{
@ -662,16 +662,18 @@ static void geo_node_delete_geometry_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(out_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_delete_geometry_cc
void register_node_type_geo_legacy_delete_geometry()
{
namespace file_ns = blender::nodes::node_geo_legacy_delete_geometry_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_DELETE_GEOMETRY, "Delete Geometry", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_delete_geometry_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_delete_geometry_exec;
ntype.declare = file_ns::geo_node_delete_geometry_declare;
ntype.geometry_node_execute = file_ns::geo_node_delete_geometry_exec;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_edge_split.cc
View File

@ -22,7 +22,7 @@ extern "C" {
Mesh *doEdgeSplit(const Mesh *mesh, EdgeSplitModifierData *emd);
}
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_edge_split_cc {
static void geo_node_edge_split_declare(NodeDeclarationBuilder &b)
{
@ -76,14 +76,16 @@ static void geo_node_edge_split_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_edge_split_cc
void register_node_type_geo_legacy_edge_split()
{
namespace file_ns = blender::nodes::node_geo_legacy_edge_split_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_LEGACY_EDGE_SPLIT, "Edge Split", NODE_CLASS_GEOMETRY, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_edge_split_exec;
ntype.declare = blender::nodes::geo_node_edge_split_declare;
ntype.geometry_node_execute = file_ns::geo_node_edge_split_exec;
ntype.declare = file_ns::geo_node_edge_split_declare;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_material_assign.cc
View File

@ -24,7 +24,7 @@
#include "BKE_material.h"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_material_assign_cc {
static void geo_node_legacy_material_assign_declare(NodeDeclarationBuilder &b)
{
@ -81,15 +81,17 @@ static void geo_node_legacy_material_assign_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_material_assign_cc
void register_node_type_geo_legacy_material_assign()
{
namespace file_ns = blender::nodes::node_geo_legacy_material_assign_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_MATERIAL_ASSIGN, "Material Assign", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_legacy_material_assign_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_legacy_material_assign_exec;
ntype.declare = file_ns::geo_node_legacy_material_assign_declare;
ntype.geometry_node_execute = file_ns::geo_node_legacy_material_assign_exec;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_mesh_to_curve.cc
View File

@ -18,7 +18,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_mesh_to_curve_cc {
static void geo_node_legacy_mesh_to_curve_declare(NodeDeclarationBuilder &b)
{
@ -65,15 +65,17 @@ static void geo_node_legacy_mesh_to_curve_exec(GeoNodeExecParams params)
params.set_output("Curve", GeometrySet::create_with_curve(curve.release()));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_mesh_to_curve_cc
void register_node_type_geo_legacy_mesh_to_curve()
{
namespace file_ns = blender::nodes::node_geo_legacy_mesh_to_curve_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_MESH_TO_CURVE, "Mesh to Curve", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_legacy_mesh_to_curve_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_legacy_mesh_to_curve_exec;
ntype.declare = file_ns::geo_node_legacy_mesh_to_curve_declare;
ntype.geometry_node_execute = file_ns::geo_node_legacy_mesh_to_curve_exec;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_distribute.cc
View File

@ -36,9 +36,9 @@
#include "node_geometry_util.hh"
using blender::bke::GeometryInstanceGroup;
namespace blender::nodes::node_geo_legacy_point_distribute_cc {
namespace blender::nodes {
using blender::bke::GeometryInstanceGroup;
static void geo_node_point_distribute_declare(NodeDeclarationBuilder &b)
{
@ -655,17 +655,19 @@ static void geo_node_point_distribute_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set_out));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_point_distribute_cc
void register_node_type_geo_point_distribute()
{
namespace file_ns = blender::nodes::node_geo_legacy_point_distribute_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_POINT_DISTRIBUTE, "Point Distribute", NODE_CLASS_GEOMETRY, 0);
node_type_update(&ntype, blender::nodes::node_point_distribute_update);
ntype.declare = blender::nodes::geo_node_point_distribute_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_point_distribute_exec;
ntype.draw_buttons = blender::nodes::geo_node_point_distribute_layout;
node_type_update(&ntype, file_ns::node_point_distribute_update);
ntype.declare = file_ns::geo_node_point_distribute_declare;
ntype.geometry_node_execute = file_ns::geo_node_point_distribute_exec;
ntype.draw_buttons = file_ns::geo_node_point_distribute_layout;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_instance.cc
View File

@ -24,7 +24,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_point_instance_cc {
static void geo_node_point_instance_declare(NodeDeclarationBuilder &b)
{
@ -255,20 +255,22 @@ static void geo_node_point_instance_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set_out));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_point_instance_cc
void register_node_type_geo_point_instance()
{
namespace file_ns = blender::nodes::node_geo_legacy_point_instance_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_POINT_INSTANCE, "Point Instance", NODE_CLASS_GEOMETRY, 0);
node_type_init(&ntype, blender::nodes::geo_node_point_instance_init);
node_type_init(&ntype, file_ns::geo_node_point_instance_init);
node_type_storage(
&ntype, "NodeGeometryPointInstance", node_free_standard_storage, node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_point_instance_declare;
ntype.draw_buttons = blender::nodes::geo_node_point_instance_layout;
node_type_update(&ntype, blender::nodes::geo_node_point_instance_update);
ntype.geometry_node_execute = blender::nodes::geo_node_point_instance_exec;
ntype.declare = file_ns::geo_node_point_instance_declare;
ntype.draw_buttons = file_ns::geo_node_point_instance_layout;
node_type_update(&ntype, file_ns::geo_node_point_instance_update);
ntype.geometry_node_execute = file_ns::geo_node_point_instance_exec;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_rotate.cc
View File

@ -21,7 +21,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_point_rotate_cc {
static void geo_node_point_rotate_declare(NodeDeclarationBuilder &b)
{
@ -218,19 +218,21 @@ static void geo_node_point_rotate_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_point_rotate_cc
void register_node_type_geo_point_rotate()
{
namespace file_ns = blender::nodes::node_geo_legacy_point_rotate_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_LEGACY_POINT_ROTATE, "Point Rotate", NODE_CLASS_GEOMETRY, 0);
node_type_init(&ntype, blender::nodes::geo_node_point_rotate_init);
node_type_update(&ntype, blender::nodes::geo_node_point_rotate_update);
node_type_init(&ntype, file_ns::geo_node_point_rotate_init);
node_type_update(&ntype, file_ns::geo_node_point_rotate_update);
node_type_storage(
&ntype, "NodeGeometryRotatePoints", node_free_standard_storage, node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_point_rotate_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_point_rotate_exec;
ntype.draw_buttons = blender::nodes::geo_node_point_rotate_layout;
ntype.declare = file_ns::geo_node_point_rotate_declare;
ntype.geometry_node_execute = file_ns::geo_node_point_rotate_exec;
ntype.draw_buttons = file_ns::geo_node_point_rotate_layout;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_scale.cc
View File

@ -21,7 +21,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_point_scale_cc {
static void geo_node_point_scale_declare(NodeDeclarationBuilder &b)
{
@ -120,20 +120,22 @@ static void geo_node_point_scale_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_point_scale_cc
void register_node_type_geo_point_scale()
{
namespace file_ns = blender::nodes::node_geo_legacy_point_scale_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_LEGACY_POINT_SCALE, "Point Scale", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_point_scale_declare;
node_type_init(&ntype, blender::nodes::geo_node_point_scale_init);
node_type_update(&ntype, blender::nodes::geo_node_point_scale_update);
ntype.declare = file_ns::geo_node_point_scale_declare;
node_type_init(&ntype, file_ns::geo_node_point_scale_init);
node_type_update(&ntype, file_ns::geo_node_point_scale_update);
node_type_storage(
&ntype, "NodeGeometryPointScale", node_free_standard_storage, node_copy_standard_storage);
ntype.geometry_node_execute = blender::nodes::geo_node_point_scale_exec;
ntype.draw_buttons = blender::nodes::geo_node_point_scale_layout;
ntype.geometry_node_execute = file_ns::geo_node_point_scale_exec;
ntype.draw_buttons = file_ns::geo_node_point_scale_layout;
nodeRegisterType(&ntype);
}

28
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_separate.cc
View File

@ -25,14 +25,6 @@
namespace blender::nodes {
static void geo_node_point_instance_declare(NodeDeclarationBuilder &b)
{
b.add_input<decl::Geometry>(N_("Geometry"));
b.add_input<decl::String>(N_("Mask"));
b.add_output<decl::Geometry>(N_("Geometry 1"));
b.add_output<decl::Geometry>(N_("Geometry 2"));
}
template<typename T>
static void copy_data_based_on_mask(Span<T> data,
Span<bool> masks,
@ -78,6 +70,18 @@ void copy_point_attributes_based_on_mask(const GeometryComponent &in_component,
}
}
} // namespace blender::nodes
namespace blender::nodes::node_geo_legacy_point_separate_cc {
static void geo_node_point_instance_declare(NodeDeclarationBuilder &b)
{
b.add_input<decl::Geometry>(N_("Geometry"));
b.add_input<decl::String>(N_("Mask"));
b.add_output<decl::Geometry>(N_("Geometry 1"));
b.add_output<decl::Geometry>(N_("Geometry 2"));
}
static void create_component_points(GeometryComponent &component, const int total)
{
switch (component.type()) {
@ -158,16 +162,18 @@ static void geo_node_point_separate_exec(GeoNodeExecParams params)
}
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_point_separate_cc
void register_node_type_geo_point_separate()
{
namespace file_ns = blender::nodes::node_geo_legacy_point_separate_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_POINT_SEPARATE, "Point Separate", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_point_instance_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_point_separate_exec;
ntype.declare = file_ns::geo_node_point_instance_declare;
ntype.geometry_node_execute = file_ns::geo_node_point_separate_exec;
ntype.geometry_node_execute_supports_laziness = true;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_point_translate.cc
View File

@ -19,7 +19,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_point_translate_cc {
static void geo_node_point_translate_declare(NodeDeclarationBuilder &b)
{
@ -89,22 +89,24 @@ static void geo_node_point_translate_update(bNodeTree *ntree, bNode *node)
*ntree, *node, "Translation", (GeometryNodeAttributeInputMode)node_storage.input_type);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_point_translate_cc
void register_node_type_geo_point_translate()
{
namespace file_ns = blender::nodes::node_geo_legacy_point_translate_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_POINT_TRANSLATE, "Point Translate", NODE_CLASS_GEOMETRY, 0);
node_type_init(&ntype, blender::nodes::geo_node_point_translate_init);
node_type_update(&ntype, blender::nodes::geo_node_point_translate_update);
node_type_init(&ntype, file_ns::geo_node_point_translate_init);
node_type_update(&ntype, file_ns::geo_node_point_translate_update);
node_type_storage(&ntype,
"NodeGeometryPointTranslate",
node_free_standard_storage,
node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_point_translate_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_point_translate_exec;
ntype.draw_buttons = blender::nodes::geo_node_point_translate_layout;
ntype.declare = file_ns::geo_node_point_translate_declare;
ntype.geometry_node_execute = file_ns::geo_node_point_translate_exec;
ntype.draw_buttons = file_ns::geo_node_point_translate_layout;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_points_to_volume.cc
View File

@ -28,7 +28,7 @@
#include "UI_interface.h"
#include "UI_resources.h"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_points_to_volume_cc {
static void geo_node_points_to_volume_declare(NodeDeclarationBuilder &b)
{
@ -259,10 +259,12 @@ static void geo_node_points_to_volume_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set_out));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_points_to_volume_cc
void register_node_type_geo_legacy_points_to_volume()
{
namespace file_ns = blender::nodes::node_geo_legacy_points_to_volume_cc;
static bNodeType ntype;
geo_node_type_base(
@ -272,10 +274,10 @@ void register_node_type_geo_legacy_points_to_volume()
node_free_standard_storage,
node_copy_standard_storage);
node_type_size(&ntype, 170, 120, 700);
node_type_init(&ntype, blender::nodes::geo_node_points_to_volume_init);
node_type_update(&ntype, blender::nodes::geo_node_points_to_volume_update);
ntype.declare = blender::nodes::geo_node_points_to_volume_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_points_to_volume_exec;
ntype.draw_buttons = blender::nodes::geo_node_points_to_volume_layout;
node_type_init(&ntype, file_ns::geo_node_points_to_volume_init);
node_type_update(&ntype, file_ns::geo_node_points_to_volume_update);
ntype.declare = file_ns::geo_node_points_to_volume_declare;
ntype.geometry_node_execute = file_ns::geo_node_points_to_volume_exec;
ntype.draw_buttons = file_ns::geo_node_points_to_volume_layout;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_raycast.cc
View File

@ -24,7 +24,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_raycast_cc {
static void geo_node_raycast_declare(NodeDeclarationBuilder &b)
{
@ -307,20 +307,22 @@ static void geo_node_raycast_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_raycast_cc
void register_node_type_geo_legacy_raycast()
{
namespace file_ns = blender::nodes::node_geo_legacy_raycast_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_LEGACY_RAYCAST, "Raycast", NODE_CLASS_GEOMETRY, 0);
node_type_size_preset(&ntype, NODE_SIZE_LARGE);
node_type_init(&ntype, blender::nodes::geo_node_raycast_init);
node_type_update(&ntype, blender::nodes::geo_node_raycast_update);
node_type_init(&ntype, file_ns::geo_node_raycast_init);
node_type_update(&ntype, file_ns::geo_node_raycast_update);
node_type_storage(
&ntype, "NodeGeometryRaycast", node_free_standard_storage, node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_raycast_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_raycast_exec;
ntype.draw_buttons = blender::nodes::geo_node_raycast_layout;
ntype.declare = file_ns::geo_node_raycast_declare;
ntype.geometry_node_execute = file_ns::geo_node_raycast_exec;
ntype.draw_buttons = file_ns::geo_node_raycast_layout;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_select_by_material.cc
View File

@ -26,7 +26,7 @@
#include "BKE_material.h"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_select_by_material_cc {
static void geo_node_legacy_select_by_material_declare(NodeDeclarationBuilder &b)
{
@ -78,15 +78,17 @@ static void geo_node_legacy_select_by_material_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_select_by_material_cc
void register_node_type_geo_legacy_select_by_material()
{
namespace file_ns = blender::nodes::node_geo_legacy_select_by_material_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_SELECT_BY_MATERIAL, "Select by Material", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_legacy_select_by_material_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_legacy_select_by_material_exec;
ntype.declare = file_ns::geo_node_legacy_select_by_material_declare;
ntype.geometry_node_execute = file_ns::geo_node_legacy_select_by_material_exec;
nodeRegisterType(&ntype);
}

14
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_subdivision_surface.cc
View File

@ -23,7 +23,7 @@
#include "UI_resources.h"
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_subdivision_surface_cc {
static void geo_node_subdivision_surface_declare(NodeDeclarationBuilder &b)
{
@ -126,18 +126,20 @@ static void geo_node_subdivision_surface_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_subdivision_surface_cc
void register_node_type_geo_legacy_subdivision_surface()
{
namespace file_ns = blender::nodes::node_geo_legacy_subdivision_surface_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_SUBDIVISION_SURFACE, "Subdivision Surface", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_subdivision_surface_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_subdivision_surface_exec;
ntype.draw_buttons = blender::nodes::geo_node_subdivision_surface_layout;
node_type_init(&ntype, blender::nodes::geo_node_subdivision_surface_init);
ntype.declare = file_ns::geo_node_subdivision_surface_declare;
ntype.geometry_node_execute = file_ns::geo_node_subdivision_surface_exec;
ntype.draw_buttons = file_ns::geo_node_subdivision_surface_layout;
node_type_init(&ntype, file_ns::geo_node_subdivision_surface_init);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
node_type_storage(&ntype,
"NodeGeometrySubdivisionSurface",

16
source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_volume_to_mesh.cc
View File

@ -35,7 +35,7 @@
#include "UI_interface.h"
#include "UI_resources.h"
namespace blender::nodes {
namespace blender::nodes::node_geo_legacy_volume_to_mesh_cc {
static void geo_node_volume_to_mesh_declare(NodeDeclarationBuilder &b)
{
@ -155,21 +155,23 @@ static void geo_node_volume_to_mesh_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set_out);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_legacy_volume_to_mesh_cc
void register_node_type_geo_legacy_volume_to_mesh()
{
namespace file_ns = blender::nodes::node_geo_legacy_volume_to_mesh_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_LEGACY_VOLUME_TO_MESH, "Volume to Mesh", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_volume_to_mesh_declare;
ntype.declare = file_ns::geo_node_volume_to_mesh_declare;
node_type_storage(
&ntype, "NodeGeometryVolumeToMesh", node_free_standard_storage, node_copy_standard_storage);
node_type_size(&ntype, 170, 120, 700);
node_type_init(&ntype, blender::nodes::geo_node_volume_to_mesh_init);
node_type_update(&ntype, blender::nodes::geo_node_volume_to_mesh_update);
ntype.geometry_node_execute = blender::nodes::geo_node_volume_to_mesh_exec;
ntype.draw_buttons = blender::nodes::geo_node_volume_to_mesh_layout;
node_type_init(&ntype, file_ns::geo_node_volume_to_mesh_init);
node_type_update(&ntype, file_ns::geo_node_volume_to_mesh_update);
ntype.geometry_node_execute = file_ns::geo_node_volume_to_mesh_exec;
ntype.draw_buttons = file_ns::geo_node_volume_to_mesh_layout;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/node_geo_attribute_capture.cc
View File

@ -21,7 +21,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_attribute_capture_cc {
static void geo_node_attribute_capture_declare(NodeDeclarationBuilder &b)
{
@ -200,10 +200,12 @@ static void geo_node_attribute_capture_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_attribute_capture_cc
void register_node_type_geo_attribute_capture()
{
namespace file_ns = blender::nodes::node_geo_attribute_capture_cc;
static bNodeType ntype;
geo_node_type_base(
@ -212,10 +214,10 @@ void register_node_type_geo_attribute_capture()
"NodeGeometryAttributeCapture",
node_free_standard_storage,
node_copy_standard_storage);
node_type_init(&ntype, blender::nodes::geo_node_attribute_capture_init);
node_type_update(&ntype, blender::nodes::geo_node_attribute_capture_update);
ntype.declare = blender::nodes::geo_node_attribute_capture_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_capture_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_capture_layout;
node_type_init(&ntype, file_ns::geo_node_attribute_capture_init);
node_type_update(&ntype, file_ns::geo_node_attribute_capture_update);
ntype.declare = file_ns::geo_node_attribute_capture_declare;
ntype.geometry_node_execute = file_ns::geo_node_attribute_capture_exec;
ntype.draw_buttons = file_ns::geo_node_attribute_capture_layout;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_attribute_remove.cc
View File

@ -16,7 +16,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_attribute_remove_cc {
static void geo_node_attribute_remove_declare(NodeDeclarationBuilder &b)
{
@ -66,15 +66,17 @@ static void geo_node_attribute_remove_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_attribute_remove_cc
void register_node_type_geo_attribute_remove()
{
namespace file_ns = blender::nodes::node_geo_attribute_remove_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_ATTRIBUTE_REMOVE, "Attribute Remove", NODE_CLASS_ATTRIBUTE, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_remove_exec;
ntype.declare = blender::nodes::geo_node_attribute_remove_declare;
ntype.geometry_node_execute = file_ns::geo_node_attribute_remove_exec;
ntype.declare = file_ns::geo_node_attribute_remove_declare;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/node_geo_attribute_statistic.cc
View File

@ -24,7 +24,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_attribute_statistic_cc {
static void geo_node_attribute_statistic_declare(NodeDeclarationBuilder &b)
{
@ -360,19 +360,21 @@ static void geo_node_attribute_statistic_exec(GeoNodeExecParams params)
}
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_attribute_statistic_cc
void register_node_type_geo_attribute_statistic()
{
namespace file_ns = blender::nodes::node_geo_attribute_statistic_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_ATTRIBUTE_STATISTIC, "Attribute Statistic", NODE_CLASS_ATTRIBUTE, 0);
ntype.declare = blender::nodes::geo_node_attribute_statistic_declare;
node_type_init(&ntype, blender::nodes::geo_node_attribute_statistic_init);
node_type_update(&ntype, blender::nodes::geo_node_attribute_statistic_update);
ntype.geometry_node_execute = blender::nodes::geo_node_attribute_statistic_exec;
ntype.draw_buttons = blender::nodes::geo_node_attribute_statistic_layout;
ntype.declare = file_ns::geo_node_attribute_statistic_declare;
node_type_init(&ntype, file_ns::geo_node_attribute_statistic_init);
node_type_update(&ntype, file_ns::geo_node_attribute_statistic_update);
ntype.geometry_node_execute = file_ns::geo_node_attribute_statistic_exec;
ntype.draw_buttons = file_ns::geo_node_attribute_statistic_layout;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/node_geo_boolean.cc
View File

@ -23,7 +23,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_boolean_cc {
static void geo_node_boolean_declare(NodeDeclarationBuilder &b)
{
@ -119,17 +119,19 @@ static void geo_node_boolean_exec(GeoNodeExecParams params)
params.set_output("Mesh", GeometrySet::create_with_mesh(result));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_boolean_cc
void register_node_type_geo_boolean()
{
namespace file_ns = blender::nodes::node_geo_boolean_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_MESH_BOOLEAN, "Mesh Boolean", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_boolean_declare;
ntype.draw_buttons = blender::nodes::geo_node_boolean_layout;
ntype.updatefunc = blender::nodes::geo_node_boolean_update;
node_type_init(&ntype, blender::nodes::geo_node_boolean_init);
ntype.geometry_node_execute = blender::nodes::geo_node_boolean_exec;
ntype.declare = file_ns::geo_node_boolean_declare;
ntype.draw_buttons = file_ns::geo_node_boolean_layout;
ntype.updatefunc = file_ns::geo_node_boolean_update;
node_type_init(&ntype, file_ns::geo_node_boolean_init);
ntype.geometry_node_execute = file_ns::geo_node_boolean_exec;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_bounding_box.cc
View File

@ -16,7 +16,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_bounding_box_cc {
static void geo_node_bounding_box_declare(NodeDeclarationBuilder &b)
{
@ -78,14 +78,16 @@ static void geo_node_bounding_box_exec(GeoNodeExecParams params)
}
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_bounding_box_cc
void register_node_type_geo_bounding_box()
{
namespace file_ns = blender::nodes::node_geo_bounding_box_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_BOUNDING_BOX, "Bounding Box", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_bounding_box_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_bounding_box_exec;
ntype.declare = file_ns::geo_node_bounding_box_declare;
ntype.geometry_node_execute = file_ns::geo_node_bounding_box_exec;
nodeRegisterType(&ntype);
}

14
source/blender/nodes/geometry/nodes/node_geo_collection_info.cc
View File

@ -27,7 +27,7 @@
#include <algorithm>
namespace blender::nodes {
namespace blender::nodes::node_geo_collection_info_cc {
static void geo_node_collection_info_declare(NodeDeclarationBuilder &b)
{
@ -155,20 +155,22 @@ static void geo_node_collection_info_exec(GeoNodeExecParams params)
params.set_output("Geometry", geometry_set_out);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_collection_info_cc
void register_node_type_geo_collection_info()
{
namespace file_ns = blender::nodes::node_geo_collection_info_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_COLLECTION_INFO, "Collection Info", NODE_CLASS_INPUT, 0);
ntype.declare = blender::nodes::geo_node_collection_info_declare;
node_type_init(&ntype, blender::nodes::geo_node_collection_info_node_init);
ntype.declare = file_ns::geo_node_collection_info_declare;
node_type_init(&ntype, file_ns::geo_node_collection_info_node_init);
node_type_storage(&ntype,
"NodeGeometryCollectionInfo",
node_free_standard_storage,
node_copy_standard_storage);
ntype.geometry_node_execute = blender::nodes::geo_node_collection_info_exec;
ntype.draw_buttons = blender::nodes::geo_node_collection_info_layout;
ntype.geometry_node_execute = file_ns::geo_node_collection_info_exec;
ntype.draw_buttons = file_ns::geo_node_collection_info_layout;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_convex_hull.cc
View File

@ -28,7 +28,7 @@
# include "RBI_hull_api.h"
#endif
namespace blender::nodes {
namespace blender::nodes::node_geo_convex_hull_cc {
static void geo_node_convex_hull_declare(NodeDeclarationBuilder &b)
{
@ -316,14 +316,16 @@ static void geo_node_convex_hull_exec(GeoNodeExecParams params)
#endif /* WITH_BULLET */
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_convex_hull_cc
void register_node_type_geo_convex_hull()
{
namespace file_ns = blender::nodes::node_geo_convex_hull_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_CONVEX_HULL, "Convex Hull", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_convex_hull_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_convex_hull_exec;
ntype.declare = file_ns::geo_node_convex_hull_declare;
ntype.geometry_node_execute = file_ns::geo_node_convex_hull_exec;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_curve_endpoint_selection.cc
View File

@ -21,7 +21,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_curve_endpoint_select_cc {
static void geo_node_curve_endpoint_selection_declare(NodeDeclarationBuilder &b)
{
@ -138,16 +138,18 @@ static void geo_node_curve_endpoint_selection_exec(GeoNodeExecParams params)
Field<bool> selection_field{std::make_shared<EndpointFieldInput>(start_size, end_size)};
params.set_output("Selection", std::move(selection_field));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_endpoint_select_cc
void register_node_type_geo_curve_endpoint_selection()
{
namespace file_ns = blender::nodes::node_geo_curve_endpoint_select_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_CURVE_ENDPOINT_SELECTION, "Endpoint Selection", NODE_CLASS_INPUT, 0);
ntype.declare = blender::nodes::geo_node_curve_endpoint_selection_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_endpoint_selection_exec;
ntype.declare = file_ns::geo_node_curve_endpoint_selection_declare;
ntype.geometry_node_execute = file_ns::geo_node_curve_endpoint_selection_exec;
nodeRegisterType(&ntype);
}

14
source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc
View File

@ -31,7 +31,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_curve_fill_cc {
static void geo_node_curve_fill_declare(NodeDeclarationBuilder &b)
{
@ -160,19 +160,21 @@ static void geo_node_curve_fill_exec(GeoNodeExecParams params)
params.set_output("Mesh", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_fill_cc
void register_node_type_geo_curve_fill()
{
namespace file_ns = blender::nodes::node_geo_curve_fill_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_FILL_CURVE, "Fill Curve", NODE_CLASS_GEOMETRY, 0);
node_type_init(&ntype, blender::nodes::geo_node_curve_fill_init);
node_type_init(&ntype, file_ns::geo_node_curve_fill_init);
node_type_storage(
&ntype, "NodeGeometryCurveFill", node_free_standard_storage, node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_curve_fill_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_fill_exec;
ntype.draw_buttons = blender::nodes::geo_node_curve_fill_layout;
ntype.declare = file_ns::geo_node_curve_fill_declare;
ntype.geometry_node_execute = file_ns::geo_node_curve_fill_exec;
ntype.draw_buttons = file_ns::geo_node_curve_fill_layout;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc
View File

@ -25,7 +25,7 @@
#include "BKE_spline.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_curve_fillet_cc {
static void geo_node_curve_fillet_declare(NodeDeclarationBuilder &b)
{
@ -629,19 +629,21 @@ static void geo_node_fillet_exec(GeoNodeExecParams params)
params.set_output("Curve", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_fillet_cc
void register_node_type_geo_curve_fillet()
{
namespace file_ns = blender::nodes::node_geo_curve_fillet_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_FILLET_CURVE, "Fillet Curve", NODE_CLASS_GEOMETRY, 0);
ntype.draw_buttons = blender::nodes::geo_node_curve_fillet_layout;
ntype.draw_buttons = file_ns::geo_node_curve_fillet_layout;
node_type_storage(
&ntype, "NodeGeometryCurveFillet", node_free_standard_storage, node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_curve_fillet_declare;
node_type_init(&ntype, blender::nodes::geo_node_curve_fillet_init);
node_type_update(&ntype, blender::nodes::geo_node_curve_fillet_update);
ntype.geometry_node_execute = blender::nodes::geo_node_fillet_exec;
ntype.declare = file_ns::geo_node_curve_fillet_declare;
node_type_init(&ntype, file_ns::geo_node_curve_fillet_init);
node_type_update(&ntype, file_ns::geo_node_curve_fillet_update);
ntype.geometry_node_execute = file_ns::geo_node_fillet_exec;
nodeRegisterType(&ntype);
}

14
source/blender/nodes/geometry/nodes/node_geo_curve_handle_type_selection.cc
View File

@ -21,7 +21,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_curve_handle_type_selection_cc {
static void geo_node_curve_handle_type_selection_declare(NodeDeclarationBuilder &b)
{
@ -152,22 +152,24 @@ static void geo_node_curve_handle_type_selection_exec(GeoNodeExecParams params)
params.set_output("Selection", std::move(selection_field));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_handle_type_selection_cc
void register_node_type_geo_curve_handle_type_selection()
{
namespace file_ns = blender::nodes::node_geo_curve_handle_type_selection_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_CURVE_HANDLE_TYPE_SELECTION, "Handle Type Selection", NODE_CLASS_INPUT, 0);
ntype.declare = blender::nodes::geo_node_curve_handle_type_selection_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_handle_type_selection_exec;
node_type_init(&ntype, blender::nodes::geo_node_curve_handle_type_selection_init);
ntype.declare = file_ns::geo_node_curve_handle_type_selection_declare;
ntype.geometry_node_execute = file_ns::geo_node_curve_handle_type_selection_exec;
node_type_init(&ntype, file_ns::geo_node_curve_handle_type_selection_init);
node_type_storage(&ntype,
"NodeGeometryCurveSelectHandles",
node_free_standard_storage,
node_copy_standard_storage);
ntype.draw_buttons = blender::nodes::geo_node_curve_handle_type_selection_layout;
ntype.draw_buttons = file_ns::geo_node_curve_handle_type_selection_layout;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_curve_length.cc
View File

@ -17,7 +17,7 @@
#include "BKE_spline.hh"
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_curve_length_cc {
static void geo_node_curve_length_declare(NodeDeclarationBuilder &b)
{
@ -40,14 +40,16 @@ static void geo_node_curve_length_exec(GeoNodeExecParams params)
params.set_output("Length", length);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_length_cc
void register_node_type_geo_curve_length()
{
namespace file_ns = blender::nodes::node_geo_curve_length_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_CURVE_LENGTH, "Curve Length", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_length_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_length_exec;
ntype.declare = file_ns::geo_node_curve_length_declare;
ntype.geometry_node_execute = file_ns::geo_node_curve_length_exec;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_curve_parameter.cc
View File

@ -20,7 +20,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_curve_parameter_cc {
static void geo_node_curve_parameter_declare(NodeDeclarationBuilder &b)
{
@ -269,13 +269,15 @@ static void geo_node_curve_parameter_exec(GeoNodeExecParams params)
params.set_output("Length", std::move(length_field));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_parameter_cc
void register_node_type_geo_curve_parameter()
{
namespace file_ns = blender::nodes::node_geo_curve_parameter_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_CURVE_PARAMETER, "Curve Parameter", NODE_CLASS_INPUT, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_curve_parameter_exec;
ntype.declare = blender::nodes::geo_node_curve_parameter_declare;
ntype.geometry_node_execute = file_ns::geo_node_curve_parameter_exec;
ntype.declare = file_ns::geo_node_curve_parameter_declare;
nodeRegisterType(&ntype);
}

14
source/blender/nodes/geometry/nodes/node_geo_curve_primitive_bezier_segment.cc
View File

@ -21,7 +21,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_curve_primitive_bezier_segment_cc {
static void geo_node_curve_primitive_bezier_segment_declare(NodeDeclarationBuilder &b)
{
@ -137,20 +137,22 @@ static void geo_node_curve_primitive_bezier_segment_exec(GeoNodeExecParams param
params.set_output("Curve", GeometrySet::create_with_curve(curve.release()));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_primitive_bezier_segment_cc
void register_node_type_geo_curve_primitive_bezier_segment()
{
namespace file_ns = blender::nodes::node_geo_curve_primitive_bezier_segment_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_CURVE_PRIMITIVE_BEZIER_SEGMENT, "Bezier Segment", NODE_CLASS_GEOMETRY, 0);
node_type_init(&ntype, blender::nodes::geo_node_curve_primitive_bezier_segment_init);
node_type_init(&ntype, file_ns::geo_node_curve_primitive_bezier_segment_init);
node_type_storage(&ntype,
"NodeGeometryCurvePrimitiveBezierSegment",
node_free_standard_storage,
node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_curve_primitive_bezier_segment_declare;
ntype.draw_buttons = blender::nodes::geo_node_curve_primitive_bezier_segment_layout;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_primitive_bezier_segment_exec;
ntype.declare = file_ns::geo_node_curve_primitive_bezier_segment_declare;
ntype.draw_buttons = file_ns::geo_node_curve_primitive_bezier_segment_layout;
ntype.geometry_node_execute = file_ns::geo_node_curve_primitive_bezier_segment_exec;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/node_geo_curve_primitive_circle.cc
View File

@ -21,7 +21,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_curve_primitive_circle_cc {
static void geo_node_curve_primitive_circle_declare(NodeDeclarationBuilder &b)
{
@ -226,22 +226,24 @@ static void geo_node_curve_primitive_circle_exec(GeoNodeExecParams params)
}
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_primitive_circle_cc
void register_node_type_geo_curve_primitive_circle()
{
namespace file_ns = blender::nodes::node_geo_curve_primitive_circle_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_CURVE_PRIMITIVE_CIRCLE, "Curve Circle", NODE_CLASS_GEOMETRY, 0);
node_type_init(&ntype, blender::nodes::geo_node_curve_primitive_circle_init);
node_type_update(&ntype, blender::nodes::geo_node_curve_primitive_circle_update);
node_type_init(&ntype, file_ns::geo_node_curve_primitive_circle_init);
node_type_update(&ntype, file_ns::geo_node_curve_primitive_circle_update);
node_type_storage(&ntype,
"NodeGeometryCurvePrimitiveCircle",
node_free_standard_storage,
node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_curve_primitive_circle_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_primitive_circle_exec;
ntype.draw_buttons = blender::nodes::geo_node_curve_primitive_circle_layout;
ntype.declare = file_ns::geo_node_curve_primitive_circle_declare;
ntype.geometry_node_execute = file_ns::geo_node_curve_primitive_circle_exec;
ntype.draw_buttons = file_ns::geo_node_curve_primitive_circle_layout;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/node_geo_curve_primitive_line.cc
View File

@ -21,7 +21,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_curve_primitive_line_cc {
static void geo_node_curve_primitive_line_declare(NodeDeclarationBuilder &b)
{
@ -134,20 +134,22 @@ static void geo_node_curve_primitive_line_exec(GeoNodeExecParams params)
params.set_output("Curve", GeometrySet::create_with_curve(curve.release()));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_primitive_line_cc
void register_node_type_geo_curve_primitive_line()
{
namespace file_ns = blender::nodes::node_geo_curve_primitive_line_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_CURVE_PRIMITIVE_LINE, "Curve Line", NODE_CLASS_GEOMETRY, 0);
node_type_init(&ntype, blender::nodes::geo_node_curve_primitive_line_init);
node_type_update(&ntype, blender::nodes::geo_node_curve_primitive_line_update);
node_type_init(&ntype, file_ns::geo_node_curve_primitive_line_init);
node_type_update(&ntype, file_ns::geo_node_curve_primitive_line_update);
node_type_storage(&ntype,
"NodeGeometryCurvePrimitiveLine",
node_free_standard_storage,
node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_curve_primitive_line_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_primitive_line_exec;
ntype.draw_buttons = blender::nodes::geo_node_curve_primitive_line_layout;
ntype.declare = file_ns::geo_node_curve_primitive_line_declare;
ntype.geometry_node_execute = file_ns::geo_node_curve_primitive_line_exec;
ntype.draw_buttons = file_ns::geo_node_curve_primitive_line_layout;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadratic_bezier.cc
View File

@ -17,7 +17,7 @@
#include "BKE_spline.hh"
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_curve_primitive_quadratic_bezier_cc {
static void geo_node_curve_primitive_quadratic_bezier_declare(NodeDeclarationBuilder &b)
{
@ -74,17 +74,19 @@ static void geo_node_curve_primitive_quadratic_bezier_exec(GeoNodeExecParams par
params.set_output("Curve", GeometrySet::create_with_curve(curve.release()));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_primitive_quadratic_bezier_cc
void register_node_type_geo_curve_primitive_quadratic_bezier()
{
namespace file_ns = blender::nodes::node_geo_curve_primitive_quadratic_bezier_cc;
static bNodeType ntype;
geo_node_type_base(&ntype,
GEO_NODE_CURVE_PRIMITIVE_QUADRATIC_BEZIER,
"Quadratic Bezier",
NODE_CLASS_GEOMETRY,
0);
ntype.declare = blender::nodes::geo_node_curve_primitive_quadratic_bezier_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_primitive_quadratic_bezier_exec;
ntype.declare = file_ns::geo_node_curve_primitive_quadratic_bezier_declare;
ntype.geometry_node_execute = file_ns::geo_node_curve_primitive_quadratic_bezier_exec;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadrilateral.cc
View File

@ -19,7 +19,7 @@
#include "UI_resources.h"
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_curve_primitive_quadrilaterial_cc {
static void geo_node_curve_primitive_quadrilateral_declare(NodeDeclarationBuilder &b)
{
@ -255,18 +255,20 @@ static void geo_node_curve_primitive_quadrilateral_exec(GeoNodeExecParams params
params.set_output("Curve", GeometrySet::create_with_curve(curve.release()));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_primitive_quadrilaterial_cc
void register_node_type_geo_curve_primitive_quadrilateral()
{
namespace file_ns = blender::nodes::node_geo_curve_primitive_quadrilaterial_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_CURVE_PRIMITIVE_QUADRILATERAL, "Quadrilateral", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_primitive_quadrilateral_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_primitive_quadrilateral_exec;
ntype.draw_buttons = blender::nodes::geo_node_curve_primitive_quadrilateral_layout;
node_type_update(&ntype, blender::nodes::geo_node_curve_primitive_quadrilateral_update);
node_type_init(&ntype, blender::nodes::geo_node_curve_primitive_quadrilateral_init);
ntype.declare = file_ns::geo_node_curve_primitive_quadrilateral_declare;
ntype.geometry_node_execute = file_ns::geo_node_curve_primitive_quadrilateral_exec;
ntype.draw_buttons = file_ns::geo_node_curve_primitive_quadrilateral_layout;
node_type_update(&ntype, file_ns::geo_node_curve_primitive_quadrilateral_update);
node_type_init(&ntype, file_ns::geo_node_curve_primitive_quadrilateral_init);
node_type_storage(&ntype,
"NodeGeometryCurvePrimitiveQuad",
node_free_standard_storage,

10
source/blender/nodes/geometry/nodes/node_geo_curve_primitive_spiral.cc
View File

@ -18,7 +18,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_curve_primitive_spiral_cc {
static void geo_node_curve_primitive_spiral_declare(NodeDeclarationBuilder &b)
{
@ -99,14 +99,16 @@ static void geo_node_curve_primitive_spiral_exec(GeoNodeExecParams params)
params.set_output("Curve", GeometrySet::create_with_curve(curve.release()));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_primitive_spiral_cc
void register_node_type_geo_curve_primitive_spiral()
{
namespace file_ns = blender::nodes::node_geo_curve_primitive_spiral_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_CURVE_PRIMITIVE_SPIRAL, "Spiral", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_primitive_spiral_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_primitive_spiral_exec;
ntype.declare = file_ns::geo_node_curve_primitive_spiral_declare;
ntype.geometry_node_execute = file_ns::geo_node_curve_primitive_spiral_exec;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_curve_primitive_star.cc
View File

@ -18,7 +18,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_curve_primitive_star_cc {
static void geo_node_curve_primitive_star_declare(NodeDeclarationBuilder &b)
{
@ -103,13 +103,15 @@ static void geo_node_curve_primitive_star_exec(GeoNodeExecParams params)
}
params.set_output("Curve", std::move(output));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_primitive_star_cc
void register_node_type_geo_curve_primitive_star()
{
namespace file_ns = blender::nodes::node_geo_curve_primitive_star_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_CURVE_PRIMITIVE_STAR, "Star", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_primitive_star_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_primitive_star_exec;
ntype.declare = file_ns::geo_node_curve_primitive_star_declare;
ntype.geometry_node_execute = file_ns::geo_node_curve_primitive_star_exec;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/node_geo_curve_resample.cc
View File

@ -26,7 +26,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_curve_resample_cc {
static void geo_node_curve_resample_declare(NodeDeclarationBuilder &b)
{
@ -285,19 +285,21 @@ static void geo_node_resample_exec(GeoNodeExecParams params)
params.set_output("Curve", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_resample_cc
void register_node_type_geo_curve_resample()
{
namespace file_ns = blender::nodes::node_geo_curve_resample_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_RESAMPLE_CURVE, "Resample Curve", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_resample_declare;
ntype.draw_buttons = blender::nodes::geo_node_curve_resample_layout;
ntype.declare = file_ns::geo_node_curve_resample_declare;
ntype.draw_buttons = file_ns::geo_node_curve_resample_layout;
node_type_storage(
&ntype, "NodeGeometryCurveResample", node_free_standard_storage, node_copy_standard_storage);
node_type_init(&ntype, blender::nodes::geo_node_curve_resample_init);
node_type_update(&ntype, blender::nodes::geo_node_curve_resample_update);
ntype.geometry_node_execute = blender::nodes::geo_node_resample_exec;
node_type_init(&ntype, file_ns::geo_node_curve_resample_init);
node_type_update(&ntype, file_ns::geo_node_curve_resample_update);
ntype.geometry_node_execute = file_ns::geo_node_resample_exec;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_curve_reverse.cc
View File

@ -20,7 +20,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_curve_reverse_cc {
static void geo_node_curve_reverse_declare(NodeDeclarationBuilder &b)
{
@ -60,13 +60,15 @@ static void geo_node_curve_reverse_exec(GeoNodeExecParams params)
params.set_output("Curve", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_reverse_cc
void register_node_type_geo_curve_reverse()
{
namespace file_ns = blender::nodes::node_geo_curve_reverse_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_REVERSE_CURVE, "Reverse Curve", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_reverse_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_reverse_exec;
ntype.declare = file_ns::geo_node_curve_reverse_declare;
ntype.geometry_node_execute = file_ns::geo_node_curve_reverse_exec;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/node_geo_curve_sample.cc
View File

@ -23,7 +23,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_curve_sample_cc {
static void geo_node_curve_sample_declare(NodeDeclarationBuilder &b)
{
@ -271,20 +271,22 @@ static void geo_node_curve_sample_exec(GeoNodeExecParams params)
params.set_output("Normal", Field<float3>(sample_op, 2));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_sample_cc
void register_node_type_geo_curve_sample()
{
namespace file_ns = blender::nodes::node_geo_curve_sample_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_SAMPLE_CURVE, " Sample Curve", NODE_CLASS_GEOMETRY, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_curve_sample_exec;
ntype.declare = blender::nodes::geo_node_curve_sample_declare;
node_type_init(&ntype, blender::nodes::geo_node_curve_sample_type_init);
node_type_update(&ntype, blender::nodes::geo_node_curve_sample_update);
ntype.geometry_node_execute = file_ns::geo_node_curve_sample_exec;
ntype.declare = file_ns::geo_node_curve_sample_declare;
node_type_init(&ntype, file_ns::geo_node_curve_sample_type_init);
node_type_update(&ntype, file_ns::geo_node_curve_sample_update);
node_type_storage(
&ntype, "NodeGeometryCurveSample", node_free_standard_storage, node_copy_standard_storage);
ntype.draw_buttons = blender::nodes::geo_node_curve_sample_layout;
ntype.draw_buttons = file_ns::geo_node_curve_sample_layout;
nodeRegisterType(&ntype);
}

14
source/blender/nodes/geometry/nodes/node_geo_curve_set_handles.cc
View File

@ -21,7 +21,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_curve_set_handles_cc {
static void geo_node_curve_set_handles_declare(NodeDeclarationBuilder &b)
{
@ -130,21 +130,23 @@ static void geo_node_curve_set_handles_exec(GeoNodeExecParams params)
}
params.set_output("Curve", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_set_handles_cc
void register_node_type_geo_curve_set_handles()
{
namespace file_ns = blender::nodes::node_geo_curve_set_handles_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_CURVE_SET_HANDLES, "Set Handle Type", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_set_handles_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_set_handles_exec;
node_type_init(&ntype, blender::nodes::geo_node_curve_set_handles_init);
ntype.declare = file_ns::geo_node_curve_set_handles_declare;
ntype.geometry_node_execute = file_ns::geo_node_curve_set_handles_exec;
node_type_init(&ntype, file_ns::geo_node_curve_set_handles_init);
node_type_storage(&ntype,
"NodeGeometryCurveSetHandles",
node_free_standard_storage,
node_copy_standard_storage);
ntype.draw_buttons = blender::nodes::geo_node_curve_set_handles_layout;
ntype.draw_buttons = file_ns::geo_node_curve_set_handles_layout;
nodeRegisterType(&ntype);
}

14
source/blender/nodes/geometry/nodes/node_geo_curve_spline_type.cc
View File

@ -23,7 +23,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_curve_spline_type_cc {
static void geo_node_curve_spline_type_declare(NodeDeclarationBuilder &b)
{
@ -288,21 +288,23 @@ static void geo_node_curve_spline_type_exec(GeoNodeExecParams params)
params.set_output("Curve", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_spline_type_cc
void register_node_type_geo_curve_spline_type()
{
namespace file_ns = blender::nodes::node_geo_curve_spline_type_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_CURVE_SPLINE_TYPE, "Set Spline Type", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_spline_type_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_spline_type_exec;
node_type_init(&ntype, blender::nodes::geo_node_curve_spline_type_init);
ntype.declare = file_ns::geo_node_curve_spline_type_declare;
ntype.geometry_node_execute = file_ns::geo_node_curve_spline_type_exec;
node_type_init(&ntype, file_ns::geo_node_curve_spline_type_init);
node_type_storage(&ntype,
"NodeGeometryCurveSplineType",
node_free_standard_storage,
node_copy_standard_storage);
ntype.draw_buttons = blender::nodes::geo_node_curve_spline_type_layout;
ntype.draw_buttons = file_ns::geo_node_curve_spline_type_layout;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc
View File

@ -25,7 +25,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_curve_subdivide_cc {
static void geo_node_curve_subdivide_declare(NodeDeclarationBuilder &b)
{
@ -351,14 +351,16 @@ static void geo_node_subdivide_exec(GeoNodeExecParams params)
params.set_output("Curve", geometry_set);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_subdivide_cc
void register_node_type_geo_curve_subdivide()
{
namespace file_ns = blender::nodes::node_geo_curve_subdivide_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_SUBDIVIDE_CURVE, "Subdivide Curve", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_subdivide_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_subdivide_exec;
ntype.declare = file_ns::geo_node_curve_subdivide_declare;
ntype.geometry_node_execute = file_ns::geo_node_subdivide_exec;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_curve_to_mesh.cc
View File

@ -23,7 +23,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_curve_to_mesh_cc {
static void geo_node_curve_to_mesh_declare(NodeDeclarationBuilder &b)
{
@ -72,14 +72,16 @@ static void geo_node_curve_to_mesh_exec(GeoNodeExecParams params)
params.set_output("Mesh", std::move(curve_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_to_mesh_cc
void register_node_type_geo_curve_to_mesh()
{
namespace file_ns = blender::nodes::node_geo_curve_to_mesh_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_CURVE_TO_MESH, "Curve to Mesh", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_to_mesh_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_to_mesh_exec;
ntype.declare = file_ns::geo_node_curve_to_mesh_declare;
ntype.geometry_node_execute = file_ns::geo_node_curve_to_mesh_exec;
nodeRegisterType(&ntype);
}

40
source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc
View File

@ -27,6 +27,20 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
void curve_create_default_rotation_attribute(Span<float3> tangents,
Span<float3> normals,
MutableSpan<float3> rotations)
{
threading::parallel_for(IndexRange(rotations.size()), 512, [&](IndexRange range) {
for (const int i : range) {
rotations[i] =
float4x4::from_normalized_axis_data({0, 0, 0}, normals[i], tangents[i]).to_euler();
}
});
}
} // namespace blender::nodes
namespace blender::nodes::node_geo_curve_to_points_cc {
static void geo_node_curve_to_points_declare(NodeDeclarationBuilder &b)
{
@ -289,18 +303,6 @@ static void copy_spline_domain_attributes(const CurveEval &curve,
ATTR_DOMAIN_CURVE);
}
void curve_create_default_rotation_attribute(Span<float3> tangents,
Span<float3> normals,
MutableSpan<float3> rotations)
{
threading::parallel_for(IndexRange(rotations.size()), 512, [&](IndexRange range) {
for (const int i : range) {
rotations[i] =
float4x4::from_normalized_axis_data({0, 0, 0}, normals[i], tangents[i]).to_euler();
}
});
}
static void geo_node_curve_to_points_exec(GeoNodeExecParams params)
{
NodeGeometryCurveToPoints &node_storage = *(NodeGeometryCurveToPoints *)params.node().storage;
@ -374,20 +376,22 @@ static void geo_node_curve_to_points_exec(GeoNodeExecParams params)
}
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_to_points_cc
void register_node_type_geo_curve_to_points()
{
namespace file_ns = blender::nodes::node_geo_curve_to_points_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_CURVE_TO_POINTS, "Curve to Points", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_curve_to_points_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_curve_to_points_exec;
ntype.draw_buttons = blender::nodes::geo_node_curve_to_points_layout;
ntype.declare = file_ns::geo_node_curve_to_points_declare;
ntype.geometry_node_execute = file_ns::geo_node_curve_to_points_exec;
ntype.draw_buttons = file_ns::geo_node_curve_to_points_layout;
node_type_storage(
&ntype, "NodeGeometryCurveToPoints", node_free_standard_storage, node_copy_standard_storage);
node_type_init(&ntype, blender::nodes::geo_node_curve_to_points_init);
node_type_update(&ntype, blender::nodes::geo_node_curve_to_points_update);
node_type_init(&ntype, file_ns::geo_node_curve_to_points_init);
node_type_update(&ntype, file_ns::geo_node_curve_to_points_update);
nodeRegisterType(&ntype);
}

18
source/blender/nodes/geometry/nodes/node_geo_curve_trim.cc
View File

@ -22,9 +22,9 @@
#include "node_geometry_util.hh"
using blender::attribute_math::mix2;
namespace blender::nodes::node_geo_curve_trim_cc {
namespace blender::nodes {
using blender::attribute_math::mix2;
static void geo_node_curve_trim_declare(NodeDeclarationBuilder &b)
{
@ -557,18 +557,20 @@ static void geo_node_curve_trim_exec(GeoNodeExecParams params)
params.set_output("Curve", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_curve_trim_cc
void register_node_type_geo_curve_trim()
{
namespace file_ns = blender::nodes::node_geo_curve_trim_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_TRIM_CURVE, "Trim Curve", NODE_CLASS_GEOMETRY, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_curve_trim_exec;
ntype.draw_buttons = blender::nodes::geo_node_curve_trim_layout;
ntype.declare = blender::nodes::geo_node_curve_trim_declare;
ntype.geometry_node_execute = file_ns::geo_node_curve_trim_exec;
ntype.draw_buttons = file_ns::geo_node_curve_trim_layout;
ntype.declare = file_ns::geo_node_curve_trim_declare;
node_type_storage(
&ntype, "NodeGeometryCurveTrim", node_free_standard_storage, node_copy_standard_storage);
node_type_init(&ntype, blender::nodes::geo_node_curve_trim_init);
node_type_update(&ntype, blender::nodes::geo_node_curve_trim_update);
node_type_init(&ntype, file_ns::geo_node_curve_trim_init);
node_type_update(&ntype, file_ns::geo_node_curve_trim_update);
nodeRegisterType(&ntype);
}

86
source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc
View File

@ -29,8 +29,6 @@
#include "node_geometry_util.hh"
using blender::bke::CustomDataAttributes;
/* Code from the mask modifier in MOD_mask.cc. */
void copy_masked_vertices_to_new_mesh(const Mesh &src_mesh,
Mesh &dst_mesh,
@ -48,39 +46,7 @@ void copy_masked_polys_to_new_mesh(const Mesh &src_mesh,
namespace blender::nodes {
static void geo_node_delete_geometry_declare(NodeDeclarationBuilder &b)
{
b.add_input<decl::Geometry>(N_("Geometry"));
b.add_input<decl::Bool>(N_("Selection"))
.default_value(true)
.hide_value()
.supports_field()
.description(N_("The parts of the geometry to be deleted"));
b.add_output<decl::Geometry>(N_("Geometry"));
}
static void geo_node_delete_geometry_layout(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
{
const bNode *node = static_cast<bNode *>(ptr->data);
const NodeGeometryDeleteGeometry &storage = *(const NodeGeometryDeleteGeometry *)node->storage;
const AttributeDomain domain = static_cast<AttributeDomain>(storage.domain);
uiItemR(layout, ptr, "domain", 0, "", ICON_NONE);
/* Only show the mode when it is relevant. */
if (ELEM(domain, ATTR_DOMAIN_POINT, ATTR_DOMAIN_EDGE, ATTR_DOMAIN_FACE)) {
uiItemR(layout, ptr, "mode", 0, "", ICON_NONE);
}
}
static void geo_node_delete_geometry_init(bNodeTree *UNUSED(tree), bNode *node)
{
NodeGeometryDeleteGeometry *data = (NodeGeometryDeleteGeometry *)MEM_callocN(
sizeof(NodeGeometryDeleteGeometry), __func__);
data->domain = ATTR_DOMAIN_POINT;
data->mode = GEO_NODE_DELETE_GEOMETRY_MODE_ALL;
node->storage = data;
}
using blender::bke::CustomDataAttributes;
template<typename T> static void copy_data(Span<T> data, MutableSpan<T> r_data, IndexMask mask)
{
@ -1177,6 +1143,44 @@ void separate_geometry(GeometrySet &geometry_set,
r_is_error = !some_valid_domain && geometry_set.has_realized_data();
}
} // namespace blender::nodes
namespace blender::nodes::node_geo_delete_geometry_cc {
static void geo_node_delete_geometry_declare(NodeDeclarationBuilder &b)
{
b.add_input<decl::Geometry>(N_("Geometry"));
b.add_input<decl::Bool>(N_("Selection"))
.default_value(true)
.hide_value()
.supports_field()
.description(N_("The parts of the geometry to be deleted"));
b.add_output<decl::Geometry>(N_("Geometry"));
}
static void geo_node_delete_geometry_layout(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
{
const bNode *node = static_cast<bNode *>(ptr->data);
const NodeGeometryDeleteGeometry &storage = *(const NodeGeometryDeleteGeometry *)node->storage;
const AttributeDomain domain = static_cast<AttributeDomain>(storage.domain);
uiItemR(layout, ptr, "domain", 0, "", ICON_NONE);
/* Only show the mode when it is relevant. */
if (ELEM(domain, ATTR_DOMAIN_POINT, ATTR_DOMAIN_EDGE, ATTR_DOMAIN_FACE)) {
uiItemR(layout, ptr, "mode", 0, "", ICON_NONE);
}
}
static void geo_node_delete_geometry_init(bNodeTree *UNUSED(tree), bNode *node)
{
NodeGeometryDeleteGeometry *data = (NodeGeometryDeleteGeometry *)MEM_callocN(
sizeof(NodeGeometryDeleteGeometry), __func__);
data->domain = ATTR_DOMAIN_POINT;
data->mode = GEO_NODE_DELETE_GEOMETRY_MODE_ALL;
node->storage = data;
}
static void geo_node_delete_geometry_exec(GeoNodeExecParams params)
{
GeometrySet geometry_set = params.extract_input<GeometrySet>("Geometry");
@ -1204,10 +1208,12 @@ static void geo_node_delete_geometry_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_delete_geometry_cc
void register_node_type_geo_delete_geometry()
{
namespace file_ns = blender::nodes::node_geo_delete_geometry_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_DELETE_GEOMETRY, "Delete Geometry", NODE_CLASS_GEOMETRY, 0);
@ -1217,10 +1223,10 @@ void register_node_type_geo_delete_geometry()
node_free_standard_storage,
node_copy_standard_storage);
node_type_init(&ntype, blender::nodes::geo_node_delete_geometry_init);
node_type_init(&ntype, file_ns::geo_node_delete_geometry_init);
ntype.declare = blender::nodes::geo_node_delete_geometry_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_delete_geometry_exec;
ntype.draw_buttons = blender::nodes::geo_node_delete_geometry_layout;
ntype.declare = file_ns::geo_node_delete_geometry_declare;
ntype.geometry_node_execute = file_ns::geo_node_delete_geometry_exec;
ntype.draw_buttons = file_ns::geo_node_delete_geometry_layout;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc
View File

@ -36,9 +36,7 @@
#include "node_geometry_util.hh"
using blender::bke::GeometryInstanceGroup;
namespace blender::nodes {
namespace blender::nodes::node_geo_distribute_points_on_faces_cc {
static void geo_node_point_distribute_points_on_faces_declare(NodeDeclarationBuilder &b)
{
@ -570,10 +568,12 @@ static void geo_node_point_distribute_points_on_faces_exec(GeoNodeExecParams par
}
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_distribute_points_on_faces_cc
void register_node_type_geo_distribute_points_on_faces()
{
namespace file_ns = blender::nodes::node_geo_distribute_points_on_faces_cc;
static bNodeType ntype;
geo_node_type_base(&ntype,
@ -581,10 +581,10 @@ void register_node_type_geo_distribute_points_on_faces()
"Distribute Points on Faces",
NODE_CLASS_GEOMETRY,
0);
node_type_update(&ntype, blender::nodes::node_point_distribute_points_on_faces_update);
node_type_update(&ntype, file_ns::node_point_distribute_points_on_faces_update);
node_type_size(&ntype, 170, 100, 320);
ntype.declare = blender::nodes::geo_node_point_distribute_points_on_faces_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_point_distribute_points_on_faces_exec;
ntype.draw_buttons = blender::nodes::geo_node_point_distribute_points_on_faces_layout;
ntype.declare = file_ns::geo_node_point_distribute_points_on_faces_declare;
ntype.geometry_node_execute = file_ns::geo_node_point_distribute_points_on_faces_exec;
ntype.draw_buttons = file_ns::geo_node_point_distribute_points_on_faces_layout;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_edge_split.cc
View File

@ -22,7 +22,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_edge_split_cc {
static void geo_node_edge_split_declare(NodeDeclarationBuilder &b)
{
@ -82,14 +82,16 @@ static void geo_node_edge_split_exec(GeoNodeExecParams params)
params.set_output("Mesh", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_edge_split_cc
void register_node_type_geo_edge_split()
{
namespace file_ns = blender::nodes::node_geo_edge_split_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_SPLIT_EDGES, "Split Edges", NODE_CLASS_GEOMETRY, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_edge_split_exec;
ntype.declare = blender::nodes::geo_node_edge_split_declare;
ntype.geometry_node_execute = file_ns::geo_node_edge_split_exec;
ntype.declare = file_ns::geo_node_edge_split_declare;
nodeRegisterType(&ntype);
}

14
source/blender/nodes/geometry/nodes/node_geo_image_texture.cc
View File

@ -32,7 +32,7 @@
#include "UI_interface.h"
#include "UI_resources.h"
namespace blender::nodes {
namespace blender::nodes::node_geo_image_texture_cc {
static void geo_node_image_texture_declare(NodeDeclarationBuilder &b)
{
@ -410,20 +410,22 @@ static void geo_node_image_texture_exec(GeoNodeExecParams params)
params.set_output("Alpha", Field<float>(image_op, 1));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_image_texture_cc
void register_node_type_geo_image_texture(void)
{
namespace file_ns = blender::nodes::node_geo_image_texture_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_IMAGE_TEXTURE, "Image Texture", NODE_CLASS_TEXTURE, 0);
ntype.declare = blender::nodes::geo_node_image_texture_declare;
ntype.draw_buttons = blender::nodes::geo_node_image_texture_layout;
node_type_init(&ntype, blender::nodes::geo_node_image_texture_init);
ntype.declare = file_ns::geo_node_image_texture_declare;
ntype.draw_buttons = file_ns::geo_node_image_texture_layout;
node_type_init(&ntype, file_ns::geo_node_image_texture_init);
node_type_storage(
&ntype, "NodeGeometryImageTexture", node_free_standard_storage, node_copy_standard_storage);
node_type_size_preset(&ntype, NODE_SIZE_LARGE);
ntype.geometry_node_execute = blender::nodes::geo_node_image_texture_exec;
ntype.geometry_node_execute = file_ns::geo_node_image_texture_exec;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_input_curve_handles.cc
View File

@ -16,7 +16,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_input_curve_handles_cc {
static void geo_node_input_curve_handles_declare(NodeDeclarationBuilder &b)
{
@ -32,15 +32,17 @@ static void geo_node_input_curve_handles_exec(GeoNodeExecParams params)
params.set_output("Right", std::move(right_field));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_input_curve_handles_cc
void register_node_type_geo_input_curve_handles()
{
namespace file_ns = blender::nodes::node_geo_input_curve_handles_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_INPUT_CURVE_HANDLES, "Curve Handle Positions", NODE_CLASS_INPUT, 0);
node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
ntype.geometry_node_execute = blender::nodes::geo_node_input_curve_handles_exec;
ntype.declare = blender::nodes::geo_node_input_curve_handles_declare;
ntype.geometry_node_execute = file_ns::geo_node_input_curve_handles_exec;
ntype.declare = file_ns::geo_node_input_curve_handles_declare;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_input_curve_tilt.cc
View File

@ -16,7 +16,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_input_curve_tilt_cc {
static void geo_node_input_curve_tilt_declare(NodeDeclarationBuilder &b)
{
@ -29,14 +29,16 @@ static void geo_node_input_curve_tilt_exec(GeoNodeExecParams params)
params.set_output("Tilt", std::move(tilt_field));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_input_curve_tilt_cc
void register_node_type_geo_input_curve_tilt()
{
namespace file_ns = blender::nodes::node_geo_input_curve_tilt_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_INPUT_CURVE_TILT, "Curve Tilt", NODE_CLASS_INPUT, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_input_curve_tilt_exec;
ntype.declare = blender::nodes::geo_node_input_curve_tilt_declare;
ntype.geometry_node_execute = file_ns::geo_node_input_curve_tilt_exec;
ntype.declare = file_ns::geo_node_input_curve_tilt_declare;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_input_id.cc
View File

@ -16,7 +16,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_input_id_cc {
static void geo_node_input_id_declare(NodeDeclarationBuilder &b)
{
@ -29,14 +29,16 @@ static void geo_node_input_id_exec(GeoNodeExecParams params)
params.set_output("ID", std::move(position_field));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_input_id_cc
void register_node_type_geo_input_id()
{
namespace file_ns = blender::nodes::node_geo_input_id_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_INPUT_ID, "ID", NODE_CLASS_INPUT, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_input_id_exec;
ntype.declare = blender::nodes::geo_node_input_id_declare;
ntype.geometry_node_execute = file_ns::geo_node_input_id_exec;
ntype.declare = file_ns::geo_node_input_id_declare;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_input_index.cc
View File

@ -16,7 +16,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_input_index_cc {
static void geo_node_input_index_declare(NodeDeclarationBuilder &b)
{
@ -29,14 +29,16 @@ static void geo_node_input_index_exec(GeoNodeExecParams params)
params.set_output("Index", std::move(index_field));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_input_index_cc
void register_node_type_geo_input_index()
{
namespace file_ns = blender::nodes::node_geo_input_index_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_INPUT_INDEX, "Index", NODE_CLASS_INPUT, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_input_index_exec;
ntype.declare = blender::nodes::geo_node_input_index_declare;
ntype.geometry_node_execute = file_ns::geo_node_input_index_exec;
ntype.declare = file_ns::geo_node_input_index_declare;
nodeRegisterType(&ntype);
}

12
source/blender/nodes/geometry/nodes/node_geo_input_material.cc
View File

@ -19,7 +19,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_input_material_cc {
static void geo_node_input_material_declare(NodeDeclarationBuilder &b)
{
@ -37,15 +37,17 @@ static void geo_node_input_material_exec(GeoNodeExecParams params)
params.set_output("Material", material);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_input_material_cc
void register_node_type_geo_input_material()
{
namespace file_ns = blender::nodes::node_geo_input_material_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_INPUT_MATERIAL, "Material", NODE_CLASS_INPUT, 0);
ntype.draw_buttons = blender::nodes::geo_node_input_material_layout;
ntype.declare = blender::nodes::geo_node_input_material_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_input_material_exec;
ntype.draw_buttons = file_ns::geo_node_input_material_layout;
ntype.declare = file_ns::geo_node_input_material_declare;
ntype.geometry_node_execute = file_ns::geo_node_input_material_exec;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_input_material_index.cc
View File

@ -16,7 +16,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_input_material_index_cc {
static void geo_node_input_material_index_declare(NodeDeclarationBuilder &b)
{
@ -29,14 +29,16 @@ static void geo_node_input_material_index_exec(GeoNodeExecParams params)
params.set_output("Material Index", std::move(material_index_field));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_input_material_index_cc
void register_node_type_geo_input_material_index()
{
namespace file_ns = blender::nodes::node_geo_input_material_index_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_INPUT_MATERIAL_INDEX, "Material Index", NODE_CLASS_INPUT, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_input_material_index_exec;
ntype.declare = blender::nodes::geo_node_input_material_index_declare;
ntype.geometry_node_execute = file_ns::geo_node_input_material_index_exec;
ntype.declare = file_ns::geo_node_input_material_index_declare;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_input_normal.cc
View File

@ -24,7 +24,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_input_normal_cc {
static void geo_node_input_normal_declare(NodeDeclarationBuilder &b)
{
@ -283,14 +283,16 @@ static void geo_node_input_normal_exec(GeoNodeExecParams params)
params.set_output("Normal", std::move(normal_field));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_input_normal_cc
void register_node_type_geo_input_normal()
{
namespace file_ns = blender::nodes::node_geo_input_normal_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_INPUT_NORMAL, "Normal", NODE_CLASS_INPUT, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_input_normal_exec;
ntype.declare = blender::nodes::geo_node_input_normal_declare;
ntype.geometry_node_execute = file_ns::geo_node_input_normal_exec;
ntype.declare = file_ns::geo_node_input_normal_declare;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_input_position.cc
View File

@ -16,7 +16,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_input_position_cc {
static void geo_node_input_position_declare(NodeDeclarationBuilder &b)
{
@ -29,14 +29,16 @@ static void geo_node_input_position_exec(GeoNodeExecParams params)
params.set_output("Position", std::move(position_field));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_input_position_cc
void register_node_type_geo_input_position()
{
namespace file_ns = blender::nodes::node_geo_input_position_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_INPUT_POSITION, "Position", NODE_CLASS_INPUT, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_input_position_exec;
ntype.declare = blender::nodes::geo_node_input_position_declare;
ntype.geometry_node_execute = file_ns::geo_node_input_position_exec;
ntype.declare = file_ns::geo_node_input_position_declare;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_input_radius.cc
View File

@ -16,7 +16,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_input_radius_cc {
static void geo_node_input_radius_declare(NodeDeclarationBuilder &b)
{
@ -29,14 +29,16 @@ static void geo_node_input_radius_exec(GeoNodeExecParams params)
params.set_output("Radius", std::move(radius_field));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_input_radius_cc
void register_node_type_geo_input_radius()
{
namespace file_ns = blender::nodes::node_geo_input_radius_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_INPUT_RADIUS, "Radius", NODE_CLASS_INPUT, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_input_radius_exec;
ntype.declare = blender::nodes::geo_node_input_radius_declare;
ntype.geometry_node_execute = file_ns::geo_node_input_radius_exec;
ntype.declare = file_ns::geo_node_input_radius_declare;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_input_shade_smooth.cc
View File

@ -16,7 +16,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_input_shade_smooth_cc {
static void geo_node_input_shade_smooth_declare(NodeDeclarationBuilder &b)
{
@ -29,14 +29,16 @@ static void geo_node_input_shade_smooth_exec(GeoNodeExecParams params)
params.set_output("Smooth", std::move(shade_smooth_field));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_input_shade_smooth_cc
void register_node_type_geo_input_shade_smooth()
{
namespace file_ns = blender::nodes::node_geo_input_shade_smooth_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_INPUT_SHADE_SMOOTH, "Is Shade Smooth", NODE_CLASS_INPUT, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_input_shade_smooth_exec;
ntype.declare = blender::nodes::geo_node_input_shade_smooth_declare;
ntype.geometry_node_execute = file_ns::geo_node_input_shade_smooth_exec;
ntype.declare = file_ns::geo_node_input_shade_smooth_declare;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_input_spline_cyclic.cc
View File

@ -16,7 +16,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_input_spline_cyclic_cc {
static void geo_node_input_spline_cyclic_declare(NodeDeclarationBuilder &b)
{
@ -29,15 +29,17 @@ static void geo_node_input_spline_cyclic_exec(GeoNodeExecParams params)
params.set_output("Cyclic", std::move(cyclic_field));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_input_spline_cyclic_cc
void register_node_type_geo_input_spline_cyclic()
{
namespace file_ns = blender::nodes::node_geo_input_spline_cyclic_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_INPUT_SPLINE_CYCLIC, "Is Spline Cyclic", NODE_CLASS_INPUT, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_input_spline_cyclic_exec;
ntype.declare = blender::nodes::geo_node_input_spline_cyclic_declare;
ntype.geometry_node_execute = file_ns::geo_node_input_spline_cyclic_exec;
ntype.declare = file_ns::geo_node_input_spline_cyclic_declare;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_input_spline_length.cc
View File

@ -18,7 +18,7 @@
#include "BKE_spline.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_input_spline_length_cc {
static void geo_node_input_spline_length_declare(NodeDeclarationBuilder &b)
{
@ -91,14 +91,16 @@ static void geo_node_input_spline_length_exec(GeoNodeExecParams params)
params.set_output("Length", std::move(length_field));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_input_spline_length_cc
void register_node_type_geo_input_spline_length()
{
namespace file_ns = blender::nodes::node_geo_input_spline_length_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_INPUT_SPLINE_LENGTH, "Spline Length", NODE_CLASS_INPUT, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_input_spline_length_exec;
ntype.declare = blender::nodes::geo_node_input_spline_length_declare;
ntype.geometry_node_execute = file_ns::geo_node_input_spline_length_exec;
ntype.declare = file_ns::geo_node_input_spline_length_declare;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_input_spline_resolution.cc
View File

@ -16,7 +16,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_input_spline_resolution_cc {
static void geo_node_input_spline_resolution_declare(NodeDeclarationBuilder &b)
{
@ -29,15 +29,17 @@ static void geo_node_input_spline_resolution_exec(GeoNodeExecParams params)
params.set_output("Resolution", std::move(resolution_field));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_input_spline_resolution_cc
void register_node_type_geo_input_spline_resolution()
{
namespace file_ns = blender::nodes::node_geo_input_spline_resolution_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_INPUT_SPLINE_RESOLUTION, "Spline Resolution", NODE_CLASS_INPUT, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_input_spline_resolution_exec;
ntype.declare = blender::nodes::geo_node_input_spline_resolution_declare;
ntype.geometry_node_execute = file_ns::geo_node_input_spline_resolution_exec;
ntype.declare = file_ns::geo_node_input_spline_resolution_declare;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_input_tangent.cc
View File

@ -20,7 +20,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_input_tangent_cc {
static void geo_node_input_tangent_declare(NodeDeclarationBuilder &b)
{
@ -161,14 +161,16 @@ static void geo_node_input_tangent_exec(GeoNodeExecParams params)
params.set_output("Tangent", std::move(tangent_field));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_input_tangent_cc
void register_node_type_geo_input_tangent()
{
namespace file_ns = blender::nodes::node_geo_input_tangent_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_INPUT_TANGENT, "Curve Tangent", NODE_CLASS_INPUT, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_input_tangent_exec;
ntype.declare = blender::nodes::geo_node_input_tangent_declare;
ntype.geometry_node_execute = file_ns::geo_node_input_tangent_exec;
ntype.declare = file_ns::geo_node_input_tangent_declare;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_instance_on_points.cc
View File

@ -24,7 +24,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_instance_on_points_cc {
static void geo_node_instance_on_points_declare(NodeDeclarationBuilder &b)
{
@ -214,15 +214,17 @@ static void geo_node_instance_on_points_exec(GeoNodeExecParams params)
params.set_output("Instances", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_instance_on_points_cc
void register_node_type_geo_instance_on_points()
{
namespace file_ns = blender::nodes::node_geo_instance_on_points_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_INSTANCE_ON_POINTS, "Instance on Points", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_instance_on_points_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_instance_on_points_exec;
ntype.declare = file_ns::geo_node_instance_on_points_declare;
ntype.geometry_node_execute = file_ns::geo_node_instance_on_points_exec;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_instances_to_points.cc
View File

@ -19,7 +19,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_instances_to_points_cc {
static void geo_node_instances_to_points_declare(NodeDeclarationBuilder &b)
{
@ -104,15 +104,17 @@ static void geo_node_instances_to_points_exec(GeoNodeExecParams params)
}
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_instances_to_points_cc
void register_node_type_geo_instances_to_points()
{
namespace file_ns = blender::nodes::node_geo_instances_to_points_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_INSTANCES_TO_POINTS, "Instances to Points", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_instances_to_points_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_instances_to_points_exec;
ntype.declare = file_ns::geo_node_instances_to_points_declare;
ntype.geometry_node_execute = file_ns::geo_node_instances_to_points_exec;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_is_viewport.cc
View File

@ -18,7 +18,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_is_viewport_cc {
static void geo_node_is_viewport_declare(NodeDeclarationBuilder &b)
{
@ -34,14 +34,16 @@ static void geo_node_is_viewport_exec(GeoNodeExecParams params)
params.set_output("Is Viewport", is_viewport);
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_is_viewport_cc
void register_node_type_geo_is_viewport()
{
namespace file_ns = blender::nodes::node_geo_is_viewport_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_IS_VIEWPORT, "Is Viewport", NODE_CLASS_INPUT, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_is_viewport_exec;
ntype.declare = blender::nodes::geo_node_is_viewport_declare;
ntype.geometry_node_execute = file_ns::geo_node_is_viewport_exec;
ntype.declare = file_ns::geo_node_is_viewport_declare;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_join_geometry.cc
View File

@ -27,7 +27,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_join_geometry_cc {
static void geo_node_join_geometry_declare(NodeDeclarationBuilder &b)
{
@ -508,14 +508,16 @@ static void geo_node_join_geometry_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set_result));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_join_geometry_cc
void register_node_type_geo_join_geometry()
{
namespace file_ns = blender::nodes::node_geo_join_geometry_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_JOIN_GEOMETRY, "Join Geometry", NODE_CLASS_GEOMETRY, 0);
ntype.geometry_node_execute = blender::nodes::geo_node_join_geometry_exec;
ntype.declare = blender::nodes::geo_node_join_geometry_declare;
ntype.geometry_node_execute = file_ns::geo_node_join_geometry_exec;
ntype.declare = file_ns::geo_node_join_geometry_declare;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_material_replace.cc
View File

@ -24,7 +24,7 @@
#include "BKE_material.h"
namespace blender::nodes {
namespace blender::nodes::node_geo_material_replace_cc {
static void geo_node_material_replace_declare(NodeDeclarationBuilder &b)
{
@ -55,15 +55,17 @@ static void geo_node_material_replace_exec(GeoNodeExecParams params)
params.set_output("Geometry", std::move(geometry_set));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_material_replace_cc
void register_node_type_geo_material_replace()
{
namespace file_ns = blender::nodes::node_geo_material_replace_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_REPLACE_MATERIAL, "Replace Material", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_material_replace_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_material_replace_exec;
ntype.declare = file_ns::geo_node_material_replace_declare;
ntype.geometry_node_execute = file_ns::geo_node_material_replace_exec;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_material_selection.cc
View File

@ -26,7 +26,7 @@
#include "BKE_material.h"
namespace blender::nodes {
namespace blender::nodes::node_geo_material_selection_cc {
static void geo_node_material_selection_declare(NodeDeclarationBuilder &b)
{
@ -118,15 +118,17 @@ static void geo_node_material_selection_exec(GeoNodeExecParams params)
params.set_output("Selection", std::move(material_field));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_material_selection_cc
void register_node_type_geo_material_selection()
{
namespace file_ns = blender::nodes::node_geo_material_selection_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_MATERIAL_SELECTION, "Material Selection", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_material_selection_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_material_selection_exec;
ntype.declare = file_ns::geo_node_material_selection_declare;
ntype.geometry_node_execute = file_ns::geo_node_material_selection_exec;
nodeRegisterType(&ntype);
}

14
source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_circle.cc
View File

@ -25,7 +25,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_mesh_primitive_circle_cc {
static void geo_node_mesh_primitive_circle_declare(NodeDeclarationBuilder &b)
{
@ -222,19 +222,21 @@ static void geo_node_mesh_primitive_circle_exec(GeoNodeExecParams params)
params.set_output("Mesh", GeometrySet::create_with_mesh(mesh));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_mesh_primitive_circle_cc
void register_node_type_geo_mesh_primitive_circle()
{
namespace file_ns = blender::nodes::node_geo_mesh_primitive_circle_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_MESH_PRIMITIVE_CIRCLE, "Mesh Circle", NODE_CLASS_GEOMETRY, 0);
node_type_init(&ntype, blender::nodes::geo_node_mesh_primitive_circle_init);
node_type_init(&ntype, file_ns::geo_node_mesh_primitive_circle_init);
node_type_storage(
&ntype, "NodeGeometryMeshCircle", node_free_standard_storage, node_copy_standard_storage);
ntype.geometry_node_execute = blender::nodes::geo_node_mesh_primitive_circle_exec;
ntype.draw_buttons = blender::nodes::geo_node_mesh_primitive_circle_layout;
ntype.declare = blender::nodes::geo_node_mesh_primitive_circle_declare;
ntype.geometry_node_execute = file_ns::geo_node_mesh_primitive_circle_exec;
ntype.draw_buttons = file_ns::geo_node_mesh_primitive_circle_layout;
ntype.declare = file_ns::geo_node_mesh_primitive_circle_declare;
nodeRegisterType(&ntype);
}

156
source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cone.cc
View File

@ -29,75 +29,6 @@
namespace blender::nodes {
static void geo_node_mesh_primitive_cone_declare(NodeDeclarationBuilder &b)
{
b.add_input<decl::Int>(N_("Vertices"))
.default_value(32)
.min(3)
.max(512)
.description(N_("Number of points on the circle at the top and bottom"));
b.add_input<decl::Int>(N_("Side Segments"))
.default_value(1)
.min(1)
.max(512)
.description(N_("The number of edges running vertically along the side of the cone"));
b.add_input<decl::Int>(N_("Fill Segments"))
.default_value(1)
.min(1)
.max(512)
.description(N_("Number of concentric rings used to fill the round face"));
b.add_input<decl::Float>(N_("Radius Top"))
.min(0.0f)
.subtype(PROP_DISTANCE)
.description(N_("Radius of the top circle of the cone"));
b.add_input<decl::Float>(N_("Radius Bottom"))
.default_value(1.0f)
.min(0.0f)
.subtype(PROP_DISTANCE)
.description(N_("Radius of the bottom circle of the cone"));
b.add_input<decl::Float>(N_("Depth"))
.default_value(2.0f)
.min(0.0f)
.subtype(PROP_DISTANCE)
.description(N_("Height of the generated cone"));
b.add_output<decl::Geometry>(N_("Mesh"));
b.add_output<decl::Bool>(N_("Top")).field_source();
b.add_output<decl::Bool>(N_("Bottom")).field_source();
b.add_output<decl::Bool>(N_("Side")).field_source();
}
static void geo_node_mesh_primitive_cone_init(bNodeTree *UNUSED(ntree), bNode *node)
{
NodeGeometryMeshCone *node_storage = (NodeGeometryMeshCone *)MEM_callocN(
sizeof(NodeGeometryMeshCone), __func__);
node_storage->fill_type = GEO_NODE_MESH_CIRCLE_FILL_NGON;
node->storage = node_storage;
}
static void geo_node_mesh_primitive_cone_update(bNodeTree *ntree, bNode *node)
{
bNodeSocket *vertices_socket = (bNodeSocket *)node->inputs.first;
bNodeSocket *rings_socket = vertices_socket->next;
bNodeSocket *fill_subdiv_socket = rings_socket->next;
const NodeGeometryMeshCone &storage = *(const NodeGeometryMeshCone *)node->storage;
const GeometryNodeMeshCircleFillType fill_type =
static_cast<const GeometryNodeMeshCircleFillType>(storage.fill_type);
const bool has_fill = fill_type != GEO_NODE_MESH_CIRCLE_FILL_NONE;
nodeSetSocketAvailability(ntree, fill_subdiv_socket, has_fill);
}
static void geo_node_mesh_primitive_cone_layout(uiLayout *layout,
bContext *UNUSED(C),
PointerRNA *ptr)
{
uiLayoutSetPropSep(layout, true);
uiLayoutSetPropDecorate(layout, false);
uiItemR(layout, ptr, "fill_type", 0, nullptr, ICON_NONE);
}
struct ConeConfig {
float radius_top;
float radius_bottom;
@ -794,6 +725,79 @@ Mesh *create_cylinder_or_cone_mesh(const float radius_top,
return mesh;
}
} // namespace blender::nodes
namespace blender::nodes::node_geo_mesh_primitive_cone_cc {
static void geo_node_mesh_primitive_cone_declare(NodeDeclarationBuilder &b)
{
b.add_input<decl::Int>(N_("Vertices"))
.default_value(32)
.min(3)
.max(512)
.description(N_("Number of points on the circle at the top and bottom"));
b.add_input<decl::Int>(N_("Side Segments"))
.default_value(1)
.min(1)
.max(512)
.description(N_("The number of edges running vertically along the side of the cone"));
b.add_input<decl::Int>(N_("Fill Segments"))
.default_value(1)
.min(1)
.max(512)
.description(N_("Number of concentric rings used to fill the round face"));
b.add_input<decl::Float>(N_("Radius Top"))
.min(0.0f)
.subtype(PROP_DISTANCE)
.description(N_("Radius of the top circle of the cone"));
b.add_input<decl::Float>(N_("Radius Bottom"))
.default_value(1.0f)
.min(0.0f)
.subtype(PROP_DISTANCE)
.description(N_("Radius of the bottom circle of the cone"));
b.add_input<decl::Float>(N_("Depth"))
.default_value(2.0f)
.min(0.0f)
.subtype(PROP_DISTANCE)
.description(N_("Height of the generated cone"));
b.add_output<decl::Geometry>(N_("Mesh"));
b.add_output<decl::Bool>(N_("Top")).field_source();
b.add_output<decl::Bool>(N_("Bottom")).field_source();
b.add_output<decl::Bool>(N_("Side")).field_source();
}
static void geo_node_mesh_primitive_cone_init(bNodeTree *UNUSED(ntree), bNode *node)
{
NodeGeometryMeshCone *node_storage = (NodeGeometryMeshCone *)MEM_callocN(
sizeof(NodeGeometryMeshCone), __func__);
node_storage->fill_type = GEO_NODE_MESH_CIRCLE_FILL_NGON;
node->storage = node_storage;
}
static void geo_node_mesh_primitive_cone_update(bNodeTree *ntree, bNode *node)
{
bNodeSocket *vertices_socket = (bNodeSocket *)node->inputs.first;
bNodeSocket *rings_socket = vertices_socket->next;
bNodeSocket *fill_subdiv_socket = rings_socket->next;
const NodeGeometryMeshCone &storage = *(const NodeGeometryMeshCone *)node->storage;
const GeometryNodeMeshCircleFillType fill_type =
static_cast<const GeometryNodeMeshCircleFillType>(storage.fill_type);
const bool has_fill = fill_type != GEO_NODE_MESH_CIRCLE_FILL_NONE;
nodeSetSocketAvailability(ntree, fill_subdiv_socket, has_fill);
}
static void geo_node_mesh_primitive_cone_layout(uiLayout *layout,
bContext *UNUSED(C),
PointerRNA *ptr)
{
uiLayoutSetPropSep(layout, true);
uiLayoutSetPropDecorate(layout, false);
uiItemR(layout, ptr, "fill_type", 0, nullptr, ICON_NONE);
}
static void geo_node_mesh_primitive_cone_exec(GeoNodeExecParams params)
{
const bNode &node = params.node();
@ -874,19 +878,21 @@ static void geo_node_mesh_primitive_cone_exec(GeoNodeExecParams params)
params.set_output("Mesh", GeometrySet::create_with_mesh(mesh));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_mesh_primitive_cone_cc
void register_node_type_geo_mesh_primitive_cone()
{
namespace file_ns = blender::nodes::node_geo_mesh_primitive_cone_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_MESH_PRIMITIVE_CONE, "Cone", NODE_CLASS_GEOMETRY, 0);
node_type_init(&ntype, blender::nodes::geo_node_mesh_primitive_cone_init);
node_type_update(&ntype, blender::nodes::geo_node_mesh_primitive_cone_update);
node_type_init(&ntype, file_ns::geo_node_mesh_primitive_cone_init);
node_type_update(&ntype, file_ns::geo_node_mesh_primitive_cone_update);
node_type_storage(
&ntype, "NodeGeometryMeshCone", node_free_standard_storage, node_copy_standard_storage);
ntype.geometry_node_execute = blender::nodes::geo_node_mesh_primitive_cone_exec;
ntype.draw_buttons = blender::nodes::geo_node_mesh_primitive_cone_layout;
ntype.declare = blender::nodes::geo_node_mesh_primitive_cone_declare;
ntype.geometry_node_execute = file_ns::geo_node_mesh_primitive_cone_exec;
ntype.draw_buttons = file_ns::geo_node_mesh_primitive_cone_layout;
ntype.declare = file_ns::geo_node_mesh_primitive_cone_declare;
nodeRegisterType(&ntype);
}

62
source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cube.cc
View File

@ -24,31 +24,6 @@
namespace blender::nodes {
static void geo_node_mesh_primitive_cube_declare(NodeDeclarationBuilder &b)
{
b.add_input<decl::Vector>(N_("Size"))
.default_value(float3(1))
.min(0.0f)
.subtype(PROP_TRANSLATION)
.description(N_("Side length along each axis"));
b.add_input<decl::Int>(N_("Vertices X"))
.default_value(2)
.min(2)
.max(1000)
.description(N_("Number of vertices for the X side of the shape"));
b.add_input<decl::Int>(N_("Vertices Y"))
.default_value(2)
.min(2)
.max(1000)
.description(N_("Number of vertices for the Y side of the shape"));
b.add_input<decl::Int>(N_("Vertices Z"))
.default_value(2)
.min(2)
.max(1000)
.description(N_("Number of vertices for the Z side of the shape"));
b.add_output<decl::Geometry>(N_("Mesh"));
}
struct CuboidConfig {
float3 size;
int verts_x;
@ -439,6 +414,35 @@ Mesh *create_cuboid_mesh(const float3 size,
return mesh;
}
} // namespace blender::nodes
namespace blender::nodes::node_geo_mesh_primitive_cube_cc {
static void geo_node_mesh_primitive_cube_declare(NodeDeclarationBuilder &b)
{
b.add_input<decl::Vector>(N_("Size"))
.default_value(float3(1))
.min(0.0f)
.subtype(PROP_TRANSLATION)
.description(N_("Side length along each axis"));
b.add_input<decl::Int>(N_("Vertices X"))
.default_value(2)
.min(2)
.max(1000)
.description(N_("Number of vertices for the X side of the shape"));
b.add_input<decl::Int>(N_("Vertices Y"))
.default_value(2)
.min(2)
.max(1000)
.description(N_("Number of vertices for the Y side of the shape"));
b.add_input<decl::Int>(N_("Vertices Z"))
.default_value(2)
.min(2)
.max(1000)
.description(N_("Number of vertices for the Z side of the shape"));
b.add_output<decl::Geometry>(N_("Mesh"));
}
static Mesh *create_cube_mesh(const float3 size,
const int verts_x,
const int verts_y,
@ -501,14 +505,16 @@ static void geo_node_mesh_primitive_cube_exec(GeoNodeExecParams params)
params.set_output("Mesh", GeometrySet::create_with_mesh(mesh));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_mesh_primitive_cube_cc
void register_node_type_geo_mesh_primitive_cube()
{
namespace file_ns = blender::nodes::node_geo_mesh_primitive_cube_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_MESH_PRIMITIVE_CUBE, "Cube", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_mesh_primitive_cube_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_mesh_primitive_cube_exec;
ntype.declare = file_ns::geo_node_mesh_primitive_cube_declare;
ntype.geometry_node_execute = file_ns::geo_node_mesh_primitive_cube_exec;
nodeRegisterType(&ntype);
}

16
source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cylinder.cc
View File

@ -25,7 +25,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_mesh_primitive_cylinder_cc {
static void geo_node_mesh_primitive_cylinder_declare(NodeDeclarationBuilder &b)
{
@ -169,18 +169,20 @@ static void geo_node_mesh_primitive_cylinder_exec(GeoNodeExecParams params)
params.set_output("Mesh", GeometrySet::create_with_mesh(mesh));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_mesh_primitive_cylinder_cc
void register_node_type_geo_mesh_primitive_cylinder()
{
namespace file_ns = blender::nodes::node_geo_mesh_primitive_cylinder_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_MESH_PRIMITIVE_CYLINDER, "Cylinder", NODE_CLASS_GEOMETRY, 0);
node_type_init(&ntype, blender::nodes::geo_node_mesh_primitive_cylinder_init);
node_type_update(&ntype, blender::nodes::geo_node_mesh_primitive_cylinder_update);
node_type_init(&ntype, file_ns::geo_node_mesh_primitive_cylinder_init);
node_type_update(&ntype, file_ns::geo_node_mesh_primitive_cylinder_update);
node_type_storage(
&ntype, "NodeGeometryMeshCylinder", node_free_standard_storage, node_copy_standard_storage);
ntype.declare = blender::nodes::geo_node_mesh_primitive_cylinder_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_mesh_primitive_cylinder_exec;
ntype.draw_buttons = blender::nodes::geo_node_mesh_primitive_cylinder_layout;
ntype.declare = file_ns::geo_node_mesh_primitive_cylinder_declare;
ntype.geometry_node_execute = file_ns::geo_node_mesh_primitive_cylinder_exec;
ntype.draw_buttons = file_ns::geo_node_mesh_primitive_cylinder_layout;
nodeRegisterType(&ntype);
}

62
source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_grid.cc
View File

@ -27,31 +27,6 @@
namespace blender::nodes {
static void geo_node_mesh_primitive_grid_declare(NodeDeclarationBuilder &b)
{
b.add_input<decl::Float>(N_("Size X"))
.default_value(1.0f)
.min(0.0f)
.subtype(PROP_DISTANCE)
.description(N_("Side length of the plane in the X direction"));
b.add_input<decl::Float>(N_("Size Y"))
.default_value(1.0f)
.min(0.0f)
.subtype(PROP_DISTANCE)
.description(N_("Side length of the plane in the Y direction"));
b.add_input<decl::Int>(N_("Vertices X"))
.default_value(3)
.min(2)
.max(1000)
.description(N_("Number of vertices in the X direction"));
b.add_input<decl::Int>(N_("Vertices Y"))
.default_value(3)
.min(2)
.max(1000)
.description(N_("Number of vertices in the Y direction"));
b.add_output<decl::Geometry>(N_("Mesh"));
}
static void calculate_uvs(
Mesh *mesh, Span<MVert> verts, Span<MLoop> loops, const float size_x, const float size_y)
{
@ -169,6 +144,35 @@ Mesh *create_grid_mesh(const int verts_x,
return mesh;
}
} // namespace blender::nodes
namespace blender::nodes::node_geo_mesh_primitive_grid_cc {
static void geo_node_mesh_primitive_grid_declare(NodeDeclarationBuilder &b)
{
b.add_input<decl::Float>(N_("Size X"))
.default_value(1.0f)
.min(0.0f)
.subtype(PROP_DISTANCE)
.description(N_("Side length of the plane in the X direction"));
b.add_input<decl::Float>(N_("Size Y"))
.default_value(1.0f)
.min(0.0f)
.subtype(PROP_DISTANCE)
.description(N_("Side length of the plane in the Y direction"));
b.add_input<decl::Int>(N_("Vertices X"))
.default_value(3)
.min(2)
.max(1000)
.description(N_("Number of vertices in the X direction"));
b.add_input<decl::Int>(N_("Vertices Y"))
.default_value(3)
.min(2)
.max(1000)
.description(N_("Number of vertices in the Y direction"));
b.add_output<decl::Geometry>(N_("Mesh"));
}
static void geo_node_mesh_primitive_grid_exec(GeoNodeExecParams params)
{
const float size_x = params.extract_input<float>("Size X");
@ -187,14 +191,16 @@ static void geo_node_mesh_primitive_grid_exec(GeoNodeExecParams params)
params.set_output("Mesh", GeometrySet::create_with_mesh(mesh));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_mesh_primitive_grid_cc
void register_node_type_geo_mesh_primitive_grid()
{
namespace file_ns = blender::nodes::node_geo_mesh_primitive_grid_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_MESH_PRIMITIVE_GRID, "Grid", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_mesh_primitive_grid_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_mesh_primitive_grid_exec;
ntype.declare = file_ns::geo_node_mesh_primitive_grid_declare;
ntype.geometry_node_execute = file_ns::geo_node_mesh_primitive_grid_exec;
nodeRegisterType(&ntype);
}

10
source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_ico_sphere.cc
View File

@ -24,7 +24,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_mesh_primitive_ico_sphere_cc {
static void geo_node_mesh_primitive_ico_sphere_declare(NodeDeclarationBuilder &b)
{
@ -78,15 +78,17 @@ static void geo_node_mesh_primitive_ico_sphere_exec(GeoNodeExecParams params)
params.set_output("Mesh", GeometrySet::create_with_mesh(mesh));
}
} // namespace blender::nodes
} // namespace blender::nodes::node_geo_mesh_primitive_ico_sphere_cc
void register_node_type_geo_mesh_primitive_ico_sphere()
{
namespace file_ns = blender::nodes::node_geo_mesh_primitive_ico_sphere_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_MESH_PRIMITIVE_ICO_SPHERE, "Ico Sphere", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_mesh_primitive_ico_sphere_declare;
ntype.geometry_node_execute = blender::nodes::geo_node_mesh_primitive_ico_sphere_exec;
ntype.declare = file_ns::geo_node_mesh_primitive_ico_sphere_declare;
ntype.geometry_node_execute = file_ns::geo_node_mesh_primitive_ico_sphere_exec;
nodeRegisterType(&ntype);
}

84
source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_line.cc
View File

@ -25,7 +25,7 @@
#include "node_geometry_util.hh"
namespace blender::nodes {
namespace blender::nodes::node_geo_mesh_primitive_line_cc {
static void geo_node_mesh_primitive_line_declare(NodeDeclarationBuilder &b)
{
@ -100,39 +100,6 @@ static void geo_node_mesh_primitive_line_update(bNodeTree *ntree, bNode *node)
count_mode == GEO_NODE_MESH_LINE_COUNT_TOTAL);
}
static void fill_edge_data(MutableSpan<MEdge> edges)
{
for (const int i : edges.index_range()) {
edges[i].v1 = i;
edges[i].v2 = i + 1;
edges[i].flag |= ME_LOOSEEDGE;
}
}
Mesh *create_line_mesh(const float3 start, const float3 delta, const int count)
{
if (count < 1) {
return nullptr;
}
Mesh *mesh = BKE_mesh_new_nomain(count, count - 1, 0, 0, 0);
BKE_id_material_eval_ensure_default_slot(&mesh->id);
MutableSpan<MVert> verts{mesh->mvert, mesh->totvert};
MutableSpan<MEdge> edges{mesh->medge, mesh->totedge};
short normal[3];
normal_float_to_short_v3(normal, delta.normalized());
for (const int i : verts.index_range()) {
copy_v3_v3(verts[i].co, start + delta * i);
copy_v3_v3_short(verts[i].no, normal);
}
fill_edge_data(edges);
return mesh;
}
static void geo_node_mesh_primitive_line_exec(GeoNodeExecParams params)
{
const NodeGeometryMeshLine &storage = *(const NodeGeometryMeshLine *)params.node().storage;
@ -174,19 +141,58 @@ static void geo_node_mesh_primitive_line_exec(GeoNodeExecParams params)
params.set_output("Mesh", GeometrySet::create_with_mesh(mesh));
}
} // namespace blender::nodes::node_geo_mesh_primitive_line_cc
namespace blender::nodes {
static void fill_edge_data(MutableSpan<MEdge> edges)
{
for (const int i : edges.index_range()) {
edges[i].v1 = i;
edges[i].v2 = i + 1;
edges[i].flag |= ME_LOOSEEDGE;
}
}
Mesh *create_line_mesh(const float3 start, const float3 delta, const int count)
{
if (count < 1) {
return nullptr;
}
Mesh *mesh = BKE_mesh_new_nomain(count, count - 1, 0, 0, 0);
BKE_id_material_eval_ensure_default_slot(&mesh->id);
MutableSpan<MVert> verts{mesh->mvert, mesh->totvert};
MutableSpan<MEdge> edges{mesh->medge, mesh->totedge};
short normal[3];
normal_float_to_short_v3(normal, delta.normalized());
for (const int i : verts.index_range()) {
copy_v3_v3(verts[i].co, start + delta * i);
copy_v3_v3_short(verts[i].no, normal);
}
fill_edge_data(edges);
return mesh;
}
} // namespace blender::nodes
void register_node_type_geo_mesh_primitive_line()
{
namespace file_ns = blender::nodes::node_geo_mesh_primitive_line_cc;
static bNodeType ntype;
geo_node_type_base(&ntype, GEO_NODE_MESH_PRIMITIVE_LINE, "Mesh Line", NODE_CLASS_GEOMETRY, 0);
ntype.declare = blender::nodes::geo_node_mesh_primitive_line_declare;
node_type_init(&ntype, blender::nodes::geo_node_mesh_primitive_line_init);
node_type_update(&ntype, blender::nodes::geo_node_mesh_primitive_line_update);
ntype.declare = file_ns::geo_node_mesh_primitive_line_declare;
node_type_init(&ntype, file_ns::geo_node_mesh_primitive_line_init);
node_type_update(&ntype, file_ns::geo_node_mesh_primitive_line_update);
node_type_storage(
&ntype, "NodeGeometryMeshLine", node_free_standard_storage, node_copy_standard_storage);
ntype.geometry_node_execute = blender::nodes::geo_node_mesh_primitive_line_exec;
ntype.draw_buttons = blender::nodes::geo_node_mesh_primitive_line_layout;
ntype.geometry_node_execute = file_ns::geo_node_mesh_primitive_line_exec;
ntype.draw_buttons = file_ns::geo_node_mesh_primitive_line_layout;
nodeRegisterType(&ntype);
}

Some files were not shown because too many files have changed in this diff Show More