Reference/Release Notes/3.0/Nodes Physics

= Blender 3.0: Nodes & Physics =

Geometry Nodes
In Blender 3.0, geometry nodes has been extended with a re-imagined method for designing node groups, a new attribute system, many new nodes for interaction with curves, text data, instances, and much more.

In bold you can find the names of about 100 newly added nodes.

Fields
Geometry nodes makes use of a new concept for passing around data and functions. Operations can be built from basic nodes and simply connected together, removing the need for named attributes as a way to store intermediate data, and removing the need for special "Attribute" nodes for simple operations. With fields it's much easier to build node groups for higher level concepts that work together better than before.

See the page in the manual for more detail: https://docs.blender.org/manual/en/3.0/modeling/geometry_nodes/fields.html


 * Dashed lines are used to represent the flow of functions while data-flow node links look the same as before.
 * Socket shapes are used to visualize whether inputs and outputs can be fields.
 * Circle sockets only support single values
 * Diamond sockets support fields. If they have a dot in the middle, then they are only a single value currently though.
 * The Set Position node simply sets a geometry's position attribute to its input.
 * The Position node outputs the position of the geometry it is evaluated for.
 * Other built-in attributes can be accessed and set by specific nodes.
 * Most nodes have been updated to make use of new concepts like selections and field inputs:
 * The Geometry Proximity node replaces the attribute proximity node.
 * The Align Euler to Vector and Rotate Euler node are now function nodes that can affect any rotation.
 * The Edge Split node now has a selection input, allowing any edges to be selected procedurally.
 * The ability to work on data without attributes means texture nodes can be ported from the shader editor:
 * Noise Texture
 * Gradient Texture
 * White Noise Texture
 * Voronoi Texture
 * Checker Texture
 * Magic Texture
 * Wave Texture
 * Musgrave Texture

Improved Attribute Workflow
The attribute workflow in geometry nodes has been completely redesigned. While the old system relied on addressing attributes by name, attribute data can now be passed around with node links just like data in the node tree. .
 * As an example, the Random Value node replaces the existing Attribute Randomize node, and can simply be connected to any input to randomize it.
 * The Capture Attribute node stores data from its input on a geometry so it is carried forward to other nodes, allowing the use of the same data in a different context.
 * For example, this node makes it possible to use data only available on curves, like the output of the Curve Parameter node, after converting a curve to a mesh.
 * The modifier interface can now interact directly with named attributes
 * A new attribute/value toggle on exposed inputs allows quick switching between attribute and single value inputs.
 * Named attributes can be created by connecting them to the group output node and choosing a name in the modifier.
 * Attribute search is supported in the modifier.
 * A new Transfer Attribute node can copy attribute values between geometries with various methods.
 * The node includes an "Index" method to retrieve a value from the target geometry at a certain index.
 * The Attributes Panel in the property editor shows all generic attributes available on a mesh.
 * Vertex group names are now stored on meshes rather than objects, which makes working with them in geometry nodes more predictable.
 * The Attribute Statistic node outputs values like average, min, and max for an attribute.
 * There is now a special domain interpolation method for selections (boolean attributes) to make the conversions work like they do in edit mode.
 * The `id` attribute is now built-in, but optional, instead of just a reserved name.
 * The ID input node outputs the `id` attribute if it exists, otherwise the index.

Instances


The way geometry nodes works with instances has been improved, to make it more intuitive and faster. (Blender Manual)
 * Geometry can now be instanced directly, without a separate object.
 * When the same geometry is instanced many times, nodes can often only do the calculation once on the original geometry, rather than realizing instances and doing it many times.
 * This can result in a large performance improvement in many cases. For example, each "A" character created by the String to Curves node in a long paragraph of text only has to be filled a single time by the Curve Fill node.
 * Mesh modifiers after geometry nodes no longer implicitly realize instances or convert point clouds to meshes.
 * Instances are now exposed properly to nodes, and aren't converted to real geometry implicitly.
 * The Realize Instances node can explicitly convert instances into real geometry.
 * Because instances each have their own transformation, there are special nodes for transforming instances.
 * The Rotate Instances node rotates instances in their local space or global space.
 * The Scale Instances node scales an instance from a center point, in local or global space.
 * The Translate Instances node moves instances along the three axes, also relative to their current transform, or globally..
 * The Instances to Points node converts the origins of a geometry's instances into a point cloud.
 * A selection boolean input is added to to Instance on Points.
 * The Object Info node can now optionally output an instance instead of real geometry.
 * The instances in the output of the Collection Info node are sorted alphabetically.
 * Known Issue: Currently updating an object name does not cause a reevaluation of the node tree.

Curve Nodes


