PGCRYPT/OpenBlender_Train huggingface dataset:
user: Explain PivotConstraint(Constraint) in complete detail according to the official Blender documentation.

assistant: # PivotConstraint(Constraint)

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

*class* bpy.types.PivotConstraint(*Constraint*)
:   Rotate around a different point

    head_tail
    :   Target along length of bone: Head is 0, Tail is 1

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

    offset
    :   Offset of pivot from target (when set), or from owner’s location (when Fixed Position is off), or the absolute pivot point

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], default (0.0, 0.0, 0.0)

    rotation_range
    :   Rotation range on which pivoting should occur

        - `ALWAYS_ACTIVE`
          Always – Use the pivot point in every rotation.
        - `NX`
          -X Rotation – Use the pivot point in the negative rotation range around the X-axis.
        - `NY`
          -Y Rotation – Use the pivot point in the negative rotation range around the Y-axis.
        - `NZ`
          -Z Rotation – Use the pivot point in the negative rotation range around the Z-axis.
        - `X`
          X Rotation – Use the pivot point in the positive rotation range around the X-axis.
        - `Y`
          Y Rotation – Use the pivot point in the positive rotation range around the Y-axis.
        - `Z`
          Z Rotation – Use the pivot point in the positive rotation range around the Z-axis.

        Type:
        :   enum in [`'ALWAYS_ACTIVE'`, `'NX'`, `'NY'`, `'NZ'`, `'X'`, `'Y'`, `'Z'`], default `'NX'`

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

    target
    :   Target Object, defining the position of the pivot when defined

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

    use_bbone_shape
    :   Follow shape of B-Bone segments when calculating Head/Tail position

        Type:
        :   boolean, default False

    use_relative_location
    :   Offset will be an absolute point in space instead of relative to the target

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Data-Blocks

The base unit for any Blender project is the data-block. Examples of data-blocks include:
meshes, objects, materials, textures, node trees, scenes, texts, brushes, and even Workspaces.

[image reference removed]

Blender File view of the Outliner.

A data-block is a generic abstraction of very different kinds of data,
which features a common set of basic features, properties and behaviors.

Some common characteristics:

- They are the primary contents of the blend-file.
- They can reference each other, for reuse and instancing.
  (Child/parent, object/object-data, materials/images, in modifiers or constraints too…)
- Their names are unique within a blend-file, for a given type.
- They can be added/removed/edited/duplicated.
- They can be linked between files (only enabled for a limited set of data-blocks).
- They can have their own animation data.
- They can have [Custom Properties](custom_properties.html).

User will typically interact with the higher level data types (objects, meshes, etc.).
When doing more complex projects, managing data-blocks becomes more important,
especially when inter-linking blend-files.
The main editor for that is the [Outliner](../editors/outliner/index.html).

Not all data in Blender is a data-block,
bones, sequence strips or vertex groups e.g. are not,
they belong to armature, scene and mesh types respectively.
user: How do I use Introduction in Blender? Include parameters, examples, warnings and best practices.

assistant: # Introduction

Each blend-file contains a database.
This database contains all scenes, objects, meshes, textures, etc. that are in the file.

A file can contain multiple [Scenes](../scene_layout/scene/introduction.xhtml)
and each scene can contain multiple [Objects](../scene_layout/object/introduction.xhtml).
Objects can contain multiple materials which can contain many textures.
It is also possible to create links between different objects, or share data between objects.
A file can link data from other Blender files.
user: Show practical ways to work with Light Linking in a Blender add-on or script – include code.

assistant: # Light Linking

With light linking, you can set up lights that only illuminate specific objects in the scene.
Shadow linking additionally gives control over which objects block the light (cast shadows).

This adds more artistic control by breaking the laws of physics. For example, you could
have a rim light that *only* illuminates a character in a scene (light linking) and is
not blocked by any objects in the scene (shadow linking).
user: Show practical ways to work with Clip in a Blender add-on or script – include code.

