PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is UVProjector(bpy_struct) and how is it used in Blender Python scripting?

assistant: # UVProjector(bpy_struct)

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

*class* bpy.types.UVProjector(*bpy_struct*)
:   UV projector used by the UV project modifier

    object
    :   Object to use as projector transform

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

    *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: Provide the full official documentation entry for Outputs, preserving all code examples.

assistant: Is Valid Offset
:   Whether the input control point plus the offset is a valid index of the original curve.
    Any offset in a cyclic curve is always valid.

Point Index
:   The index of the offset curve point.
user: What is Cube and how is it used in Blender Python scripting?

assistant: Adds a standard cube mesh composed of six quad faces, eight vertices, and twelve edges.
This is one of the most basic and frequently used primitives in modeling,
serving as a starting point for creating boxes, crates, buildings, or sculpting bases.

Size
:   Sets the total width, height, and depth of the cube (i.e., the full diameter along each axis).
    A size of 2 creates a cube that spans from -1 to +1 on all axes.
user: Give a detailed overview of Hints: syntax, arguments, return values, common patterns.

assistant: Many modeling tasks involve creating objects that are symmetrical.
This modifier offers a simple and efficient way to do this, with real-time update of the mirror as you edit it.
Once your modeling is completed you can either click *Apply* to make a real version of your mesh,
or leave it as-is for future editing.

### Accurately Positioning the Mirror Plane

To apply a *Mirror* modifier, it is common to have to move the object’s origin onto
the edge or face that is to be the axis for mirroring.
This can be tricky when attempted visually.

