PGCRYPT/OpenBlender_Train huggingface dataset:
user: How do I use NodeTreeInterfaceSocketIntFactor(NodeTreeInterfaceSocket) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeTreeInterfaceSocketIntFactor(NodeTreeInterfaceSocket)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`NodeTreeInterfaceItem`](bpy.types.NodeTreeInterfaceItem.html#bpy.types.NodeTreeInterfaceItem "bpy.types.NodeTreeInterfaceItem"), [`NodeTreeInterfaceSocket`](bpy.types.NodeTreeInterfaceSocket.html#bpy.types.NodeTreeInterfaceSocket "bpy.types.NodeTreeInterfaceSocket")

*class* bpy.types.NodeTreeInterfaceSocketIntFactor(*NodeTreeInterfaceSocket*)
:   Integer number socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   int in [0, inf], default 0

    max_value
    :   Maximum value

        Type:
        :   int in [-inf, inf], default 0

    min_value
    :   Minimum value

        Type:
        :   int in [-inf, inf], default 0

    subtype
    :   Subtype of the default value

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with Multicam Selector Strip in a Blender add-on or script – include code.

assistant: # Multicam Selector Strip

The Multicam Selector strip is used for multi-camera editing.
Multi-camera editing is when a scene is recorded using multiple cameras from different angles
and then edited together afterwards.
user: Describe Examples from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Using Image Output

This can simply be achieved by using the Alpha Over node.

[image reference removed]

Image output.

### Using Plane Output

This can be achieved by mixing the movie clip and the image by using the plane output as the factor.

[image reference removed]

Plane output.
user: Provide the full official documentation entry for Spline Types, preserving all code examples.

assistant: ### Poly

Poly splines are the simplest type, with no interpolation between control points.
They are used when [converting meshes to curves](../../scene_layout/object/editing/convert.html#bpy-ops-object-convert)
for accurate representation of the original mesh.
While Poly splines are precise, [Bézier](#bezier) or [NURBS](#nurbs) splines are generally preferred for smooth curves.

### Bézier

Bézier splines use control points and handles to define their shape.
A curve segment exists between two control points, with the handles controlling the curvature.

In the illustration below, the control points are at the center of the pink lines, while the handles extend outward.
The arrows represent the curve normals, indicating direction and tilt.

[image reference removed]

Bézier Curve in Edit Mode.

#### Handle Types

Bézier curves support four handle types, which can be changed with `V`:

[image reference removed]

Bézier Curve Handle Types.

Automatic:
:   Automatically adjusts handle length and direction for the smoothest curve.
    Displayed as yellow handles. Converts to *Aligned* when moved.

Vector:
:   Handles point directly toward adjacent control points, enabling straight lines or sharp corners.
    Displayed as green handles. Converts to *Free* when moved.

Aligned:
:   Handles remain on a straight line, ensuring smooth, continuous curves.
    Displayed as purple handles.

Free:
:   Handles move independently, allowing for asymmetric curves.
    Displayed as black handles.

### NURBS

NURBS (Non-Uniform Rational B-Splines) are mathematically precise splines, offering exact shapes.
Unlike Bézier curves, which approximate shapes (e.g., a Bézier circle approximates a perfect circle),
NURBS can represent exact geometry.

For more information, refer to the [Wikipedia page](https://en.wikipedia.org/wiki/NURBS).

NURBS control points have a unique weight property that determines their influence on the curve.
This weight differs from the [Goal Weight](editing/transform_panel.html#curves-weight) used in soft body simulations.
Weights can be adjusted in the *W* field of the [Transform panel](editing/transform_panel.html).
user: What is AssetTag(bpy_struct) and how is it used in Blender Python scripting?

assistant: # AssetTag(bpy_struct)

base class — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct")

*class* bpy.types.AssetTag(*bpy_struct*)
:   User defined tag (name token)

    name
    :   The identifier that makes up this tag

        Type:
        :   string, default “”, (never None)

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Magic Texture Node and how is it used in Blender Python scripting?

assistant: # Magic Texture Node

[image reference removed]

The Magic Texture node is used to add a psychedelic color texture.
It can be used for “Thin Film Interference” if you assign a *Reflection* Texture Coordinate
to the Vector input and use a relatively high *Turbulence*.
The RGB components are generated independently with a sine formula.
user: How do I use Tracks in Blender? Include parameters, examples, warnings and best practices.

assistant: New Blender versions can sometimes introduce breaking changes in Blender’s
Python API or even change how entire features work. If this affects your
extension, you may want to maintain two “tracks” of your extension concurrently:
one for Blender “old” and one for Blender “new”.

You can use version numbering to accomplish this in a reasonably clear way. For
example, if your extension is currently on version 1.2.1, and you wish to
release a new version for the breaking changes in Blender “new”, you can release
that new version as version 1.3.0. Then if you need to make bug fixes in the
version of the extension for Blender “old”, you can still increment the patch
number to 1.2.2, 1.2.3, etc. In effect, 1.2.x and 1.3.x are two different
“tracks” of the extension, each of which can continue to get new releases.

Alternatively, you can increment the major version number for the tracks,
particularly if you expect to do more than just bug fixes for the older tracks.
Either way, we strongly recommend against only incrementing the patch version
for these kinds of updates: you never know when you might need to make a bug fix
release.
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: To toggle between the two projections for the 3D Viewport, select
View ‣ Perspective/Orthographic or use the shortcut
`Numpad5`. Changing the projection for a 3D Viewport does not affect
the way the scene will be rendered. Rendering is in perspective by default.
If you need to create an orthographic rendering, select the camera, go to
the Camera tab in the [Properties editor](../../properties_editor.xhtml),
and set the Type in the Lens panel to *Orthographic*.
user: Provide the full official documentation entry for Dt Method Vertex Items, preserving all code examples.

assistant: # Dt Method Vertex Items

TOPOLOGY:
:   Topology.

    Copy from identical topology meshes.

NEAREST:
:   Nearest Vertex.

    Copy from closest vertex.

EDGE_NEAREST:
:   Nearest Edge Vertex.

    Copy from closest vertex of closest edge.

EDGEINTERP_NEAREST:
:   Nearest Edge Interpolated.

    Copy from interpolated values of vertices from closest point on closest edge.

POLY_NEAREST:
:   Nearest Face Vertex.

    Copy from closest vertex of closest face.

POLYINTERP_NEAREST:
:   Nearest Face Interpolated.

    Copy from interpolated values of vertices from closest point on closest face.

POLYINTERP_VNORPROJ:
:   Projected Face Interpolated.

    Copy from interpolated values of vertices from point on closest face hit by normal-projection.
user: Show practical ways to work with Transparency in a Blender add-on or script – include code.

assistant: The [Transparent BSDF](../../shader_nodes/shader/transparent.html) shader is given
special treatment. Rays pass straight through it, changing neither direction nor type
as if there were no geometry at all.

Alpha pass output is also different for the transparent
BSDF.
Other transmission BSDFs are considered opaque,
because they change the light direction. As such they cannot be used for
alpha-over compositing, while this is possible with the transparent BSDF.

Note that, while semantically the ray passes through as if no geometry was hit,
rendering performance is affected as each transparency step requires executing the shader and tracing a ray.
user: Describe Separate Spherical Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Separate Spherical Node

[image reference removed]

The *Separate Spherical* node converts a vector from Cartesian coordinates (X, Y, Z)
into spherical coordinates (R, Φ, Θ) and outputs each component separately.
It is the inverse of the [Combine Spherical](../../../../modeling/geometry_nodes/utilities/vector/combine_spherical.xhtml) node.

Spherical coordinates describe a position in 3D space using radius, azimuth (horizontal angle),
and polar (vertical) angle. This representation is useful for procedural effects involving
rotational symmetry, spherical gradients, or direction-based transformations.
user: Provide the full official documentation entry for Using an External Image Editor, preserving all code examples.

assistant: If you use an external program to edit your UV texture, you must:

1. Run that paint program (GIMP, Krita, etc.).
2. Load the image or create a new one.
3. Change the image.
4. And re-save it within that program.
5. Back in Blender, you reload the image in the Image Editor.

You want to use an external program if you have teams of people using different programs
that are developing the UV textures, or if you want to apply any special effects
that Texture Paint does not feature, or if you are much more familiar with
your favorite paint program.
user: Provide the full official documentation entry for FModifierEnvelopeControlPoint(bpy_struct), preserving all code examples.

assistant: # FModifierEnvelopeControlPoint(bpy_struct)

base class — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct")

*class* bpy.types.FModifierEnvelopeControlPoint(*bpy_struct*)
:   Control point for envelope F-Modifier

    frame
    :   Frame this control-point occurs on

        Type:
        :   float in [-inf, inf], default 0.0

    max
    :   Upper bound of envelope at this control-point

        Type:
        :   float in [-inf, inf], default 0.0

    min
    :   Lower bound of envelope at this control-point

        Type:
        :   float in [-inf, inf], default 0.0

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Scripted Expression - Orbit a Point, preserving all code examples.

assistant: Orbit an object’s position around a point with a custom *Scripted Expression*.
The object’s position will change when scrubbing the timeline.
Using trigonometry, circular motion can be defined in 2D using the sine and cosine functions.
(See [Unit Circle](https://en.wikipedia.org/wiki/Unit_circle).)
In this example, the current frame is used as the variable that induces the motion.
`frame` is a [Simple Expression](drivers_panel.xhtml#drivers-simple-expressions) that corresponds to
`bpy.context.scene.frame_current`.

[image reference removed]

1. Add a driver to the X Location property.

   1. Set the *Driver Type* to *Scripted Expression*.
   2. Add the expression `0 + (sin(frame / 8) * 4)`, where:

      - `frame/8` : is the current frame of the animation, divided by 8 to slow the orbit down.
      - `(sin( )*4)` : multiplies the result of `sin(frame/8)` by 4 for a bigger circle.
      - `0 +` : is used to control the offset to the orbit center point.
2. Add a driver to the Y Location property with the expression `0 + (cos(frame / 8) * 4)`.
3. Scrub the timeline to see the effect.
   Experiment with the variables to control the size and center of the orbit.
user: Give a detailed overview of Snap: syntax, arguments, return values, common patterns.

assistant: Snapping in the UV Editor is similar to
[Snapping in 3D](../../../editors/3dview/controls/snapping.xhtml).
For the snap to pixel options to work an image has to be loaded.

Selected to Pixels
:   Moves selection to nearest pixel. See also *Round to Pixels* below.

Selected to Cursor
:   Moves selection to 2D cursor location.

Selected to Cursor (Offset)
:   Moves selection center to 2D cursor location, while preserving the offset of the vertices from the center.

Selected to Adjacent Unselected
:   Moves selection to adjacent unselected element.

Cursor to Pixels
:   Snaps the cursor to the nearest pixels.

Cursor to Selected
:   Moves the Cursor to the center of the selection.

Cursor to Origin
:   Places the cursor to the location (0, 0, 0).
user: Describe Bone Parent from the Blender manual or Python API, including usage steps and snippets.

assistant: Bone parenting allows you to make a certain bone in an armature the parent object of another object.
This means that when transforming an armature the child object will only move
if the specific bone is the child object of moves.

[image reference removed]

Three pictures of armatures with four bones.

In Fig. [Three pictures of armatures with four bones.](#fig-view3d-parent-bone-parent) with the 2nd bone being the bone parent of the child object cube.
The cube is only transformed if the 1st or 2nd bones are.
Notice altering the 3rd and 4th bones has no effect on the cube.

To use bone parenting, you must first select all the child objects you wish to parent to a specific armature bone,
then `Shift`-`LMB` select the armature object and switch it into Pose Mode and
then select the specific bone you wish to be the parent bone by `LMB` selecting it.
Once done press `Ctrl`-`P` and select bone from the *Set Parent To* pop-up menu.

Now transforming that bone in Pose Mode will result in the child objects also transforming.

### Relative Parenting

Bone relative parenting is an option you can toggle for each bone.
This works in the same way as bone parenting with one difference.

With bone parenting if you have parented a bone to some child objects and
you select that bone and switch it into Edit Mode and then move that bone;
When you switch back into Pose Mode on that bone,
the child object which is parented to that bone will snap back to the location of the bone in Pose Mode.

[image reference removed]

Single armature bone which has a child object cube parented to it using bone parenting.

In Fig. [Single armature bone which has a child object cube parented to it using bone parenting.](#fig-view3d-parent-bone-parent-child) the 1st picture shows the position of the cube and
armature before the bone is moved in Edit Mode.
2nd picture shows the position of the cube and armature after the bone was selected in Edit Mode,
moved and switched back into Pose Mode. Notice that the child object moves to the new location of the pose bone.

Bone relative parenting works differently;
If you move a parent bone in Edit Mode, when you switch back to Pose Mode,
the child objects will not move to the new location of the Pose Bone.

[image reference removed]

Single bone with bone relative parent to a cube.

In Fig. [Single bone with bone relative parent to a cube.](#fig-view3d-parent-bone-parent-relative) the 1st picture
shows the position of the cube and armature before the bone is moved in Edit Mode.
2nd picture shows the position of the cube and armature after the bone was selected in Edit Mode,
moved and switched back into Pose Mode.
Notice that the child object does not move to the new location of the pose bone.
user: What is Output and how is it used in Blender Python scripting?

assistant: The compositor only supports a single active output target, that is, only one of the
[Group Output nodes](types/output/group_output.html) or [Viewer nodes](types/output/viewer.html#bpy-types-compositornodeviewer) in the node tree will be considered active and the rest will be
ignored. In particular, the compositor searches the *Active Node Tree Context* and falls back to the
*Root Node Tree Context* if no active output was found in the active node tree context. The active
node tree context is the node tree of an expanded node group, that is, when the user selects a node
group node and edits its underlying tree, while the root node tree context is the top level node
tree without any expanded node groups.

The compositor searches for the active *Group Output* node, if none was found, it searches for the
active *Viewer* node. If none was found, the compositor doesn’t run altogether.
Consequently, note that adding a *Viewer* node will have no effect on the viewport render if there
is a *Group Output* node, since the priority is given to *Group Output* nodes.
user: Show practical ways to work with Source in a Blender add-on or script – include code.

assistant: [image reference removed]

Paint source panel.

*Paint* source setting lets you define how brush influence/intersection is defined.

Mesh Volume

The Brush affects all surface point inside the mesh volume.

[image reference removed]

Source: Mesh Volume.

Proximity

Only uses defined distance to the closest point on brush mesh surface.
Note that inside of the volume is not necessarily affected because it is not close to the surface.

[image reference removed]

Source: Proximity. Brush affects all canvas pixels around it.

Mesh Volume + Proximity

Same as volume type, but also has influence over defined distance.

Inner Proximity
:   Applies proximity inside the mesh volume.

Negate Volume
:   Negates brush alpha within mesh volume.

|  |  |
| --- | --- |
| ../../_images/physics_dynamic-paint_brush_source-mesh-volume-proximity-1.png   The Volume + Proximity brush with no additional settings. | ../../_images/physics_dynamic-paint_brush_source-mesh-volume-proximity-2.png   Inner Proximity. Proximity falloff is now visible inside the volume. |
| ../../_images/physics_dynamic-paint_brush_source-mesh-volume-proximity-3.png   Negate Volume. Inner side of the volume has become completely transparent. | ../../_images/physics_dynamic-paint_brush_source-mesh-volume-proximity-4.png   Inner Proximity and Negate Volume enabled together. |

Object Center

Instead of calculating proximity to the brush object mesh, which can be quite slow in some cases,
only distance to only center is calculated. This is much faster and often good enough.

[image reference removed]

Source: Object Center.

Particle System

Brush influence is defined by particles from a selected particle system.

[image reference removed]

Effect Solid Radius
:   Defines the distance, inside which paint is solid color.

Use Particle Radius
:   Uses the settings in the particle panel to determine solid radius size.
    Solid Radius size disabled while Particle Radius enabled.

Smooth Radius
:   An additional radius outside Solid Radius to add a smooth falloff.

    If you set “Smooth Radius” to zero, particle will be painted as a solid sphere.
    If you set “Solid Radius” to zero, it gets painted as a smooth halo.

    [image reference removed]

    [image reference removed]

    Source: Particle System.

### Common Options

Paint Distance
:   The maximum distance to mesh surface to affect paint.

Project
:   Projects brush to the canvas from a defined direction.
    Basically this can be considered as “direction aligned” proximity.

    [image reference removed]

    The Project option enabled. See how brush only affects canvas in normal direction.

Falloff
:   Sharp:
    :   Paints solid paint within the defined distance.

    Smooth:
    :   Makes paint to linearly fade out until becoming completely invisible
        when it reaches the maximum distance.

    Color Ramp:
    :   Allows you to manually make a custom falloff behavior.
user: What is Goal and how is it used in Blender Python scripting?

assistant: A “goal” is a shape that a soft body object tries to conform to.
It acts like a pin on a chosen set of vertices, controlling how much of an effect soft body has on them.

Enabling *Soft Body Goal* tells Blender to use the position (or animated position) of a vertex in the simulation.
Animating the vertices can be done in all the usual ways (F-Curves, armatures, parents, lattices, etc.)
before the soft body simulation is applied. The “goal” is the desired end position for vertices.
How a soft body tries to achieve this goal can be defined using stiffness forces and damping.

See the [Goal Settings](../settings/goal.html) for details.

### Goal Strength

The *Goal Strength* defines how much motion from an animation system gets applied.

A *Goal* value of 1.0 means no soft body simulation,
the object act like any regular animated object (i.e. the vertex is kept at its original position).
When setting *Goal* to 0.0 (or no goal), the vertex is only influenced by physical laws
according to soft body simulation.

By setting goal values between 0.0 and 1.0,
you can blend between having the object affected only by the animation system,
and having the object affected only by the soft body effect.

Goal also serves as a memory, to make sure soft objects don’t deform too much,
ending up in the non-soft animated shape. Using the *Vertex Group* weight system,
you can define a *Goal* weight per vertex. To make this look more natural,
spring forces can be defined to control how far vertices can move from their original position.

Often [Weight Paint](../../../sculpt_paint/weight_paint/index.html#painting-weight-index) is used to adjust the weight comfortably.
For non-mesh objects the *Weight* parameter of their vertices/control points is used instead;
Use the Context menu in Edit Mode or the *Transform* panel in the Sidebar region.
The weight of *Hair* particles can also be painted in [Particle Edit Mode](../../particles/mode.html).
user: What is Inherited Properties and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`ShaderFx.name`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.name "bpy.types.ShaderFx.name") - [`ShaderFx.type`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.type "bpy.types.ShaderFx.type") - [`ShaderFx.show_viewport`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.show_viewport "bpy.types.ShaderFx.show_viewport") | - [`ShaderFx.show_render`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.show_render "bpy.types.ShaderFx.show_render") - [`ShaderFx.show_in_editmode`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.show_in_editmode "bpy.types.ShaderFx.show_in_editmode") - [`ShaderFx.show_expanded`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.show_expanded "bpy.types.ShaderFx.show_expanded") |
user: What is World Volume and how is it used in Blender Python scripting?

assistant: A volume shader can also be applied to the world, filling the entire space.

Currently, this is most useful for night time or other dark scenes,
as the world surface shader or sun lights will have no effect if a volume shader is used.
This is because the world background is assumed to be infinitely far away,
which is accurate enough for the sun for example.
However, for modeling effects such as fog or atmospheric scattering,
it is not a good assumption that the volume fills the entire space,
as most of the distance between the sun and the earth is empty space.
For such effects it is be better to create a volume object surrounding the scene.
The size of this object will determine how much light is scattered or absorbed.
user: Provide the full official documentation entry for Edges, preserving all code examples.

assistant: An edge always connects two vertices by a straight line.
The edges are the “wires” you see when you look at a mesh in wireframe view.
They are usually invisible on the rendered image. They are used to construct faces.
user: Give a detailed overview of Culling: syntax, arguments, return values, common patterns.

assistant: Camera Cull
:   Automatically culls objects based on the camera frustum defined by the *Margin*.

Distance Cull
:   Automatically culls objects based on their distance from the active camera.
    This is set via the *Distance* property.
user: What is Vertex Parent and how is it used in Blender Python scripting?

assistant: For objects of type curve, surface, mesh and lattice,
there is the possibility to use one of its vertices or points as the parent of other objects.
You can parent an object to a single vertex or a group of three vertices as well;
that way the child/children will move when the parent mesh is deformed.

### Vertex Parent from Edit Mode

In *Object Mode*, select the child/children and then the parent object.
`Tab` into *Edit Mode* and on the parent object select either one vertex
that defines a single point, or select three vertices that define an area
(the three vertices do not have to form a complete face;
they can be any three vertices of the parent object),
and then press `Ctrl`-`P` and confirm.

At this point, if a single vertex was selected,
a relationship/parenting line will be drawn from the vertex to the child/children. If three
vertices were selected then a relationship/parenting line is drawn from the averaged center of
the three points (of the parent object) to the child/children. Now,
as the parent mesh deforms and the chosen parent vertex/vertices move,
the child/children will move as well.

### Vertex Parent from Object Mode

Vertex parenting can be performed from Object Mode,
this is done like regular object parenting,
press `Ctrl`-`P` in Object Mode and select *Vertex* or *Vertex (Triangle)*.

The nearest vertices will be used from each object which is typically what you would want.

Vertex Parent example.

|  |  |  |
| --- | --- | --- |
| ../../../_images/scene-layout_object_editing_parent_object-mode-example-1.png   The small cubes can each be automatically parented to a triad of nearby vertices on the icosphere using the “Vertex (Triangle)” in the set parent context menu. | ../../../_images/scene-layout_object_editing_parent_object-mode-example-2.png   Reshaping the object in Edit Mode then means each of the cubes follows their vertex parent separately. | ../../../_images/scene-layout_object_editing_parent_object-mode-example-3.png   Scaling the parent icosphere in Object Mode means the child cubes are also scaled as expected. |

The parent context menu item means users can rapidly set up a large number of vertex parent
relationships,
and avoid the tedious effort of establishing each parent-child vertex relationship separately.
user: How do I use Introduction in Blender? Include parameters, examples, warnings and best practices.

assistant: # Introduction

The Preview mode shows how the final edited video will look like. It also offers tools for
moving, rotating, and scaling images, as well as scopes for analyzing color distribution.

[image reference removed]

Preview mode of the Video Sequencer.

You can pan around the view with `MMB` and zoom with `Wheel` or `NumpadPlus`/
`NumpadMinus`. Alternatively, you can use the gizmos.

Pressing `Home` resets the view, maximizing the size of the preview within the editor’s area.
user: Show practical ways to work with Collisions in a Blender add-on or script – include code.

assistant: # Collisions

[image reference removed]

Rigid Body Collisions panel.

Shape
:   Determines the collision shape of the object;
    these can be broken into two categories: primitive shapes and mesh based shapes.

    Primitive shapes (*Box*, *Sphere*, *Capsule*, *Cylinder*, and *Cone*)
    are best in terms of memory and performance but do not
    necessarily reflect the actual shape of the object.
    The size of the shape is calculated based on the object’s bounding box.
    The center of gravity is always in the geometric center of the shape.
    Primitive shapes can be shown in the 3D Viewport by enabling
    [Extras Overlay](../../../editors/3dview/display/overlays.xhtml#bpy-types-view3doverlay-show-extras).

    Mesh based shapes (*Convex Hull* and *Mesh*) are calculated based on the geometry of the object
    so they are a better representation of the object.
    The center of gravity for these shapes is the object origin.

    Box:
    :   Box-like shapes (e.g. cubes), including planes (e.g. ground planes).
        The size per axis is calculated from the bounding box.

    Sphere:
    :   Sphere-like shapes. The radius is the largest axis of the bounding box.

    Capsule:
    :   This points up the Z axis.

    Cylinder:
    :   This points up the Z axis.
        The height is taken from the Z axis, while the radius is the larger of the X or Y axes.

    Cone:
    :   This points up the Z axis.
        The height is taken from the Z axis, while the radius is the larger of the X or Y axes.

    Convex Hull:
    :   A mesh-like surface encompassing (e.g. shrink-wrapped over) all vertices (best results with fewer vertices).
        A convex approximation of the object, which has good performance and stability.

    Mesh:
    :   [Mesh](../../../glossary/index.xhtml#term-Mesh) consisting of triangles only, allowing for more detailed interactions than convex hulls.
        Allows simulating concave objects, but is rather slow and unstable.

    Compound Parent:
    :   Takes the collision shapes from the object’s [children](../../../scene_layout/object/editing/parent.xhtml)
        and combines them. This makes it possible to create concave shapes from primitive shapes.
        This usually results in a faster simulation than the *Mesh* collision shape
        while also being generally more stable.

Source
:   Source of the mesh used to create the collision shape.

    Base:
    :   The base mesh of the object.

    Deform:
    :   Includes any deformations added to the mesh (shape keys, deform modifiers).

    Final:
    :   Includes all deformations and modifiers.

Deforming
:   Mesh shapes can deform during simulation.
user: What is Material and how is it used in Blender Python scripting?

assistant: # Material

The *Material* modifier alters the base property with a new one taken from a given range mapped on
the current material under the stroke.

You can use various properties of the materials, among which many are mono-component
(i.e. give black-and-white results). In this case for the color modifier, an optional color ramp can be used to
map these gray-scale values to colored ones.
In the reverse case properties of the materials, which are multi-components
(i.e. give RGB results) the mean value will be used for Alpha and Thickness modifiers.

If used with the *Split by Material* option in the *Stroke* tab,
the result will not be blurred between materials along the strokes.

[[image reference removed]](../../../../../../_images/render_freestyle_parameter-editor_line-style_modifiers_color_material_example.png)

Material modifiers demo by T.K.
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Lilies_Color_Material.zip)).
user: Describe Stiffness from the Blender manual or Python API, including usage steps and snippets.

assistant: Tension
:   How much the material resists stretching.

Compression
:   How much the material resists compression.

Structural
:   Overall stiffness of the cloth (only in linear bending model).

Shear
:   How much the material resists shearing.

Bending
:   Wrinkle coefficient. Higher creates more large folds.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Color
:   Color of the surface, or physically speaking,
    the probability that light is reflected or transmitted for each wavelength.

Roughness Cycles Only
:   Surface roughness; 0.0 gives standard Lambertian reflection, higher values activate the Oren-Nayar BSDF.

Normal
:   Normal used for shading; if nothing is connected the default shading normal is used.
user: Show practical ways to work with Viewport Display in a Blender add-on or script – include code.

assistant: Wireframe
:   Method used to represent volumes in [wireframe](../../editors/3dview/display/shading.xhtml#dview-shading-rendered) shading mode.
    For heavy volume data sets, it can be useful to set the object to always display as wireframe.
    This way, the 3D Viewport remains responsive but the volume still appears in the final render.

    None:
    :   The volume is not displayed in wireframe mode.

    Bounds:
    :   Displays the volume as a [Bounding Box](../../glossary/index.xhtml#term-Bounding-Box) for the entire grid.

    Boxes:
    :   Displays bounding boxes for nodes in the volume tree.

    Points:
    :   Displays points for nodes in the volume tree.

Detail
:   The amount of detail to display for *Boxes* or *Points* wireframe mode.

    Coarse:
    :   Display one box or point for each intermediate tree node.

    Fine:
    :   Display a box or point for each leaf node containing 8×8 voxels.

Density
:   Thickness of the volume in the 3D Viewport.
    The density of the volume in the render is adjusted via
    [Volume Shading](../../render/shader_nodes/shader/volume_principled.xhtml).

Interpolation
:   Interpolation method to use for the visualization of the fluid grid.

    Linear:
    :   Linear interpolation between voxels. Gives good smoothness and speed.

    Cubic:
    :   Cubic interpolation between voxels. Gives smoothed high quality interpolation, but is slower.

    Closest:
    :   No interpolation between voxels. Gives raw voxels.

### Slice

Renders only a single 2D section of the domain object.

Axis
:   Auto:
    :   Adjust slice direction according to the view direction.

    X/Y/Z:
    :   Slice along the X, Y, or Z axis.

Position
:   Position of the slice relative to the length of the respective domain side.
user: What is Shrinkwrap Modifier and how is it used in Blender Python scripting?

assistant: # Shrinkwrap Modifier

The *Shrinkwrap* modifier allows an object to “shrink” to the surface of another object.
It moves each vertex of the object being modified to the closest position on
the surface of the given mesh (using one of the four methods available).

It can be applied to meshes, lattices, curves, surfaces and texts.
user: What is Ray Portal BSDF and how is it used in Blender Python scripting?

assistant: # Ray Portal BSDF

Cycles Only

The *Ray Portal BSDF* node transports rays that enter to another location
in the scene. It can be used to render portals for visual effects, and
other production rendering tricks.

It acts much like a [Transparent BSDF](transparent.html):
render passes are passed through,
and it is affected by light path max transparent bounces.
user: Give a detailed overview of Draw: syntax, arguments, return values, common patterns.

assistant: # Draw

Moves vertices inward or outward, based the average vertex normals within the brush radius.
This is a very default behavior for sculpting and can be used in most cases.

It is common to use this particular brush with heavy customization for creating many custom brushes.
user: How do I use Cube Projection in Blender? Include parameters, examples, warnings and best practices.

assistant: Projects each selected face onto the most suitable side of a virtual cube,
then places all these sides in the UV map, overlapping each other.
If you don’t want them to overlap, you can use [Pack Islands](../uv/editing.xhtml#bpy-ops-uv-pack-islands).

The cube is centered on the [Transform Pivot Point](../../../editors/3dview/controls/pivot_point/index.xhtml)
and aligned to the mesh’s local axes.

### Options

The [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel allows fine control over how the mesh is unwrapped:

Cube Size
:   The size of the cube to project onto.

Correct Aspect
:   Adjusts the UV mapping to account for the aspect ratio of the image associated with the material.
    This ensures that UVs are scaled correctly when unwrapping onto non-square textures.

    For this option to work, the mesh must have a material with an
    [Image Texture node](../../../render/shader_nodes/textures/image.xhtml), and this node must be selected in the
    [Shader Editor](../../../editors/shader_editor.xhtml).

Clip to Bounds
:   Moves any out-of-bounds UVs to the nearest border.

Scale to Bounds
:   Stretches the resulting UV map to fill the complete texture.
user: How do I use Committing Your Changes in Blender? Include parameters, examples, warnings and best practices.

assistant: After making your edits, proceed to the bottom of the page:

- Provide a clear, concise summary of your changes in the commit message box
  (e.g., “Fixed typo in Sculpting documentation”).
- Select “Commit Changes”.

This action will automatically guide you to create a “Pull Request” to submit your edits for review.
user: How do I use Normal Map Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Normal Map Node

[image reference removed]

The *Normal Map* node generates a perturbed normal from an RGB normal map image.
This is usually chained with an *Image Texture* node in the color input,
to specify the normal map image. For tangent space normal maps,
the UV coordinates for the image must match,
and the image texture should be set to *Non-Color* mode to give correct results.
user: How do I use FILEBROWSER_UL_dir(UIList) in Blender? Include parameters, examples, warnings and best practices.

assistant: # FILEBROWSER_UL_dir(UIList)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`UIList`](bpy.types.UIList.html#bpy.types.UIList "bpy.types.UIList")

*class* bpy.types.FILEBROWSER_UL_dir(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *item*, *icon*, *_active_data*, *_active_propname*, *_index*)

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Options and how is it used in Blender Python scripting?

assistant: Node Group
:   A [Node Group](../../interface/controls/nodes/groups.html) with the geometry input and output.
    Those are respectively what is received and passed to the previous and next modifier in the stack.
    See [Nodes](../geometry_nodes/index.html) for all available nodes.

Inputs
:   A list of the node group’s inputs which can have unique values even
    if the group is shared among multiple modifiers.

    If the input is connected to a [Field](../geometry_nodes/fields.html) socket,
    there will be a toggle to switch between using a single value for the input or
    using an attribute on the input geometry. Using an attribute for input means the
    value can be different for every element.

    The attribute name used by default when using the node group in a modifier for the first
    time is defined in the [node group inputs panel](../../interface/controls/nodes/groups.html).

### Warnings

Nodes that show a warning message in the node editor will also show that message here.

Custom warning messages can be created using the [Warning Node](../geometry_nodes/output/warning.html).

### Output Attributes

By connecting a field socket to the group output node,
you can create custom [Attributes](../geometry_nodes/attributes_reference.html)
from a [Field](../geometry_nodes/fields.html) output of any node in the node tree.
The domain of the attribute must be specified in the group node’s output properties.
Note, this does not work with [Instanced Data](../geometry_nodes/instances.html).

The attribute name used by default when using the node group in a modifier for the first
time is defined in the [node group outputs panel](../../interface/controls/nodes/groups.html).

This panel is hidden unless output node has attribute sockets.

### Manage

Displays options for managing data within the node group,

The *Manage* panel can be hidden by disabling *Show Manage Panel*
in the modifier’s header options.
This controls whether the panel is shown for that specific modifier.

To disable the panel by default for new modifiers created from a node group asset,
toggle [Show Manage Panel Geometry Nodes](../../interface/controls/nodes/groups.html#bpy-types-geometrynodetree-show-modifier-manage-panel)
in the node group’s properties.

#### Bake

Bake Target
:   Specifies where baked data should be stored. This can be overridden for individual bakes.

    Packed:
    :   The baked data is packed into the .blend file. So no separate file is necessary.

    Disk:
    :   The baked data is stored in a separate directory on disk.

Bake Path
:   Location on disk where the baked data for
    [Simulation Zones](../geometry_nodes/simulation/simulation_zone.html)
    and [Bake Nodes](../geometry_nodes/geometry/operations/bake.html) are stored.

#### Named Attributes

This panel displays information about all custom named attributes used by the node group.
More information is available in the
[geometry nodes inspection page](../geometry_nodes/inspection.html#bpy-types-spacenodeoverlay-show-named-attributes).
user: What is Replace Material Node and how is it used in Blender Python scripting?

assistant: # Replace Material Node

[image reference removed]

The *Replace Material* node swaps one material with another.
Replacing a material with this node is more efficient than creating a selection of all faces
with the old material with the [Material Selection Node](material_selection.xhtml)
and then using the [Set Material Node](set_material.xhtml).
user: Give a detailed overview of Mix Vector Node: syntax, arguments, return values, common patterns.

assistant: # Mix Vector Node

The *Mix Node* mixes values, colors and vectors inputs
using a factor to control the amount of interpolation.
The *Color* mode has additional blending modes.

[image reference removed]
user: Explain Nested Instancing in complete detail according to the official Blender documentation.

assistant: Since instances can store a geometry, and a geometry can contain instances, nested instancing is possible.
In other words, it is possible to instance an instance, or even a collection of instances.
For example, by default, the [Instance on Points Node](instances/instance_on_points.html) will create
nested instances by instancing instances on the points of real geometry.

[image reference removed]

A node group that creates nested instancing by chaining
[Instance on Points](instances/instance_on_points.html) nodes.

Here, nested instancing is used to distribute geometry that contains both a mesh
and instances. The output geometry contains a “real” mesh and a group of instances.
Each instance contains a sphere mesh and many instances of a cone geometry.

[[image reference removed]](../../_images/modeling_geometry-nodes_instances-nested-tree.png)

The tree of instanced geometry for the example above.

What makes this method helpful is the output geometry only contains three unique meshes:
the plane, the sphere, and the cone. This would make the performance much better if the meshes
were more complicated.
user: Provide the full official documentation entry for Import (Legacy), preserving all code examples.

assistant: ### Include

Import Normals

Import Subdivision Surface
:   Import FBX subdivision information as subdivision surface modifiers.

Import User Properties
:   Import user properties as custom properties.

Import Enums as Strings
:   Store custom property enumeration values as strings.

Image Search

### Transform

Scale
:   Value by which to scale the imported objects in relation to the world’s origin.

Decal Offset

Manual Orientation

Forward / Up Axis.. todo:: Add this information.
:   Since many applications use a different axis for ‘Up’, these are axis conversion for these settings,
    Forward and Up axes – By mapping these to different axes you can convert rotations
    between applications default up and forward axes.

    Blender uses Y Forward, Z Up (since the front view looks along the +Y direction).
    For example, its common for applications to use Y as the up axis, in that case -Z Forward, Y Up is needed.

Apply Transform
:   Bake space transform into object data, avoids getting unwanted rotations
    to objects when target space is not aligned with Blender’s space.

Use Pre/Post Rotation

### Materials

Material Name Collision
:   Behavior when the name of an imported material conflicts with an existing material.

    Make Unique:
    :   Import each USD material as a unique Blender material.

    Reference Existing:
    :   If a material with the same name already exists, reference that instead of importing.

### Animation

Animation Offset
:   Offset to apply to animation timestamps, in frames.

### Armature

Ignore Leaf Bones
:   Ignore the last bone at the end of each chain (used to mark the length of the previous bone).

Force Connect Children

Automatic Bone Orientation

Primary/Secondary Bone Axis