assistant: Set Scene Frames
:   See [Set Scene Frames](../editing/clip.xhtml#bpy-ops-clip-set-scene-frames).

Prefetch
:   See [Prefetch](../editing/clip.xhtml#bpy-ops-clip-prefetch).

Reload
:   See [Reload Clip](../editing/clip.xhtml#bpy-ops-clip-reload).
user: Describe Time from the Blender manual or Python API, including usage steps and snippets.

assistant: The Time panel is used to control source and timeline position of the strip.

Lock (padlock icon in panel header)
:   Prevents the strip from being moved.

Show Retiming Keys
:   Toggle visibility and selectability of [Retiming Keys](../../../../video_editing/edit/montage/editing.html#sequencer-editing-retiming).

Channel
:   Changes the channel number, or row, of the strip.

Start
:   Changes the starting frame of the strip, which is the same as selecting and moving the strip.

Duration
:   Changes the length (in frames) of the strip. This works by changing the end frame,
    which is the same as selecting and moving the strip’s right handle.

End
:   Shows the ending time and frame of the strip.

Strip Offset Start/End
:   Positive values will move the strip’s handles inwards, making it start later than the start
    of the source material and stop before its end. This lets you trim down the source material
    to the part you need. You can enable the
    [Offsets overlay](../display.html#bpy-types-sequencertimelineoverlay-show-strip-offset)
    to see the start and end of the full source file.

    Negative values will move the strip’s handles outwards, making it start earlier than the start
    of the source material and stop after its end. This lets you show the first and/or last frame
    as a frozen image for some time.

    Instead of adjusting these offsets in the Sidebar, you can also drag the strip’s handles.

Hold Offset Start/End
:   Used for trimming frames off the start/end of the source material. At first sight, this
    does the same as the *Strip Offset* properties, but you can in fact combine them
    to hold (freeze) a frame other than the first or last one. For example, if you set the
    *Hold Offset Start* to 10 and the *Strip Offset Start* to -20, the video will first show
    the 11th frame of the source for 21 frames, and then play the remaining frames.

Current Frame
:   The Playhead’s frame number relative to the start of the strip.
user: How do I use Wipe Strip in Blender? Include parameters, examples, warnings and best practices.

assistant: # Wipe Strip

The *Wipe* transition strip can be used to transition from one strip to the next.
The wipe will have no effect if created from a single strip instead of two strips.
The duration of the wipe is the intersection of the two source strips and cannot be adjusted.
To adjust the start and end of the wipe you must adjust the temporal bounds of the source strips
in a way that alters their intersection.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`RenderViews.active`](bpy.types.RenderViews.html#bpy.types.RenderViews.active "bpy.types.RenderViews.active") - [`RenderViews.new`](bpy.types.RenderViews.html#bpy.types.RenderViews.new "bpy.types.RenderViews.new") - [`RenderViews.remove`](bpy.types.RenderViews.html#bpy.types.RenderViews.remove "bpy.types.RenderViews.remove") | - [`RenderSettings.stereo_views`](bpy.types.RenderSettings.html#bpy.types.RenderSettings.stereo_views "bpy.types.RenderSettings.stereo_views") - [`RenderSettings.views`](bpy.types.RenderSettings.html#bpy.types.RenderSettings.views "bpy.types.RenderSettings.views") |
user: What is KeyConfigPreferences(bpy_struct) and how is it used in Blender Python scripting?

assistant: # KeyConfigPreferences(bpy_struct)

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

*class* bpy.types.KeyConfigPreferences(*bpy_struct*)
:   bl_idname
    :   Type:
        :   string, default “”, (never None)

    bl_system_properties_get(*\**, *do_create=False*)
    :   DEBUG ONLY. Internal access to runtime-defined RNA data storage, intended solely for testing and debugging purposes. Do not access it in regular scripting work, and in particular, do not assume that it contains writable data

        Parameters:
        :   **do_create** (*boolean**,* *(**optional**)*) – Ensure that system properties are created if they do not exist yet

        Returns:
        :   The system properties root container, or None if there are no system properties stored in this data yet, and its creation was not requested

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

    *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 Faces & Edges by Vertices in complete detail according to the official Blender documentation.

assistant: *Faces & Edges by Vertices* is similar to *Faces by Edges* except that
it also splits the vertices of the adjacent connecting edges.
This has the same functionality as manually ripping all faces and edges away from a vertex.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_mesh_split_faces-before.png   Before. | ../../../../_images/modeling_meshes_editing_mesh_split_faces-after.png   After (also moving edges away). |
user: Provide the full official documentation entry for World, preserving all code examples.

assistant: The Viewport Display panel in the World Properties has several settings that
are used by the Workbench Engine.

Color
:   The color of the world background. This color will be rendered
    in the background of the scene.
user: Explain Using Assets in complete detail according to the official Blender documentation.

assistant: As a general rule, **an asset can be used by dragging it from the Asset Browser to the desired location**.
Objects and worlds can be dragged from the Asset Browser into the scene.
Materials can be dragged onto the object that should use them.
Geometry nodes can also be dragged onto objects to add a [Geometry Nodes Modifier](../modeling/modifiers/geometry_nodes.html).
The use of pose assets is different, and is described in [Pose Library](../animation/armatures/posing/editing/pose_library.html).

When you drag a collection, it will be added as an
[instance](../scene_layout/object/properties/instancing/collection.html) – that is, a single object representing
the entire collection, meaning the contents aren’t visible in the [Outliner](outliner/introduction.html)
and can’t be edited. You can change this in the following ways:

- Use [Make Instances Real](../scene_layout/object/editing/apply.html#bpy-ops-object-duplicates-make-real) to replace the object by the collection contents.
- Alternatively: delete the object, find the collection in the Outliner’s *Blender File*
  [Display Mode](outliner/interface.html#bpy-types-spaceoutliner-display-mode), and click Link to Scene in its context menu.

There are several things that can happen when an asset is used,
depending on the [Import Method](#bpy-types-fileassetselectparams-import-method).

Note that all regular Blender operations are available after the asset has been added to the current file.
For example, you could choose to link an object to the scene; this will also link its mesh and its materials.
Then you can make the object itself local
(Object ‣ Relations ‣ Make Local… ‣ Selected Objects),
while keeping the mesh and materials linked to the asset files. This will result in a local,
and thus editable, object, and keep the mesh and materials automatically up to date with
any changes in the asset library.
user: What is Redistribute Curve Points and how is it used in Blender Python scripting?

assistant: # Redistribute Curve Points

The *Redistribute Curve Points* node repositions existing control points so they are
evenly spaced along each curve.
This helps improve uniformity, especially after deformations or procedural
operations that distort point spacing, ensuring consistent interpolation and smoother results.
user: Explain Delta Transforms in complete detail according to the official Blender documentation.

assistant: Delta Transforms are simply transformations that are applied on top of the transforms described above.
Delta Transforms are particularly useful in animations. For example,
you can animate an object with the primary transforms then move them around with Delta Transforms.
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: The output of the node is dynamic. It is either a vector or a scalar depending on the operator.
For instance, the *Length* operator has a scalar output while the *Add* operator has a vector output.

Vector
:   Output vector.

Value
:   Output value.
user: Describe face.basic_tongue from the Blender manual or Python API, including usage steps and snippets.

assistant: Generates a simple tongue, extracted from the original PitchiPoy [super_face](faces.xhtml#rigify-rigs-faces-super-face) rig.

B-Bone Segments (integer)
:   Defines the number of b-bone segments each tweak control will be split into.

Primary Control Layers
:   Optionally specifies bone collections for the main control.
user: Show practical ways to work with Luma Waveform in a Blender add-on or script – include code.

assistant: This scope visualizes the luminosity (brightness) distribution of the image,
letting you see at a glance if there’s enough contrast and if any areas are
under- or overexposed.

The scope works by plotting a curve for each scanline in the current video frame.
Another way of saying this is that each pixel column in the luma waveform
is a brightness histogram of the corresponding pixel column in the frame.
Specifically:

- The horizontal position of a pixel in the waveform refers to a pixel column in the frame.
- The vertical position of a pixel in the waveform refers to a brightness value,
  going from 0 at the bottom to 1 at the top.
- The brightness of a pixel in the waveform indicates how many pixels in the above frame column
  have the above brightness. If no pixels in the frame column have this brightness, the
  waveform pixel is black. If at least three pixels in the frame column have this brightness,
  the waveform pixel is white.

When this scope is selected, you have the following option in
Sidebar ‣ View ‣ View Settings:

The examples below show two images and their corresponding luma waveforms.

|  |  |
| --- | --- |
| ../../../../_images/video-editing_preview_display-mode_luma-waveform-example-1.png   The various horizontal lines in the luma waveform match the uniform-colored lines of the picture. Note that the ‘gray 20%’ one-pixel width line (inside the yellow strip) is represented in the Luma waveform by a gray line. The two lines drawing an “X” are from the two monochrome gradients. Finally, the broken line matches the colored gradient at the bottom. | ../../../../_images/video-editing_preview_display-mode_luma-waveform-example-2.png   The curves are quite visible. We found a luma of 80-100% for the sky, a luma around 40% for the sea, and a luma of 10-20% for the mountains, growing around 40% for the sunny part. |
user: Give a detailed overview of Workspaces: syntax, arguments, return values, common patterns.

assistant: # Workspaces

Workspaces are essentially predefined window layouts.
Each Workspace consists of a set of [Areas](areas.xhtml)
containing [Editors](../../editors/index.xhtml), and is geared towards a specific task such as
modeling, animating, or scripting. You’ll typically switch between
multiple Workspaces while working on a project.

[image reference removed]

Workspaces are located at the Topbar.
user: How do I use Introduction in Blender? Include parameters, examples, warnings and best practices.

assistant: # Introduction

*Curves Sculpt Mode* allows working with curves using various brushes.
It is commonly used for hair grooming, but can be used with all kinds of curves.

The curves’ surface object plays an important role in many curves sculpting brushes.
Most brushes such as [Add Curves](brushes/add_curves.html)
require the surface to be set already.
user: What is BlendDataVolumes(bpy_struct) and how is it used in Blender Python scripting?

assistant: # BlendDataVolumes(bpy_struct)

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

*class* bpy.types.BlendDataVolumes(*bpy_struct*)
:   Collection of volumes

    new(*name*)
    :   Add a new volume to the main database

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – New name for the data-block

        Returns:
        :   New volume data-block

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

    remove(*volume*, *\**, *do_unlink=True*, *do_id_user=True*, *do_ui_user=True*)
    :   Remove a volume from the current blendfile

        Parameters:
        :   - **volume** ([`Volume`](bpy.types.Volume.html#bpy.types.Volume "bpy.types.Volume"), (never None)) – Volume to remove
            - **do_unlink** (*boolean**,* *(**optional**)*) – Unlink all usages of this volume before deleting it (WARNING: will also delete objects instancing that volume data)
            - **do_id_user** (*boolean**,* *(**optional**)*) – Decrement user counter of all data-blocks used by this volume data
            - **do_ui_user** (*boolean**,* *(**optional**)*) – Make sure interface does not reference this volume data

    tag(*value*)
    :   tag

        Parameters:
        :   **value** (*boolean*) – Value

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

assistant: Mode
:   Inputs to use to control the line.

    Offset:
    :   Specify the offset from one vertex to the next.

    End Points:
    :   Specify the start and end point of the line.

Count Mode
:   Determines how the number of vertices is chosen.
    This is only available when the mode is set to *End Points*.

    Count:
    :   Specify the total number of vertices.

    Resolution:
    :   Specify the distance between vertices.
user: Describe JSON from the Blender manual or Python API, including usage steps and snippets.

assistant: To generate a valid JSON file use the [server generate](../../command_line/extension_arguments.xhtml#command-line-args-extension-server-generate)
Blender command-line tool:

```
blender --command extension server-generate --repo-dir=/path/to/packages
```

This creates an `index.json` listing from all the .zip extensions found in the –repo-dir location.

For more details, read the generated JSON
[API](https://developer.blender.org/docs/features/extensions/api_listing/).

### Testing

To test the generated repository, add a new Remote Repository from the Preferences:

- Get Extensions → Repositories → [+] → Add Remote Repository
- Paste the location of the generated JSON as the URL.
  So the example `/path/to/packages` would use the:

  - `file:///path/to/packages/index.json` on Linux and macOS.
  - `file:///C:/path/to/packages/index.json` on Windows.
  - `file://HOST/share/path/to/packages/index.json` for network shares on Windows.
user: What is Animation and how is it used in Blender Python scripting?

assistant: ```
blender -b file.blend -a
```

`-a`
:   Render the whole animation using all the settings saved in the blend-file.

```
blender -b file.blend -E CYCLES -s 10 -e 500 -t 2 -a
```

`-E CYCLES`
:   Use the “Cycles Render” engine.
    For a list of available render engines, run `blender -E help`.

`-s 10 -e 500`
:   Set the start frame to `10` and the end frame to `500`.

`-t 2`
:   Use only two threads.
user: What is ShaderNodeEeveeSpecular(ShaderNode) and how is it used in Blender Python scripting?

assistant: # ShaderNodeEeveeSpecular(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.ShaderNodeEeveeSpecular(*ShaderNode*)
:   Similar to the Principled BSDF node but uses the specular workflow instead of metallic, which functions by specifying the facing (along normal) reflection color. Energy is not conserved, so the result may not be physically accurate

    *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 Moving Bones between Collections and how is it used in Blender Python scripting?

assistant: Blender should be in *Edit Mode* or *Pose Mode* to move bones between collections.
Note that as with objects, bones can be assigned to in several collections at once.

Move to Bone Collection
:   Shows a list of the Armature’s *editable* bone collections. Choosing a bone
    collection unassign the selected bones from all other bone collections, then
    assigns them to the chosen one.

    Available as Pose ‣ Move to Collection (*Pose Mode*)
    Armature ‣ Move to Collection (*Edit Mode*), and `M` (either mode).

Bone Collections
:   Shows a list of the Armature’s *editable* bone collections. The collections
    that the active bone is assigned to are prefixed with a `-`, and choosing
    those will unassign all selected bones from that collection. Similarly,
    choosing a bone collection prefixed with a `+` will assign all selected bones
    to that collection.

    Available as Pose ‣ Bone Collections (*Pose Mode*)
    Armature ‣ Bone Collections (*Edit Mode*), and `Shift`-`M` (either mode).
user: What is Conclusions and how is it used in Blender Python scripting?

assistant: Add-ons can encapsulate certain functionality neatly for writing tools
to improve your workflow or for writing utilities for others to use.

While there are limits to what Python can do within Blender,
there is certainly a lot that can be achieved without having to dive into Blender’s C/C++ code.

The example given in the tutorial is limited, but shows the Blender API used
for common tasks that you can expand on to write your own tools.

### Further Reading

Blender comes with commented templates which are accessible from the Text editor’s header.
If you have specific areas you want to see example code for, this is a good place to start.

Here are some sites you might like to check on after completing this tutorial.

- [Blender/Python API Overview](https://docs.blender.org/api/current/info_overview.html) –
  For more background details on Blender/Python integration.
- [How to Think Like a Computer Scientist](https://runestone.academy/ns/books/published/thinkcspy/index.html) –
  Great info for those who are still learning Python.
- [Blender Development](https://developer.blender.org/) –
  Blender Development, general information and helpful links.
- [Blender Developer Forum](https://devtalk.blender.org/tag/python) –
  Forum where people ask Python development questions.
user: How do I use Closure in Blender? Include parameters, examples, warnings and best practices.

assistant: # Closure

The *Closure* node defines a zone that encapsulates a reusable section of nodes behaving like a function.
It specifies inputs, outputs, and internal logic that can be executed elsewhere in the node tree using an
[Evaluate Closure](../../../interface/controls/nodes/types/utilities/closure/evaluate_closure.xhtml) node.

Closures allow users to pass custom procedural logic into node groups, making tools more modular and adaptable.
Instead of duplicating or editing an existing group, a closure can expose user-defined behavior while preserving
the structure of the main system.

[image reference removed]

An empty closure zone.
user: Describe Chroma Key Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Chroma Key Node

[image reference removed]

The *Chroma Key* node determines if a pixel is a foreground or background
(and thereby should be transparent) based on its chroma values.

Use this, for example, to composite images that have been shot in front of a green or blue screen.
user: Show practical ways to work with Point to Target in a Blender add-on or script – include code.

assistant: All selected normals are set to point from their vertex to the target
after confirmed by `Return` or `LMB`.

A target is set by the keys:

- The mouse cursor `M`
- The pivot `L`
- The object origin `O`
- The cursor (set at this click) `Ctrl`-`LMB`
- A mesh item selection (set by this click) `Ctrl`-`RMB`

Mode
:   The tool operation can be modified; if one of the following keys has been previously pressed:

    Align `A`
    :   All normals will point in the same direction: from the center of selected points to the target.

    Spherize `S`
    :   Each normal will be an interpolation between its original value and the direction to the target.

    Invert `I`
    :   The normal directions are reversed from what was specified above.

Reset `R`
:   Will reset the custom normals back to what they were when the operation started.
user: Explain GeometryNodeFieldToGridItem(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeFieldToGridItem(bpy_struct)

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

*class* bpy.types.GeometryNodeFieldToGridItem(*bpy_struct*)
:   color
    :   Color of the corresponding socket type in the node editor

        Type:
        :   float array of 4 items in [0, inf], default (0.0, 0.0, 0.0, 0.0), (readonly)

    data_type
    :   Type:
        :   enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items), default `'FLOAT'`

    identifier
    :   Type:
        :   int in [-inf, inf], default 0, (readonly)

    name
    :   Type:
        :   string, default “”, (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: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Resolution
:   The number of edges on the curve.

Start, Middle, End
:   Positions of the three control points.
    The generated curve passes through the two end points, and is tangent to the lines between
    the middle point and the two end points.
user: Give a detailed overview of Symmetry: syntax, arguments, return values, common patterns.

assistant: # Symmetry

Mirror
:   Mirror the brush strokes across the selected local axes.
    Note that if you want to alter the directions the axes point in,
    you must rotate the model in Edit Mode and not in Object Mode.
user: What is Overriding Context and how is it used in Blender Python scripting?

assistant: It is possible to override context members that the operator sees, so that they
act on specified rather than the selected or active data, or to execute an
operator in the different part of the user interface.

The context overrides are passed in as keyword arguments,
with keywords matching the context member names in `bpy.context`.
For example to override `bpy.context.active_object`,
you would pass `active_object=object` to [`bpy.types.Context.temp_override`](bpy.types.Context.html#bpy.types.Context.temp_override "bpy.types.Context.temp_override").

```
# Remove all objects in scene rather than the selected ones.
import bpy
from bpy import context
context_override = context.copy()
context_override["selected_objects"] = list(context.scene.objects)
with context.temp_override(**context_override):
    bpy.ops.object.delete()
```
user: Give a detailed overview of Troubleshooting macOS – Other GPU: syntax, arguments, return values, common patterns.

assistant: # Troubleshooting macOS – Other GPU

Blender uses OpenGL for the 3D Viewport and user interface. The graphics processing unit (GPU) and driver have a big
impact on Blender’s behavior and performance.

This section lists possible solutions for graphics glitches, problems with EEVEE and Cycles, and crashes related to
your GPU.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: Blend
:   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

Opacity
:   The amount of the blend of the second image gets composed onto the first.
user: What is Displace Hair Curves and how is it used in Blender Python scripting?

assistant: # Displace Hair Curves

The *Displace Hair Curves* node offsets the shape or position of hair curves using a displacement vector.
This allows for procedural control over hair movement, direction, or surface alignment.
The displacement can be applied in object, world, or surface normal space, depending on the configuration.
user: Give a detailed overview of Join: syntax, arguments, return values, common patterns.

assistant: # Join

Join merges all selected objects into the last selected *Active* object.
All object data is linked to the active object (which must be selected).
All objects must be of the same type: mesh, curve, surface or armature.
If several curves are joined, each one will keep its subtype (NURBS or Bézier).
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

The Boolean modifier.

Operation
:   Intersect:
    :   Only keep the volume that’s inside the modified mesh and all of the source meshes.

    Union:
    :   Add the source meshes to the modified mesh while removing any interior faces.

    Difference:
    :   Cut the source meshes out of the modified mesh.

Operand Type
:   Object:
    :   The source is a single mesh object.

    Collection:
    :   The source is a collection of any number of mesh objects.
        If the *Solver* is *Float*, the *Intersect* operation is not allowed.

Object
:   The source mesh object.

Collection
:   The source collection. May be empty if *Solver* is *Exact*,
    in which case the modifier simply removes the modified mesh’s
    interior (self-intersecting) geometry.

Solver
:   Algorithm used to perform the Boolean operation.

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

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

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

### Solver Options

Materials Exact Solver
:   Method for setting materials on the new faces.

    Index Based:
    :   Map the [first material](../../../render/materials/assignment.html#bpy-types-materialslot) of the source mesh to the first material
        of the modified mesh, the second to the second, and so on. If a source face has a higher
        material index than the number of material slots on the modified mesh, the modified mesh’s
        first material is used.

    Transfer:
    :   Use the same materials as on the source mesh, adding new material slots to the modified mesh
        as necessary. For empty slots, fall back to using the same material index as the source mesh.

Self Intersection Exact Solver
:   Correctly handle self-intersection in the participating meshes, at the cost of performance.

Hole Tolerant Exact Solver
:   Optimizes the Boolean output for [Non-manifold](../../../glossary/index.html#term-Non-manifold) geometry
    at the cost of increased computational time.
    Because of the performance impact, this option should only be enabled
    when the *Exact* solver demonstrates errors with non-manifold geometry.

Overlap Threshold Float Solver
:   Maximum distance between two faces to consider them as overlapping.
    This helps solve the limitation of this solver.
    If the result is still not as expected, try using the *Exact* solver.
user: Give a detailed overview of Grease Pencil Materials: syntax, arguments, return values, common patterns.

assistant: # Grease Pencil Materials

Materials control the appearance of the Grease Pencil object.
They define the base color and texture of the strokes and filled areas.

There is always only one active material in the list (the selected one).
When you draw, the new strokes use the active material.

You can override the base material color using the tools in
[Vertex Mode](../modes/vertex_paint/introduction.xhtml)
or the Draw and Tint tool in Draw Mode.

The material always remains linked to the strokes, this means that any change in a material will change
the look of already drawn strokes.

[image reference removed]

Same stroke linked to different materials.
user: What is OperatorMacro(bpy_struct) and how is it used in Blender Python scripting?

assistant: # OperatorMacro(bpy_struct)

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

*class* bpy.types.OperatorMacro(*bpy_struct*)
:   Storage of a sub operator in a macro after it has been added

    properties
    :   Type:
        :   [`OperatorProperties`](bpy.types.OperatorProperties.html#bpy.types.OperatorProperties "bpy.types.OperatorProperties"), (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 Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Projection Matrix
:   A 4x4 matrix that represents the camera’s projection transform, combining focal length,
    sensor size, shift, and clipping range. Can be used to project 3D coordinates into screen space.

Focal Length
:   The focal length of the camera in millimeters. Affects field of view in perspective cameras.

Sensor
:   The physical size of the camera sensor in millimeters, as a 2D vector (X and Y dimensions).
    This value is influenced by the sensor fit properties.

Shift
:   Horizontal and vertical shift of the camera view, expressed as a 2D vector.

Clip Start
:   The near clipping distance of the camera.

Clip End
:   The far clipping distance of the camera.

Focus Distance
:   The distance from the camera to the focus point, in Blender units.
    Typically used for depth of field calculations.

Is Orthographic
:   A boolean output that is *true* when the camera is in orthographic mode, and *false* when in perspective mode.

Orthographic Scale
:   The orthographic scale used when the camera is set to orthographic mode.
    Controls the size of the view area instead of using focal length.
user: What is Properties and how is it used in Blender Python scripting?

assistant: Operation
:   Intersect:
    :   Produce a new geometry containing only the volume inside of both geometry 1 and geometry 2.

    Union:
    :   The two input meshes are joined, then any interior elements are removed.

    Difference:
    :   Geometry 2 is subtracted from geometry 1 (everything outside of geometry 2 is kept).

Solver
:   Algorithm used to calculate the Boolean intersections.

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

    Exact:
    :   Uses a mathematically complex solver which offers the best results
        when there are coplanar faces or other overlapping geometry;
        however, this solver is much slower.

    Manifold:
    :   Uses a solver that is usually fastest but only works on [Manifold](../../../../glossary/index.html#term-Manifold) meshes,
        (plus the special case of Difference with a plane).
user: Show practical ways to work with Light Probe Sphere in a Blender add-on or script – include code.

assistant: # Light Probe Sphere

A light probe sphere records the light incoming from many directions at a single location.

They are used for smooth and semi-rough reflections.
Sphere probes smoothly blend to light probe volume lighting for completely diffuse reflections.

If *Raytracing* is turned on, they are used as a fallback if a ray misses.

Adjusting their resolution is done inside the [Scene data](../scene_settings.html) panel.

The world also has an internal light probe sphere with a resolution that can be adjusted
in the [World data](../world_settings.html) panel.
user: Give a detailed overview of NodeGroupInput(NodeInternal): syntax, arguments, return values, common patterns.

assistant: # NodeGroupInput(NodeInternal)

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

*class* bpy.types.NodeGroupInput(*NodeInternal*)
:   Expose connected data from inside a node group as inputs to its interface

    *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 GeometryNodeImageInfo(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeImageInfo(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.GeometryNodeImageInfo(*GeometryNode*)
:   Retrieve information about an image

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of CompositorNodeDistanceMatte(CompositorNode): syntax, arguments, return values, common patterns.

assistant: # CompositorNodeDistanceMatte(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.CompositorNodeDistanceMatte(*CompositorNode*)
:   Create matte based on 3D distance between colors

    *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