PGCRYPT/OpenBlender_Train huggingface dataset:
user: Give a detailed overview of Waves: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Brush Waves panel.

This panel is used to adjust brush influence to “Wave” surfaces.

Wave Type
:   Select what effect the brush creates in the wave simulation.

    Depth Change:
    :   The brush create waves when the intersection depth with the surface is *changed* on that point.
        If the brush is not moved, it will have no effect.

        Using a negative “Factor” with this type can create a nice looking “wake” for moving objects like ships.

    Obstacle:
    :   Constantly affects surface whenever intersecting.
        Waves are also reflected off this brush type.
        However, due the nature of wave simulation algorithm this type creates
        an unnatural “dent” in the surface if the brush is not moved.

    Force:
    :   Directly affects the velocity of wave motion.
        Therefore the effect is not one-to-one with brush intersection depth, yet the force strength depends on it.

    Reflect Only:
    :   This type has no visible effect on the surface alone but reflects waves that are already on the surface.

Factor
:   Adjusts how strongly brush “depth” affects the simulation.
    You can also use negative values to make brush pull water up instead of down.

Clamp Waves
:   In some cases the brush goes very deep inside the surface messing whole simulation up.
    You can use this setting to “limit” influence to only certain depth.
user: Explain Legacy vs Extension Add-ons in complete detail according to the official Blender documentation.

assistant: With the introduction of Extensions in Blender 4.2, the old way of creating add-ons is considered deprecated.
While the changes are rather small they impact existing add-ons.

