archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
4b9ff3cd42be427e478743648e9951bf8c189a04
blender-archive/source/blender/nodes/NOD_geometry.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

98 lines
4.1 KiB
C++
Raw Normal View History

Simulations: Add simulation node tree type This implements a new builtin node tree type called `SimulationNodeTree`. It is not yet embedded in the `Simulation` data block. The node tree will initially be used for the new particle nodes system. When the cmake option `WITH_NEW_SIMULATION_TYPE` is enabled, a new `Simulation Editor` is shown in the editors menu (which is just a node editor). This patch does not add entries to the Add Node menu, so it is empty. Reviewers: brecht Differential Revision: https://developer.blender.org/D7287
2020-04-20 10:58:43 +02:00
/*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
Fix: Missing GeometryNodeCustomGroup This is a minor change to add some plumbing code to support custom geo nodes. This is working the same way as the custom cycles and compositor nodes. An example add-in is attached to D10784 Reviewed By: JacquesLucke Differential Revision: http://developer.blender.org/D10784
2021-04-08 16:25:09 -06:00
#include "BKE_node.h"
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
extern struct bNodeTreeType *ntreeType_Geometry;
Simulations: Add simulation node tree type This implements a new builtin node tree type called `SimulationNodeTree`. It is not yet embedded in the `Simulation` data block. The node tree will initially be used for the new particle nodes system. When the cmake option `WITH_NEW_SIMULATION_TYPE` is enabled, a new `Simulation Editor` is shown in the editors menu (which is just a node editor). This patch does not add entries to the Add Node menu, so it is empty. Reviewers: brecht Differential Revision: https://developer.blender.org/D7287
2020-04-20 10:58:43 +02:00
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
void register_node_tree_type_geo(void);
Simulations: Add simulation node tree type This implements a new builtin node tree type called `SimulationNodeTree`. It is not yet embedded in the `Simulation` data block. The node tree will initially be used for the new particle nodes system. When the cmake option `WITH_NEW_SIMULATION_TYPE` is enabled, a new `Simulation Editor` is shown in the editors menu (which is just a node editor). This patch does not add entries to the Add Node menu, so it is empty. Reviewers: brecht Differential Revision: https://developer.blender.org/D7287
2020-04-20 10:58:43 +02:00
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
void register_node_type_geo_group(void);
Fix: Missing GeometryNodeCustomGroup This is a minor change to add some plumbing code to support custom geo nodes. This is working the same way as the custom cycles and compositor nodes. An example add-in is attached to D10784 Reviewed By: JacquesLucke Differential Revision: http://developer.blender.org/D10784
2021-04-08 16:25:09 -06:00
void register_node_type_geo_custom_group(bNodeType *ntype);
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
Cleanup: Alphabetize function order
2021-02-07 17:21:21 -06:00
void register_node_type_geo_align_rotation_to_vector(void);
Geometry Nodes: Add Attribute Clamp Node This adds a Clamp node for Geometry Nodes Attributes. Supports both Min-Max and Range clamp modes. Float, Vector, Color and Int data types supported. Reviewed By: HooglyBoogly, simonthommes Differential Revision: https://developer.blender.org/D10526
2021-03-26 09:28:15 +00:00
void register_node_type_geo_attribute_clamp(void);
Cleanup: Alphabetize function order
2021-02-07 17:21:21 -06:00
void register_node_type_geo_attribute_color_ramp(void);
Geometry Nodes: Add Combine and Separate XYZ nodes for attributes These are similar to the regular "Combine XYZ" and "Separate XYZ" nodes, but they work on attributes. They will make it easier to switch between vector attributes and float attributes. Differential Revision: https://developer.blender.org/D10308
2021-02-09 11:12:24 -06:00
void register_node_type_geo_attribute_combine_xyz(void);
Cleanup: Alphabetize function order
2021-02-07 17:21:21 -06:00
void register_node_type_geo_attribute_compare(void);
Geometry Nodes: Add Attribute Convert node The Attribute Convert node provides functionality to change attributes between different domains and data types. Before it was impossible to write to a UV Map attribute with the attribute math nodes since they did not output a 2D vector type. This makes it possible to "convert into" a UV map attribute. The data type conversion uses the implicit conversions provided by `\nodes\intern\node_tree_multi_function.cc`. The `Auto` domain mode chooses the domain based on the following rules: 1. If the result attribute already exists, use that domain. 2. If the result attribute doesn't exist, use the source attribute domain. 3. Otherwise use the default domain (points). See {T85700} Differential Revision: https://developer.blender.org/D10624
2021-03-13 11:49:56 -05:00
void register_node_type_geo_attribute_convert(void);
Geometry Nodes: Add Attribute Curve Map Node This node has the same functionality as the color and vector curve mapping nodes in the shader editor. Here is works on every value for the selected attribute, and it can also output a float value. Other than that, the implementation is quite straightforward-- almost completely boilerplate code. Differential Revision: https://developer.blender.org/D10921
2021-05-06 23:47:51 -05:00
void register_node_type_geo_attribute_curve_map(void);
Geometry Nodes: Attribute Fill Node This commit adds a node that fills every element of an attribute with the same value. Currently it supports float, vector, and color attributes. An immediate use case is for "billboard" scattering. Currently people are using the same input to a Random Attribute node's min and max input to fill every element of a vector with the same value, which is an unintuitive way to accomplish the same thing. Differential Revision: https://developer.blender.org/D9790
2020-12-10 07:58:45 -06:00
void register_node_type_geo_attribute_fill(void);
Geometry Nodes: Add Attribute Map Range Node This commit adds a node with a "Map Range" operation for attributes just like the non-attribute version of the node. However, unlike the regular version of the node, it also supports operations on vectors. Differential Revision: https://developer.blender.org/D10344
2021-03-25 23:29:33 -04:00
void register_node_type_geo_attribute_map_range(void);
Cleanup: Alphabetize function order
2021-02-07 17:21:21 -06:00
void register_node_type_geo_attribute_math(void);
void register_node_type_geo_attribute_mix(void);
Geometry Nodes: Add Attribute Proximity Node This node calculates a distance from each point to the closest position on a target geometry, similar to the vertex weight proximity modifier. Mapping the output distance to a different range can be done with an attribute math node after this node. A drop-down changes whether to calculate distances from points, edges, or faces. In points mode, the node also calculates distances from point cloud points. Design task and use cases: T84842 Differential Revision: https://developer.blender.org/D10154
2021-02-05 08:28:31 -06:00
void register_node_type_geo_attribute_proximity(void);
Cleanup: Alphabetize function order
2021-02-07 17:21:21 -06:00
void register_node_type_geo_attribute_randomize(void);
Geometry Nodes: Add Combine and Separate XYZ nodes for attributes These are similar to the regular "Combine XYZ" and "Separate XYZ" nodes, but they work on attributes. They will make it easier to switch between vector attributes and float attributes. Differential Revision: https://developer.blender.org/D10308
2021-02-09 11:12:24 -06:00
void register_node_type_geo_attribute_separate_xyz(void);
Geometry Nodes: initial Attribute Transfer node This is a first version of an Attribute Transfer node. It only supports two modes for mapping attributes from one geometry to another for now. More options are planned for the future. Ref T87421. Differential Revision: https://developer.blender.org/D11037
2021-04-27 12:56:13 +02:00
void register_node_type_geo_attribute_transfer(void);
Cleanup: Alphabetize function order
2021-02-07 17:21:21 -06:00
void register_node_type_geo_attribute_vector_math(void);
Geometry Nodes: Add Attribute Vector Rotate node Port vector rotate node to geo attributes. Request by @simonthommes Reviewed By: simonthommes, HooglyBoogly
2021-05-11 10:53:13 +01:00
void register_node_type_geo_attribute_vector_rotate(void);
Nodes: Add Attribute Remove Node This patch adds a node, that removes an attribute if possible, otherwise it adds an error message. Differential Revision: https://developer.blender.org/D10697
2021-03-11 23:06:16 +01:00
void register_node_type_geo_attribute_remove(void);
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
void register_node_type_geo_boolean(void);
Geometry Nodes: Bounding Box Node This commit adds a simple node to output the min and max of an axis-aligned bounding box for the input geometry, as well a rectangular prism mesh created from these values for convenience. The initial use case for this node is a "bounding box boolean", where doing the boolean with just a bounding box could be signigicantly faster, for cases like cutting a hole in a wall for a window. But it's easy to imagine other cases where it could be useful. This node supports mesh and point cloud data right now, volume support will come as a separate patch. Also note that there is plenty of room to improve the performance of this node through parallelization. Differential Revision: https://developer.blender.org/D10420
2021-04-06 16:02:55 -05:00
void register_node_type_geo_bounding_box(void);
Cleanup: Alphabetize function order
2021-02-07 17:21:21 -06:00
void register_node_type_geo_collection_info(void);
Geometry Nodes: Add Convex Hull Node This commit adds a node to output the convex hull of any input geometry as a mesh, which is an enclosing geometry around a set of points. All geometry types are supported, besides volumes. The code supports operating on instances to avoid copying all input geometry before the operation. The implementation uses the same backend as the operation in edit mode, but uses Mesh directly instead of BMesh. Attribute transfer is not supported currently, but would be a point of improvement for the future if it can work in a predictable way on different geometry input types. Differential Revision: https://developer.blender.org/D10925
2021-06-09 11:58:08 -05:00
void register_node_type_geo_convex_hull(void);
Geometry Nodes: Curve Length Node This commit adds a node that outputs the total length of all evalauted curve splines in a geometry set as a float value. Differential Revision: https://developer.blender.org/D11459
2021-06-03 19:12:38 -04:00
void register_node_type_geo_curve_length(void);
Geometry Nodes: Initial basic curve data support This patch adds initial curve support to geometry nodes. Currently there is only one node available, the "Curve to Mesh" node, T87428. However, the aim of the changes here is larger than just supporting curve data in nodes-- it also uses the opportunity to add better spline data structures, intended to replace the existing curve evaluation code. The curve code in Blender is quite old, and it's generally regarded as some of the messiest, hardest-to-understand code as well. The classes in `BKE_spline.hh` aim to be faster, more extensible, and much more easily understandable. Further explanation can be found in comments in that file. Initial builtin spline attributes are supported-- reading and writing from the `cyclic` and `resolution` attributes works with any of the attribute nodes. Also, only Z-up normal calculation is implemented at the moment, and tilts do not apply yet. **Limitations** - For now, you must bring curves into the node tree with an "Object Info" node. Changes to the curve modifier stack will come later. - Converting to a mesh is necessary to visualize the curve data. Further progress can be tracked in: T87245 Higher level design document: https://wiki.blender.org/wiki/Modules/Physics_Nodes/Projects/EverythingNodes/CurveNodes Differential Revision: https://developer.blender.org/D11091
2021-05-03 12:29:17 -05:00
void register_node_type_geo_curve_to_mesh(void);
Geometry Nodes: Curve to Points Node for Evaluated Data This node implements the second option of T87429, creating points along the input splines with the necessary evaluated information for instancing: `tangent`, `normal`, and `rotation` attributes. All generic curve point and spline attributes are copied to the result points as well. The "Count" and "Length" methods are just like the current options in the resample node, but the output is points instead of a curve. The "Evaluated" method uses the points you see on the curve directly, and therefore should be the fastest. The rotation data is retrieved from a transform matrix built with the same method that the curve to mesh node uses. The radius attribute is divided by 10 so the points don't look absurdly huge in the viewport. In the future that could be an option. For the implementation, one thing that could use an improvement is the amount of temporary allocations while resampling to evaluated points before the final points. I expect that reusing a buffer for each thread would give a nice improvement. Differential Revision: https://developer.blender.org/D11539
2021-06-14 12:51:25 -05:00
void register_node_type_geo_curve_to_points(void);
Geometry Noes: Curve Resample Node This node generates a naturally parametarized (even length edge) poly spline version of every spline in the input. There are two modes, "Count", and "Length". These are similar to the same options for the line primitive node in end points mode. I implemented this instead of a "Sample Points" node, because for this operation it's trivial to keep the result as a curve, which is nice since it increases flexibility, and because it can make instancing simpler, i.e. using the transforms of each evaluated point rather than requiring the construction of a "rotation" attribute. Differential Revision: https://developer.blender.org/D11173
2021-05-07 15:37:06 -05:00
void register_node_type_geo_curve_resample(void);
Geometry Nodes: Curve Reverse Node This is an implementation of T88722. It accepts a curve object and for each spline, reverses the order of the points and all attributes. This is more of a foundational node to support other nodes in the future (like curve deform) Selection takes spline domain attributes to determine which splines are selected. If no selection is present all splines are reversed. Differential Revision: https://developer.blender.org/D11538
2021-06-14 13:28:38 -05:00
void register_node_type_geo_curve_reverse(void);
Geometry Nodes: Add Curve Subdivision Node This node creates splines with more control points in between the existing control points. The point is to give the splines more definition for further tweaking like randomization with white noise, instead of deforming a resampled poly spline with a noise texture. For poly splines and NURBS, the node simply interpolates new values between the existing control points. However, for Bezier splines, the result follows the existing evaluated shape of the curve, changing the handle positions and handle types to make that possible. The number of "cuts" can be controlled by an integer input, or an attribute can be used. Both spline and point domain attributes are supported, so the number of cuts can vary using the value from the point at the start of each segment. Dynamic curve attributes are interpolated to the result with linear interpolation. Differential Revision: https://developer.blender.org/D11421
2021-06-17 11:39:23 -05:00
void register_node_type_geo_curve_subdivide(void);
Geometry Nodes: Add Delete Geometry Node This node is similar to the mask modifier, but it deletes the elements of the geometry corresponding to the selection, which is retrieved as a boolean attribute. The node currently supports both mesh and point cloud data. For meshes, which elements are deleted depends on the domain of the input selection attribute, just like how behavior depends on the selection mode in mesh edit mode. In the future this node will support curve data, and ideally volume data in some way. Differential Revision: https://developer.blender.org/D10748
2021-06-01 17:32:03 -04:00
void register_node_type_geo_delete_geometry(void);
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
void register_node_type_geo_edge_split(void);
Geometry Nodes: new Material input node This node is similar to the Value and Vector node. It just provides a way to use the same material in multiple nodes without exposing it outside of a node group. Differential Revision: https://developer.blender.org/D11305
2021-05-20 12:29:06 +02:00
void register_node_type_geo_input_material(void);
Cleanup: Alphabetize function order
2021-02-07 17:21:21 -06:00
void register_node_type_geo_is_viewport(void);
void register_node_type_geo_join_geometry(void);
Geometry Nodes: new Material Assign node This adds a new Material Assign node. It can be used to change the material used by an existing mesh or to assign a material to a mesh that has been generated from scratch. Differential Revision: https://developer.blender.org/D11155
2021-05-20 12:22:13 +02:00
void register_node_type_geo_material_assign(void);
Geometry Nodes: new Material Replace node This node can change all faces that use a specific material to use a different material. Using this node is significantly more efficient than creating a selection from all faces with a specific material index and then using the Material Assign node. Ref T88055. Differential Revision: https://developer.blender.org/D11325
2021-05-21 09:43:55 +02:00
void register_node_type_geo_material_replace(void);
Geometry Nodes: Add initial version of mesh primitives This commit includes nodes to build the following primitives: - Cone - Cylinder - Circle - Cube - UV Sphere - Ico Sphere - Line - Plane/Grid In general the inputs are the same as the corresponding operators in the 3D view. **Line Primitive** The line primitive has two modes-- adding vertices between two end points, or adding vertices each at an offset from the start point. For the former mode, there is a choice between a vertex count and a distance between each point. **Plane Primitive** This commit includes the "Plane" and "Grid" primitives as one node. Generally primitives are named after the simpler form of the shape they create (i.e. "Cone" can make some more complex shapes). Also, generally you want to tweak the number of subdivisions anyway, so defaulting to plane is not an inconvenience. And generally having fewer redundant base primitives is better. **Future Improvements** A following patch proposes to improve the speed of the cylinder, cone, and sphere primitives: D10730. Additional possible future improvements would be adding subdivisions to the cube node and rings to the cone and cylinder nodes. Differential Revision: https://developer.blender.org/D10715
2021-03-16 17:35:12 -04:00
void register_node_type_geo_mesh_primitive_circle(void);
void register_node_type_geo_mesh_primitive_cone(void);
void register_node_type_geo_mesh_primitive_cube(void);
void register_node_type_geo_mesh_primitive_cylinder(void);
Geometry Nodes: Rename "Plane" primitive to "Grid" Although "Grid" may not be techincally correct since a grid could be 3D, it was decided to rename the "Plane" primtive to "Grid". The primitive node allows subdivisions, so the name is more consistent with the operator in the 3D view. Ref T86819 This commit includes a file subversion bump for the versioning.
2021-03-26 13:09:35 -04:00
void register_node_type_geo_mesh_primitive_grid(void);
Geometry Nodes: Add initial version of mesh primitives This commit includes nodes to build the following primitives: - Cone - Cylinder - Circle - Cube - UV Sphere - Ico Sphere - Line - Plane/Grid In general the inputs are the same as the corresponding operators in the 3D view. **Line Primitive** The line primitive has two modes-- adding vertices between two end points, or adding vertices each at an offset from the start point. For the former mode, there is a choice between a vertex count and a distance between each point. **Plane Primitive** This commit includes the "Plane" and "Grid" primitives as one node. Generally primitives are named after the simpler form of the shape they create (i.e. "Cone" can make some more complex shapes). Also, generally you want to tweak the number of subdivisions anyway, so defaulting to plane is not an inconvenience. And generally having fewer redundant base primitives is better. **Future Improvements** A following patch proposes to improve the speed of the cylinder, cone, and sphere primitives: D10730. Additional possible future improvements would be adding subdivisions to the cube node and rings to the cone and cylinder nodes. Differential Revision: https://developer.blender.org/D10715
2021-03-16 17:35:12 -04:00
void register_node_type_geo_mesh_primitive_ico_sphere(void);
void register_node_type_geo_mesh_primitive_line(void);
void register_node_type_geo_mesh_primitive_uv_sphere(void);
Geometry Nodes: Add Mesh to Curve Node This node creates poly curve splines from mesh edges. A selection attribute input allows only using some of the edges from the mesh. The node builds cyclic splines from branchless groups of edges where possible, but when there is a three-way intersection, the spline stops. The node also transfers all attributes from the mesh to the resulting control points. In the future we could add a way to limit that to a subset of the attributes to improve performance. The algorithm is from Animation Nodes, written by @OmarSquircleArt. I added the ability to use a selection, attribute transferring, and used different variable names, etc, but other than that the algorithm is the same. Differential Revision: https://developer.blender.org/D11265
2021-05-28 10:42:22 -04:00
void register_node_type_geo_mesh_to_curve(void);
Cleanup: Alphabetize function order
2021-02-07 17:21:21 -06:00
void register_node_type_geo_object_info(void);
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
void register_node_type_geo_point_distribute(void);
void register_node_type_geo_point_instance(void);
Cleanup: Alphabetize function order
2021-02-07 17:21:21 -06:00
void register_node_type_geo_point_rotate(void);
Geometry Nodes: Add "Point Translate" and "Point Scale" nodes The translate node moves every point in the geometry, and the scale node multiplies the "scale" attribute of the input geometry by its input. While these operations are already possible with the "Attribute" nodes, these new nodes fit nicely with the nodes specifically for changing the "rotation" attribute that already exist, and they provide a simpler way to do the same thing. Differential Revision: https://developer.blender.org/D10100
2021-01-13 10:30:42 -06:00
void register_node_type_geo_point_scale(void);
Cleanup: Alphabetize function order
2021-02-07 17:21:21 -06:00
void register_node_type_geo_point_separate(void);
Geometry Nodes: Add "Point Translate" and "Point Scale" nodes The translate node moves every point in the geometry, and the scale node multiplies the "scale" attribute of the input geometry by its input. While these operations are already possible with the "Attribute" nodes, these new nodes fit nicely with the nodes specifically for changing the "rotation" attribute that already exist, and they provide a simpler way to do the same thing. Differential Revision: https://developer.blender.org/D10100
2021-01-13 10:30:42 -06:00
void register_node_type_geo_point_translate(void);
Geometry Nodes: new Points to Volume node This implements a new geometry node based on T84606. It is the first node that generates a `VolumeComponent`. Differential Revision: https://developer.blender.org/D10169
2021-01-26 17:37:58 +01:00
void register_node_type_geo_points_to_volume(void);
Raycast geometry node. The //Raycast// node intersects rays from one geometry onto another. It computes hit points on the target mesh and returns normals, distances and any surface attribute specified by the user. A ray starts on each point of the input //Geometry//. Rays continue in the //Ray Direction// until they either hit the //Target Geometry// or reach the //Ray Length// limit. If the target is hit, the value of the //Is Hit// attribute in the output mesh will be true. //Hit Position//, //Hit Normal//, //Hit Distance// and //Hit Index// are the properties of the target mesh at the intersection point. In addition, a //Target Attribute// can be specified that is interpolated at the hit point and the result stored in //Hit Attribute//. Docs: D11620 Reviewed By: HooglyBoogly Differential Revision: https://developer.blender.org/D11619
2021-06-17 09:31:53 +01:00
void register_node_type_geo_raycast(void);
Cleanup: Alphabetize function order
2021-02-07 17:21:21 -06:00
void register_node_type_geo_sample_texture(void);
Geometry Nodes: new Select by Material node This node creates a boolean face attribute that is "true" for every face that has the given material. Differential Revision: https://developer.blender.org/D11324
2021-06-08 16:01:54 +02:00
void register_node_type_geo_select_by_material(void);
Geometry Nodes: Separate Components Node Implementation of T86970. This node takes a geometry input with multiple components and outputs them by component type. Meshes, Curves, and Point Clouds support combining multiple input instances, while volumes will only output the first volume component input until suitable instance realization for multiple volumes is finished. When direct geometry instancing is implemented it will be possible to avoid realizing instances in this node. Differential Revision: https://developer.blender.org/D11577
2021-06-15 22:31:57 -05:00
void register_node_type_geo_separate_components(void);
Geometry Nodes: Rename subdivision nodes This makes the following changes to the name of the two geometry nodes subvision nodes: - `Subdivision Surface` -> `Subdivide Smooth` - `Subdivision Surface Simple` -> `Subdivide` Most of the benefit is that the names are shorter, but it also better mirrors the naming of operations in edit mode, and phrases the names more like actions. This was discussed with the geometry nodes team.
2021-03-08 13:37:49 -05:00
void register_node_type_geo_subdivide(void);
Geometry Nodes: Rename "Subdivide Smooth" back to "Subdivision Surface" Following concerns raised in the commit that changed the name initially, rB2e19509e60b39837, it makes more sense to keep the "Surface" name for this node because it has a specific meaning that should not be confused with other types of subdivision.
2021-03-17 14:40:38 -04:00
void register_node_type_geo_subdivision_surface(void);
Geometry Nodes: new Switch node This is a first iteration of a switch node. It can only switch between two inputs values based on a boolean. A more sophisticated switch node that has an integer selector will probably come later. Currently, the geometry nodes evaluator does not support lazy evaluation of individual inputs. Therefore, all inputs will be computed currently. An improvement to the evaluator will be worked on separately. Ref: T85374 Differential Revision: https://developer.blender.org/D10460
2021-04-19 10:38:50 +02:00
void register_node_type_geo_switch(void);
Cleanup: Alphabetize function order
2021-02-07 17:21:21 -06:00
void register_node_type_geo_transform(void);
void register_node_type_geo_triangulate(void);
Geometry Nodes: add Volume to Mesh node This node takes a volume and generates a mesh on it's "surface". The surface is defined by a threshold value. Currently, the node only works on volumes generated by the Points to Volume node. This limitation will be resolved soonish. Ref T84605. Differential Revision: https://developer.blender.org/D10243
2021-02-05 16:20:14 +01:00
void register_node_type_geo_volume_to_mesh(void);
Simulations: Add simulation node tree type This implements a new builtin node tree type called `SimulationNodeTree`. It is not yet embedded in the `Simulation` data block. The node tree will initially be used for the new particle nodes system. When the cmake option `WITH_NEW_SIMULATION_TYPE` is enabled, a new `Simulation Editor` is shown in the editors menu (which is just a node editor). This patch does not add entries to the Add Node menu, so it is empty. Reviewers: brecht Differential Revision: https://developer.blender.org/D7287
2020-04-20 10:58:43 +02:00
#ifdef __cplusplus
}
#endif
Copy Permalink