A good technique to achieve an exact position is
to select the edge, then [snap](../../../editors/3dview/controls/snapping.html) *Cursor to Selection*.
This will position the 3D Cursor in the center of the edge.
Finally, use the [Set Origin](../../../scene_layout/object/origin.html#bpy-ops-object-origin-set) menu, and select *Origin to 3D Cursor*.
This will move the object’s origin (and thus, the mirror plane) to where the 3D cursor is located,
and the mirroring will be exact.

An alternative is to use an empty as a *Mirror Object* that you move to the correct position.
user: Explain Noise in complete detail according to the official Blender documentation.

assistant: # Noise

[image reference removed]

Noise Texture panel.

Although this looks great, it is not Perlin Noise! This is a true, randomly generated Noise.
This gives a different result every time, for every frame, for every pixel.
user: Explain Scatter on Surface Node in complete detail according to the official Blender documentation.

assistant: # Scatter on Surface Node

[image reference removed]

The *Scatter on Surface* node distributes points or instances across the surface of a mesh.
It provides flexible control over how elements are placed using density, randomization,
and Poisson disk sampling.
This node is useful for procedural scattering of objects such as grass, rocks, or debris
on terrain or any other surface.
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

Constraints are a way of automatically controlling the location, rotation,
and scale of an [object](../../glossary/index.html#term-Object) or [bone](../../glossary/index.html#term-Bone). For example, they can
[attach](relationship/child_of.html)
a sword to a knight’s hand, or make a tennis player’s eyes
[point towards](tracking/damped_track.html) the ball.

Each object or bone can have a *stack* of constraints that’s evaluated from top to bottom.
In addition, each constraint has an [Influence](interface/common.html#bpy-types-constraint-influence) factor
for weakening it or mixing it with other constraints. What’s more, this Influence can be
keyframed, which makes it possible to turn constraints on and off over the course of an animation.

|  |  |  |
| --- | --- | --- |
| ../../_images/animation_constraints_introduction_tab-object.png   Object | ../../_images/animation_constraints_introduction_tab-bone.png   Bone | ../../_images/animation_constraints_interface_stack_example.png   Constraint Stack |
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Curve
:   Standard geometry input.

Selection
:   Whether or not to resample each spline. True values mean spline will be resampled to a poly spline,
    false values mean the spline will be unaffected.

Mode
:   How to specify the amount of samples.

    Count:
    :   Sample the specified number of points along each spline.

    Length:
    :   Calculate the number of samples by splitting each spline into segments with the specified length.
        The length will be rounded down so that a whole number of samples will fit in each input spline.

    Evaluated:
    :   Evaluate the spline’s points based on the resolution attribute for NURBS and Bézier splines.
        Changes nothing for poly splines.

Count Count
:   The number of control points on the new splines.

Length Length
:   The approximate length between the control points of the new splines.
user: Show practical ways to work with NodeTreeInterfaceSocketObject(NodeTreeInterfaceSocket) in a Blender add-on or script – include code.

assistant: # NodeTreeInterfaceSocketObject(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketObject(*NodeTreeInterfaceSocket*)
:   Object socket of a node

    default_value
    :   Input value used for unconnected socket

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

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: The Keymap editor lets you change the default hotkeys for each of Blender’s editors.

[image reference removed]

Keymap editor.

Usage

1. Find the operation whose shortcut you want to change. Filtering can help with this.
2. Select whether the operation should be triggered by a keyboard key, a mouse button, or something else.
3. Click the button on the right and press the shortcut you want to assign.

Active
:   Uncheck the checkbox to disable this keymap item.

Map Type
:   Keyboard:
    :   Single hotkey or key combination.

    Mouse:
    :   Actions from mouse buttons, tablet or touchpad input.

    NDOF:
    :   Movement or button from a 3D mouse ([NDOF](../../glossary/index.xhtml#term-NDOF)) device.

    Tweak:
    :   Mouse click and drag *(optionally map drag direction to different actions)*.

    Text Input:
    :   Use this function by entering a text.

    Timer:
    :   For Blender internal use.

Operator ID Name
:   The identifier for the operator to call.

Event
:   Type
    :   The key or button that activates this keymap item (depending on the map type).

    Value
    :   The action (such as press, release, click, drag, etc.), (depending on the map type).

    Modifier
    :   Additional keys to hold (such as `Ctrl`, `Shift`, `Alt`).

Operator Properties
:   Initial values for the operator-specific properties.

### Restoring

If you want to restore the default settings for a keymap,
just click on the *Restore* button at the top right of this keymap.
user: Explain Notes in complete detail according to the official Blender documentation.

assistant: The slightest difference in seed values would result in completely different outputs.
Consequently, bad precision may have significant impact on the output.
Usually, we can mitigate this issue by:

- Eliminating the problematic seed value. If the problematic seed value is constant,
  it should be eliminated by choosing a lower dimension or multiplying it by zero.
- Adding an arbitrary value to the seed. The issue might only happen at certain boundaries,
  like unit boundaries, so simply adding an arbitrary value might solve the issue.
- Taking the absolute value of the seed. In computing, zero may be positive or negative,
  so taking the absolute values unifies the zero into a single value.

|  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_textures_white-noise_issue.png   Precision issue due to signed zeros on the Z axis. | ../../../_images/render_shader-nodes_textures_white-noise_solution1.png   Mitigating the issue by eliminating the Z axis. |
| ../../../_images/render_shader-nodes_textures_white-noise_solution2.png   Mitigating the issue by adding an arbitrary value. | ../../../_images/render_shader-nodes_textures_white-noise_solution3.png   Mitigating the issue by taking the absolute value. |
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`NodeClosureInputItems.new`](bpy.types.NodeClosureInputItems.html#bpy.types.NodeClosureInputItems.new "bpy.types.NodeClosureInputItems.new") - [`NodeClosureInputItems.remove`](bpy.types.NodeClosureInputItems.html#bpy.types.NodeClosureInputItems.remove "bpy.types.NodeClosureInputItems.remove") | - [`NodeClosureOutput.input_items`](bpy.types.NodeClosureOutput.html#bpy.types.NodeClosureOutput.input_items "bpy.types.NodeClosureOutput.input_items") |
user: How do I use Select Next/Previous in Blender? Include parameters, examples, warnings and best practices.

assistant: These operators will select the next or previous control point(s),
based on the current selection
(i.e. the control points following or preceding the selected ones along the curve).
In case of a cyclic curve, the first and last points are not considered as neighbors.
user: What is Brush Settings and how is it used in Blender Python scripting?

assistant: ### General

### Unique

Deformation
:   Deformation type that is used by the brush.

    Drag:
    :   Pulls the displacement values in the direction of the brush.

    Pinch:
    :   Pulls the displacement values towards the center of the brush,
        creating hard surface effects without pinching the topology.

    Expand:
    :   Pushes the displacement values away from the brush center, smoothing the displacement.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Grid
:   The input SDF grid to be smoothed.
    Typically generated from another SDF operation such as a boolean or mesh conversion.

Iterations
:   The number of smoothing iterations to apply.
    Higher values produce a larger, smoother fillet radius but also increase computation time.
    A single iteration results in a subtle rounding, while multiple iterations
    create progressively softer surfaces.
user: Give a detailed overview of Keys: syntax, arguments, return values, common patterns.

assistant: ### Available Keys

When customizing keymaps it’s useful to use keys which won’t conflict with Blender’s default keymap.

Here are keys which aren’t used and aren’t likely to be used in the future.

F-Keys (`F5` - `F8`)
:   These F-keys (including modifier combination)
    have been intentionally kept free for users to bind their own keys to.

`OSKey` (also known as the `Windows-Key`, `Cmd` or `Super`)
:   Blender doesn’t use this key for any bindings.

    *macOS* is an exception, where `Cmd` replaces `Ctrl`
    except in cases it would conflict with the system’s key bindings.

`Hyper` is a modifier available on Wayland and X11
:   Blender doesn’t use this key for any bindings.

    Note that this modifier typically needs to be configured,
    see: [!136340](https://projects.blender.org/blender/blender/pulls/136340) for details.

Modifier Double Click
:   Binding modifier keys as primary keys is supported,
    to avoid conflicts with regular usage you can bind them to double click.

### Multi-Action Keys

#### Click/Drag

It’s possible to configure a single key to perform multiple operations
using *Click* event instead of *Press*. Then you may bind *Drag* to a separate action.

This is useful for mixing actions where one uses a drag event, e.g:
Toggle a setting using with `Tab`, drag to open a pie menu showing all options related to the setting.

This is used in the default keymap in the 3D Viewport,
`Alt`-`MMB` dragging in different directions rotates the view.
user: Give a detailed overview of External: syntax, arguments, return values, common patterns.

assistant: Screen Grab Size
:   Size of the captured image for reprojecting.

Quick Edit
:   Edit a snapshot of the viewport in an external image editor.

Apply
:   Project edited image back onto the object.

Apply Camera Image
:   Project an edited render from the active camera back onto the object.
user: Provide the full official documentation entry for Example, preserving all code examples.

assistant: [image reference removed]

In this example a simple subdivided cube has been transformed into a rather complex object using
a stack of modifiers.

[Download example file](https://archive.blender.org/wiki/2015/index.php/File:25-Manual-Modifiers-example.blend).
user: How do I use Linestyle Geometry Modifier Type Items in Blender? Include parameters, examples, warnings and best practices.

assistant: # Linestyle Geometry Modifier Type Items

2D_OFFSET:
:   2D Offset.

2D_TRANSFORM:
:   2D Transform.

BACKBONE_STRETCHER:
:   Backbone Stretcher.

BEZIER_CURVE:
:   Bézier Curve.

BLUEPRINT:
:   Blueprint.

GUIDING_LINES:
:   Guiding Lines.

PERLIN_NOISE_1D:
:   Perlin Noise 1D.

PERLIN_NOISE_2D:
:   Perlin Noise 2D.

POLYGONIZATION:
:   Polygonization.

SAMPLING:
:   Sampling.

SIMPLIFICATION:
:   Simplification.

SINUS_DISPLACEMENT:
:   Sinus Displacement.

SPATIAL_NOISE:
:   Spatial Noise.

TIP_REMOVER:
:   Tip Remover.
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Data Type
:   Float:
    :   The output will be a *Float* field.

    Integer:
    :   The output will be an *Integer* field.

    Vector:
    :   The output will be a *Vector* field.

    Boolean:
    :   The output will be a *Boolean* field.
user: Describe Line Set from the Blender manual or Python API, including usage steps and snippets.

assistant: # Line Set

A line set selects, among the lines (edges) detected by Freestyle,
which ones will be rendered using its attached
[line style](line_style/index.xhtml), through various methods.

[image reference removed]

Freestyle Line Set panel.

Select By
:   Image Border
    :   Causes Freestyle to only take geometry within the image border into consideration for line calculation.
        This reduces render times but increases continuity problems when geometry is moved out of and
        into camera view.
user: Provide the full official documentation entry for Properties, preserving all code examples.

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

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

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

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

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

Clamp Result (Color only)
:   Limit the Result to the range between 0.0 and 1.0.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [[image reference removed]](../../../_images/grease-pencil_modifiers_deform_hook_panel.png)

The Hook modifier.

Object
:   The name of the object to hook points to.

Strength
:   Adjust this hooks influence on the stroke points, were (0.0 to 1.0) (no change to fully follow the hook).

### Falloff

Type
:   This can be used to adjust the type of curve for the Strength attenuation.
    You can also define a custom curve to get a much higher level of control.

Radius
:   The size of the hooks influence.

Uniform Falloff
:   This setting is useful when using hooks on scaled objects,
    especially in cases where non-uniform scale would stretch the result of the hook.

### Influence

See [Influence Filters](../introduction.html#grease-pencil-modifier-influence-filters).
user: What is Noise Modifier and how is it used in Blender Python scripting?

assistant: # Noise Modifier

The *Noise* Modifier changes the value of one or more stroke/points properties like:
location, strength, thickness or UV texture position
by adding varied values that make the line unstable and noisy.

Random values can be used for the noise factor for more vivid effects.
user: Show practical ways to work with Float4x4AttributeValue(bpy_struct) in a Blender add-on or script – include code.

assistant: # Float4x4AttributeValue(bpy_struct)

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

*class* bpy.types.Float4x4AttributeValue(*bpy_struct*)
:   Matrix value in geometry attribute

    value
    :   Matrix

        Type:
        :   [`mathutils.Matrix`](mathutils.html#mathutils.Matrix "mathutils.Matrix") of 4 \* 4 items in [-inf, inf], default ((0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0))

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

assistant: # Color Spill Node

[image reference removed]

The *Color Spill* node is used to suppress unwanted color casts—typically green or blue;
caused by light reflecting from a chroma key (green or blue screen) onto the subject.

This “spill” is common in compositing workflows and can give a subject an unnatural colored tint.
The node reduces the influence of the selected color channel,
removing the excess and restoring a more natural appearance.
user: Describe Sculpt Curves Operators from the Blender manual or Python API, including usage steps and snippets.

assistant: # Sculpt Curves Operators

bpy.ops.sculpt_curves.brush_stroke(*\**, *stroke=None*, *mode='NORMAL'*, *pen_flip=False*)
:   Sculpt curves using a brush

    Parameters:
    :   - **stroke** (`bpy_prop_collection` of `OperatorStrokeElement`, (optional)) – Stroke
        - **mode** (enum in [`'NORMAL'`, `'INVERT'`, `'SMOOTH'`, `'ERASE'`], (optional)) –

          Stroke Mode, Action taken when a paint stroke is made

          - `NORMAL`
            Regular – Apply brush normally.
          - `INVERT`
            Invert – Invert action of brush for duration of stroke.
          - `SMOOTH`
            Smooth – Switch brush to smooth mode for duration of stroke.
          - `ERASE`
            Erase – Switch brush to erase mode for duration of stroke.
        - **pen_flip** (*boolean**,* *(**optional**)*) – Pen Flip, Whether a tablet’s eraser mode is being used

bpy.ops.sculpt_curves.min_distance_edit()
:   Change the minimum distance used by the density brush

bpy.ops.sculpt_curves.select_grow(*\**, *distance=0.1*)
:   Select curves which are close to curves that are selected already

    Parameters:
    :   **distance** (*float in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Distance, By how much to grow the selection

bpy.ops.sculpt_curves.select_random(*\**, *seed=0*, *partial=False*, *probability=0.5*, *min=0.0*, *constant_per_curve=True*)
:   Randomizes existing selection or create new random selection

    Parameters:
    :   - **seed** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Seed, Source of randomness
        - **partial** (*boolean**,* *(**optional**)*) – Partial, Allow points or curves to be selected partially
        - **probability** (*float in* *[**0**,* *1**]**,* *(**optional**)*) – Probability, Chance of every point or curve being included in the selection
        - **min** (*float in* *[**0**,* *1**]**,* *(**optional**)*) – Min, Minimum value for the random selection
        - **constant_per_curve** (*boolean**,* *(**optional**)*) – Constant per Curve, The generated random number is the same for every control point of a curve
user: Show practical ways to work with Tilt in a Blender add-on or script – include code.

assistant: This setting controls how the normals (visualized as arrows)
twist around each control point – so it is only relevant with 3D curves!
The tilt will be interpolated from point to point (you can check it with the normals).

[[image reference removed]](../../../_images/modeling_curves_editing_control-points_extrude-mean-tilt.png)

30 degree Mean Tilt of all control points.
user: Show practical ways to work with Weight Options in a Blender add-on or script – include code.

assistant: Multiframe
:   Sometimes you may need to assign weight to several frames at the same time with the Weight Paint tools.

    You can activate multiframe editing with the Multiframe button next to the modes selector (faded lines icon).
    See [Multiframe](../../multiframe.xhtml) for more information.
user: Give a detailed overview of Linesets(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # Linesets(bpy_struct)

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

*class* bpy.types.Linesets(*bpy_struct*)
:   Line sets for associating lines and style parameters

    active
    :   Active line set being displayed

        Type:
        :   [`FreestyleLineSet`](bpy.types.FreestyleLineSet.html#bpy.types.FreestyleLineSet "bpy.types.FreestyleLineSet"), (readonly)

    active_index
    :   Index of active line set slot

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

    new(*name*)
    :   Add a line set to scene render layer Freestyle settings

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – New name for the line set (not unique)

        Returns:
        :   Newly created line set

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

    remove(*lineset*)
    :   Remove a line set from scene render layer Freestyle settings

        Parameters:
        :   **lineset** ([`FreestyleLineSet`](bpy.types.FreestyleLineSet.html#bpy.types.FreestyleLineSet "bpy.types.FreestyleLineSet"), (never None)) – Line set to remove

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: The core glTF 2.0 format can be extended with extra information, using glTF extensions.
This allows the file format to hold details that were not considered universal at the time of first publication.
Not all glTF readers support all extensions, but some are fairly common.

Certain Blender features can only be exported to glTF via these extensions.
The following [glTF 2.0 extensions](https://github.com/KhronosGroup/glTF/tree/main/extensions)
are supported directly by this add-on:

Import

- `KHR_materials_pbrSpecularGlossiness`
- `KHR_materials_clearcoat`
- `KHR_materials_transmission`
- `KHR_materials_unlit`
- `KHR_materials_emissive_strength`
- `KHR_materials_volume`
- `KHR_materials_sheen`
- `KHR_materials_specular`
- `KHR_materials_anisotropy`
- `KHR_materials_ior`
- `KHR_materials_variants`
- `KHR_lights_punctual`
- `KHR_texture_transform`
- `KHR_mesh_quantization`
- `EXT_mesh_gpu_instancing`

Export

- `KHR_draco_mesh_compression`
- `KHR_lights_punctual`
- `KHR_materials_clearcoat`
- `KHR_materials_transmission`
- `KHR_materials_unlit`
- `KHR_materials_emissive_strength`
- `KHR_materials_volume`
- `KHR_materials_sheen`
- `KHR_materials_specular`
- `KHR_materials_anisotropy`
- `KHR_materials_ior`
- `KHR_materials_variants`
- `KHR_texture_transform`
- `EXT_mesh_gpu_instancing`

### Third-party glTF Extensions

It is possible for Python developers to add Blender support for additional glTF extensions by writing their
own third-party add-on, without modifying this glTF add-on. For more information, [see the example on GitHub](https://github.com/KhronosGroup/glTF-Blender-IO/tree/main/example-addons/) and if needed,
[register an extension prefix](https://github.com/KhronosGroup/glTF/blob/main/extensions/Prefixes.md).
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Mode
:   Whether to consider left and/or right handles.
    When both are selected, the output value is true
    if either of the handles are of the chosen type.

    Left:
    :   Consider the left handle.

    Right:
    :   Consider the right handle.

Handle Type
:   Handle type for which the selection will be true.
    See the [Bézier curves](../../../curves/structure.xhtml#curve-bezier-handle-type) page for more details
    on the different handle types.
user: Show practical ways to work with Components in a Blender add-on or script – include code.

assistant: Materials consist of three shaders, defining the appearance of the surface,
the volume inside the object, and the displacement of the surface.

[image reference removed]

### Surface Shader

The [surface shader](components/surface.xhtml) controls the textures
and light interaction at the surface of the mesh.

### Volume Shader

The [volume shader](components/volume.xhtml) defines the interior of the mesh.
A material can have just a volume shader for cases like smoke and fire,
or it can be combined with a surface shader for materials like cloudy glass.

### Displacement

The shape of the surface and the volume inside it may be altered by
[displacement](components/displacement.xhtml).
This way, textures can then be used to make the mesh surface more detailed.

Depending on the settings, the displacement may be virtual,
only modifying the surface normals to give the impression of displacement,
which is known as bump mapping, or a combination of real and virtual displacement.
user: How do I use Object Shaderfx Type Items in Blender? Include parameters, examples, warnings and best practices.

assistant: # Object Shaderfx Type Items

FX_BLUR:
:   Blur.

    Apply Gaussian Blur to object.

FX_COLORIZE:
:   Colorize.

    Apply different tint effects.

FX_FLIP:
:   Flip.

    Flip image.

FX_GLOW:
:   Glow.

    Create a glow effect.

FX_PIXEL:
:   Pixelate.

    Pixelate image.

FX_RIM:
:   Rim.

    Add a rim to the image.

FX_SHADOW:
:   Shadow.

    Create a shadow effect.

FX_SWIRL:
:   Swirl.

    Create a rotation distortion.

FX_WAVE:
:   Wave Distortion.

    Apply sinusoidal deformation.
user: How do I use Tool Settings in Blender? Include parameters, examples, warnings and best practices.

assistant: Material:
:   Create a new material with the Stroke Base Color to be the sampled color.

    Material Mode
    :   The color transformation will be applied on the stroke and/or the fill color.

        Stroke:
        :   Only paint over strokes.

        Fill:
        :   Only paint over fill areas.

        Both:
        :   Paint over strokes and fill areas

Palette:
:   Add a new color to the color palette based on the sampled color.

Brush:
:   Sets the brush color to the sampled color.
user: Give a detailed overview of RenderViews(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # RenderViews(bpy_struct)

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

*class* bpy.types.RenderViews(*bpy_struct*)
:   Collection of render views

    active
    :   Active Render View

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

    active_index
    :   Active index in render view array

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

    new(*name*)
    :   Add a render view to scene

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – New name for the marker (not unique)

        Returns:
        :   Newly created render view

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

    remove(*view*)
    :   Remove a render view

        Parameters:
        :   **view** ([`SceneRenderView`](bpy.types.SceneRenderView.html#bpy.types.SceneRenderView "bpy.types.SceneRenderView"), (never None)) – Render view to remove

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with Apply in a Blender add-on or script – include code.

assistant: # Apply

Pose as Rest Pose
:   Conversely, you may define the current pose as the new rest pose
    (i.e. “apply” current transformations to the *Edit Mode*). When you do so,
    the skinned objects/geometry is **also** reset to its default,
    non-deformed state, which generally means you will have to skin it again.

Pose Selected as Rest Pose
:   Same as *Pose as Rest Pose* but only applies to selected bones.

Visual Transform to Pose
:   Applies the position of the bone after [Constraints](../../../constraints/index.xhtml);
    allowing the constraints to be deleted and the bones will remain in their constrained positions.

Assign Custom Property Values as Default
:   Assign the current values of custom properties as their defaults,
    for use as part of the rest pose state in NLA track mixing.
user: What is Animated Transform to Deltas and how is it used in Blender Python scripting?

assistant: Converts existing animation keyframes from the object’s primary transforms
(*Location*, *Rotation*, *Scale*) into [Delta Transforms](../properties/transforms.xhtml#bpy-types-object-delta).

This means that the animation data is moved from the main transform channels
to the corresponding delta channels, leaving the main transforms unchanged at their current values.
user: Describe Known Limitations from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Blender Versions

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

While the keymap can be manually updated, the more customizations you make, the higher the chance of conflicts
in newer Blender versions is.
user: Give a detailed overview of Adjustment Layer Strip: syntax, arguments, return values, common patterns.

assistant: # Adjustment Layer Strip

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

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

Or you can stack a primary color correction and several secondary color corrections on top of
each other (probably using the new mask input for area selection).
user: Show practical ways to work with Textures in a Blender add-on or script – include code.

assistant: Blender has various built in procedural texture nodes,
with texture coordinates and various parameters as input, and a color or value as output.
No texture data-blocks are needed; instead node groups can be used for reusing texture setups.

For UV mapping and texture painting in the 3D Viewport, the Image Texture node must be used.
When setting such a node as active, it will be displayed in the 3D Viewport
while using [Texture color](../workbench/color.xhtml) mode.
This method can be used to preview painted textures while texture painting.

The default texture coordinates for all nodes are Generated coordinates,
except for Image textures that use UV coordinates by default.
Each node includes some options to modify the texture mapping and resulting color,
and these can be edited in the texture properties.
user: Give a detailed overview of Principled BSDF: syntax, arguments, return values, common patterns.

assistant: # Principled BSDF

[image reference removed]

The *Principled* BSDF
that combines multiple layers into a single easy to use node.
It can model a wide variety of materials.

It is based on the OpenPBR Surface shading model, and provides parameters
compatible with similar PBR shaders found in other software,
such as the Disney and Standard Surface models.
Image textures painted or baked from software like Substance Painter
may be directly linked to the corresponding input in this shader.
user: Give a detailed overview of Collection Info Node: syntax, arguments, return values, common patterns.

assistant: # Collection Info Node

[[image reference removed]](../../../../_images/node-types_GeometryNodeCollectionInfo.webp)

The *Collection Info* node gets information from collections.
This can be useful to control parameters in the geometry node tree with an external collection.
user: Describe Setting up Materials from the Blender manual or Python API, including usage steps and snippets.

assistant: Materials can be created in either the [Material properties](../../editors/properties_editor.html),
or in the [Shader Editor](../../editors/shader_editor.html).
These provide a different view of the same shader nodes and material settings.

The default Shading workspace has a Shader Editor and a 3D Viewport that can be set to
Material Preview or Rendered shading, to interactively preview how the material interacts
with objects and lights in the scene.

Materials are data-blocks that can be [assigned](assignment.html)
to one or more objects, and different materials can be assigned to different parts of meshes.

Image textures can be created from scratch in [Texture Paint Mode](../../sculpt_paint/texture_paint/index.html),
or by loading in existing images with the [Image Texture node](../shader_nodes/textures/image.html).
A variety of [procedural texture nodes](../shader_nodes/textures/index.html) is also available.
user: Provide the full official documentation entry for TextureNodeValToNor(TextureNode), preserving all code examples.

assistant: # TextureNodeValToNor(TextureNode)

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

*class* bpy.types.TextureNodeValToNor(*TextureNode*)
:   *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 Symmetry in Blender? Include parameters, examples, warnings and best practices.

assistant: # Symmetry

Mirror Vertex Groups
:   Use this option for mirrored painting on groups that have symmetrical names,
    like with suffix “.R”/ “.L” or “_R” / “_L”. If a group has no mirrored counterpart,
    it will paint symmetrically on the active group itself.
    You can read more about the naming convention in
    [Editing Armatures: Naming conventions](../../../animation/armatures/bones/editing/naming.html#armature-editing-naming-conventions).
    The conventions for armatures/bones apply here as well.

Mirror X, Y, Z
:   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.

Radial X, Y, Z
:   These settings allow for radial symmetry in the desired axes.
    The number determines how many times the stroke will be repeated
    within 360 degrees around the central axes.

Topology Mirror
:   Use topology-based mirroring, for when both sides of a mesh have matching mirrored topology.
    See [here](../../../modeling/meshes/tools/tool_settings.html#bpy-types-mesh-use-mirror-topology) for more information.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Camera Solver constraint.

Active Clip
:   Whether to follow the physical camera of the scene’s [Active Clip](../../../scene_layout/scene/properties.xhtml#bpy-types-scene-active-clip).
    If unchecked, a selector appears for choosing another clip.

Constraint to F-Curve
:   Replaces the constraint by a set of equivalent [keyframes](../../keyframes/introduction.xhtml).

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

assistant: Every data-block has its usage counted (reference count), when there is more than one,
you can see the number of current users of a data-block to the right of its name in the interface.
Blender follows the general rule that unused data is eventually removed.

Since it is common to add and remove a lot of data while working,
this has the advantage of not having to manually manage every single data-block.
This works by skipping zero user data-blocks when writing blend-files.

### Protected

Since zero user data-blocks are not saved,
there are times when you want to force the data to be kept irrespective of its users.

If you are building a blend-file to serve as a library of assets that you intend to link to and from other files,
you will need to make sure that they do not accidentally get deleted from the library file.

To protect a data-block, use the button with the shield icon next to its name.
The data-block will then never be silently deleted by Blender,
but you can still manually remove it if needed.
user: Explain Unpack Data in complete detail according to the official Blender documentation.

assistant: ### Unpack Resources

Unpack all external resource files stored into a blend-file.

#### Options

Use files in current directory (create when necessary)
:   Unpacks all files in the same directory `//` as the blend-file,
    grouping them in proper folders (like ‘’textures’’ for instance).
    However, if the final file exists already, it will use that file, instead of unpacking it.

Write files to current directory (overwrite existing files)
:   As with previous option, but if the final file exists already, it will overwrite it.

Use files in original location (create when necessary)
:   Unpacks all files in their original location.
    However, if the final file exists already, it will use that file, instead of unpacking it.

Write files to original location (overwrite existing files)
:   As with previous option, but if the final file exists already, it will overwrite it.

Disable AutoPack, keep all packed files
:   Only deactivates the *Automatically Pack Resources* option.

### Selective Unpacking

A single file can be unpacked by clicking on the little “gift box” icon to the left of its file-path UI widget.

#### Options

Remove Pack
:   Just mark the file as unpacked, without actually writing it or reloading it from the drive.

Create <local file path>
:   Unpack the file at the proposed path, which is local to the current blend-file.

Use <original file path> (differs)|(identical)
:   If the original file path still exists, mark it as unpacked.
    Note that it won’t be automatically reloaded from the drive.
    *(differs)* or *(identical)* show difference status between the packed version
    and the one on-drive.

Overwrite <original file path>
:   If the original file path still exists but differs from the packed version,
    mark it as unpacked and overwrite the on-drive file with the packed version.

Create <original file path>
:   If the original file path does not exist, mark it as unpacked and write it to drive.
user: Describe Tool System from the Blender manual or Python API, including usage steps and snippets.

assistant: # Tool System

Tools are accessed from the [Toolbar](#ui-region-toolbar).

This is a general introduction to tools. Individual tools have their own documentation.

There can only be one active tool per [Workspace](window_system/workspaces.xhtml)
and [mode](../editors/3dview/modes.xhtml).
This tool is remembered: if you’re in Edit Mode and have the Extrude tool selected,
then switch to Object Mode (which has no Extrude tool) and back to Edit Mode,
the Extrude tool will still be active.

Most tools are controlled using just `LMB`, though some also have modifier keys
(shown in the [Status Bar](window_system/status_bar.xhtml) while using the tool).
This can all be customized in the [Keymap Preferences](../editors/preferences/keymap.xhtml).

Some tools define gizmos (*Shear* and *Spin* for example) to help control them.
user: Describe Usage from the Blender manual or Python API, including usage steps and snippets.

assistant: 1. Select the desired keyframes to draw, edit or sculpt at the same time.
2. Activate the Multiframe tool in the 3D Viewport’s header with the toggle button (faded lines icon).
3. Once activated you can:

   - Select the points in all the selected keyframes and make your edits.
   - Start sculpting. The sculpt brushes will affects all the strokes in the selected keyframes.
   - Start weight painting. The weight paint brush will affect all the strokes in the selected keyframes.
   - Start Drawing. The new strokes will be added in all the selected keyframes.
     If you are using the Fill tool then it will be applied in all the selected keyframes.
   - When interpolating you can select the stroke from the different frames in the right order.
     Interpolate tool will use the selection order to calculate the correct stroke pairs.
user: What is For Each Geometry Element Zone and how is it used in Blender Python scripting?

assistant: # For Each Geometry Element Zone

This zone type allows executing nodes for each element of a geometry. For example, the nodes can process
every face of a mesh, or every instance.

[image reference removed]

The *For Each Element* zone.

The zone is ideal for tasks that generate large or complex geometry for every element of an input geometry.
For example, generating a unique tree for every input curve, or a unique building on every input face.

The zone makes less sense for processing small amounts of geometry. In that case (for example each of a character’s
hairs separately) it will likely **always be slower** than working on fewer larger geometries. The additional
flexibility from processing each element separately comes at the cost that Blender can’t optimize the operation
as well. For node groups that need to handle lots of geometry elements, it’s recommended to design the node setup
so that iteration over tiny sub-geometries is not required.