PGCRYPT/OpenBlender_Train huggingface dataset:
user: Show practical ways to work with GeometryNodeTransform(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeTransform(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.GeometryNodeTransform(*GeometryNode*)
:   Translate, rotate or scale the geometry

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

assistant: Format
:   A string using either python format style or Blender’s format specifier.
    For example, `Count: {}` inserts the first input value in place of the {}.

Additional input values (Float, Integer, or String) can be managed in the Format Items list in the sidebar.
user: Provide the full official documentation entry for Image Menu, preserving all code examples.

assistant: ### Clear

#### Position

Resets the strips [Position Transforms](../../../editors/video_sequencer/sequencer/sidebar/strip.html#bpy-types-striptransform-rotation) to a value of zero.

#### Scale

Resets the strips [Scale Transforms](../../../editors/video_sequencer/sequencer/sidebar/strip.html#bpy-types-striptransform-scale) to a value of one.

#### Rotation

Resets the strips [Rotation Transform](../../../editors/video_sequencer/sequencer/sidebar/strip.html#bpy-types-striptransform-rotation) to a value of zero.

#### All Transforms

Resets the strips position, scale, and rotation [Transforms](../../../editors/video_sequencer/sequencer/sidebar/strip.html#bpy-types-striptransform) to
their default values.

### Apply

#### Scale to Fit

Adjusts the strips [Scale Transforms](../../../editors/video_sequencer/sequencer/sidebar/strip.html#bpy-types-striptransform-scale)
so the visual contents of the strip to fit exactly within the project’s
[Resolution](../../../render/output/properties/format.html#bpy-types-rendersettings-resolution-x)
while maintaining the original aspect ratio.

This may mean that the transparent areas may be added
along the content’s border to fit the content in the rendered area.

#### Scale to Fill

Adjusts the strips [Scale Transforms](../../../editors/video_sequencer/sequencer/sidebar/strip.html#bpy-types-striptransform-scale)
so the visual contents of the strip to span the project’s
[Resolution](../../../render/output/properties/format.html#bpy-types-rendersettings-resolution-x)
while maintaining the original aspect ratio.

This may mean that portions of the original image no longer fit the content inside the rendered area.

#### Stretch to Fill

Adjusts the strips [Scale Transforms](../../../editors/video_sequencer/sequencer/sidebar/strip.html#bpy-types-striptransform-scale)
so the visual contents of the strip to fill the project’s
[Resolution](../../../render/output/properties/format.html#bpy-types-rendersettings-resolution-x).
Note, unlike the other two methods described above, *Stretch to Fill* does not maintaining the original aspect ratio.

This may mean that the original image becomes distorted to fit the content inside the rendered area.
user: What is Rip Vertices and Extend and how is it used in Blender Python scripting?

assistant: # Rip Vertices and Extend

This tool takes any number of selected vertices and duplicate-drags them along the closest edge to the mouse.
When extending an edge loop, it extends the vertices at the endpoints of the loop.
The behavior is similar to the *Extrude* tool, but it creates an n-gon.

It helps to easily add details to existing edges.
user: Provide the full official documentation entry for Randomize Transforms Node, preserving all code examples.

assistant: # Randomize Transforms Node

[image reference removed]

The *Randomize Transforms* node applies random translation, rotation, and scale to instances.
It is commonly used to create natural variation among duplicated objects, such as scattered
rocks, trees, or other elements in a scene.
user: How do I use Material Operators in Blender? Include parameters, examples, warnings and best practices.

assistant: # Material Operators

bpy.ops.material.copy()
:   Copy the material settings and nodes

bpy.ops.material.new()
:   Add a new material

bpy.ops.material.paste()
:   Paste the material settings and nodes
user: How do I use UV Maps in Blender? Include parameters, examples, warnings and best practices.

assistant: UV Maps are used to map a 3D object onto a 2D plane that determines where a texture appears on the 3D object.
Different UV Maps can be used for different textures. For more information see [UV Maps](../uv/uv_texture_spaces.xhtml#uv-maps-panel).
user: Give a detailed overview of CompositorNodeTrackPos(CompositorNode): syntax, arguments, return values, common patterns.

assistant: # CompositorNodeTrackPos(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.CompositorNodeTrackPos(*CompositorNode*)
:   Provide information about motion tracking points, such as x and y values

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

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

    tracking_object
    :   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")

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

assistant: # Info Editor

The Info editor logs the executed operators as well as errors, warnings,
and informational messages. You can select an entry by clicking it,
optionally holding `Shift` to add it to the existing selection.

[image reference removed]

Info Editor.
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_shader_translucent_example.jpg   Translucent shader example. | ../../../_images/render_shader-nodes_shader_translucent_behavior.svg   Translucent shader behavior. |
user: Explain Output in complete detail according to the official Blender documentation.

assistant: # Output

[image reference removed]

Output panel.

This panel provides options for setting the location of rendered frames for animations,
and the quality of the saved images.

File Path
:   Choose the location to save rendered frames.

    When rendering an animation,
    the frame number is appended at the end of the file name with four padded zeros (e.g. `image0001.png`).
    You can set a custom padding size by adding the appropriate number of `#` anywhere in the file name
    (e.g. `image_##_test.png` translates to `image_01_test.png`).

    This setting expands [Relative Paths](../../../files/blend/open_save.xhtml#files-blend-relative-paths)
    where a `//` prefix represents the directory of the current blend-file.

Saving – File Extensions
:   Adds the correct file extensions per file type to the output files.

Saving – Cache Result
:   Saves the rendered view layers and their [passes](../../layers/passes.xhtml) to a multi-layer OpenEXR image.
    The Compositor can then use this file to improve performance, especially for heavy compositing.

    The image is stored in the *Render Cache* folder as specified in the
    [File Paths Preferences](../../../editors/preferences/file_paths.xhtml).
    You can also load it back into the Image Editor’s Render Result, even after closing
    and reopening Blender; see [Open Cached Render](../../../editors/image/editing.xhtml#bpy-ops-image-read-viewlayers).

Media Type
:   The type of media to save.

    Image:
    :   Saves each input as a separate image file.
        Each input can use its own image format settings.

    Multi-Layer EXR:
    :   Saves all inputs together in a single multi-layer OpenEXR file.

    Video:
    :   Encodes each frame into a video container.
        Encoding options can be found in the [Encoding](#encoding) panel.

File Format Image
:   Choose the image file format to save to. Based on which format is used,
    other options such as channels, bit depth and compression level are available.
    See [saving images](../../../files/media/image_formats.xhtml#bpy-types-imageformatsettings) for list of image encoding options.

Color Image Multi-Layer EXR
:   The color format to save the image or video to.
    This setting is used by some formats to optimize how much data is written to the file.
    Note, *RGBA* is not available for all image formats, check the list above for details.

    BW:
    :   Saves the image using grayscale colors.

    RGB:
    :   Saves red, green and blue channels

    RGBA:
    :   Saves red, green, blue and alpha channels.

Image Sequence – Overwrite Image Multi-Layer EXR
:   Overwrite existing files when rendering.

Image Sequence – Overwrite Image Multi-Layer EXR
:   Create empty placeholder frames while rendering.
user: How do I use Displays in Blender? Include parameters, examples, warnings and best practices.

assistant: A full HD display (1920x1080) or higher is recommended. Multi-monitor setups are supported, and workspaces can be
configured to span multiple monitors.

[image reference removed]

Example of Blender’s multi-monitor support.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

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

Roughness
:   Influences sharpness of the refraction; perfectly sharp at 0.0 and smoother with higher values.

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

assistant: |  |  |
| --- | --- |
| - [**Action**](glossary/index.xhtml#term-Action) - [**Action Safe**](glossary/index.xhtml#term-Action-Safe) - [**Active**](glossary/index.xhtml#term-Active) - [Add-ons](addons/index.xhtml#index-0), [[1]](advanced/extensions/addons.xhtml#index-1) - [Add-ons Extensions](advanced/extensions/addons.xhtml#index-0) - [**Aliasing**](glossary/index.xhtml#term-Aliasing) - [**Alpha Channel**](glossary/index.xhtml#term-Alpha-Channel) - [**Ambient Light**](glossary/index.xhtml#term-Ambient-Light) - [**Ambient Occlusion**](glossary/index.xhtml#term-Ambient-Occlusion) | - [**Animation**](glossary/index.xhtml#term-Animation) - [**Anti-Aliasing**](glossary/index.xhtml#term-Anti-Aliasing) - [**Armature**](glossary/index.xhtml#term-Armature) - [**Asset**](glossary/index.xhtml#term-Asset) - [**Asset Catalog**](glossary/index.xhtml#term-Asset-Catalog) - [**Asset Library**](glossary/index.xhtml#term-Asset-Library) - [**Asset Metadata**](glossary/index.xhtml#term-Asset-Metadata) - [**Attribute**](glossary/index.xhtml#term-Attribute) - [**Axis**](glossary/index.xhtml#term-Axis) - [**Axis Angle**](glossary/index.xhtml#term-Axis-Angle) |
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Geometry
:   Standard geometry input.

Mode
:   How the transformation is specified.

    Components:
    :   Provide separate inputs for location, rotation and scale.

    Matrix:
    :   Use a transformation matrix.

Translation
:   Translation of the entire geometry in the local space of the modified object.

Rotation
:   Euler rotation in the local space of the modified object.

Scale
:   Scale for the geometry in the local space of the modified object.

Transform
:   A [Transformation Matrix](../../../../glossary/index.html#term-Transformation-Matrix), available when using *Matrix* mode.
user: Show practical ways to work with Installation on macOS in a Blender add-on or script – include code.

assistant: # Installation on macOS

This guide covers the following topics:

1. [Installing Dependencies](#installing-dependencies)
2. [Downloading the Repository](#downloading-the-repository)
3. [Setting up the Build Environment](#setting-up-the-build-environment)
user: Provide the full official documentation entry for Color Management, preserving all code examples.

assistant: This panel controls how [Color Management](../../color_management/index.html) is applied when saving images.

Follow Scene:
:   Uses the same color management settings defined by the active Scene.
    These properties are defined in the Render Settings

Override:
:   Uses custom color management settings defined by the properties below in the panel;
    disregarding any color management settings set at the Scene level.

For a detailed description of color management properties,
see the [Color Management](../../color_management/displays_views.html#render-post-color-management) page.
user: Describe Legacy vs Extension Add-ons from the Blender manual or Python API, including usage steps and snippets.

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

assistant: Mesh
:   The input mesh to be converted into a density grid.
    The mesh defines the surface that will be voxelized.

Density
:   The scalar value assigned to voxels inside the mesh.
    Typically a value of `1.0` for full density and `0.0` for empty space,
    though any scalar range can be used to represent material thickness or opacity.

Voxel Size
:   The size of each voxel in object space units.
    Smaller values produce higher-resolution grids with more detail, while
    larger values reduce detail but improve performance and memory efficiency.

Gradient Width
:   The width of the gradient region inside the mesh.
    Controls how smoothly the density falls off from the interior toward the
    exterior. Larger values create a broader transition, while smaller values
    produce a sharper surface boundary.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`ImageStrip.retiming_keys`](bpy.types.ImageStrip.html#bpy.types.ImageStrip.retiming_keys "bpy.types.ImageStrip.retiming_keys") - [`MovieStrip.retiming_keys`](bpy.types.MovieStrip.html#bpy.types.MovieStrip.retiming_keys "bpy.types.MovieStrip.retiming_keys") - [`RetimingKeys.add`](bpy.types.RetimingKeys.html#bpy.types.RetimingKeys.add "bpy.types.RetimingKeys.add") | - [`SceneStrip.retiming_keys`](bpy.types.SceneStrip.html#bpy.types.SceneStrip.retiming_keys "bpy.types.SceneStrip.retiming_keys") - [`SoundStrip.retiming_keys`](bpy.types.SoundStrip.html#bpy.types.SoundStrip.retiming_keys "bpy.types.SoundStrip.retiming_keys") |
user: Explain Input in complete detail according to the official Blender documentation.

assistant: If you have a compact keyboard without a separate number pad, enable
Preferences ‣ Input ‣ Keyboard ‣ Emulate Numpad. This gives you the 3D view shortcuts regularly
used on the number pad.

If you do not have a middle mouse button, you can enable
Preferences ‣ Input ‣ Mouse ‣ Emulate 3 Button Mouse. This allows you to hold the `Alt`
or `OSKey` key while dragging with the mouse, to orbit.

See [Configuring Peripherals](hardware.xhtml) for more information about these options, and see
[Input Preferences](../../editors/preferences/input.xhtml) for details on configuring their settings.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Type
:   Specifies the input/output type.

    Vector, Point, Normal.

Convert From
:   Coordinate Space to convert from:

    World, Object, Camera.

Convert To
:   Coordinate Space to convert to:

    World, Object, Camera.
user: How do I use Pan in Blender? Include parameters, examples, warnings and best practices.

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

assistant: Almost all nodes that process geometry do so by processing each unique
geometry separately rather than realized geometry. For example,
if a [Subdivision Surface Node](mesh/operations/subdivision_surface.xhtml) was placed at
the end of the example above, it would only have to subdivide three meshes,
rather than each instance of a mesh. Another important example is processing with
the output of the [String to Curves Node](utilities/text/string_to_curves.xhtml),
where each unique character only has to be processed once.

This method can improve performance a lot, but it means that the result of an operation
will be the same for every instance of a certain geometry. In order to have unique results
for every instance, the [Realize Instances Node](instances/realize_instances.xhtml)
node can be used.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`Mesh.corner_normals`](bpy.types.Mesh.html#bpy.types.Mesh.corner_normals "bpy.types.Mesh.corner_normals") - [`Mesh.polygon_normals`](bpy.types.Mesh.html#bpy.types.Mesh.polygon_normals "bpy.types.Mesh.polygon_normals") | - [`Mesh.vertex_normals`](bpy.types.Mesh.html#bpy.types.Mesh.vertex_normals "bpy.types.Mesh.vertex_normals") |
user: How do I use Custom Split Normals of Meshes in Blender? Include parameters, examples, warnings and best practices.

assistant: Blender supports the import and export of [custom normals](../../modeling/meshes/structure.html#modeling-meshes-normals-custom) to
Alembic files. As a basic rule of thumb, a completely smooth mesh will be exported without normals
and thus produce the smallest Alembic file. This is reflected in the importer; an Alembic mesh
without normals is loaded as a smooth mesh.

On export, for every mesh:

- If it has *Custom Loop Normals* then the loop normals are exported.
- If one or more polygons are marked flat then loop normals are also exported.
- Otherwise, no normals are exported.

On import, when the Alembic mesh contains:

- Loop normals (`kFacevaryingScope`) are used as custom loop normals.
- Vertex normals (`kVertexScope` or `kVaryingScope`) are convert to loop normals, and handle as above.
- If there are no normals then the mesh is marked as smooth.
- Unsupported normal types (`kConstantScope`, `kUniformScope`, `kUnknownScope`) are handled as *no normals*.

When an imported mesh does not contain normals, the final look can be controlled using the
[Normal’s Shading](../../modeling/meshes/structure.html#modeling-meshes-structure-normals-shading).
user: Describe Shrinkwrap Hair Curves from the Blender manual or Python API, including usage steps and snippets.

assistant: # Shrinkwrap Hair Curves

The *Shrinkwrap Hair Curves* node projects hair curves onto a target surface,
adjusting their positions so they follow the shape of a mesh.
It can be used to conform hair to a scalp or other underlying geometry,
ensuring curves remain properly positioned relative to a surface.
user: How do I use Mask in Blender? Include parameters, examples, warnings and best practices.

assistant: # Mask

This page details the mask related shortcut operators and menu operators in sculpt mode.
Other related information to masks can also be found at the bottom of the page.

Masks can be edited across all visible faces.
Using `A` opens a pie menu to choose the most common operations.
user: How do I use BlendImportContextItems(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # BlendImportContextItems(bpy_struct)

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

*class* bpy.types.BlendImportContextItems(*bpy_struct*)
:   Collection of blendfile import context items

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

assistant: # UnknownType(bpy_struct)

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

*class* bpy.types.UnknownType(*bpy_struct*)
:   Stub RNA type used for pointers to unknown or internal data

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

assistant: # Introduction

[Constraints](../../../glossary/index.html#term-Constraint) (also known as joints) for rigid bodies connect two rigid bodies.
The physics constraints are meant to be attached to an [Empty](../../../glossary/index.html#term-Empty) object.
The constraint then has fields which can be pointed at the two physics-enabled object
which will be bound by the constraint.
The empty object provides a location and axis for the constraint distinct from the two constrained objects.
The location of the entity hosting the physics constraint marks a location and
set of axes on each of the two constrained objects.
These two anchor points are calculated at the beginning of the animation and their position and
orientation remain fixed in the *local* coordinate system of the object for the duration of the animation.
The objects can move far from the constraint object, but the constraint anchor moves with the object.
If this feature seems limiting, consider using multiple objects with a non-physics *Child of* constraint and
animate the relative location of the child.
user: What is Example and how is it used in Blender Python scripting?

assistant: Tint uniform color sample.

|  |  |  |
| --- | --- | --- |
| <../../../_images/grease-pencil_modifiers_color_tint_factor-0.png>   Strength: 0 (original color). | <../../../_images/grease-pencil_modifiers_color_tint_factor-05.png>   Strength: 0.5. | <../../../_images/grease-pencil_modifiers_color_tint_factor-1.png>   Strength: 1.0 (fully tinted). |

Tint gradient color sample.

|  |  |  |
| --- | --- | --- |
| <../../../_images/grease-pencil_modifiers_color_tint_gradient-01.png>   Radius: 1, Strength: 1. | <../../../_images/grease-pencil_modifiers_color_tint_gradient-02.png>   Radius: 5, Strength: 1. | <../../../_images/grease-pencil_modifiers_color_tint_gradient-03.png>   Radius: 10, Strength: 1. |
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Face Count
:   The number of faces that use the edge as one of their sides.
    When the value is one, the edge is a [non-manifold](../../../../glossary/index.html#term-Non-manifold) boundary edge.
    Alternatively, when the value is zero, the edge is a loose edge, not used by any faces.
user: Explain Blur Attribute Node in complete detail according to the official Blender documentation.

assistant: # Blur Attribute Node

[image reference removed]

The *Blur Attribute* node smooths attribute values between neighboring geometry elements.

The goal of each step is mixing values of each element with its neighbors.
The weight for element is factor for multiplying all neighbor’s values before accumulating them as new primitive
value.

Blurring will only work with certain geometry types and [attribute domains](../attributes_reference.xhtml#attribute-domains).
Therefore, the attribute can only be affected on the [Meshes](../../meshes/introduction.xhtml) and
[Curves](../../curves/introduction.xhtml) components.

The domains this node works on is based on the [field context](../fields.xhtml#field-context) of the node’s evaluation.
Only domains with explicit relations with their neighbors will work with this node.
Explicit relations for correct blurring are vertices, edges, and faces of meshes, and curve control points.

All [attribute data types](../attributes_reference.xhtml#attribute-data-types) are supported except
for boolean attributes.
user: Describe Rendering From The Command Line from the Blender manual or Python API, including usage steps and snippets.

assistant: # Rendering From The Command Line

In some situations we want to increase the render speed,
access Blender remotely to render something or build scripts that use the command line.

One advantage of using the command line is that we do not need a graphical display
(no need for X server on Linux for example)
and consequently we can render via a remote shell (typically SSH).

- See [Command Line Arguments](arguments.xhtml)
  for a full list of arguments
  (for example to specify which scene to render, the end frame number, etc.), or simply run:

```
blender --help
```

- See [Command Line Launching](launch/index.xhtml#command-line-launch-index)
  for specific instructions on launching Blender from the command line.
user: Give a detailed overview of Cache: syntax, arguments, return values, common patterns.

assistant: # Cache

The *Cache* is used to store preview frames in memory so they can be displayed much faster
during playback, rather than being re-rendered for each frame. This is especially useful for
maintaining smooth performance when editing or scrubbing through a sequence.

The total cache memory limit can be configured in the [System tab](../../../preferences/system.xhtml)
of the Preferences.
user: What is Operators and how is it used in Blender Python scripting?

assistant: Most hotkeys and buttons in Blender call an operator which is also exposed to Python via [`bpy.ops`](bpy.ops.html#module-bpy.ops "bpy.ops").

To see the Python equivalent hover your mouse over the button and see the tooltip,
e.g `Python: bpy.ops.render.render()`,
If there is no tooltip or the `Python:` line is missing then this button is not using an operator
and can’t be accessed from Python.

If you want to use this in a script you can press `Ctrl`-`C` while your mouse is over the button
to copy it to the clipboard.
You can also use button’s context menu and view the *Online Python Reference*, this mainly shows arguments and
their defaults, however, operators written in Python show their file and line number which may be useful if you
are interested to check on the source code.

### Info Editor

Blender records operators you run and displays them in the Info editor.
Select the Scripting workspace that comes default with Blender to see its output.
You can perform some actions and see them show up – delete a vertex for example.

Each entry can be selected, then copied `Ctrl`-`C`, usually to paste in the text editor or Python console.
user: How do I use Transforming in Blender? Include parameters, examples, warnings and best practices.

assistant: # Transforming

Transform tools to [move, rotate and scale](../tools/transforms.xhtml)
are also available in Sculpt Mode,
but with an important difference to other modes. Sculpt Mode uses its own pivot point,
which can be manually positioned `Shift`-`RMB`
or automatically positioned with [Mask Expand](../editing/expand.xhtml#bpy-ops-sculpt-mask-expand).
This ensures that the pivot point can be more freely placed and always moves with the transformed geometry.

Optionally instead of keeping the transform tools active, you can enable the
[viewport gizmos](../../../editors/3dview/display/gizmo.xhtml) to have access to the gizmo at all times.

Apart from the transform tools there are also special brushes to move,
rotate and scale the topology like [Pose](../brushes/pose.xhtml),
[Boundary](../brushes/boundary.xhtml)
and [Elastic Deform](../brushes/elastic_deform.xhtml).
user: Explain UV Project Modifier in complete detail according to the official Blender documentation.

assistant: # UV Project Modifier

[image reference removed]

Projecting the Blender logo onto Suzanne.

The *UV Project* modifier acts like a slide projector.
It emits a UV map from the negative Z axis of a controller object
(such as an [empty object](../../empties.xhtml)),
and applies it to the object as the “light” hits it.

[Download an example](https://archive.blender.org/wiki/2015/index.php/File:Uvproject.blend).
user: Give a detailed overview of Tool Settings: syntax, arguments, return values, common patterns.

assistant: Offset
:   How far items are shifted from their original location.

Axis
:   Defines one axis of the imaginary shearing plane.

Axis Orthographic
:   Defines the other axis of the imaginary shearing plane.

Orientation
:   See [Transform Orientations](../../../../../editors/3dview/controls/orientation.xhtml).

Proportional Editing
:   See [Proportional Editing](../../../../../editors/3dview/controls/proportional_editing.xhtml).
user: Give a detailed overview of ThemeRegions(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # ThemeRegions(bpy_struct)

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

*class* bpy.types.ThemeRegions(*bpy_struct*)
:   Theme settings for regions that are common among editors

    asset_shelf
    :   Type:
        :   [`ThemeRegionsAssetShelf`](bpy.types.ThemeRegionsAssetShelf.html#bpy.types.ThemeRegionsAssetShelf "bpy.types.ThemeRegionsAssetShelf"), (readonly, never None)

    channels
    :   Type:
        :   [`ThemeRegionsChannels`](bpy.types.ThemeRegionsChannels.html#bpy.types.ThemeRegionsChannels "bpy.types.ThemeRegionsChannels"), (readonly, never None)

    scrubbing
    :   Type:
        :   [`ThemeRegionsScrubbing`](bpy.types.ThemeRegionsScrubbing.html#bpy.types.ThemeRegionsScrubbing "bpy.types.ThemeRegionsScrubbing"), (readonly, never None)

    sidebars
    :   Type:
        :   [`ThemeRegionsSidebars`](bpy.types.ThemeRegionsSidebars.html#bpy.types.ThemeRegionsSidebars "bpy.types.ThemeRegionsSidebars"), (readonly, never None)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe Spin from the Blender manual or Python API, including usage steps and snippets.

assistant: The *Spin* operator only works for one dimensional [surface](../../surfaces/index.html) objects.
Its use for curves is currently not possible,
the full feature is documented in [Surface editing](../../surfaces/editing/surface.html#bpy-ops-curve-spin).
user: Show practical ways to work with Tool Settings in a Blender add-on or script – include code.

assistant: Mode
:   The operation to apply to the face set.

    Grow Face Set:
    :   Grows the face sets boundary by one face based on mesh topology.
        This is also available as a [shortcut operator](../editing/face_sets.xhtml#bpy-ops-sculpt-face-set-edit)
        via `Ctrl`-`W`.

    Shrink Face Set:
    :   Shrinks the face sets boundary by one face based on mesh topology.
        This is also available as a [shortcut operator](../editing/face_sets.xhtml#bpy-ops-sculpt-face-set-edit)
        via `Ctrl`-`Alt`-`W`.

    Delete Geometry:
    :   Deletes the faces that are assigned to the face set.

    Fair Positions:
    :   Creates a perfectly flat and smooth geometry patch from the face set.
        This is the ideal way to trim parts of your mesh
        if the vertex count is too high for other operations,
        or the vertex IDs must not be altered
        (Like when using [Multires](../../../modeling/modifiers/generate/multiresolution.xhtml) sculpting).

    Fair Tangency:
    :   Creates a smooth as possible geometry patch from the face set
        by minimizing changes in vertex [tangents](../../../glossary/index.xhtml#term-Tangent).
        This is ideal for creating smooth curved surfaces on complex topology,
        where just using the smooth brush will not lead to desired results

    |  |  |  |
    | --- | --- | --- |
    | ../../../_images/sculpt-paint_sculpt_fairing_none.png   Before fairing. | ../../../_images/sculpt-paint_sculpt_fairing_positions.png   After using Fair Positions. | ../../../_images/sculpt-paint_sculpt_fairing_tangency.png   After using Fair Tangency. |

Strength
:   The amount of effect the filter has on the mesh.
    This setting is only available for the fairing operations.

Modify Hidden
:   Apply the edit operation to hidden face sets.
user: Provide the full official documentation entry for Language, preserving all code examples.

assistant: Enable Edit ‣ Preferences ‣ Interface ‣ Translation, and choose the *Language* and what to
translate from *Interface*, *Tooltips* and *New Data*.

See [Language](../../editors/preferences/interface.xhtml#prefs-interface-translation) for details.
user: Show practical ways to work with Calligraphy in a Blender add-on or script – include code.

assistant: # Calligraphy

The *Calligraphy* modifier mimics some broad and flat pens for calligraphy.
It generates different thickness based on the orientation of the stroke.

Orientation
:   The angle (orientation) of the virtual drawing tool, from the vertical axis of the picture.
    For example, an angle of 0.0 mimics a pen aligned with the vertical axis.
    Hence, the thickest strokes will be the vertical ones i.e. stroke’s direction is aligned with the angle, and
    the thinnest will be the horizontal ones i.e. stroke’s direction is perpendicular to the angle.

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

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

assistant: # GeometryNodeOffsetCornerInFace(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.GeometryNodeOffsetCornerInFace(*GeometryNode*)
:   Retrieve corners in the same face as another

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: In advanced mode you can additionally enter expressions and units.

Use `=` or `NumpadAsterisk` to enable advanced mode,
and `Ctrl`-`=` or `Ctrl`-`NumpadAsterisk` to switch back to simple mode.

It features:

- Units (`cm`, `"`, `deg`, etc.).
  See [unit system](../../../../scene/properties.xhtml#bpy-types-unitsettings).
- Basic operations from Python (`+`, `*`, `/`, `**`, etc.).
- Math constants and functions (`pi`, `sin`, `sqrt`, etc.).
  See Python’s [math](https://docs.python.org/3.8/library/math.html) module.

You can still use the negate and inverse shortcuts (`Minus`, `Slash`),
as well as non-number inputs, but you have to hold `Ctrl` to activate them.
user: Provide the full official documentation entry for Separate Cylindrical Node, preserving all code examples.

assistant: # Separate Cylindrical Node

[image reference removed]

The *Separate Cylindrical* node converts a vector from Cartesian coordinates (X, Y, Z)
into cylindrical coordinates (R, Φ, Z) and outputs each component separately. It is the inverse of the
[Combine Cylindrical](combine_cylindrical.xhtml) node.

This node is useful for analyzing geometry or generating procedural effects that depend on
radial distance, angular position, or height – for example, creating spiral deformations,
cylindrical gradients, or radial masks.
user: What is Examples and how is it used in Blender Python scripting?

assistant: ### Keyframe Animation

This example shows you how to animate a cube’s location, rotation, and scale.

1. First, in the Timeline, or other animation editors, set the frame to 1.
2. With the cube selected in Object Mode, press `I` in the 3D Viewport.
   This will record the location, rotation, and scale, for the cube on frame 1.
3. Set the frame to 100.
4. Use Move `G`, Rotate `R`, Scale `S`, to transform the cube.
5. Press `I` in the 3D Viewport.

To test the animation, press `Spacebar` to play.

[image reference removed]

The animation on frames 1, 50 and 100.
user: Describe Armature Constraint from the Blender manual or Python API, including usage steps and snippets.

assistant: # Armature Constraint

The *Armature* constraint transforms an “owner” object or bone based on the
weighted pose transformations of one or more “target” bones. It’s similar to the
[Armature Modifier](../../../modeling/modifiers/deform/armature.html), which performs this operation for
every vertex in a mesh.

Unlike the modifier, the constraint also uses bones whose
[Deform](../../armatures/bones/properties/deform.html) option is disabled.
user: Describe Array (Legacy) Modifier from the Blender manual or Python API, including usage steps and snippets.

assistant: # Array (Legacy) Modifier

The *Array* modifier creates an array of copies of the base object, with each copy being offset from
the previous one in any of a number of possible ways. Vertices in adjacent copies can be merged if they are nearby,
allowing smooth [Subdivision Surface](subdivision_surface.xhtml)
frameworks to be generated.

This modifier can be useful when combined with tileable meshes for quickly developing large scenes.
It is also useful for creating complex repetitive shapes.

Multiple Array modifiers may be active for an object at the same time
(e.g. to create complex three-dimensional constructs).
user: Describe Workflow from the Blender manual or Python API, including usage steps and snippets.

assistant: The process of multi camera editing can be rather easy in the Video Sequencer if properly setup.
The following guide shows the basic steps to setup a basic multi camera editing workflow.

1. First you are going to want to add in each of your video strips.
2. Next, you will want to sync all your cameras by either using
   [Audio Waveforms](../sound.html) or by the movement of objects.
3. Split the editor into many [Previews](../../../../../editors/video_sequencer/preview/index.html), one for each input track.
   Then change the [Display Channel](../../../../../editors/video_sequencer/preview/sidebar.html#bpy-types-spacesequenceeditor-display-channel)
   of each of the previews to the channel number of the input track.
4. Add a Multicam Selector strip *above* all the video channel tracks.

   After completing these steps you should get something similar to the following image:

   [image reference removed]

   Multi-camera editing setup.
5. Now select the Multicam strip, if you take a look at the strip options (in the Sidebar),
   you will notice, that Multicam is a rather simple effect strip:
   It just takes a selected channel as its input. That is all.
   The magic comes with the convenient keyboard layout.
6. When you select the Multicam strip, the keys `1` to `9` are mapped to the cut buttons.
   So, select the Multicam strip and start playback and press the keys
   for the correct input while watching the individual cameras.
7. You will end up with a small Multicam Selector strip for every cut.

In reality, it boils down to: watch a few seconds to see, what is coming,
watch it again and do a rough cut using the number keys.
Then fine-tune the placement by selecting the outer handles of two neighboring Multicam for A/B rolling.