PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe Stroke Placement from the Blender manual or Python API, including usage steps and snippets.

assistant: # Stroke Placement

[image reference removed]

Stroke Placement pop-over.

The Stroke Placement selector helps to select the location in which strokes are drawn.

Origin:
:   Strokes are placed at Grease Pencil object origin.

3D Cursor:
:   Strokes are placed at 3D cursor.

Surface:
:   Strokes will stick on mesh surfaces.

    Offset
    :   Distance from the mesh surface to place the new strokes.

    Project Onto Selected
    :   Only project the strokes onto selected objects.

Stroke:
:   Strokes will stick on other strokes.

    Target
    :   All Points:
        :   All the points of the new stroke sticks to other strokes.

        End Points:
        :   Only the start and end points of the new stroke sticks to other strokes.

        First Point:
        :   Only the start point of the new stroke sticks to other strokes.

Stroke using different Stroke Placements.

|  |  |  |  |
| --- | --- | --- | --- |
| ../../../_images/grease-pencil_modes_draw_stroke-placement_origin.png   Origin. | ../../../_images/grease-pencil_modes_draw_stroke-placement_3D-cursor.png   3D Cursor. | ../../../_images/grease-pencil_modes_draw_stroke-placement_surface.png   Surface. | ../../../_images/grease-pencil_modes_draw_stroke-placement_stroke.png   Stroke. |
user: Describe bpy_extras submodule (bpy_extras.asset_utils) from the Blender manual or Python API, including usage steps and snippets.

assistant: # bpy_extras submodule (bpy_extras.asset_utils)

Helpers for asset management tasks.

*class* bpy_extras.asset_utils.AssetBrowserPanel

*class* bpy_extras.asset_utils.AssetMetaDataPanel

*class* bpy_extras.asset_utils.SpaceAssetInfo
user: Give a detailed overview of Gabor Texture Node: syntax, arguments, return values, common patterns.

assistant: # Gabor Texture Node

[image reference removed]

The *Gabor Texture* node evaluates a Gabor noise at the input texture coordinates. Gabor noise is
visually characterized by random interleaved bands whose direction and width can be controlled.
Additionally, it can be used to create omnidirectional noise like the standard Noise Texture node,
but since it is more expensive to compute, using the Noise Texture node is probably the better
option in those cases. See the examples for more information.
user: Describe Snap Target for Individual Elements from the Blender manual or Python API, including usage steps and snippets.

assistant: Type of element for individual transformed elements to snap to.

Face Project:
:   Snaps to the face that’s under the mouse cursor.
    This can be used for bending a flat sheet so it snugly fits against a curved surface, for example.

    This works similar to the [Shrinkwrap Modifier](../../../modeling/modifiers/deform/shrinkwrap.xhtml).

Face Nearest:
:   Individually snaps each object (in Object Mode) or vertex (in Edit Mode) to the face that’s closest
    to its new location. This makes it possible to snap to occluded geometry.
user: Explain Walk Navigation in complete detail according to the official Blender documentation.

assistant: This navigation method behaves like a typical first person game.
It works with a combination of keyboard keys and mouse movement.

### Usage

Move the mouse in the direction you want to look and use the keys
listed below to walk around the scene.

When you are happy with the new view, press `LMB` to confirm.
In case you want to go back to where you started, press `Esc` or `RMB`.

All these keys are also listed in the Status Bar while navigating.
Settings like mouse sensitivity and default speed can be adjusted in the
[Preferences](../../preferences/navigation.html).

|  |  |
| --- | --- |
| `W`/`Up` | Move forward. |
| `S`/`Down` | Move backward. |
| `A`/`Left` | Strafe left. |
| `D`/`Right` | Strafe right. |
| `E` | Move up (global) – only available if *Gravity* is off. |
| `Q` | Move down (global) – only available if *Gravity* is off. |
| `R` | Move up (local) – only available if *Gravity* is off. |
| `F` | Move down (local) – only available if *Gravity* is off. |
| `Spacebar` | Teleport to the location at the crosshair (offset by the *Camera Height* value set in the Preferences). |
| `WheelUp`/`NumpadPlus` | Increase the movement speed. |
| `WheelDown`/`NumpadMinus` | Decrease the movement speed. |
| `Shift` | Speed up the movement temporarily. |
| `Alt` | Slow down the movement temporarily. |
| `V` | Jump – only available if *Gravity* is on. |
| `Tab` | Toggle *Gravity*. |
| `Z` | Correct the Z axis of the view (smoothly roll it to ensure it’s upright, not tilted to a side). |
| `Period` | Increases the jump height. |
| `Comma` | Decreases the jump height. |
user: Provide the full official documentation entry for NodeSocketVectorFactor2D(NodeSocketStandard), preserving all code examples.