Curve data is now supported in the node tree.
 * The Curve to Mesh node extrudes a profile curve along another curve.
 * A "Fill Caps" option allows generating an N-gon at the ends of the profile, producing a manifold mesh.
 * Custom attributes are automatically transferred from the curve to the mesh output.
 * The Resample Curve node distributes evenly spaced segments along a curve.
 * The Fill Curve node creates a filled 2D mesh from an input curve
 * The Subdivide Curve node adds new control points between existing control points.
 * The Sample Curve node outputs values from the curve at a given factor or length along it.
 * The Trim Curve node makes a curve shorter by discarding sections at the start and end.
 * The Fillet Curve node rounds corners of a curve with Bezier or Poly control points.
 * The Mesh to Curve node creates curve poly splines from mesh edges.
 * The Endpoint Selection node outputs a selection for a number of points at the start and end of each spline.
 * The Curve to Points node creates a point cloud with data necessary for instancing along the curve.




 * There are field inputs specifically for curve data:
 * The Curve Parameter node outputs how far along the spline each point is as a 0-1 factor.
 * The Curve Tangent node outputs the direction of the curve at each control point.
 * The Normal node outputs curve normals at each control point.
 * The Handle Type Selection outputs which handles have a certain type.
 * The Set Handle Type node changes the left or right handles of Bezier control points.
 * The Curve Length node outputs the total length of all splines in the curve.
 * The Reverse Curve node reverses the order of all of a curve's control points.
 * The type (Bezier, Poly, or NURBS) of each spline can be changed with the Set Spline Type node.
 * Curves fully support the existing attribute system.
 * Splines have `resolution` and `cyclic` builtin attributes.
 * Control points have `position`, `radius`, `tilt`, `handle_left` and `handle_right` built-in attributes.
 * Attributes with any name or data type can be created or removed on splines or control points.
 * Attributes can be interpolated between the two curve domains.
 * Curve primitive nodes have been added for parametric addition of curve data directly.
 * Bezier Segment.
 * Quadratic Bezier Segment.
 * Quadrilateral.
 * Circle.
 * Spiral.
 * Star.
 * Line.
 * The geometry nodes modifier is now supported on curve (and text) object types.
 * Curve data from curve objects without a geometry nodes modifier will also display in the spreadsheet.
 * Known Issue: This does not work in the "Original" mode of the spreadsheet.

General

 * Raycast node projects lines to a mesh, returning information about the hit location to attributes.
 * Delete Geometry node removes parts of geometry, depending on the domain of the selection attribute
 * Switch node can efficiently select between two inputs of any type.
 * Convex Hull node outputs a convex mesh containing all of the input points.
 * Separate Components node splits a geometry set into an output for each data type.
 * RGB Curves and Vector Curves nodes from shader nodes are supported in geometry node trees.
 * Float to integer conversion can be done more explicitly with the Float to Integer node.
 * Intermediate geometry data can be viewed in the spreadsheet with the Viewer node.
 * This also replaces the screen icon in the header of every node.
 * Some mesh primitive nodes have been improved:
 * The Cube node has been updated to allow a separate size and vertex count in each dimension.
 * The Cone and Cylinder nodes have been updated with options for the amount of side and fill segments.
 * The Index node outputs the index of each element when evaluating a field.
 * The Normal node outputs mesh normals, normalized on every domain, including faces and vertices.
 * Mesh to Points and Points to Vertices nodes allow converting directly between point clouds and mesh elements.
 * The old Point Separate node was updated to become more general as the Separate Geometry node.
 * There are more basic input nodes
 * A new Color input node is an easier way to directly input a color.
 * There are now Boolean and Integer input nodes.

Text Nodes



 * The String to Curves node generates curve instances for a text paragraph, like the text object type but procedural.
 * Because the node creates curve instances, performance can be much better than the existing text object.
 * String manipulation nodes allow creating text for the string to curve node procedurally.
 * String Length Outputs length of a string
 * Slice String Outputs part of a string
 * Value to String Converts a value to a string
 * Join Strings Concatenates multiple strings with a delimiter
 * Replace String A node-based find and replace operation
 * The Special Characters node can be used to build a paragraph with multiple lines.

Performance

 * Geometry nodes has a new, faster evaluation system.
 * Multiple branches of the node tree are now executed in parallel where possible.
 * Lazy evaluation is supported, so where possible, only the inputs and outputs that are required are computed.
 * For example, the Separate Geometry node can be twice as fast if only one output is used and the Switch node only computes the input that is actually used.
 * All field evaluation is parallelized, so computations for many geometry elements will always be multi-threaded.
 * The Instance on Points node now executes faster, especially when multiple CPU threads are available.
 * Transforming meshes with the Transform node is now much faster in some situations.

Materials



 * An object's material slots can change during evaluation of geometry nodes.
 * Joining geometries from other objects will now properly add their materials to the modifier object.
 * The Set Material node sets the material for a selection of faces.
 * Though volumes only support a single material, it can also be changed.
 * The Replace Material node replaces an existing material on a geometry with another.
 * The Material Selection node creates a boolean mask of the parts of a geometry with a certain material.
 * The Material Input node allows using the same material in multiple places.
 * The built-in `material_index` attribute on meshes can be accessed with the Material Index input node.

Volumes

 * The geometry nodes modifier is now supported on volume objects.
 * Known Issue: Currently EEVEE cannot display procedurally generated volumes, converting the volume to a mesh and using a volume shader does work though

Node Editor

 * The node editor now has an "Overlays" popover, with options for displaying wire colors and annotations.
 * The editor's view now pans automatically when links or nodes are dragged to the edges.
 * Node editor UI style changes
 * There were many changes to the style of nodes themselves, to increase clarity and make them look nicer.
 * The background grid is now displayed with dots instead of lines.
 * The breadcrumbs to show the path of the node tree are now drawn differently, on the top left.
 * On node frames, the label text is only displayed when there is a label set.
 * Node links between different types with no possible implicit conversion now turn red to indicate the error (Geometry Nodes).
 * Socket labels on nodes like "Object Info" are hidden to give more space to data-block names.
 * Node links with sockets outside the view are dimmed, to remove visual noise from long links.
 * Parent node trees are no longer displayed behind a green background when editing a nested node group.
 * Wire colors overlay to match the socket's color they are connected to..

Spreadsheet Editor

 * The spreadsheet now has a region on the left to quickly switch between geometry components or domains.
 * Row filters were added to a right property region, to allow removing rows from the view.

Modifier

 * Node warnings are also displayed in the modifier, so they don't get lost in the node tree.