PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is Rigging and how is it used in Blender Python scripting?

assistant: Rigging is a general term used for adding controls to objects,
typically for the purpose of animation.

Rigging often involves using one or more of the following features:

[Armatures](armatures/index.xhtml#armatures-index)
:   This allows mesh objects to have flexible joints and is often used for skeletal animation.

[Constraints](constraints/index.xhtml#constraints-index)
:   To control the kinds of motions that make sense and add functionality to the rig.

[Object Modifiers](../modeling/modifiers/index.xhtml)
:   Mesh deformation can be quite involved, there are multiple modifiers that help control this.

[Shape Keys](shape_keys/index.xhtml#animation-shape-keys-index)
:   To support different target shapes *(such as facial expressions)* to be controlled.

[Drivers](drivers/index.xhtml#animation-drivers-index)
:   So your rig can control many different values at once,
    as well as making some properties automatically update based on changes elsewhere.

Rigging can be as advanced as your project requires.
Rigs effective define a user interface for the animator to use,
without being concerned with the underlying mechanisms

### Examples

- An armature is often used with a modifier to deform a mesh for character animation.
- A camera rig can be used instead of animating the camera object directly to simulate real-world camera rigs
  (with a boom arm, mounted on a rotating pedestal for example, effects such as camera jitter can be added too).
user: Describe Select Random from the Blender manual or Python API, including usage steps and snippets.

assistant: Select Random control points.

Percent
:   Selects the defined percentage of control points.

Random Seed
:   [Seed](../../glossary/index.xhtml#term-Seed) used by the pseudo-random number generator.

Action
:   Controls whether the operator *Selects* or *Deselects* control points.
user: What is Blender 2.9 and how is it used in Blender Python scripting?

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: How do I use Import Nodes in Blender? Include parameters, examples, warnings and best practices.

assistant: # Import Nodes

Nodes used to import data from external file formats.

Geometry Nodes supports automatically creating import nodes by dragging supported file types into the node editor.

When dropping a supported file into a Geometry Node tree,
the corresponding import node is added automatically and configured with the file path.
user: Give a detailed overview of Text Boxes: syntax, arguments, return values, common patterns.

assistant: Text boxes (or frames) allow you to distribute the text among rectangular areas within a single text object.
An arbitrary number of freely movable and re-sizable text frames are allowed per text object.

The text flows continuously from the lowest-numbered frame to the highest-numbered frame with text
inside each frame word-wrapped.
It flows between frames when a lower-numbered frame cannot fit any more text.
If the last frame is reached, text overflows out of it (by default, see options below).

[image reference removed]

Text Boxes panel.

Add Textbox
:   Inserts a new frame, just after the current one (in text flow order).
    The new frame will have the same size and position as the selected one.

(Remove Text Block)
:   Delete the current frame.

Overflow
:   How to handle text overflowing available space in the defined boxes.

    Overflow:
    :   Just keep text running out of the last box.

    Scale to Fit:
    :   Scale text to fit into the available space.

    Truncate:
    :   Hide the end of the text that does not fit into the available space.

Size X, Y
:   Specifies the width and height of the text box, if set to **zero** no word wrapping happens
    (it is ignored, and the whole text box system is disabled if all are set to a null size).

Offset X, Y
:   Controls the *X* and *Y* offset of the frame, i.e. its position.

[image reference removed]

Multiple columns, text flowing between boxes.
user: Give a detailed overview of Selection Mode: syntax, arguments, return values, common patterns.

assistant: Vertex:
:   `1` Select vertices.

Edge:
:   `2` Select edges.

Face:
:   `3` Select faces.

If *Sync Selection* is enabled, you can hold `Shift` while clicking a selection mode to
activate multiple ones at the same time, or `Ctrl` to expand/contract the selection.
user: What is Examples and how is it used in Blender Python scripting?

assistant: |  |  |  |
| --- | --- | --- |
| ../../../_images/modeling_modifiers_generate_remesh_example-none.png   Unmodified mesh. | ../../../_images/modeling_modifiers_generate_remesh_example-blocks-depth-3.png   Blocks mode with Octree Depth 3. | ../../../_images/modeling_modifiers_generate_remesh_example-smooth-depth-3.png   Smooth mode with Octree Depth 3. |
| ../../../_images/modeling_modifiers_generate_remesh_example-sharp-depth-2.png   Sharp mode with Octree Depth 2. | ../../../_images/modeling_modifiers_generate_remesh_example-sharp-depth-3.png   Sharp mode with Octree Depth 3. | ../../../_images/modeling_modifiers_generate_remesh_example-sharp-depth-4.png   Sharp mode with Octree Depth 4. |

[image reference removed]

The Remesh Modifier applied to a text to improve its topology.

[Animated Example](https://www.youtube.com/watch?v=Mh-gUnS2c0Y)
user: How do I use Generic Spring Constraint in Blender? Include parameters, examples, warnings and best practices.

assistant: # Generic Spring Constraint

The generic spring constraint adds some spring parameters for the X/Y/Z axes
to all the options available on the Generic constraint.
Using the spring alone allows the objects to bounce around as if attached
with a spring anchored at the constraint object.
This is usually a little too much freedom,
so most applications will benefit from enabling translation or rotation constraints.

If the damping on the springs is set to 1, then the spring forces are prevented from realigning the anchor points,
leading to strange behavior. If your springs are acting weird, check the damping.
user: Describe Cache from the Blender manual or Python API, including usage steps and snippets.

assistant: # Cache

Soft Body physics simulations use a unified system for caching and baking.
See [Particle Cache](../../particles/emitter/cache.xhtml) and
[General Baking](../../baking.xhtml) documentation for reference.
user: Describe Example from the Blender manual or Python API, including usage steps and snippets.

assistant: Colorize Effect samples.

|  |  |  |  |
| --- | --- | --- | --- |
| <../../_images/grease-pencil_visual-effects_colorize_grayscale.png>   Mode: Grayscale. | <../../_images/grease-pencil_visual-effects_colorize_sepia.png>   Mode: Sepia. | <../../_images/grease-pencil_visual-effects_colorize_duotone.png>   Mode: Duotone. | <../../_images/grease-pencil_visual-effects_colorize_transparent.png>   Mode: Transparent. |
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Menu
:   Determines which input socket is passed through to the output.

One input is created for each menu entry. The input corresponding to the selected menu item
is evaluated and passed through.

Menu item labels can be renamed using `Ctrl`-`LMB` on the socket name or in the node’s *Properties* panel.

Additional input sockets can be added by:
- Dragging a connection onto the empty socket at the bottom of the list.
- Clicking the  icon in the node header.

Unused inputs are not computed, improving performance in complex node networks.
user: What is Common Problems and how is it used in Blender Python scripting?

assistant: ### Unsupported Graphics Driver Error

This means your graphics card and driver do not have the minimum required OpenGL 3.3 version needed by Blender.

Installing the latest version of the correct driver can help upgrade the OpenGL version, though some graphics cards
are simply too old to run the latest Blender. In such cases, using Blender 2.79 or earlier is the only option.
Starting with Blender 2.8 (which added EEVEE), there is less support for older graphics hardware.

### Crash on Startup

Try running Blender from the [command line](../../../advanced/command_line/index.xhtml), to see if any helpful error messages
are printed.

On Windows, graphics drivers can sometimes get corrupted or incorrectly replaced by Windows Update. In this case, it
can help to uninstall all graphics drivers (there may be multiple sets installed from Intel, AMD and NVIDIA) and
perform a clean installation with drivers from the manufacturer’s website.

### Poor Performance

- Update your graphics drivers (see above).
- On laptops, make sure you are using a dedicated GPU (see above).
- Try lowering quality settings in Preferences ‣ System ‣ Memory & Limits.
- Try undoing settings in your graphics drivers, if you made any changes there.

### Render Errors

See [EEVEE](../../../render/eevee/limitations/index.xhtml) and [Cycles](../../../render/cycles/gpu_rendering.xhtml) documentation
respectively.

### Wrong Selection in 3D Viewport

See [Invalid Selection, Disable Anti-Aliasing](../../3d_view.xhtml#troubleshooting-3dview-invalid-selection).

### Virtual Machines

Running Blender inside a virtual machine is known to have problems when OpenGL drawing calls are forwarded to the host
operating system.

To resolve this, configure the system to use PCI passthrough.

Some VM hosts may require turning on GPU paravirtualization. Some GPU vendors restrict this function to higher-priced
cards or models.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

The Edge Split modifier.

Edge Angle
:   When enabled, an edge will be split if the angle between its
    two adjacent faces is greater than the *Split Angle*.

    Split Angle
    :   On 0: all edges are split. On 180: no edges are split.

Sharp Edges
:   When enabled, edges will be split if they were [marked as sharp](../../meshes/editing/edge/edge_data.xhtml#bpy-ops-mesh-mark-sharp).
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Texture Mapping.

Mode
:   The texture transformation will be applied to the stroke/fill or stroke UVs.

    Stroke:
    :   Stroke Fit Method
        :   Selects the texture fitting method.

            Constant Length:
            :   The texture keep a consistent length along the strokes.

            Stroke Length:
            :   The texture is normalized to fit the stroke length.

        UV Offset
        :   Moves the texture along the strokes.

        Rotation
        :   Rotates the points of the strokes.

        Scale
        :   Factor for the texture scale.

    Fill:
    :   Fill Rotation
        :   Sets the texture angle.

        Offset
        :   Moves the texture origin.

            X, Y

        Scale
        :   Factor for the texture scale.

### Influence

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: Explain KeyingSetPath(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # KeyingSetPath(bpy_struct)

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

*class* bpy.types.KeyingSetPath(*bpy_struct*)
:   Path to a setting for use in a Keying Set

    array_index
    :   Index to the specific setting if applicable

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

    data_path
    :   Path to property setting

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

    group
    :   Name of Action Group to assign setting(s) for this path to

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

    group_method
    :   Method used to define which Group-name to use

        Type:
        :   enum in [Keyingset Path Grouping Items](bpy_types_enum_items/keyingset_path_grouping_items.html#rna-enum-keyingset-path-grouping-items), default `'NAMED'`

    id
    :   ID-Block that keyframes for Keying Set should be added to (for Absolute Keying Sets only)

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

    id_type
    :   Type of ID-block that can be used

        Type:
        :   enum in [Id Type Items](bpy_types_enum_items/id_type_items.html#rna-enum-id-type-items), default `'OBJECT'`

    use_entire_array
    :   When an ‘array/vector’ type is chosen (Location, Rotation, Color, etc.), entire array is to be used

        Type:
        :   boolean, default False

    use_insertkey_needed
    :   Only insert keyframes where they’re needed in the relevant F-Curves

        Type:
        :   boolean, default False

    use_insertkey_override_needed
    :   Override default setting to only insert keyframes where they’re needed in the relevant F-Curves

        Type:
        :   boolean, default False

    use_insertkey_override_visual
    :   Override default setting to insert keyframes based on ‘visual transforms’

        Type:
        :   boolean, default False

    use_insertkey_visual
    :   Insert keyframes based on ‘visual transforms’

        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: Describe Precision from the Blender manual or Python API, including usage steps and snippets.

assistant: # Precision

Holding `Ctrl` during a transform operation (such as move, rotate or scale)
will toggle [Transform Snapping](../../../../../editors/3dview/controls/snapping.html).
When using [Increment Snap](../../../../../editors/3dview/controls/snapping.html#bpy-types-toolsettings-snap-elements-base)
this allows the transformation to be performed in discrete amounts.

Holding `Shift` during a transform operation will transform
the object at 1/10th the speed, allowing much finer control.

The magnitude of the transformation can be viewed in the 3D Viewport header.
Releasing `Ctrl` or `Shift` during the transformation will cause
the movement to revert back to its normal mode of operation.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`FileAssetSelectParams.filter_asset_id`](bpy.types.FileAssetSelectParams.html#bpy.types.FileAssetSelectParams.filter_asset_id "bpy.types.FileAssetSelectParams.filter_asset_id") |  |
user: Provide the full official documentation entry for ShaderNodeTangent(ShaderNode), preserving all code examples.

assistant: # ShaderNodeTangent(ShaderNode)

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"), [`ShaderNode`](bpy.types.ShaderNode.html#bpy.types.ShaderNode "bpy.types.ShaderNode")

*class* bpy.types.ShaderNodeTangent(*ShaderNode*)
:   Generate a tangent direction for the Anisotropic BSDF

    axis
    :   Axis for radial tangents

        - `X`
          X – X axis.
        - `Y`
          Y – Y axis.
        - `Z`
          Z – Z axis.

        Type:
        :   enum in [`'X'`, `'Y'`, `'Z'`], default `'X'`

    direction_type
    :   Method to use for the tangent

        - `RADIAL`
          Radial – Radial tangent around the X, Y or Z axis.
        - `UV_MAP`
          UV Map – Tangent from UV map.

        Type:
        :   enum in [`'RADIAL'`, `'UV_MAP'`], default `'RADIAL'`

    uv_map
    :   UV Map for tangent generated from UV

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

    *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: Show practical ways to work with Editing in a Blender add-on or script – include code.

assistant: ### Join in New Frame

Creates a new *Frame* node around the selected nodes.

When called using the shortcut `F`, a popup appears allowing you to assign a custom
[Label](../../node_editors.xhtml#bpy-types-node-label) to the new frame node.
This label is shown as the title of the frame and can be used to describe its contents.

### Add to Frame

Once a frame node is placed, nodes can be added by dropping them onto the frame or
by selecting the node(s) then the frame and using `Ctrl`-`P`.
This can be thought of as Parenting the selection to the frame.

### Remove from Frame

To remove nodes from a frame, select and use `Alt`-`P`.
This can be thought of as unparenting the selection from the frame.
user: Describe Surface Response from the Blender manual or Python API, including usage steps and snippets.

assistant: Friction
:   Resistance of object to movement. Specifies how much velocity is lost when objects collide with each other.

Bounciness
:   Tendency of object to bounce after colliding with another (0 to 1) (rigid to perfectly elastic).
    Specifies how much objects can bounce after collisions.
user: Describe Usage from the Blender manual or Python API, including usage steps and snippets.

assistant: # Usage

For example, we will take an existing blend-file
that was made for monoscopic rendering and transform it to be stereo 3D ready.

[image reference removed]

Creature Factory 2 by Andy Goralczyk rendered in stereo 3D (anaglyph).
user: Describe Inherited Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`FileHandler.bl_idname`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_idname "bpy.types.FileHandler.bl_idname") - [`FileHandler.bl_import_operator`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_import_operator "bpy.types.FileHandler.bl_import_operator") | - [`FileHandler.bl_export_operator`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_export_operator "bpy.types.FileHandler.bl_export_operator") - [`FileHandler.bl_label`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_label "bpy.types.FileHandler.bl_label") - [`FileHandler.bl_file_extensions`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_file_extensions "bpy.types.FileHandler.bl_file_extensions") |
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Value
:   The field to evaluate. Can be a float or a vector depending on the *Data Type*.
    For vector values, variance is computed separately per component (X, Y, Z).

Group ID
:   An index used to group values together for multiple separate variances.
    This can be thought of as a choice of the “bin” in which to place each value.
    This input has no effect when it is only a single value.
user: Explain Fillet Curve Node in complete detail according to the official Blender documentation.

assistant: # Fillet Curve Node

[image reference removed]

The *Fillet Curve* rounds corners on curve control points, similar to the effect of
the [Bevel Modifier](../../../modifiers/generate/bevel.html) on a 2D mesh.
However, a key difference is that the rounded portions created by the Fillet Curve node
are always portions of a circle.
user: Explain Error Messages in complete detail according to the official Blender documentation.

assistant: Vertex group *group_name* is not valid
:   This message is displayed when a user deletes the vertex group or changes its name.

Vertices changed from X to Y
:   This message is displayed when a user adds or deletes vertices to/from the mesh.

Edges changed from X to Y
:   This message is displayed when a user adds or deletes edges to/from the mesh.

The system did not find a solution
:   This message is displayed if the solver could not find a solution for the linear system.
user: Explain Example in complete detail according to the official Blender documentation.

assistant: ### Fade To Black

To transition the audience from one scene or shot to another,
a common technique is to “fade to black”. As its name implies,
the scene fades to a black screen. You can also “fade to white” or whatever color you wish,
but black is a good neutral color that is easy on the eyes and intellectually “resets” the viewer’s mind.
The node tree below shows how to do this using the Set Alpha node.

[image reference removed]

Fade to black.

In the example above, the alpha channel of the swirl image is ignored.
Instead, a [Time Curve node](../input/scene/time_curve.xhtml)
introduces a factor from 0.0 to 1.0 over 60 frames, or about 2 seconds,
to the Set Alpha node. Note that the time curve is exponentially-shaped,
so that the overall blackness will fade in slowly and then accelerate toward the end.
The Set Alpha node does not need an input image; instead, the flat (shadeless) black color is used.
The Set Alpha Node uses the input factor and color to create a black image that has an alpha
set which goes from 0.0 to 1.0 over 60 frames, or completely transparent to completely opaque.
Think of alpha as a multiplier for how vivid you can see that pixel.
These two images are combined by the Alpha Over node completely (a *Factor* of 1.0)
to produce the composite image. The Set Alpha node will thus, depending on the frame being rendered,
produce a black image that has some amount of transparency.
Setup and animate, and you have an image sequence that fades to black over a two-second period.

### Fade In a Title

To introduce your animation,
you will want to present the title of your animation over a background.
You can have the title fly in, or fade it in. To fade it in,
use the Set Alpha node with the Time Curve node as shown below.

[image reference removed]

Using Set Alpha to fade in a title.

In the above example, a Time curve provides the Alpha value to the input socket.
The current Render Layer node, which has the title in view, provides the image. As before,
the Alpha Over node mixes (using the alpha values)
the background swirl and the alpha title to produce the composite image.

### Colorizing a BW Image

[image reference removed]

Using Set Alpha to colorize an image.

In the example above, notice how the blue tinge of the render input colors the swirl.
You can use the Set Alpha node’s color field with this kind of node tree to add a consistent color to a BW image.

In the example tree to the right,
use the *Alpha* value of the Set Alpha node to give a desired degree of colorization.
Thread the input image and the Set Alpha node into an Alpha Over node to colorize
any black-and-white image in this manner.
user: Give a detailed overview of Limitations: syntax, arguments, return values, common patterns.

assistant: The following selections are not supported by the rip operator and will give an error message:

- Face(s), including when selecting vertices or edges that form up a face.
- Edges or vertices that are not “between” two faces (non [Manifold](../../../../glossary/index.xhtml#term-Manifold)).
- Two vertices that aren’t connected to each other.
user: How do I use A Bouncing Cube in Blender? Include parameters, examples, warnings and best practices.

assistant: ### The Process

First, change your start and end frames to 1 and 150.

Then, add a plane, and scale it five times. Next, go to the physics tab, and add a collision.
The default settings are fine for this example.

Now add a cube, or use the default cube, then enter *Edit Mode* to subdivide it three times.
Add a Bevel Modifier to it to smoothen the edges and then to add a little more,
press `R` twice, and move your cursor a bit.

When finished, your scene should look like this:

[image reference removed]

The scene, ready for soft body physics.

Everything is ready to add the soft body physics.
Go to Properties ‣ Physics and choose *Soft Body*.
Uncheck the *Soft Body Goal*, and check *Soft Body Self Collision*.
Also, under *Soft Body Edges*, increase the Bending to 10.

Playing the animation will now give a slow animation of a bouncing cube.
To speed things up, we need to bake the soft body physics.

Under *Soft Body Cache* change the values of your start and end frames. In this case 1 and 150.
Now, to test if everything is working, you can take a cache step of 5 or 10,
but for the final animation it is better to reduce it to 1, to cache everything.

When finished, your physics panel should look like this:

[image reference removed]

The physics cache settings.

[image reference removed]

The physics edges and self collision settings.

You can now bake the simulation, give the cube materials and textures and render the animation.

### The Result

[The rendered bouncing cube](https://www.youtube.com/watch?v=3PzgB9jw9iA)
user: Explain GeometryNodeInputIndex(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeInputIndex(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.GeometryNodeInputIndex(*GeometryNode*)
:   Retrieve an integer value indicating the position of each element in the list, starting at zero

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

assistant: When you are happy with your changes, you can upload them, so that they will be in the online manual. At first, this
is done by submitting patches so that someone can review your changes and give you feedback. After, you can commit
your changes directly. This process is described in detail in the next section.
user: Describe Controls from the Blender manual or Python API, including usage steps and snippets.

assistant: Sculpt mode provides several properties that give advanced control of the tool’s behavior.
These options can be found in the right-hand side of the 3D Viewport’s Header.

Mirror
:   Allows tools to affect curves symmetrically according to the chosen axis.

Use Sculpt Collision
:   Prevents the curve segments from passing through the [Surface Object](../../modeling/curves_new/properties.xhtml#bpy-types-curves-surface).
user: Show practical ways to work with Scale in a Blender add-on or script – include code.

assistant: # Scale

Scaling means changing proportions of objects. Pressing `S` will enter
the *Scale* transformation mode where the selected element is scaled inward or
outward according to the mouse pointer’s location. The element’s scale will
increase as the mouse pointer is moved away from the Pivot Point and decrease as
the pointer is moved towards it. If the mouse pointer crosses from the original side of
the [Pivot Point](../../../../editors/3dview/controls/pivot_point/index.xhtml)
to the opposite side, the scale will continue in the negative direction and flip the element.

[image reference removed]

Basic scale usage. From left to right, the panels show: the original object,
a scaled down object, a scaled up object and a scale-flipped object.

The amount of scaling will be displayed in the header of the 3D Viewport.

[image reference removed]

Scale values.
user: Provide the full official documentation entry for Components of a Catalog, preserving all code examples.

assistant: Each catalog consists of a *catalog path*, a *UUID*, and a *simple name*.
Normally you would only deal with the catalog path; the rest is for internal Blender
use and/or for emergency situations.

### Catalog Path

The path of a catalog determines where in the catalog hierarchy the catalog is shown.
Examples are `Characters/Ellie/Poses/Hand` or `Kitbash/City/Skyscrapers`,
which would result in the following catalog tree.
The highlighted catalog has path `Characters/Ellie/Poses/Hand`.

[[image reference removed]](../../_images/asset-catalog-tree.png)

Example tree of asset catalogs.

### UUID

Each catalog has a [UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier),
which is normally hidden from the user interface
(enable Developer Extras and the experimental Asset Debug Info option to see them).
This is what is stored in the asset, and what determines the “identity” of the catalog.
As a result, a catalog can be renamed or moved around (i.e. you can change its path),
and all assets that are contained in it will move along with it.
This only requires a change to the catalog itself, and not to any asset blend-file.

### Simple Name

Each catalog has an optional *simple name*. This name is stored along with the UUID in each asset.
The purpose is to make it possible for humans to recognize the catalog the asset was assigned to,
even when the *catalog definition file* (see below) is lost.

Like the UUID, the simple name is normally hidden from the user interface.
Enable Developer Extras in the interface preferences to make it visible in the Asset Browser.
user: Describe Propagate to Shapes from the Blender manual or Python API, including usage steps and snippets.

assistant: # Propagate to Shapes

The *Propagate to Shapes* operator applies the current positions of the selected vertices
to all other [shape keys](../../../../animation/shape_keys/index.xhtml) on the object.
This allows edits made in *Edit Mode* to be consistently transferred across every shape key.

This is useful for:

- Correcting vertex positions that should be the same in all shape keys.
- Fixing topology issues or small modeling mistakes without manually editing each shape key.
- Ensuring consistent base structure across shape key variations.
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Unsigned Angle
:   The shortest angle in radians between two faces where they meet at an edge.
    The range of the data is from zero to PI. Flat edges and [Non-manifold](../../../../glossary/index.html#term-Non-manifold)
    edges have an angle of zero. An edge between two faces completely folded
    back on each other has an angle of PI, or 180 degrees.

Signed Angle
:   The signed angle in radians between two faces where they meet at an edge. Flat edges
    and Non-manifold edges have an angle of zero. Concave angles are positive and convex
    angles are negative.
user: What is MovieTrackingReconstruction(bpy_struct) and how is it used in Blender Python scripting?

assistant: # MovieTrackingReconstruction(bpy_struct)

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

*class* bpy.types.MovieTrackingReconstruction(*bpy_struct*)
:   Match-moving reconstruction data from tracker

    average_error
    :   Average error of reconstruction

        Type:
        :   float in [-inf, inf], default 0.0, (readonly)

    cameras
    :   Collection of solved cameras

        Type:
        :   [`MovieTrackingReconstructedCameras`](bpy.types.MovieTrackingReconstructedCameras.html#bpy.types.MovieTrackingReconstructedCameras "bpy.types.MovieTrackingReconstructedCameras") [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`MovieReconstructedCamera`](bpy.types.MovieReconstructedCamera.html#bpy.types.MovieReconstructedCamera "bpy.types.MovieReconstructedCamera"), (readonly)

    is_valid
    :   Whether the tracking data contains valid reconstruction information

        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: How do I use Make Vertex Parent in Blender? Include parameters, examples, warnings and best practices.

assistant: # Make Vertex Parent

Creates a parent-child relationship between the active object and selected vertex or triangle from the edited mesh.

This operator is used to make the active object follow a vertex (or triangle of vertices) on the edited mesh,
so that when the vertex moves, the child object follows.
This is particularly useful for attaching objects to deforming geometry,
such as having an accessory follow a character mesh during animation.
user: How do I use Transform Orientation in Blender? Include parameters, examples, warnings and best practices.

assistant: # Transform Orientation

The *Transform Orientation* determines the orientation of the
[Object Gizmo](../display/gizmo.xhtml).
Changing this orientation can make it easier to perform
transformations in the direction you want.

[image reference removed]

With the default Global transform orientation (left) it’s tricky to
move the plane in the direction it’s facing, but with Local (right)
it’s easy.

The Transform Orientation can be changed using a
selector in the 3D Viewport’s header:

[image reference removed]

Transform Orientation selector.

The orientation can also be changed temporarily while performing
a hotkey-based transformation with
[axis locking](../../../scene_layout/object/editing/transform/control/axis_locking.xhtml).
For example, if you first press `G` to start moving an object,
then `X` to lock to the orientation’s X axis, and finally `X` a second time,
you’ll get a lock to an alternative orientation:
the Local orientation if it was Global previously, and the Global orientation
otherwise.

In addition to the builtin orientations,
you can also define your own (see [Custom Orientations](#custom-orientations) below).
user: What is Brush Gpencil Weight Types Items and how is it used in Blender Python scripting?

assistant: # Brush Gpencil Weight Types Items

WEIGHT:
:   Weight.

    Paint weight in active vertex group.

BLUR:
:   Blur.

    Blur weight in active vertex group.

AVERAGE:
:   Average.

    Average weight in active vertex group.

SMEAR:
:   Smear.

    Smear weight in active vertex group.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: The inputs are dynamic, they become available if needed depending on the node properties.

Vector
:   Vector used as seed in 2D, 3D, and 4D dimensions.

W
:   Value used as seed in 1D and 4D dimensions.
user: Describe Debug from the Blender manual or Python API, including usage steps and snippets.

assistant: Undo Legacy
:   Use legacy undo (slower than the new default one, but may be more stable in some cases).

No Override Auto Resync
:   Disables library overrides automatic resync detection and process on file load.
    Enable when dealing with older blend-files that need manual Resync (Enforce) handling.

Cycles Debug
:   Show the Cycles rendering debug panel.

Asset Debug Info
:   Enable some extra fields in the Asset Browser to aid debugging.

Asset Indexing
:   Disabling the asset indexer forces every asset library refresh to completely reread assets from disk.

Viewport Debug
:   Enable viewport debugging options for developers in the overlays pop-over.

EEVEE Debug
:   Enable EEVEE debugging options for developers.
user: What is Visibility Control and how is it used in Blender Python scripting?

assistant: Parts of the mesh can be hidden in Sculpt Mode.
Because hidden faces cannot be sculpted, hiding makes it easier to isolate what you want to work on.
Hiding geometry also improves the viewport performance.

Hiding is shared between all modes, except Object Mode
(i.e. hiding/showing of faces in one mode will hide the same faces in other modes too).

Unlike [Selection Masking](../../selection_visibility.xhtml) in other painting modes,
Sculpt Mode primarily uses Masks and Face Sets to easily control the mesh visibility
and which faces can currently be edited.
The exception is the [Clipping Region](../../selection_visibility.xhtml#clipping-region), which can be used in any mode.

The most common shortcuts are `H` to hide the face set under the cursor
and `Shift`-`H` to isolate the face set under the cursor (or show everything).

[Inverting the visibility](../editing/sculpt.xhtml#bpy-ops-sculpt-face-set-change-visibility)
and [showing all](../editing/sculpt.xhtml#bpy-ops-paint-hide-show-all) is also available in the `Alt`-`W` pie menu.

Modifying visibility can also be done via the [Hide Gesture Tools](../tools/hide_tools.xhtml).
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: [image reference removed]

Copy Location constraint.

[Target](../interface/common.xhtml#rigging-constraints-interface-common-target)
:   The object or bone whose location to copy.

Axis
:   The axes for which to copy location coordinates.

Invert
:   The axes for which invert the sign (so a coordinate of 10 becomes -10 and vice versa).

Offset
:   When enabled, the target’s current position (from all its constraints) is not copied over,
    but added to the owner’s original position (from its preceding constraints).

[Target/Owner](../interface/common.xhtml#rigging-constraints-interface-common-space)
:   The spaces for retrieving the coordinates from the target and for applying them to the owner.

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: How do I use Spin in Blender? Include parameters, examples, warnings and best practices.

assistant: # Spin

The *Spin* tool extrudes (or duplicates it if the selection is manifold) the selected elements,
rotating around a specific point and axis.

Use the tool to create the sort of objects that you would produce on a lathe
(this tool is often called “lathe” tool or “sweep” tool in the literature, for this reason).
In fact, it does a sort of circular extrusion of your selected elements,
centered on the 3D cursor, and around the axis perpendicular to the working view…

- The point of view will determine around which axis the extrusion spins…
- The position of the 3D cursor will be the center of the rotation.
user: Describe Viewport from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| `Alt`-`LMB` | Orbit View |
| `Alt`-`MMB` | Pan View |
| `Alt`-`RMB` | Zoom View |
| `F1` - `F4` | Front/Side/Top/Camera Viewpoints |
| `F` | Frame Selected |
| `Shift` `F` | Center View to Mouse |
| `A` | Frame All |
user: Show practical ways to work with Inpaint Node in a Blender add-on or script – include code.

assistant: # Inpaint Node

[image reference removed]

The *Inpaint node* is used to extend borders of an image into transparent or masked regions.
This can be useful to solve problems like “wire removal” and holes created during chroma keying.
user: Explain Overview in complete detail according to the official Blender documentation.

assistant: Closures are a socket type that represent callable node graphs.
They define a set of inputs and outputs that can be evaluated inside another node group through the
[Evaluate Closure](../../../../interface/controls/nodes/types/utilities/closure/evaluate_closure.xhtml) node.

When a closure is connected, its internal node graph is *injected* into the evaluation of the node group where it is
used. This allows procedural systems to remain flexible while exposing clear, customizable control points.

Closures can be thought of as function parameters for node groups.
They let users define operations that can be executed in a controlled environment defined by the parent node tree.
user: Provide the full official documentation entry for Legacy Intel HD 4000/5000, preserving all code examples.

assistant: When running on Intel 3rd, 4th or 5th gen iGPUs, the latest Intel driver will crash on startup. In order to start
Blender try to install a previous version of the driver. Drivers that are known to work are:

- 20.19.15.4835
- 20.19.15.4963
- 20.19.15.5063

Drivers that are known to fail are:

- 20.19.15.5126
- 20.19.15.5144
- 20.19.15.5166
- 20.19.15.5171

[Download older Intel Drivers](https://www.intel.com/content/www/us/en/support/articles/000089377/graphics.html)
user: Show practical ways to work with VIEW3D_AST_brush_sculpt_curves(AssetShelf) in a Blender add-on or script – include code.

assistant: # VIEW3D_AST_brush_sculpt_curves(AssetShelf)

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

*class* bpy.types.VIEW3D_AST_brush_sculpt_curves(*AssetShelf*)
:   *classmethod* brush_type_poll(*context*, *asset*)

    *static* draw_popup_selector(*layout*, *context*, *brush*, *show_name=True*)

    *static* get_shelf_name_from_context(*context*)

    *classmethod* has_tool_with_brush_type(*context*, *brush_type*)

    *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: Describe Pan from the Blender manual or Python API, including usage steps and snippets.

assistant: Pans the 3D Viewport by moving the view left, right, up, or down without rotating it.
This is useful for repositioning your view without changing orientation.

- `Shift`-`MMB` – Pan the view freely by dragging the mouse.
- `Shift`-`WheelUp` / `Shift`-`WheelDown` – Pan the view vertically.
- `Shift`-`WheelLeft` / `Shift`-`WheelRight` – Pan the view horizontally.
- `Ctrl`-`Numpad8` / `Ctrl`-`Numpad2` – Pan the view up/down in fixed steps.
- `Ctrl`-`Numpad4` / `Ctrl`-`Numpad6` – Pan the view left/right in fixed steps.
user: Give a detailed overview of Addons(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # Addons(bpy_struct)

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

*class* bpy.types.Addons(*bpy_struct*)
:   Collection of add-ons

    *classmethod* new()
    :   Add a new add-on

        Returns:
        :   Add-on data

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

    *classmethod* remove(*addon*)
    :   Remove add-on

        Parameters:
        :   **addon** ([`Addon`](bpy.types.Addon.html#bpy.types.Addon "bpy.types.Addon"), (never None)) – Add-on 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: Give a detailed overview of Node Bundles: syntax, arguments, return values, common patterns.

assistant: # Node Bundles

A *bundle* is a container that groups multiple values into one socket.
This makes it possible to pass many values through
a single link, similar to a *struct* in programming.

Bundles reduce the number of exposed inputs and outputs in a node group,
and can contain mixed data types such as geometry, fields, values, objects,
or even nested bundles.

[image reference removed]

A cube and cylinder combined into a bundle, then separated again.
user: Describe Curve Segment from the Blender manual or Python API, including usage steps and snippets.

assistant: # Curve Segment

The *Curve Segment* node provides information about the segment connecting
each point on a curve to its previous point.
It is useful for analyzing or manipulating per-segment data, such as length,
direction, or connectivity, and for constructing effects that depend on local curve structure.
user: How do I use Q in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [**Quad**](glossary/index.xhtml#term-Quad) - [**Quadrangle**](glossary/index.xhtml#term-Quadrangle) | - [**Quadrilateral**](glossary/index.xhtml#term-Quadrilateral) - [**Quaternion**](glossary/index.xhtml#term-Quaternion) - [**Quaternion Rotation**](glossary/index.xhtml#term-Quaternion-Rotation) |