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

assistant: # GeometryNodePointsOfCurve(GeometryNode)

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

*class* bpy.types.GeometryNodePointsOfCurve(*GeometryNode*)
:   Retrieve a point index within a curve

    *classmethod* is_registered_node_type()
    :   True if a registered node type

        Returns:
        :   Result

        Return type:
        :   boolean

    *classmethod* input_template(*index*)
    :   Input socket template

        Parameters:
        :   **index** (*int in* *[**0**,* *inf**]*) – Index

        Returns:
        :   result

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

    *classmethod* output_template(*index*)
    :   Output socket template

        Parameters:
        :   **index** (*int in* *[**0**,* *inf**]*) – Index

        Returns:
        :   result

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

    *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 2D Traditional Animation, preserving all code examples.

assistant: ### Keyframes

Traditional animation in Grease Pencil is achieved with the use of
[keyframes](../../animation/keyframes/introduction.html)
that hold the strokes information at a particular frame or frame range.

With [Auto keyframe](../../animation/animation_editors.html#bpy-types-toolsettings-use-keyframe-insert-auto) activated,
every time you create a stroke in Grease Pencil object Draw Mode
a new keyframe is added at the current frame on the active channel.
With Auto keyframe deactivated, you will have to add manually
a new keyframe or your new strokes will be added on the active keyframe.

See [Keyframe Editing](../../animation/keyframes/editing.html) for more information.

Grease Pencil has its own mode in the Dope Sheet to work with keyframes.
See Grease Pencil mode in the [Dope Sheet](../../editors/dope_sheet/modes/grease_pencil.html)
section for more information.
There are also several tools on the Stroke menu to work with keyframes and strokes.
See [Animation tools](tools.html) for more information.

### Onion Skinning

One key element in traditional animation is the use of onion skinning.
Grease Pencil offer a lot of flexibility and options for this tool.
See [Onion Skinning](../properties/onion_skinning.html) for more information.
user: Give a detailed overview of NodeGeometryCaptureAttributeItems(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # NodeGeometryCaptureAttributeItems(bpy_struct)

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

*class* bpy.types.NodeGeometryCaptureAttributeItems(*bpy_struct*)
:   Collection of capture attribute items

    new(*socket_type*, *name*)
    :   Add an item at the end

        Parameters:
        :   - **socket_type** (enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items)) – Socket Type, Socket type of the item
            - **name** (*string**,* *(**never None**)*) – Name

        Returns:
        :   Item, New item

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

    remove(*item*)
    :   Remove an item

        Parameters:
        :   **item** ([`NodeGeometryCaptureAttributeItem`](bpy.types.NodeGeometryCaptureAttributeItem.html#bpy.types.NodeGeometryCaptureAttributeItem "bpy.types.NodeGeometryCaptureAttributeItem"), (never None)) – Item, The item to remove

    clear()
    :   Remove all items

    move(*from_index*, *to_index*)
    :   Move an item to another position

        Parameters:
        :   - **from_index** (*int in* *[**0**,* *inf**]*) – From Index, Index of the item to move
            - **to_index** (*int in* *[**0**,* *inf**]*) – To Index, Target index for the item

    *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 Inputs in a Blender add-on or script – include code.

assistant: Value/Vector
:   The input value or vector to be remapped.

From Min
:   The lower bound of the range to remap from.

From Max
:   The higher bound of the range to remap from.

To Min
:   The lower bound of the target range.

To Max
:   The higher bound of the target range.

Steps
:   The number of values allowed between *To Min* and *To Max* when using *Stepped Linear* interpolation.
    A higher value will give a smoother interpolation while lower values will progressively quantize the input.
user: How do I use Motion Blur in Blender? Include parameters, examples, warnings and best practices.

assistant: # Motion Blur

Blender’s animations are by default rendered as a sequence of *perfectly still* images.
While great for stop-motion and time-lapses, this is unrealistic, since fast-moving
objects do appear to be blurred in the direction of motion,
both in a movie frame and in a photograph from a real-world camera.

[image reference removed]

Motion blur example.
([blend-file](https://archive.blender.org/wiki/2015/uploads/0/03/Blender2.65_motion_blur.blend))

Position
:   Controls at what point the shutter opens in relation to the current frame.

    Start on Frame:
    :   Shutter is starting to open at the current frame.

    Center on Frame:
    :   Shutter is fully opened at the current frame.

    End on Frame:
    :   Shutter is fully closed at the current frame.

Shutter
:   Time (in frames) between when the shutter starts to open and fully closed.
    For example, shutter time 1.0 blurs over the length of 1 frame.

Rolling Shutter
:   Creates a [Rolling Shutter](../../../glossary/index.xhtml#term-Rolling-Shutter) effect.

    None:
    :   No rolling shutter effect.

    Top-Bottom:
    :   Renders rolling shutter from the top of the image to the bottom.

Rolling Shutter Duration
:   Controls balance between pure rolling shutter effect (if the value is zero)
    and pure motion blur effect (if the value is one).
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Size X
:   Side length of the plane in the X direction.

Size Y
:   Side length of the plane in the Y direction.

Vertices X
:   Number of vertices in the X direction.
    If this is smaller than two, no mesh is generated.

Vertices Y
:   Number of vertices in the Y direction.
    If this is smaller than two, no mesh is generated.
user: What is Socket Inspection and how is it used in Blender Python scripting?

assistant: [image reference removed]

Socket Inspection.

Socket inspection shows information about the value in a socket during the last evaluation.
For primitive data types such as integers, vectors, and strings the actual value is shown.
For geometry sockets only some data about the geometry is stored, including the set of
data types the geometry contains, and a count of their elements.

Socket values are only logged from when the node tree was executed, so a node must be
connected to the *Group Output* to have a value for inspection. Values are not logged during
rendering, to improve performance.
user: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

Cloth simulation is one of the hardest aspects of computer graphics,
it is a deceptively simple real-world item that is taken for granted,
but it actually has very complex internal and environmental interactions.
Cloth is commonly modeled as 2D mesh to simulate real world objects such as fabrics, flags, banners.
And yet cloth can also be used to model 3D objects such as teddy bears, pillows, balloons, or balls.

Cloth interacts with and is affected by other moving objects,
the wind and other forces, as well as a general aerodynamic model,
all of which is under your control.

|  |  |  |
| --- | --- | --- |
| ../../_images/physics_cloth_introduction_example1.jpg   Cloth example. | ../../_images/physics_cloth_introduction_oncarved-wood.jpg   Cloth on carved wooden men (made by motorsep). | ../../_images/physics_cloth_introduction_example2.jpg   Cloth example. |

Once Cloth physics have been added to a mesh, a [Cloth Modifier](../../modeling/modifiers/physics/cloth.xhtml)
will be added to the object’s modifier stack. As a modifier then,
it can interact with other modifiers, such as *Armature* and *Smooth*. In these cases,
the ultimate shape of the mesh is computed in accordance with the order of the modifier stack.
For example, you should smooth the cloth *after* the modifier computes the shape of the cloth.

You can *Apply* the Cloth Modifier to freeze, or lock in,
the shape of the mesh at that frame, which removes the modifier. For example,
you can drape a flat cloth over a table, let the simulation run, and then apply the modifier.
In this sense, you are using the simulator to save yourself a lot of modeling time.

Results of the simulation are saved in a cache, so that the shape of the mesh,
once calculated for a frame in an animation, does not have to be recomputed again.
If changes to the simulation are made, you have full control over clearing the cache and re-running the simulation.
Running the simulation for the first time is fully automatic and no baking or separate step interrupts the workflow.

Computation of the shape of the cloth at every frame is automatic and done in the background;
thus you can continue working while the simulation is computed. However, it is CPU-intensive
and depending on the power of your PC and the complexity of the simulation,
the amount of CPU needed to compute the mesh varies, as does the lag you might notice.
user: What is Usage and how is it used in Blender Python scripting?

assistant: The *Bevel Edges* tool works only on selected edges with exactly two adjacent faces.
It will recognize any edges included in a vertex or face selection as well,
and perform the bevel the same as if those edges were explicitly selected.
In “vertex only” mode, the *Bevel Vertices* tool works on selected vertices instead of edges,
and there is no requirement about having any adjacent faces.
The *Bevel* tool smooths the edges and/or “corners” (vertices)
by replacing them with faces making smooth profiles with a specified number of *segments*
(see the options below for details about the bevel algorithm).

Use `Ctrl`-`B` or a method listed above to run the tool.
Move the mouse to interactively or type a number to specify the bevel offset,
and scroll the `Wheel` to increase or decrease the number of segments (see below).

|  |  |  |
| --- | --- | --- |
| <../../../../_images/modeling_meshes_editing_edge_bevel_example-1.png>   Selected edge before beveling. | <../../../../_images/modeling_meshes_editing_edge_bevel_example-2.png>   Result of bevel (one segment). | <../../../../_images/modeling_meshes_editing_edge_bevel_example-3.png>   Result of bevel (vertex only). |
user: Describe Auto-Masking from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Auto-Masking settings.

These properties automatically mask geometry based on stroke, layers and materials under the cursor.
It’s an quick alternative to frequent manual masking.
These masks are initialized on every new tool usage. They are also never visible as an overlay.

These properties can be accessed via a [Pie Menus](../../../interface/controls/buttons/menus.xhtml#bpy-types-uipiemenu) by pressing `Shift`-`Alt`-`A`.

All auto-masking modes can be combined, which makes the generated auto-mask more specific.
For example it’s possible to auto-mask strokes that use specific layer and material while excluding others.

Stroke
:   Only strokes that are under the cursor when you started the tool are affected.

Layer
:   Only strokes on the same layers that are under the cursor when you started the tool are affected.

Material
:   Only materials with the same material that are under the cursor when you started the tool are affected.

Active Layer
:   Only the strokes on the active layer are affected.

Active Material
:   Only the strokes with the active material are affected.
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Mesh
:   Standard geometry output.

UV Map
:   A 2D vector representing the default X/Y coordinates of the [UV Map](../../../../glossary/index.xhtml#term-UV-Map) for the primitive’s shape.
    This can be connected to the [Store Named Attribute Node](../../attribute/store_named_attribute.xhtml),
    to be used once the Geometry Nodes Modifier get applied.
    The UV map must be stored on the face corner in order to be accessed.
user: How do I use [Local Editing](local_editing/index.xhtml) in Blender? Include parameters, examples, warnings and best practices.

assistant: Edit manual files on your computer using a plain text editor.
Files are synchronized with the online version through a repository, ensuring your local edits remain up-to-date.

Local editing also lets you build and preview your changes before submitting.
user: What is Magic and how is it used in Blender Python scripting?

assistant: # Magic

The Magic Texture node is used to add a psychedelic color texture.
It can be used for “Thin Film Interference” if you set *Mapping*
to *Reflection* and use a relatively high *Turbulence*.
The RGB components are generated independently with a sine formula.

[image reference removed]

Magic Texture panels.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Grid
:   The input voxel grid to convert into a mesh.
    The grid must store float values such as those from a signed distance or density field.

Threshold
:   The value that defines the surface of the generated mesh.
    Voxels with values larger than this threshold are considered *inside* the
    mesh, while smaller values are considered *outside*.
    For SDF grids, a threshold of `0.0` typically corresponds to the surface.

Adaptivity
:   Controls the simplification of the generated mesh based on curvature.
    Higher values reduce polygon count by merging nearly flat areas, while
    smaller values preserve more detail.
    A value of `0.0` disables adaptivity and produces a uniform mesh density.
user: How do I use LimitRotationConstraint(Constraint) in Blender? Include parameters, examples, warnings and best practices.

assistant: # LimitRotationConstraint(Constraint)

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

*class* bpy.types.LimitRotationConstraint(*Constraint*)
:   Limit the rotation of the constrained object

    euler_order
    :   Explicitly specify the euler rotation order

        - `AUTO`
          Default – Euler using the default rotation order.
        - `XYZ`
          XYZ Euler – Euler using the XYZ rotation order.
        - `XZY`
          XZY Euler – Euler using the XZY rotation order.
        - `YXZ`
          YXZ Euler – Euler using the YXZ rotation order.
        - `YZX`
          YZX Euler – Euler using the YZX rotation order.
        - `ZXY`
          ZXY Euler – Euler using the ZXY rotation order.
        - `ZYX`
          ZYX Euler – Euler using the ZYX rotation order.

        Type:
        :   enum in [`'AUTO'`, `'XYZ'`, `'XZY'`, `'YXZ'`, `'YZX'`, `'ZXY'`, `'ZYX'`], default `'AUTO'`

    max_x
    :   Upper X angle bound

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

    max_y
    :   Upper Y angle bound

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

    max_z
    :   Upper Z angle bound

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

    min_x
    :   Lower X angle bound

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

    min_y
    :   Lower Y angle bound

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

    min_z
    :   Lower Z angle bound

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

    use_legacy_behavior
    :   Use the old semi-broken behavior that does not understand that rotations loop around

        Type:
        :   boolean, default False

    use_limit_x
    :   Use the minimum X value

        Type:
        :   boolean, default False

    use_limit_y
    :   Use the minimum Y value

        Type:
        :   boolean, default False

    use_limit_z
    :   Use the minimum Z value

        Type:
        :   boolean, default False

    use_transform_limit
    :   Transform tools are affected by this constraint as well

        Type:
        :   boolean, default False

    *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 Attributes, preserving all code examples.

assistant: The *Attributes* panel contains different hair characteristics such as the position and color of hair strands.

Use the [List View](../../interface/controls/templates/list_view.html#ui-list-view) to manage attributes.
user: Give a detailed overview of Active Spline: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Active Spline panel.

Feather Offset
:   The method used for calculating the offset of the mask spline feather.

    Even:
    :   Preserves the thickness of the feather, but can give undesirable loops of the feather curve.

    Smooth:
    :   Gives a nicer and smoother shape,
        but can also give an undesirable sharp feather when a curve segment forms an S-shape.

Weight Interpolation
:   The type of weight (thickness of feather) interpolation between points.
    *Linear* or *Ease* (i.e. changes occur slowly at the beginning and at the end).

Cyclic
:   If the spline is closed or not.

Fill
:   Creates splines with filled areas.
    If disabled, Blender will create curves with a thickness to mask out thin objects such as wires or hair.

Self Intersection Check
:   Prevent the feather (not the curve itself) from intersecting with itself.
user: How do I use Limitations in Blender? Include parameters, examples, warnings and best practices.

assistant: - Viewer and inspection nodes may not display accurate values when closures are evaluated in multiple contexts.
- Captured external values are read-only and cannot be modified inside the evaluation.
- Closures currently cannot access attributes or data outside their evaluation context.
user: Describe Surface Structure from the Blender manual or Python API, including usage steps and snippets.

assistant: # Surface Structure

Surfaces are similar to [Curves](../curves/structure.xhtml),
in that they use Bézier or NURBS splines to produce smooth geometry
that follows a set of control points. The main difference, of course,
is that a Curve produces a line while a Surface produces a sheet.

A Surface object can contain multiple disconnected surfaces.
The one that’s selected in Edit Mode is referred to as the
“active spline.”
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Is Valid
:   Outputs `true` if the provided transform was valid and successfully
    applied to the grid.

    The new transform can fail to be applied if the input transform isn’t
    invertible or for some extremes of scaling (0 or combinations of negative and positive).

Grid
:   The resulting grid with the updated transform applied.
    The new transform affects how the grid’s voxel indices are interpreted
    in object space, which in turn changes how the grid interacts with other
    geometry and sampling operations.
user: Describe BrushCapabilities(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # BrushCapabilities(bpy_struct)

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

*class* bpy.types.BrushCapabilities(*bpy_struct*)
:   Read-only indications of supported operations

    has_overlay
    :   Type:
        :   boolean, default False, (readonly)

    has_random_texture_angle
    :   Type:
        :   boolean, default False, (readonly)

    has_smooth_stroke
    :   Type:
        :   boolean, default False, (readonly)

    has_spacing
    :   Type:
        :   boolean, default False, (readonly)

    *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: Explain Evaluate Closure in complete detail according to the official Blender documentation.

assistant: # Evaluate Closure

[image reference removed]

The *Evaluate Closure* node executes a connected [Closure Zone](closure.xhtml).
It acts as the *call site* of the closure, running its internal node graph and returning the resulting values.

Closures enable dynamic and customizable node groups by allowing users to pass procedural logic into another node tree.
When the *Evaluate Closure* node runs, the connected closure is evaluated within the current context, matching its input
and output sockets by name.

Common uses for the *Evaluate Closure* node include:

- Allowing user-defined behaviors inside procedural systems (e.g. custom scattering, placement rules, or shading logic).
- Injecting logic into reusable node groups for advanced effects.
- Providing optional customization inputs for high-level node-based tools.
user: Give a detailed overview of ArmatureEditBones(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # ArmatureEditBones(bpy_struct)

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

*class* bpy.types.ArmatureEditBones(*bpy_struct*)
:   Collection of armature edit bones

    active
    :   Armatures active edit bone

        Type:
        :   [`EditBone`](bpy.types.EditBone.html#bpy.types.EditBone "bpy.types.EditBone")

    new(*name*)
    :   Add a new bone

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – New name for the bone

        Returns:
        :   Newly created edit bone

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

    remove(*bone*)
    :   Remove an existing bone from the armature

        Parameters:
        :   **bone** ([`EditBone`](bpy.types.EditBone.html#bpy.types.EditBone "bpy.types.EditBone"), (never None)) – EditBone to remove

    *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: How do I use Selecting Point Cloud Objects in Blender? Include parameters, examples, warnings and best practices.

assistant: # Selecting Point Cloud Objects

This section describes the available selection operators when working with point cloud objects in *Edit Mode*.
These operators allow you to quickly select or deselect points for further editing or transformation.
user: What is Import/Export SVG as Grease Pencil and how is it used in Blender Python scripting?

assistant: # Import/Export SVG as Grease Pencil

The Scalable Vector Graphics (SVG) format is used for interchanging vector-based illustrations between applications
and is supported by vector graphics editors such as Inkscape and modern browsers, among others.
user: Provide the full official documentation entry for Symmetrize, preserving all code examples.

assistant: # Symmetrize

The Symmetrize operator mirrors selected bones along the X axis using Blender’s bone
[naming convention](naming.xhtml#armature-editing-naming-conventions) for symmetrical armatures.
Bones can be mirrored from left to right or right to left, depending on the selection.

- If matching bones are selected on both sides, mirroring happens from right to left.
- Bones with opposite names that don’t exist are created, and existing ones are overwritten.
- Bones that cannot be determined as left or right are ignored.

Symmetrized bone and constraint properties are adjusted to mirror their behaviors.
For bones with [Action Constraints](../../../constraints/relationship/action.xhtml),
keyframes are added to the target Action, ensuring symmetrical motion when the Action is activated.

Bone Collections

Bone collection assignments are also symmetrized. Collections that follow the
[naming convention](naming.xhtml#armature-editing-naming-conventions) are mirrored.
If a collection does not exist, it is created and parented to the same collection as the original.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Thickness Modifier.

Uniform Thickness
:   When enabled, makes the thickness equal for the entire strokes.

    Thickness
    :   Absolute Thickness for the stroke points.

Thickness Factor
:   Value to add or subtract to the actual points thickness.

### Influence

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`Linesets.active`](bpy.types.Linesets.html#bpy.types.Linesets.active "bpy.types.Linesets.active") - [`Linesets.new`](bpy.types.Linesets.html#bpy.types.Linesets.new "bpy.types.Linesets.new") | - [`Linesets.remove`](bpy.types.Linesets.html#bpy.types.Linesets.remove "bpy.types.Linesets.remove") - [`FreestyleSettings.linesets`](bpy.types.FreestyleSettings.html#bpy.types.FreestyleSettings.linesets "bpy.types.FreestyleSettings.linesets") |
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`ThemeClipEditor.space`](bpy.types.ThemeClipEditor.html#bpy.types.ThemeClipEditor.space "bpy.types.ThemeClipEditor.space") - [`ThemeConsole.space`](bpy.types.ThemeConsole.html#bpy.types.ThemeConsole.space "bpy.types.ThemeConsole.space") - [`ThemeDopeSheet.space`](bpy.types.ThemeDopeSheet.html#bpy.types.ThemeDopeSheet.space "bpy.types.ThemeDopeSheet.space") - [`ThemeFileBrowser.space`](bpy.types.ThemeFileBrowser.html#bpy.types.ThemeFileBrowser.space "bpy.types.ThemeFileBrowser.space") - [`ThemeGraphEditor.space`](bpy.types.ThemeGraphEditor.html#bpy.types.ThemeGraphEditor.space "bpy.types.ThemeGraphEditor.space") - [`ThemeImageEditor.space`](bpy.types.ThemeImageEditor.html#bpy.types.ThemeImageEditor.space "bpy.types.ThemeImageEditor.space") - [`ThemeInfo.space`](bpy.types.ThemeInfo.html#bpy.types.ThemeInfo.space "bpy.types.ThemeInfo.space") - [`ThemeNLAEditor.space`](bpy.types.ThemeNLAEditor.html#bpy.types.ThemeNLAEditor.space "bpy.types.ThemeNLAEditor.space") - [`ThemeNodeEditor.space`](bpy.types.ThemeNodeEditor.html#bpy.types.ThemeNodeEditor.space "bpy.types.ThemeNodeEditor.space") | - [`ThemeOutliner.space`](bpy.types.ThemeOutliner.html#bpy.types.ThemeOutliner.space "bpy.types.ThemeOutliner.space") - [`ThemePreferences.space`](bpy.types.ThemePreferences.html#bpy.types.ThemePreferences.space "bpy.types.ThemePreferences.space") - [`ThemeProperties.space`](bpy.types.ThemeProperties.html#bpy.types.ThemeProperties.space "bpy.types.ThemeProperties.space") - [`ThemeSequenceEditor.space`](bpy.types.ThemeSequenceEditor.html#bpy.types.ThemeSequenceEditor.space "bpy.types.ThemeSequenceEditor.space") - [`ThemeSpreadsheet.space`](bpy.types.ThemeSpreadsheet.html#bpy.types.ThemeSpreadsheet.space "bpy.types.ThemeSpreadsheet.space") - [`ThemeStatusBar.space`](bpy.types.ThemeStatusBar.html#bpy.types.ThemeStatusBar.space "bpy.types.ThemeStatusBar.space") - [`ThemeTextEditor.space`](bpy.types.ThemeTextEditor.html#bpy.types.ThemeTextEditor.space "bpy.types.ThemeTextEditor.space") - [`ThemeTopBar.space`](bpy.types.ThemeTopBar.html#bpy.types.ThemeTopBar.space "bpy.types.ThemeTopBar.space") |
user: Give a detailed overview of Socket Inspection: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Socket Inspection.

Socket inspection shows information about the value in a socket during the last evaluation.
For primitive data types such as integers, vectors, and strings the actual value is shown.
For geometry sockets only some data about the geometry is stored, including the set of
data types the geometry contains, and a count of their elements.

Socket values are only logged from when the node tree was executed, so a node must be
connected to the *Group Output* to have a value for inspection. Values are not logged during
rendering, to improve performance.
user: What is Elements and how is it used in Blender Python scripting?

assistant: Cube
:   The gray cube in the center of the scene is a [mesh](../../modeling/meshes/index.xhtml) object.
    Its orange outline indicates that it’s selected.
    The orange dot in the center is its [Origin](../../scene_layout/object/origin.xhtml),
    which indicates its precise location.

Light
:   The set of concentric black circles is a [light source](../../render/lights/light_object.xhtml)
    illuminating the cube.

Camera
:   The pyramid with a big triangle above it is the [camera](../../render/cameras.xhtml),
    which is used as the point of view for rendering.

3D Cursor
:   The [3D cursor](3d_cursor.xhtml), a cross with a red-and-white circle,
    determines where newly added objects are placed and can also serve as a
    transformation [pivot point](controls/pivot_point/index.xhtml).

Grid Floor
:   The gray lines forming a floor mark the zero height of the world.
    The red and green lines are the axes of the world coordinate system.
    They meet at the world origin, which is also where the origin of the *Cube* is located.
    The Grid Floor settings are in the [Viewport Overlays](display/overlays.xhtml) popover.

### Text Info

The top left corner of the viewport shows various bits of information –
see [Viewport Overlays](display/overlays.xhtml) for details.
user: Provide the full official documentation entry for Draw Sharp, preserving all code examples.

assistant: # Draw Sharp

Similar to the [Draw](draw.html) brush,
but it always deforms the mesh from the original coordinates
and uses the *Sharper* Falloff by default.

Draw Sharp is useful on high density meshes for creating cloth wrinkles, stylized hair or hard surface edges.
To further sharpen or polish sharp edges in the case that the mesh density is not enough,
it’s recommended to use the [Pinch](pinch.html),
[Crease](crease.html) or
[Multiplane Scrape](multiplane_scrape.html) brushes.

A limitation is that the brush does not remesh the sculpted surfaces
with [Dyntopo](../tool_settings/dyntopo.html#bpy-ops-sculpt-dynamic-topology-toggle) enabled.
Because of that, a better brush to use with Dyntopo can be [Crease](crease.html).
user: Show practical ways to work with Usage in a Blender add-on or script – include code.

assistant: By default, the position of vertices on the edge loop move as a percentage of the distance
between their original position and the adjacent edge loop, regardless of the edges’ lengths.

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_edge_edge-slide_before.png>   Selected edge loop. | <../../../../_images/modeling_meshes_editing_edge_edge-slide_after.png>   Repositioned edge loop. |

### Even Mode

*Even* mode keeps the shape of the selected edge loop the same as one of the edge loops adjacent to it,
rather than sliding a percentage along each perpendicular edge.

In *Even* mode, the tool shows the position along the length of the currently selected edge
which is marked in yellow, from the vertex that has an enlarged red marker.
Movement of the sliding edge loop is restricted to this length. As you move the mouse
the length indicator in the header changes showing where along the length of the edge you are.

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_edge_edge-slide_even.png>   Even Mode enabled. | <../../../../_images/modeling_meshes_editing_edge_edge-slide_even-flip.png>   Even Mode with Flip enabled. |

Moving the mouse moves the selected edge loop towards or away from the start vertex,
but the loop line will only move as far as the length of the currently selected edge,
conforming to the shape of one of the bounding edge loops.

### Limitations & Workarounds

There are restrictions on the type of edge selections that can be operated upon.
Invalid selections are:

Loop Crosses Itself
:   This means that the tool could not find any suitable faces that were adjacent to the selected edge(s).
    An example that shows this is selecting two edges that share the same face.
    A face cannot be adjacent to itself.

Multiple Edge Loops
:   The selected edges are not in the same edge loop, which means they do not have a common edge.
    You can minimize this error by always selecting edges end-to-end or in a “chain”.
    If you select multiple edges just make sure they are connected.
    This will decrease the possibility of getting looping errors.

Border Edges
:   When a single edge was selected in a single-sided object.
    An edge loop cannot be found because there is only one face.
    Remember, edge loops are loops that span two or more faces.

A general rule of thumb is that if multiple edges are selected they should be connected end-to-end
such that they form a continuous chain. This is *literally* a general rule because you
can still select edges in a chain that are invalid because some of the edges in the chain are
in different edge loops.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Data Type
:   The data type that is used for mixing.
    The node supports float, vector, color, and rotation data types.

Factor Mode (Vector only)
:   The factor mode can be set to *Uniform* and *Non-Uniform*.
    In uniform mode, a single float controls the factor.
    In non-uniform mode, a vector controls the factor for
    each XYZ channel separately.

Mix (Color only)
:   The Blend modes can be selected in the select menu.
    See [Color Blend Modes](../../../../glossary/index.html#term-Color-Blend-Modes) for details on each blending mode.

    Add, Subtract, Multiply, Screen, Divide, Difference,
    Darken, Lighten, Overlay, Color Dodge, Color Burn,
    Hue, Saturation, Value, Color, Soft Light, Linear Light

Clamp Factor
:   Limit the factor value between 0.0 and 1.0. If this option is
    unchecked then the node operates using *Extrapolation*.

Clamp Result (Color only)
:   Limit the Result to the range between 0.0 and 1.0.
user: Explain Installing Git and Downloading the Repository in complete detail according to the official Blender documentation.

assistant: In this guide, we will use the official Git client, though any Git client will do.

1. Download and install [Git](https://git-scm.com/download/win) for Windows.
2. Simply check out the Blender Manual’s repository using:

   ```
   cd ~
   git lfs install
   git clone https://projects.blender.org/blender/blender-manual.git
   ```
3. The repository will now be downloaded which may take a few minutes depending on your internet connection.
user: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Visibility Management

Each [Scene](../../scene_layout/scene/introduction.xhtml) consists of one or more
[Collections](../../scene_layout/collections/collections.xhtml).
Collections can be enabled or disabled per View Layer, allowing you to control what appears in each layer’s render.

This makes it easy to separate lighting, characters, props, or effects into their own passes.

Collection visibility for each View Layer can be adjusted in the [Outliner](../../editors/outliner/editing.xhtml#editors-outliner-editing-collections) or [Collection View Layer Properties](../../scene_layout/collections/collections.xhtml#bpy-types-layercollection).

[image reference removed]

View Layer collections in the Outliner.

From the Outliner, you can:

- Enable or disable collections per View Layer.
- Set holdout and indirect-only options (Cycles only).
- Manage what objects contribute to the render or compositing.

### Rendering & Compositing

When a scene is rendered, each View Layer is available in the
[Compositor](../../compositing/introduction.xhtml) using they [Render Layers Node](../../compositing/types/input/scene/render_layers.xhtml).
This allows you to process each layer independently, combining or adjusting them to create the final output.

Each View Layer can output multiple [Render Passes](passes.xhtml) including:

- Combined (final image)
- Diffuse, Glossy, Transmission components
- Shadow, Mist, Ambient Occlusion
- Cryptomatte and Object/Material/ID Masks
- Data passes like Normal, UV, and Depth

These passes make it possible to perform detailed color grading,
masking, relighting, and other post-processing operations in a non-destructive workflow.
user: How do I use TimelineMarkers(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # TimelineMarkers(bpy_struct)

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

*class* bpy.types.TimelineMarkers(*bpy_struct*)
:   Collection of timeline markers

    new(*name*, *\**, *frame=1*)
    :   Add a timeline marker

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – New name for the marker (not unique)
            - **frame** (*int in* *[**-1048574**,* *1048574**]**,* *(**optional**)*) – The frame for the new marker

        Returns:
        :   Newly created timeline marker

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

    remove(*marker*)
    :   Remove a timeline marker

        Parameters:
        :   **marker** ([`TimelineMarker`](bpy.types.TimelineMarker.html#bpy.types.TimelineMarker "bpy.types.TimelineMarker"), (never None)) – Timeline marker to remove

    clear()
    :   Remove all timeline markers

    *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 Weight Paint and how is it used in Blender Python scripting?

assistant: [image reference removed]

3D Viewport Mode selector: Weight Paint Mode.

Weight Paint Mode is selected from the *Mode* menu in the 3D Viewport header.
Once Weight Paint Mode is activated, the Toolbar of the 3D Viewport will change to Weight Paint Mode specific panels.
A red circle will appear and follow the location of the cursor in the 3D Viewport.
user: Explain RENDER_UL_renderviews(UIList) in complete detail according to the official Blender documentation.

assistant: # RENDER_UL_renderviews(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.RENDER_UL_renderviews(*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: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Mesh
:   The geometry to retrieve the attribute from.

Value
:   A field to evaluate on the *Source* geometry for use with the transfer method.

Group ID
:   Is evaluated on the face domain and splits the input mesh into multiple parts, each with its own id.

Sample Position
:   The position to start from when finding the closest location on the target mesh.
    By default, this is the same as if the [Position Node](../../geometry/read/position.xhtml) was connected.

Sample Group ID
:   Determines in which group the closest nearest surface is detected.
user: Explain Directory Structure in complete detail according to the official Blender documentation.

assistant: # Directory Structure

A video project is most likely a combination of several different assets.
You can separate them into three broad categories.

- Video files: video clips (or movies in Blender-talk), photos, graphic files (charts, logos, …),
  and Visual Effects (VFX) such as masks, lens flares, animation.
- Audio files: recorded dialog, voice-over, music, and Sound Effects (SFX) such as environmental sounds, swooshes, …
- Project files: the blend files and backups, (partial) render results, documentation such as scripts and storyboards.

Together they can form rapidly an intangible heap of files.
It’s good practice to collect all those assets in *one* project directory with appropriate subdirectories.
Why? It will lower the probability that you accidentally delete a file
(which will result in a ‘file not found’ error) or that you forget
to include a necessary file when transferring the project (‘file is missing’ error).
And most of all, an appropriate directory structure, will help you to keep a clear overview of your assets.

It’s also good practice to use some kind of naming convention and add metadata.
Figure 1 shows a possible example, based on our categorization of the assets above.
The directories are numbered so that they mimic a normal workflow.

[image reference removed]

Figure 1: Organizing your project.
user: Describe Combine Cylindrical Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Combine Cylindrical Node

[image reference removed]

The *Combine Cylindrical* node converts cylindrical coordinates (R, Φ, Z)
into a Cartesian vector (X, Y, Z). It is the inverse of the
[Separate Cylindrical](separate_cylindrical.html) node.

This node is useful for constructing positions or directions based on radial distance,
rotation angle, and height, such as creating spiral shapes or cylindrical displacements.
user: Explain Adjust Last Operation in complete detail according to the official Blender documentation.

assistant: You can tweak the parameters of an [operator](operators.html) after running it.
In editors that support it, there is a “head-up display” panel in the bottom left
based on the last performed operation.
Alternatively, you can create a pop-up with `F9` which does the same thing.

For example, if your last operation was a rotation in *Object Mode*,
Blender will show you the last value changed for the angle
(see Fig. [Rotation (Object Mode, 60 degrees).](#fig-interface-redo-last-object-mode) left),
where you can change your action back completely by typing `Numpad0` in the *Angle* Field.
There are other useful options, based on the operator,
and you cannot only Undo actions, but change them completely using the available options.

If you are in *Edit Mode*,
Blender will also change its contents based on your last action taken.
In the second example (on the right), the last operation was a Move in Object Mode;
but a *Scale* on a Face in Edit Mode, and, as you can see,
the contents of *Adjust Last Operation* are different, because of the mode (Edit Mode)
(See Fig. [Scale (Edit Mode, Resize face).](#fig-interface-redo-last-edit-mode) right).

Adjust Last Operation.

|  |  |
| --- | --- |
| <../_images/interface_undo-redo_redo-last-object-mode.png>   Rotation (Object Mode, 60 degrees). | <../_images/interface_undo-redo_redo-last-edit-mode.png>   Scale (Edit Mode, Resize face). |
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Geometry
:   Standard Geometry input.

Selection
:   Boolean field used to calculate which output each part of the geometry will go to.
    Parts in the selection will move to the *Selection* output.
    Parts not in the selection will move to the *Inverted* output.