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
e684c170f9f8fb1aaeb7e59c9d1a14ba94b6791d
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.

75 lines
3.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
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);
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: 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);
Cleanup: Alphabetize function order
2021-02-07 17:21:21 -06:00
void register_node_type_geo_attribute_vector_math(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);
Cleanup: Alphabetize function order
2021-02-07 17:21:21 -06:00
void register_node_type_geo_collection_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_edge_split(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: 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_plane(void);
void register_node_type_geo_mesh_primitive_cylinder(void);
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);
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);
Cleanup: Alphabetize function order
2021-02-07 17:21:21 -06:00
void register_node_type_geo_sample_texture(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);
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