assistant: # NodeSocketVectorFactor2D(NodeSocketStandard)

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

*class* bpy.types.NodeSocketVectorFactor2D(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   float array of 2 items in [0, 1], default (0.0, 0.0)

    links
    :   List of node links from or to this socket.

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

        (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 Blender 2.9 in complete detail according to the official Blender documentation.

assistant: - [Blender 2.93 LTS](https://docs.blender.org/manual/en/2.93/)
- [Blender 2.92](https://docs.blender.org/manual/en/2.92/)
- [Blender 2.91](https://docs.blender.org/manual/en/2.91/)
- [Blender 2.90](https://docs.blender.org/manual/en/2.90/)
user: Provide the full official documentation entry for Brush Settings, preserving all code examples.

assistant: ### General

### Unique

Deformation
:   Deformation type that is used by the brush.

    Drag:
    :   Slides the topology of the mesh in the direction of the stroke.

    Pinch:
    :   Slides the topology of the mesh towards the center of the stroke.

    Expand:
    :   Slides the topology of the mesh away from the center of the stroke.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Tools can have their own settings, which are available from multiple places:

- The Tool ‣ Active Tool panel in the Sidebar `N`.
- The *Active Tool* tab in the [Properties editor](../editors/properties_editor.xhtml).
- The *Tool Settings* region below the area header.
user: Show practical ways to work with Linked Flat Faces in a Blender add-on or script – include code.

assistant: Selects all connected faces with a similar angle.

Sharpness
:   Select connected faces with a reference angle less than the value specified.

[image reference removed]

Looking at the image above, when at least one face is selected (as seen on the left),
*Linked Flat Faces* will select all connecting faces that lie
on the same or similar plane (as shown in the middle image).
If the corners are smoothed, those faces are no longer lined up with the selected faces.
At this point, increasing the *Sharpness* value in the tool options could include the smoothed faces.
user: How do I use Active Spline in Blender? Include parameters, examples, warnings and best practices.

assistant: # Active Spline

The *Active Spline* panel contains the properties of the active surface.

[image reference removed]

Active Spline panel.

Cyclic U/V
:   When enabled, the last row/column of the surface will be connected back to the first,
    creating a closed loop.

Bézier U/V
:   When enabled, the surface will be generated as a series of Bézier splines instead of a
    NURBS curve in the row/column direction.

Endpoint U/V
:   Controls whether the surface touches the borders of its control point grid.

    [image reference removed]

    Surface with *Endpoint U* enabled.

Order U/V
:   A higher *Order* gives each control point a broader influence along its
    row/column. This makes the surface smoother, but also makes it follow
    the shape of the control grid less closely.
    See [NURBS Curves Order](../../curves/properties/active_spline.xhtml#modeling-curve-order).

    [image reference removed]

    Surfaces with *Order U* set to 2 (top) and 4 (bottom).

    If *Bézier* is enabled, *Order* determines the number of control points per spline.

    The *Order* for a certain direction cannot be higher than the number of control
    points along that direction.

Resolution U/V
:   Determines the preview density of the generated surface mesh. The higher this number,
    the more vertices there will be and the smoother the surface will look.

    This setting only affects the active surface. To change the resolution of all surfaces
    in the object, you can use the [Resolution Preview U/V](shape.xhtml#bpy-types-curve-resolution-v) setting in the
    *Shape* panel instead.

    If the *Render U/V* values in the *Shape* panel are nonzero, they will override these
    *Resolution U/V* values during rendering.

Smooth
:   Whether to apply [smooth shading](../../meshes/editing/mesh/shading.xhtml#modeling-meshes-editing-normals-shading)
    to the generated surface mesh.
user: Explain Select Menus in complete detail according to the official Blender documentation.

assistant: [image reference removed]

The 3D Viewport Mode Select menu.

A *Select Menu* (or “selector”) allows you to choose from a predefined list of options.
It appears as a text label and/or icon with a down arrow on the right.

Click with `LMB` to open the menu and choose an option.
The selected option will then appear inside the button.
You can also cycle through options without opening the menu
by scrolling on top of the button with `Ctrl`-`Wheel`.

### Expanded View

[image reference removed]

Expanded menu view.

Some select menus use an expanded layout to show all available options at once.
In this view, the active option is highlighted with a colored background.

In certain cases, you can select multiple options by holding `Shift` and clicking with `LMB`.
user: Show practical ways to work with NodeTreeInterfaceSocketVectorFactor2D(NodeTreeInterfaceSocket) in a Blender add-on or script – include code.

assistant: # NodeTreeInterfaceSocketVectorFactor2D(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.NodeTreeInterfaceSocketVectorFactor2D(*NodeTreeInterfaceSocket*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   float array of 2 items in [0, 1], default (0.0, 0.0)

    dimensions
    :   Dimensions of the vector socket

        Type:
        :   int in [2, 4], default 0

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

        Type:
        :   float in [-inf, inf], default 0.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: Explain GeometryNodeGridInfo(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeGridInfo(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.GeometryNodeGridInfo(*GeometryNode*)
:   Retrieve information about a volume grid

    data_type
    :   Node socket data type

        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), default `'FLOAT'`

    *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: Give a detailed overview of Select Edge Loops: syntax, arguments, return values, common patterns.

assistant: Holding `Alt` while selecting an edge selects a loop of edges that are connected in
a line end-to-end, passing through the edge under the mouse pointer.
Holding `Shift`-`Alt` while clicking adds to the current selection.

[image reference removed]

Longitudinal and latitudinal edge loops.

The left sphere shows an edge that was selected longitudinally. Notice how the loop is open.
This is because the algorithm hit the vertices at the poles and is terminated
because the vertices at the pole connect to more than four edges. However,
the right sphere shows an edge that was selected latitudinally and has formed a closed loop.
This is because the algorithm hit the first edge that it started with.

### Select Edge Loops (All Boundaries)

All boundary edges can be selected by performing a second loop select action on a boundary edge.

This can be useful for selecting boundaries for meshes that include triangles and n-gons,
where loop select would not otherwise select the full boundary.

[image reference removed]

The second loop select action is shown on the right.
user: Explain Delete Tracks in complete detail according to the official Blender documentation.

assistant: Deletes the selected tracks and the strips they contain.

When using the keyboard shortcuts, make sure the mouse cursor is hovering over the track region,
as otherwise, Blender will only delete the selected strips.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.collection`](bpy.context.html#bpy.context.collection "bpy.context.collection") - [`Context.layer_collection`](bpy.types.Context.html#bpy.types.Context.layer_collection "bpy.types.Context.layer_collection") - [`LayerCollection.children`](#bpy.types.LayerCollection.children "bpy.types.LayerCollection.children") | - [`ViewLayer.active_layer_collection`](bpy.types.ViewLayer.html#bpy.types.ViewLayer.active_layer_collection "bpy.types.ViewLayer.active_layer_collection") - [`ViewLayer.layer_collection`](bpy.types.ViewLayer.html#bpy.types.ViewLayer.layer_collection "bpy.types.ViewLayer.layer_collection") |
user: What is Select Random and how is it used in Blender Python scripting?

assistant: Adds random control points to the selection. The [Adjust Last Operation](../../interface/undo_redo.html#bpy-ops-screen-redo-last)
panel offers the following options:

Ratio
:   The ratio of control points that should end up selected, e.g. 0.5 to select half of all points
    (that are not [hidden](../../scene_layout/object/editing/show_hide.html)).

    Note that the existing selection is ignored: if half of the control points are already selected,
    setting *Ratio* to 0.1 won’t deselect anything, nor will it select 10% of the unselected
    points. Instead, it always picks 10% of *all* visible points and adds them to the selection.

Random Seed
:   A number that influences which specific control points get picked.

Action
:   Select:
    :   Add random control points to the selection.

    Deselect:
    :   Remove random control points from the selection.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Mode
:   Element-Wise:
    :   Compare each axis of the input vectors separately, and output true only when the result is true
        for each axis.

    Length:
    :   Compare the length of the two input vectors.

    Average:
    :   Compare the average of the elements of the input vectors. This is the same as the implicit
        conversion used when setting the node’s data type to *Float*.

    Dot Product:
    :   Compare the dot product of the two vectors with the separate *C* input, using the selected operation.
        The dot product outputs a single value that says how much the two vectors “agree”.

    Direction:
    :   Compare the angle between the two vectors with the separate *Angle* input, using the selected operation.
        The vectors are normalized, so their length does not matter.

Operation
:   Less Than:
    :   True when the first input is smaller than second input.

    Less Than or Equal:
    :   True when the first input is smaller than the second input or equal.

    Greater Than:
    :   True when the first input is greater than the second input.

    Greater Than or Equal:
    :   True when the first input is greater than the second input or equal.

    Equal:
    :   True when both the difference between the two inputs is smaller than the *Epsilon* input.

    Not Equal:
    :   True when both the difference between the two inputs is larger than the *Epsilon* input.

    Brighter:
    :   True when the first color input is brighter than the second.

    Darker:
    :   True when the first color input is darker than the second.
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`MovieTrackingReconstruction.cameras`](bpy.types.MovieTrackingReconstruction.html#bpy.types.MovieTrackingReconstruction.cameras "bpy.types.MovieTrackingReconstruction.cameras") |  |
user: Give a detailed overview of NodeTreeInterfaceSocketVectorFactor(NodeTreeInterfaceSocket): syntax, arguments, return values, common patterns.

assistant: # NodeTreeInterfaceSocketVectorFactor(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.NodeTreeInterfaceSocketVectorFactor(*NodeTreeInterfaceSocket*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   float array of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    dimensions
    :   Dimensions of the vector socket

        Type:
        :   int in [2, 4], default 0

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

        Type:
        :   float in [-inf, inf], default 0.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: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`BlendData.hair_curves`](bpy.types.BlendData.html#bpy.types.BlendData.hair_curves "bpy.types.BlendData.hair_curves") - [`BlendDataHairCurves.new`](bpy.types.BlendDataHairCurves.html#bpy.types.BlendDataHairCurves.new "bpy.types.BlendDataHairCurves.new") | - [`BlendDataHairCurves.remove`](bpy.types.BlendDataHairCurves.html#bpy.types.BlendDataHairCurves.remove "bpy.types.BlendDataHairCurves.remove") - [`Curves.unit_test_compare`](#bpy.types.Curves.unit_test_compare "bpy.types.Curves.unit_test_compare") |
user: Describe Simple Deform Modifier from the Blender manual or Python API, including usage steps and snippets.

assistant: # Simple Deform Modifier

The *Simple Deform* modifier allows the application of a simple deformation to
an object. Meshes, lattices, curves, surfaces and texts are supported objects.
The deformation is either a rotation (Twist, Bend) or a scaling (Taper, Stretch).
The amount of deformation is specified by the Deform Angle (rotation) or Deform Factor (scaling).

[image reference removed]

The Simple Deform modifier.

The deformation is calculated in the *local* coordinate space.
Be aware that the local axes of an object can differ from the global ones.
In the figure above, the global Z axis points up and the local Z axis points at 45°.
The deformation is applied along a Deform axis, which can be set by selection from a list (X, Y or Z).
By using the *Limits* field, the influence of the modifier can be restricted to a subset of the Deform axis.
All distances are measured from the origin of the object.
The vertices that are furthest away from the origin on the Deform axis
represent the upper and lower limits.
The origin of the object and the orientation of the local axes
can be defined by an external Deform object (most of the time, an empty).
user: How do I use Example in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Smoke density.

[image reference removed]

Computing the color of fire using the *Blackbody* node.
Since the *Blackbody* node expects its input in Kelvin,
the temperature output has to be remapped first.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Direction
:   A vector that defines the reference direction to compare against the element normals.
    The direction should typically be normalized.

Threshold
:   The maximum angular difference between the element normal and the given direction
    for the element to be included in the selection.
user: Provide the full official documentation entry for Animation, preserving all code examples.

assistant: Controls animation data for scene-level properties, including active [Actions](../../animation/actions.xhtml)
and their assigned [Slot](../../animation/actions.xhtml#animation-actions-slots).

See [Manually Assigning Actions and Slots](../../animation/actions.xhtml#animation-actions-slots-manual-assign) for more information.

Scene
:   Specifies the action and slot where animation data for scene properties is stored/retrieved.
user: What is Surface and how is it used in Blender Python scripting?

assistant: Direct Light
:   This option limits the maximum light intensity a surface can reflect.
    It reduces [Aliasing](../../../glossary/index.html#term-Aliasing) noise and [Fireflies](../../../glossary/index.html#term-Fireflies) at the cost of accuracy.
    Setting this option to 0.0 disables clamping altogether.
    Lower values have a greater effect on the resulting image than higher values.

Indirect Light
:   Similar to **Direct Light** but limits the maximum light intensity reflected using ray-tracing and light-probes.
    This also limits the intensity of the world lighting since it is considered as indirect light.
user: What is Space Image Mode All Items and how is it used in Blender Python scripting?

assistant: # Space Image Mode All Items

VIEW:
:   View.

    Inspect images or render results.

UV:
:   UV Editor.

    View and edit UVs.

PAINT:
:   Paint.

    Paint images in 2D.

MASK:
:   Mask.

    View and edit masks.
user: Explain GeometryNodeCurveSetHandles(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeCurveSetHandles(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.GeometryNodeCurveSetHandles(*GeometryNode*)
:   Set the handle type for the control points of a Bézier curve

    handle_type
    :   - `FREE`
          Free – The handle can be moved anywhere, and does not influence the point’s other handle.
        - `AUTO`
          Auto – The location is automatically calculated to be smooth.
        - `VECTOR`
          Vector – The location is calculated to point to the next/previous control point.
        - `ALIGN`
          Align – The location is constrained to point in the opposite direction as the other handle.

        Type:
        :   enum in [`'FREE'`, `'AUTO'`, `'VECTOR'`, `'ALIGN'`], default `'FREE'`

    mode
    :   Whether to update left and right handles

        Type:
        :   enum set in [Node Geometry Curve Handle Side Items](bpy_types_enum_items/node_geometry_curve_handle_side_items.html#rna-enum-node-geometry-curve-handle-side-items), default set()

    *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: What is MeshVertices(bpy_struct) and how is it used in Blender Python scripting?

assistant: # MeshVertices(bpy_struct)

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

*class* bpy.types.MeshVertices(*bpy_struct*)
:   Collection of mesh vertices

    add(*count*)
    :   add

        Parameters:
        :   **count** (*int in* *[**0**,* *inf**]*) – Count, Number of vertices to add

    *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 Object Modes in Blender? Include parameters, examples, warnings and best practices.

assistant: # Object Modes

[image reference removed]

The Mode select menu.

Modes allow editing different aspects of objects. While Object Mode allows
you to position/rotate/scale them, Edit Mode allows changing their geometry,
Pose Mode allows posing them, and so on.

You can change the current mode using the *Mode* selector in the 3D Viewport header.
Which modes are available depends on the object’s type. The complete list
is shown below.

Apart from using the selector, you can also press `Ctrl`-`Tab` to bring up
a pie menu around the cursor for faster access. (If the selected object is an
[Armature](../../animation/armatures/introduction.xhtml), this shortcut will instead
switch between Object Mode and Pose Mode.)

Pressing `Tab` will toggle Edit Mode for objects that support it.

Modes can affect many things in Blender:

- Each mode changes the header and Toolbar to show its own unique set of menus and tools.
  This also means it affects the available keyboard shortcuts.
- Modes can completely change the look of the viewport. For example, Weight Paint mode
  will shade the object to show its vertex weights, which are not normally visible.
- Modes can affect other editors. For example, the [UV Editor](../uv/introduction.xhtml)
  can only be used if the 3D Viewport is in Edit Mode. In the
  [Properties](../properties_editor.xhtml) editor, too, certain buttons and panels
  can only be used in certain modes.
user: Describe FModifierStepped(FModifier) from the Blender manual or Python API, including usage steps and snippets.

assistant: # FModifierStepped(FModifier)

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

*class* bpy.types.FModifierStepped(*FModifier*)
:   Hold each interpolated value from the F-Curve for several frames without changing the timing

    frame_end
    :   Frame that modifier’s influence ends (if applicable)

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

    frame_offset
    :   Reference number of frames before frames get held (use to get hold for ‘1-3’ vs ‘5-7’ holding patterns)

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

    frame_start
    :   Frame that modifier’s influence starts (if applicable)

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

    frame_step
    :   Number of frames to hold each value

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

    use_frame_end
    :   Restrict modifier to only act before its ‘end’ frame

        Type:
        :   boolean, default False

    use_frame_start
    :   Restrict modifier to only act after its ‘start’ frame

        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: What is Linear Workflow and how is it used in Blender Python scripting?

assistant: Different [Color Spaces](../../glossary/index.xhtml#term-Color-Space)
are needed for rendering, display and storage of images.

Rendering and compositing is best done in a *scene linear* color space,
which corresponds more closely to nature, and makes computations more physically accurate.
Blender primarily works with scene linear colors for materials, lighting, geometry and
compositing.

However, these values do not directly correspond to human perception or the way display devices
work. Image files are also often stored in different color spaces for more efficient compression.

For a correct linear workflow, it is important to assign the correct color spaces for images
and displays. Blender will then perform conversion to and from scene linear colors.

[image reference removed]

An example of a linear workflow.
user: How do I use Custom Distance in Blender? Include parameters, examples, warnings and best practices.

assistant: If enabled, uses [Distance](#bpy-types-light-cutoff-distance) as the custom attenuation distance
instead of global Light Threshold. In order to avoid long setup times, this distance is first computed
automatically based on a light threshold.
The distance is computed at the light origin and using the inverse square falloff.

Distance
:   Specifies where light influence will be set to 0.
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Data Type
:   Map Range supports both Float and Vector data types. Changing the data type will
    also update the sockets to reflect the data type chosen.

Interpolation Type
:   The mathematical method used to transition between gaps in the numerical inputs.

    Linear:
    :   Linear interpolation between From Min and From Max values.

    Stepped Linear:
    :   Stepped linear interpolation between From Min and From Max values.

    Smooth Step:
    :   Smooth Hermite edge interpolation between From Min and From Max values.

    Smoother Step:
    :   Smoother Hermite edge interpolation between From Min and From Max values.

Clamp
:   If enabled, the output is clamped to the target range.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

The Lattice modifier.

Object
:   The [Lattice](../../../animation/lattice.xhtml) object with which to deform the base object.

Vertex Group
:   An optional vertex group name which lets you limit the modifier’s effect to a part of the base mesh.

    Invert
    :   Inverts the influence of the selected vertex group, meaning that the group
        now represents vertices that will not be deformed by the modifier.

        The setting reverses the weight values of the group.

Strength
:   A factor to control blending between original and deformed vertex positions.
user: Give a detailed overview of Tool Settings: syntax, arguments, return values, common patterns.

assistant: Solver
:   Algorithm used to calculate the Boolean intersections.

    Exact:
    :   Uses a complex solver which offers the best results and has full
        support for overlapping geometry; however, this solver is much slower.

    Float:
    :   Uses a simple solver which offers the good performance;
        however, this solver lacks support for overlapping geometry.

    Manifold:
    :   Uses a solver that is usually fastest but only works on [Manifold](../../../glossary/index.xhtml#term-Manifold) meshes,
        (plus the special case of Difference with a plane).

Trim Mode
:   Geometry can be either added or removed by choosing one of these modes.

    Difference:
    :   Removes geometry, filling any holes that are created.

    Union:
    :   Creates a geometry and joins any intersections with existing geometry.

    Join:
    :   Similar to *Union* but joins the mesh as separate geometry,
        without performing any Boolean operations with existing geometry.

Shape Orientation
:   The method used to orientate the trimming shape.

    View:
    :   Use the view to orientate the trimming shape.

    Surface:
    :   Use the surface normal to orientate the trimming shape.

Extrude Mode
:   Fixed:
    :   Aligns new geometry orthogonally for 90 degree angles in depth.

    Project:
    :   Aligns new geometry with the perspective of the current view for a tapered result.

Use Cursor for Depth
:   Use cursor location and radius for the dimensions and position of the trimming shape.
    If not set, the tool uses the full depth of the object from the camera view.
user: Show practical ways to work with Viewing Color Attributes in a Blender add-on or script – include code.

assistant: Color Attributes can be used in a material node tree using the [Color Attribute Node](../../render/shader_nodes/input/vertex_color.xhtml).

Color Attributes can be viewed in the 3D viewport using the Workbench render engine.
To use such feature, set the 3D Viewport to [Solid Shading](../../editors/3dview/display/shading.xhtml#dview-shading-solid)
and select the *Attribute* Color option.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Width / Bottom Width / Top Width
:   The X axis size of the shape.

Height
:   The Y axis size of the shape.

Bottom Height / Top Height
:   The distance between the bottom or top point and the X axis, in *Kite* mode.

Offset
:   In *Parallelogram* mode, the relative X difference between the top and bottom edge.
    In *Trapezoid* mode, the amount to move the top edge in the positive X axis.

Point 1 - 4
:   Input vectors for the *Points* mode.
user: Show practical ways to work with Subdivide in a Blender add-on or script – include code.

assistant: # Subdivide

Subdividing adds resolution to the mesh by dividing faces or edges into smaller units.

This process follows a few rules depending on the situation:

- When only one edge of a triangle or [quad](../../../../glossary/index.html#term-Quad) is selected,
  that face is turned into a quad or [N-gon](../../../../glossary/index.html#term-N-gon) respectively.
  If the *Create N-Gons* option is disabled, the face is split into triangles instead.
- When two edges of a face are selected:

  - If the face is a triangle, a new edge is created between the two new vertices,
    subdividing the triangle into a triangle and a quad.
  - If the face is a quad and the edges are neighbors, the face is split according
    to the *Quad Corner Type* setting (see below).
  - If the face is a quad and the edges are opposite,
    the quad is just subdivided in two quads by the edge linking the two new vertices.
- When three edges of a face are selected:

  - If the face is a triangle, this means the whole face is selected and
    it is subdivided into four smaller triangles.
  - If the face is a quad, first the two opposite edges are subdivided as described above.
    Then, the “middle” edge is subdivided, affecting its new “sub-quad” as described above for only one edge.
- When all four edges of a quad are selected, the face is subdivided into four smaller quads.
- When one or more edges of an N-gon are selected,
  the individual edges will be subdivided but the face will stay unsubdivided.
user: Explain UV Sphere in complete detail according to the official Blender documentation.

assistant: A UV sphere is composed of quad faces arranged in horizontal rings and vertical segments,
with triangle fans at the poles. This structure mirrors how textures are typically mapped
in 2D (hence the name “UV” sphere), making it well-suited for texturing.

It resembles lines of latitude and longitude on a globe, which also makes it useful for
planetary models or spherical shapes with pole-to-pole UV seams.

Segments
:   Number of vertical segments (longitudinal divisions).
    These are like meridians on a globe, running from the north to south pole.

Rings
:   Number of horizontal segments (latitudinal divisions).
    These are like parallels on a globe, stacked from top to bottom.

Radius
:   Distance from the center to the outer surface of the sphere.
user: Explain Known Limitations in complete detail according to the official Blender documentation.

assistant: ### Blender Versions

A problem with modifying your own keymap is that newer Blender versions may change the way tools are accessed,
breaking your customized keymap.

While the keymap can be manually updated, the more customizations you make, the higher the chance of conflicts
in newer Blender versions is.
user: How do I use Known Limitations in Blender? Include parameters, examples, warnings and best practices.

assistant: - Highly memory demanding: All mesh objects in a view layer are loaded at once.
- Only faced mesh objects are supported.
- No edges at face intersections are detected yet.
- Freestyle rendering results do not have any Z depth information.
- Panoramic cameras are not supported.
user: Provide the full official documentation entry for Compositor, preserving all code examples.

assistant: Device
:   The device used for compositing.

    CPU:
    :   Use the CPU for compositing.

    GPU:
    :   Use the GPU for compositing.

Precision GPU
:   The precision of compositor intermediate result.

    Auto:
    :   Use full precision for final renders, half precision otherwise.

    Full:
    :   Use full precision for final renders and viewport.

### Denoise Nodes

Denoising Device
:   The device to use to process [Denoise nodes](../../../compositing/types/filter/denoise.xhtml) in the compositor.

    Auto:
    :   Use the same device used by the compositor to process the denoise node.

    CPU:
    :   Use the CPU to process the denoise node.

    GPU:
    :   Use the GPU to process the denoise node if available, otherwise fallback to CPU.

Preview Quality
:   The quality used by [Denoise nodes](../../../compositing/types/filter/denoise.xhtml) during viewport
    and interactive compositing of a render if their quality is set to *Follow Scene*.

    High:
    :   Produces the highest quality output at the cost of long processing times.

    Balanced:
    :   Balanced between performance and quality, typically processing in half the time as *High*,
        while retaining most of the quality.

    Fast:
    :   Produces an output quickly at a noticeable cost of quality.

Final Quality
:   The quality used by [Denoise nodes](../../../compositing/types/filter/denoise.xhtml) during the final
    render if their quality is set to *Follow Scene*.

    High:
    :   Produces the highest quality output at the cost of long processing times.

    Balanced:
    :   Balanced between performance and quality, typically processing in half the time as *High*,
        while retaining most of the quality.

    Fast:
    :   Produces an output quickly at a noticeable cost of quality.