In order to allow a smooth transition process, the so-called legacy add-ons will continue to be supported by Blender.
They can be installed via [Install legacy Add-on](../../editors/preferences/addons.xhtml#prefs-extensions-install-legacy-addon) button in the User
Preferences.

All add-on maintainers are urged to convert the add-ons they want to share, so they are future proof and can support
features like updating from the extensions platform.

### Converting a Legacy Add-on into an Extension

1. Create a [manifest file](getting_started.xhtml#extensions-getting-started).
2. Remove the `bl_info` information (this is now in the manifest).
3. Replace all references to the module name to `__package__`.
4. Make all module imports to use relative import.
5. Use [wheels](https://pythonwheels.com/) to pack your external Python dependencies.
6. Remember to test it thoroughly.

### Extensions and Namespace

The legacy add-ons would use their module name to access the preferences. This could lead to a name clash when
extensions with the same name (from different repositories) would be installed.
To prevent this conflict, the repository name is now part of the namespace.

For example, now instead of `kitsu` the module name would be `bl_ext.{repository_module_name}.kitsu` instead.

This has a few implications for preferences and module imports.

#### User Preferences and `__package__`

Add-ons can define their own preferences which use the package name as an identifier.
This can be accessed using `__package__`.

This was already supported in the legacy add-ons, but not reinforced.
As such this can break backward compatibility.

Before:

> ```
> class KitsuPreferences(bpy.types.AddonPreferences):
>     bl_idname = "kitsu"
>     # ... snip ...
>
> # Access with:
> addon_prefs = bpy.context.preferences.addons["kitsu"]
> ```

Now:

> ```
> class KitsuPreferences(bpy.types.AddonPreferences):
>     bl_idname = __package__
>     # ... snip ...
>
> # Access with:
> addon_prefs = bpy.context.preferences.addons[__package__]
> ```

Sub-packages
:   An add-on that defines sub-packages (sub-directories with their own `__init__.py` file)
    that needs to use this identifier will have to import the top-level package using a relative import.

    ```
    from .. import __package__ as base_package
    ```

    Then `base_package` can be used instead of `__package__`.
    The `..` imports relative to the packages parent, sub-sub-packages must use `...` and so on.

#### Relative Imports

> before:
> :   `from kitsu import utils`
>
> now:
> :   `from . import utils`

Importing packages within the add-on module need to use relative paths.
This is a standard Python feature and only applicable for add-ons that have multiple folders.

This was already supported in the legacy add-ons, but not reinforced. As such this can break backward compatibility.
user: Describe Extrude from the Blender manual or Python API, including usage steps and snippets.

assistant: # Extrude

This operators shown in this menu are dependent of what part of a mesh is currently selected.
Many of the operators are also available in the [Vertex](../vertex/index.html),
[Edge](../edge/index.html), and [Face](../face/index.html) menus.
user: Explain Save Copy in complete detail according to the official Blender documentation.

assistant: Choose a file path to save the blend-file to, but return to editing the original file upon completion.
This can be used to save backups of the current working state without modifying the original file.

For options see [Save As](#bpy-ops-wm-save-as-mainfile).
user: Provide the full official documentation entry for Extrude to Cursor or Add, preserving all code examples.

assistant: # Extrude to Cursor or Add

Interactively places new vertices with `Ctrl`-`RMB` at the mouse cursor position.

The most basic element, a vertex, can be added with a `Ctrl`-`RMB` click
when no other vertices are selected.
Because the camera space (computer screen) is two-dimensional,
Blender cannot determine all three vertex coordinates from a single mouse click,
so the new vertex is placed at the depth of the 3D cursor.

To create interconnected vertices, you can add a vertex and continuously make subsequent `Ctrl`-`RMB`
operations with the last vertex selected.
This will link the last selected vertex with the vertex created at the mouse position with an edge
(see Fig. [Adding vertices one by one.](#fig-mesh-basics-add-one)),
and will continuously create and connect new vertices if you continue repeating this operation.

[image reference removed]

Adding vertices one by one.
user: Explain Notes in complete detail according to the official Blender documentation.

assistant: In some configurations of the node, especially for low values of *Randomness*,
rendering artifacts may occur. This happens due to the same reasons described
in the [Notes section](white_noise.xhtml#shader-white-noise-notes) in the White Noise Texture page
and can be fixed in a similar manner as described there.
user: What is Add Curves and how is it used in Blender Python scripting?

assistant: # Add Curves

Used to distribute new curves on the surface mesh.
This tool requires the curve to have a [surface](../introduction.xhtml) object set.

The curves follow the surface normals. Using the interpolation options allows the brush to take the characteristics
of existing curves.
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

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

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

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

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

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

Clamp Result (Color only)
:   Limit the Result to the range between 0.0 and 1.0.
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Uniform
:   Normalized coordinates centered at zero, scaled based on the image’s largest dimension.
    This is useful for procedural effects that need aspect-ratio-independent coordinates,
    similar to *Object* coordinates in shader nodes.

Normalized
:   Normalized coordinates ranging from 0 to 1 across the image dimensions,
    with half-pixel offsets to align with pixel centers.

Pixel
:   Pixel-space coordinates representing the center position of each pixel.
    These are integer-based coordinates with a half-pixel offset applied.
user: How do I use Pivot Constraint in Blender? Include parameters, examples, warnings and best practices.

assistant: # Pivot Constraint

The *Pivot* constraint makes an object or bone rotate around a point other than
its [origin](../../../scene_layout/object/origin.html). This can be a point that’s relative
to the same or another object/bone, or a point that’s fixed in space.
user: How do I use Examples in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

The difference between *F1* and *Smooth F1* can be used to create beveled Voronoi cells.

[image reference removed]

Creating a hammered metal shader using the *Voronoi Texture* node.
user: Show practical ways to work with I in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [**IK**](glossary/index.xhtml#term-IK) - [**Index of Refraction**](glossary/index.xhtml#term-Index-of-Refraction) | - [**Interpolation**](glossary/index.xhtml#term-Interpolation) - [**Inverse Kinematics**](glossary/index.xhtml#term-Inverse-Kinematics) - [**IOR**](glossary/index.xhtml#term-IOR) |
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`ParticleSettings.active_instanceweight`](bpy.types.ParticleSettings.html#bpy.types.ParticleSettings.active_instanceweight "bpy.types.ParticleSettings.active_instanceweight") | - [`ParticleSettings.instance_weights`](bpy.types.ParticleSettings.html#bpy.types.ParticleSettings.instance_weights "bpy.types.ParticleSettings.instance_weights") |
user: Show practical ways to work with Select Invert in a Blender add-on or script – include code.

assistant: Inverts the selection state of each point in the point cloud:

- Points that were selected become deselected.
- Points that were not selected become selected.

This operator is useful for quickly selecting the opposite subset of points in your current selection.
user: Provide the full official documentation entry for Volume, preserving all code examples.

assistant: Some phenomena of real-world hair can be simulated more efficiently using a volumetric model instead
of the basic geometric strand model. This means constructing a regular grid such as those used in
fluid simulations and interpolating hair properties between the grid cells.

Air Drag
:   Controls how thick the air is around the hair causing the hair to flow slower.

Internal Friction
:   Amount of friction between individual hairs.

Voxel Grid Cell Size
:   Size of the voxel grid cells for interaction effects.

Density Target
:   Maximum density of the hair.

Density Strength
:   The influence that the *Density Target* has on the simulation.
user: Show practical ways to work with Kerning in a Blender add-on or script – include code.

assistant: Font kerning is the space between individual characters.

Decrease Kerning `Alt`-`Left`
:   Decreases the spacing between the characters on either side of the cursor.

Increase Kerning `Alt`-`Right`
:   Increase the spacing between the characters on either side of the cursor.

Reset Kerning
:   Sets the spacing between the characters on either side of the cursor to their initial value.
user: How do I use Toggle Bold, Italics, Underline, Small Caps in Blender? Include parameters, examples, warnings and best practices.

assistant: To apply the *Bold*, *Italics*, *Underline* or *Small Caps* attribute to a set of characters,
you either turn on the related setting prior to typing characters,
or select existing text, and then toggle desired style from the menu.
user: Show practical ways to work with Inherited Properties in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`BoidRule.name`](bpy.types.BoidRule.html#bpy.types.BoidRule.name "bpy.types.BoidRule.name") - [`BoidRule.type`](bpy.types.BoidRule.html#bpy.types.BoidRule.type "bpy.types.BoidRule.type") | - [`BoidRule.use_in_air`](bpy.types.BoidRule.html#bpy.types.BoidRule.use_in_air "bpy.types.BoidRule.use_in_air") - [`BoidRule.use_on_land`](bpy.types.BoidRule.html#bpy.types.BoidRule.use_on_land "bpy.types.BoidRule.use_on_land") |
user: Describe Separate Spherical Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Separate Spherical Node

[image reference removed]

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

Spherical coordinates describe a position in 3D space using radius, azimuth (horizontal angle),
and polar (vertical) angle. This representation is useful for procedural effects involving
rotational symmetry, spherical gradients, or direction-based transformations.
user: What is Text & Search Fields and how is it used in Blender Python scripting?

assistant: [image reference removed]

A text and a search field.

Text fields show a rounded rectangular border, and optionally an icon and/or text inside the border.
Text fields store text strings, and provide the means to edit text by standard text editing shortcuts:

|  |  |
| --- | --- |
| `Home` | Go to the start of the line. |
| `End` | Go to the end of the line. |
| `Left`, `Right` | Move the cursor a single character. |
| `Ctrl`-`Left`, `Ctrl`-`Right` | Move the cursor an entire word. |
| `Backspace`, `Delete` | Delete characters. |
| `Ctrl`-`Backspace`, `Ctrl`-`Delete` | Delete words. |
| `Shift` | Select while holding the key and moving the cursor. |
| `Ctrl`-`A` | Select all text. |
| `Ctrl`-`C` | Copy the selected text. |
| `Ctrl`-`X` | Cut the selected text. |
| `Ctrl`-`V` | Paste text at the cursor position. |

For text fields with an icon and pop-ups, see [Data ID](../templates/data_block.html#ui-data-id).
user: Show practical ways to work with Make Vertex Parent in a Blender add-on or script – include code.

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

assistant: Open the Command Prompt, go to the directory where Blender is installed,
and then run Blender:

```
cd c:\<blender installation directory>
blender
```

You can also add the Blender folder to your system `PATH` so that you do not have to `cd` to it each time.
user: Explain Getting Help in complete detail according to the official Blender documentation.

assistant: If you’re unsure about a change, formatting, or workflow, don’t hesitate to ask questions:

- Join the [Blender Chat #docs](https://chat.blender.org/#/room/#docs:blender.org) channel.
- Open an issue at the [documentation project](https://projects.blender.org/blender/documentation)
  for broader discussions or complex questions.

Thank you for helping improve Blender’s documentation!
user: How do I use Interface in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Header Menus

#### View Menu

Zoom In / Zoom Out
:   Increases/decreases the font size.

Move to Previous Word `Ctrl`-`Left`
:   Moves the cursor to the beginning of the previous word.
    If the cursor is in the middle of a word, the cursor is moved to the beginning of the current word.

Move to Next Word `Ctrl`-`Right`
:   Moves the cursor to the end of the next word.
    If the cursor is in the middle of a word, the cursor is moved to the end of the current word.

Move to Line Begin `Home`
:   Moves the cursor to the start of the current line.

    `Shift`-`Home`: Selects all text between the cursor and the start of the current line.

Move to Line End `End`
:   Moves the cursor to the end of the current line.

    `Shift`-`End`: Selects all text between the cursor and the end of the current line.

#### Console Menu

Clear All
:   Refreshes the console, giving the view a fresh start.
    Note that command history is not cleared.

Clear Line `Shift`-`Return`.
:   Removes everything from the prompt line.

Delete Previous Word `Ctrl`-`Backspace`
:   Deletes everything between the cursor and the beginning of the previous word (separated by periods).
    If the cursor is in the middle of a word, deletes everything to the beginning of the current word.

Delete Next Word `Ctrl`-`Delete`
:   Deletes everything between the cursor and the end of the next word.
    If the cursor is in the middle of a word, deletes everything to the end of the current word.

Copy as Script `Shift`-`Ctrl`-`C`
:   Copies the full history buffer to the clipboard.
    This can be pasted into a text file to be used as a Python script.

Cut `Ctrl`-`X`
:   Copies the selected text into the clipboard and deletes it.

Copy `Ctrl`-`C`
:   Copies the selected text into the clipboard.

Paste `Ctrl`-`V`
:   Pastes into the command line.

Indent `Tab`
:   Inserts a tab character at the cursor.

Unindent `Shift`-`Tab`
:   Unindents the selection.

Backward in History `Up`
:   Changes the current command to the previous one from the command history.

Forward in History `Down`
:   Changes the current command to the next one from the command history.

Autocomplete `Tab`
:   See [Auto Completion](#auto-completion).

### Main View

Key Bindings

- `LMB` – Moves the cursor along the input line.
- `Left` / `Right` – Moves the cursor by one character.
- `Ctrl`-`Left` / `Ctrl`-`Right` – Moves the cursor by one word.
- `Shift`-`Left` / `Shift`-`Right` – Selects characters to the left/right.
- `Shift`-`Ctrl`-`Left` / `Shift`-`Ctrl`-`Right` – Selects words to the left/right.
- `Ctrl`-`A` Selects all text and text history.
- `Backspace` / `Delete` – Erase characters.
- `Ctrl`-`Backspace` / `Ctrl`-`Delete` – Erase words.
- `Return` – Execute command.
- `Shift`-`Return` – Add to command history without executing.
user: Give a detailed overview of Light Probes: syntax, arguments, return values, common patterns.

assistant: - EEVEE supports up to 128 active light probe spheres.
- EEVEE supports up to 16 active light probe planes inside the view frustum.
- Active light probe volumes must fit inside the
  [Light Probes Volume Memory Pool](../render_settings/performance.xhtml#bpy-types-sceneeevee-gi-irradiance-pool-size).
user: Give a detailed overview of Render: syntax, arguments, return values, common patterns.

assistant: SMAA Threshold
:   Threshold for the edge detection algorithm used to correct aliasing for the final render,
    Higher values may result in loss of detail due to excessive blurring.

SSAA Samples
:   Number of samples used for super-sampling anti-aliasing in the final render.
    Higher values produce smoother lines but increase render time.

Motion Blur Steps
:   Controls accuracy of [motion blur](../../../glossary/index.html#term-Motion-Blur), more steps result in longer render time.
    Only used when [Motion Blur](../../cycles/render_settings/motion_blur.html#bpy-types-rendersettings-use-motion-blur) is enabled.
    Set to 0 to disable motion blur for Grease Pencil objects.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Geometry
:   Standard geometry input.

Selection
:   Boolean field indicating which elements to scale.

Scale
:   The scaling factor for each element.

Center
:   The pivot point for each element.

Axis Single Axis Mode Only
:   Axis along which to scale each element. This vector is normalized internally, so the length does not matter.

Scale Mode
:   Uniform:
    :   Scale elements by the same factor in every direction.

    Single Axis:
    :   Scale elements in a single direction defined by the *Axis* input.
user: Explain CollectionChildren(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # CollectionChildren(bpy_struct)

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

*class* bpy.types.CollectionChildren(*bpy_struct*)
:   Collection of child collections

    link(*child*)
    :   Add this collection as child of this collection

        Parameters:
        :   **child** ([`Collection`](bpy.types.Collection.html#bpy.types.Collection "bpy.types.Collection"), (never None)) – Collection to add

    unlink(*child*)
    :   Remove this child collection from a collection

        Parameters:
        :   **child** ([`Collection`](bpy.types.Collection.html#bpy.types.Collection "bpy.types.Collection")) – Collection to remove

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use Examples in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

The Cube object was linked duplicated.

The object `Cube` was linked duplicated, using `Alt`-`D`.
Though both these cubes are separate objects with unique names:
`Cube` and `Cube.001`, the single mesh named `Cube`, is shared by both.

- As a mesh is edited in *Edit Mode* in one object, the same occurs in
  the other cube as well. The mesh data are links, not copies.
- In contrast, if one of these two cubes is rotated or scaled in *Object Mode*,
  the other remains unchanged. The transform properties are copied, not linked.
- As in the previous example, the newly created cube has inherited
  the material of the original cube. The material properties are linked, not copied.

A common table has a top and four legs. Model one leg, and then make linked duplicates
three times for each of the remaining legs. If you later make a change to the mesh,
all the legs will still match. Linked duplicates also apply to a set of drinking glasses,
wheels on a car… anywhere there is repetition or symmetry.
user: Describe CompositorNodeEllipseMask(CompositorNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CompositorNodeEllipseMask(CompositorNode)

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

*class* bpy.types.CompositorNodeEllipseMask(*CompositorNode*)
:   Create elliptical mask suitable for use as a simple matte or vignette mask

    *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")

    update()

    *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 Beztriple Interpolation Mode Items: syntax, arguments, return values, common patterns.

assistant: # Beztriple Interpolation Mode Items

**Interpolation**

Standard transitions between keyframes.

CONSTANT:
:   Constant.

    No interpolation, value of A gets held until B is encountered.

LINEAR:
:   Linear.

    Straight-line interpolation between A and B (i.e. no ease in/out).

BEZIER:
:   Bézier.

    Smooth interpolation between A and B, with some control over curve shape.

**Easing (by strength)**

Predefined inertial transitions, useful for motion graphics (from least to most “dramatic”).

SINE:
:   Sinusoidal.

    Sinusoidal easing (weakest, almost linear but with a slight curvature).

QUAD:
:   Quadratic.

    Quadratic easing.

CUBIC:
:   Cubic.

    Cubic easing.

QUART:
:   Quartic.

    Quartic easing.

QUINT:
:   Quintic.

    Quintic easing.

EXPO:
:   Exponential.

    Exponential easing (dramatic).

CIRC:
:   Circular.

    Circular easing (strongest and most dynamic).

**Dynamic Effects**

Simple physics-inspired easing effects.

BACK:
:   Back.

    Cubic easing with overshoot and settle.

BOUNCE:
:   Bounce.

    Exponentially decaying parabolic bounce, like when objects collide.

ELASTIC:
:   Elastic.

    Exponentially decaying sine wave, like an elastic band.
user: How do I use Ptcache Operators in Blender? Include parameters, examples, warnings and best practices.

assistant: # Ptcache Operators

bpy.ops.ptcache.add()
:   Add new cache

bpy.ops.ptcache.bake(*\**, *bake=False*)
:   Bake physics

    Parameters:
    :   **bake** (*boolean**,* *(**optional**)*) – Bake

bpy.ops.ptcache.bake_all(*\**, *bake=True*)
:   Bake all physics

    Parameters:
    :   **bake** (*boolean**,* *(**optional**)*) – Bake

bpy.ops.ptcache.bake_from_cache()
:   Bake from cache

bpy.ops.ptcache.free_bake()
:   Delete physics bake

bpy.ops.ptcache.free_bake_all()
:   Delete all baked caches of all objects in the current scene

bpy.ops.ptcache.remove()
:   Delete current cache
user: What is ShaderNodeRGB(ShaderNode) and how is it used in Blender Python scripting?

assistant: # ShaderNodeRGB(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.ShaderNodeRGB(*ShaderNode*)
:   A color picker

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

assistant: # Instance Scale Node

[image reference removed]

The *Instance Scale* outputs the size of top-level instances on each axis in the
local space of the modifier object.

The [Instances](../instances.xhtml) page contains more information about geometry instances.
user: Provide the full official documentation entry for GeometryNodeTranslateInstances(GeometryNode), preserving all code examples.

assistant: # GeometryNodeTranslateInstances(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.GeometryNodeTranslateInstances(*GeometryNode*)
:   Move top-level geometry instances in local or global space

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

assistant: # Examples

To start with cloth, the first thing you need, of course, is some fabric. So,
let us delete the default cube and add a plane. In order to get some good floppy and flexible fabric,
you will need to subdivide it several times, about eight is a good number.
So `Tab` into *Edit Mode* and subdivide the mesh a couple of times.

Now, we will make this cloth by going to the Physics tab.
Scroll down until you see the *Cloth* panel, and press the *Cloth* button.
Now, a lot of settings will appear, most of which we will ignore for now.

That is all you need to do to set your cloth up for animating,
but if you playback the animation, the drop of your newly created fabric will be quite unspectacular.
That is what we will cover in the next two sections about pinning and colliding.
user: How do I use GeometryNodeGridToMesh(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeGridToMesh(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.GeometryNodeGridToMesh(*GeometryNode*)
:   Generate a mesh on the “surface” of a volume grid

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

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 GreasePencilDashModifierSegment(bpy_struct), preserving all code examples.

assistant: # GreasePencilDashModifierSegment(bpy_struct)

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

*class* bpy.types.GreasePencilDashModifierSegment(*bpy_struct*)
:   Configuration for a single dash segment

    dash
    :   The number of consecutive points from the original stroke to include in this segment

        Type:
        :   int in [1, 32767], default 2

    gap
    :   The number of points skipped after this segment

        Type:
        :   int in [0, 32767], default 1

    material_index
    :   Use this index on generated segment. -1 means using the existing material.

        Type:
        :   int in [-1, 32767], default -1

    name
    :   Name of the dash segment

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

    opacity
    :   The factor to apply to the original point’s opacity for the new points

        Type:
        :   float in [0, 1], default 1.0

    radius
    :   The factor to apply to the original point’s radius for the new points

        Type:
        :   float in [0, 1], default 1.0

    use_cyclic
    :   Enable cyclic on individual stroke dashes

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

assistant: Generated
:   Automatically-generated texture coordinates from the vertex positions of the mesh without deformation,
    keeping them sticking to the surface under animation.
    Range from 0.0 to 1.0 over the bounding box of the non-deformed mesh.
    See [Texture Spaces](../../../modeling/meshes/uv/uv_texture_spaces.xhtml#properties-texture-space) for more information.

Normal
:   Object space normal, for texturing objects with the texture staying fixed on the object as it transformed.
    The Normal output can be used on Point and Spot lights. The coordinates will take
    the rotation of the light into account.

UV
:   UV texture coordinates from the [Active Render](../../../modeling/meshes/uv/uv_texture_spaces.xhtml#bpy-types-meshuvlooplayer-active-render) UV map.
    See [UV Mapping](../../../editors/uv/index.xhtml#editors-uv-index) for more information.

Object
:   Uses an object as a source for coordinates. Often used with an empty,
    this is an easy way to place a small image at a given point on the object.
    This object can also be animated, to move a texture around or through a surface.

Camera
:   Position coordinate in camera space.

Window
:   Location of shading point on the screen, ranging from 0.0 to 1.0
    from the left to right side and bottom to top of the render.
    This is well suited for blending two objects.

Reflection
:   Uses the direction of the reflection vector as coordinates.
    This is useful for adding reflection maps. You will need this input when using environment maps.
user: Show practical ways to work with Introduction in a Blender add-on or script – include code.

assistant: # Introduction

Geometry Nodes is a system for modifying the geometry of an object with node-based operations.
It can be accessed by adding a [Geometry Nodes Modifier](../modifiers/geometry_nodes.html)
and setting up the nodes in the [Geometry Node Editor](../../editors/geometry_node.html).

[image reference removed]

The properties of a Geometry Nodes modifier in the modifier stack.

The geometry node tree connected to a modifier is a [Node Group](../../interface/controls/nodes/groups.html).
The geometry from the state before the modifier (the original geometry or the result of the previous
modifier) will be passed to the *Group Input* node. Then the node group can operate on the geometry
and pass an output to the *Group Output* node, where it will be passed to the next modifier.

Geometry nodes can modify different types of geometry:

- [Meshes](../meshes/introduction.html)
- [Curves](../curves/introduction.html)
- [Point Clouds](../point_cloud/index.html)
- [Volumes](../volumes/introduction.html)
- [Instances](instances.html)

The interface of the modifier is described in the
[Modifier](../modifiers/geometry_nodes.html) page.

To expand Blender with node-group operators, see the [Node-Based Tools](tools.html) page.
user: Give a detailed overview of ShaderNodeGroup(ShaderNode): syntax, arguments, return values, common patterns.

assistant: # ShaderNodeGroup(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.ShaderNodeGroup(*ShaderNode*)
:   node_tree
    :   Type:
        :   [`NodeTree`](bpy.types.NodeTree.html#bpy.types.NodeTree "bpy.types.NodeTree")

    *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 Recovering an Auto Save in Blender? Include parameters, examples, warnings and best practices.

assistant: Blender automatically saves temporary backups of your work at regular intervals.
If Blender crashes or you close it without saving, you may be able to recover your work using the autosave.

Follow these steps to recover an autosave:

1. Open Blender.
2. Go to the top-left menu bar and select: [File –> Recover –> Auto Save](../files/blend/open_save.xhtml#bpy-ops-wm-recover-auto-save).
3. In the file browser that appears, find the desired auto save.
   The files are named like: `<filename>_autosave.blend`
   Note, these files are timestamped to help identify the correct one.
4. Select the autosave file and click *Open*.
5. Once opened, immediately save the file manually using
   [Save As](../files/blend/open_save.xhtml#bpy-ops-wm-save-as-mainfile) to avoid overwriting the autosave.
user: Describe NodeTreeInterfaceSocketTexture(NodeTreeInterfaceSocket) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeTreeInterfaceSocketTexture(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.NodeTreeInterfaceSocketTexture(*NodeTreeInterfaceSocket*)
:   Texture socket of a node

    default_value
    :   Input value used for unconnected socket

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

    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 Adjustment Layer Strip in complete detail according to the official Blender documentation.

assistant: # Adjustment Layer Strip

The Adjustment Layer strip works like a regular input file strip except for the fact,
that it considers all strips below it as its input.

Real-world use cases, you want to add some last finishing color correction on top of parts of
your final sequence, timeline without messing with meta strips around.
Just add an adjustment layer on top and activate the color balance.

Or you can stack a primary color correction and several secondary color corrections on top of
each other (probably using the new mask input for area selection).
user: Explain Subdivision Surface Modifier in complete detail according to the official Blender documentation.

assistant: # Subdivision Surface Modifier

The *Subdivision Surface* modifier (often shortened as slang to “Subdiv” or “Subsurf”)
is used to split the faces of a mesh into smaller faces, giving it a smooth appearance.
It enables you to create complex smooth surfaces while modeling simple, low-vertex meshes.
It avoids the need to save and maintain huge amounts of data,
and gives a smooth “organic” look to the object.

As with any modifier, order of execution (position in the [modifier stack](../introduction.xhtml#modifier-stack))
has an important bearing on the results.

Keep in mind that this is a different operation than its companion,
[Smooth Shading](../../meshes/editing/mesh/shading.xhtml#modeling-meshes-editing-normals-shading).
You can see the difference between the two in the grid image below.

[image reference removed]

Subdivision levels 0 to 3, without and with Smooth Shading.