PGCRYPT/OpenBlender_Train huggingface dataset:
user: Explain Split in complete detail according to the official Blender documentation.

assistant: # Split

The *Split* operator disconnects selected bones from the rest of the armature,
creating a new, unconnected bone chain.

This is useful for restructuring rigs, separating limbs, or preparing bone chains to be transformed independently.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`CameraBackgroundImage.clip_user`](bpy.types.CameraBackgroundImage.html#bpy.types.CameraBackgroundImage.clip_user "bpy.types.CameraBackgroundImage.clip_user") - [`SpaceClipEditor.clip_user`](bpy.types.SpaceClipEditor.html#bpy.types.SpaceClipEditor.clip_user "bpy.types.SpaceClipEditor.clip_user") | - [`UILayout.template_marker`](bpy.types.UILayout.html#bpy.types.UILayout.template_marker "bpy.types.UILayout.template_marker") - [`UILayout.template_movieclip_information`](bpy.types.UILayout.html#bpy.types.UILayout.template_movieclip_information "bpy.types.UILayout.template_movieclip_information") |
user: Provide the full official documentation entry for CameraBackgroundImages(bpy_struct), preserving all code examples.

assistant: # CameraBackgroundImages(bpy_struct)

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

*class* bpy.types.CameraBackgroundImages(*bpy_struct*)
:   Collection of background images

    new()
    :   Add new background image

        Returns:
        :   Image displayed as viewport background

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

    remove(*image*)
    :   Remove background image

        Parameters:
        :   **image** ([`CameraBackgroundImage`](bpy.types.CameraBackgroundImage.html#bpy.types.CameraBackgroundImage "bpy.types.CameraBackgroundImage"), (never None)) – Image displayed as viewport background

    clear()
    :   Remove all background images

    *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 Inputs, preserving all code examples.

assistant: Mesh
:   The input mesh whose volume is converted into a signed distance field grid.

Voxel Size
:   The size of each voxel in object space units.
    Smaller values produce higher-resolution fields that more accurately capture
    surface details, but require more memory and computation.

Band Width
:   The width of the active voxel band around the mesh surface, measured in voxels.
    Only voxels within this band store meaningful signed distance values.
    Increasing this value captures a wider region around the surface at the cost
    of additional memory.
user: Provide the full official documentation entry for Add-on Information, preserving all code examples.

assistant: You can click the arrow at the left of the add-on box to see more information,
such as its location, a description and a link to the documentation.
Here you can also find a button to report a bug specific of this add-on.

### Add-on Preferences

Some add-ons may have their own preferences which can be found
in the *Preferences* section of the add-on information box.

Some add-ons use this section for example to enable/disable
certain functions of the add-on. Sometimes these might even all default to off.
So it is important to check if the enabled add-on has any particular preferences.
user: Describe NodeSocketMaterial(NodeSocketStandard) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeSocketMaterial(NodeSocketStandard)

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

*class* bpy.types.NodeSocketMaterial(*NodeSocketStandard*)
:   Material socket of a node

    default_value
    :   Input value used for unconnected socket

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

    links
    :   List of node links from or to this socket.

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: User directories store preferences, startup file, installed extensions,
presets and more. By default these use the standard configuration folders
for each operating system.

### Linux

```
$HOME/.config/blender/5.0/
```

If the `$XDG_CONFIG_HOME` environment variable is set:

```
$XDG_CONFIG_HOME/blender/5.0/
```

### macOS

```
/Users/$USER/Library/Application Support/Blender/5.0/
```

### Windows

```
%USERPROFILE%\AppData\Roaming\Blender Foundation\Blender\5.0\
```

### Portable Installation

When running Blender from a portable drive, it’s possible to keep the configuration
files on the same drive to take with you.

To enable this, create a folder named `portable` at the following locations:

- Windows: Next to the Blender executable, in the unzipped folder
- Linux: Next to the Blender executable, in the unzipped folder
- macOS: Inside the application bundle at `Blender.app/Contents/Resources`

This folder will then store preferences, startup file, installed extensions
and presets.

### Environment Variables

The `BLENDER_USER_RESOURCES` [environment variable](command_line/arguments.xhtml#command-line-args-environment-variables)
can be set to a custom directory to replace the default user directory.
user: Show practical ways to work with Custom Function - Square Value in a Blender add-on or script – include code.

assistant: Create a custom function to get the square of a value (i.e. *value*2).
Adding the function to the *Driver Namespace* allows it to be used from driver expressions.
The *Driver Namespace* has a list of built-in functions for use in driver expressions,
as well as constants such as π and e.
These can be inspected via the Python Console:

```
>>> bpy.app.driver_namespace[' <tab>
                              acos']
                              acosh']
                              asin']
                              asinh']
                              atan']
                              ...
```

To add a new function to the *Driver Namespace*, the function itself needs to be implemented
and then added to the `bpy.app.driver_namespace`.

1. Add the following to the Text Editor inside Blender and press *Run Script*.

   ```
   import bpy

   def square(val):
      """Returns the square of the given value"""
      return val * val

   # Add function to driver_namespace.
   bpy.app.driver_namespace['square'] = square
   ```
2. Add a driver with a *Scripted Expression* such as `square(frame)`.
3. Observe the effect when scrubbing the timeline.

There are more custom function examples available in Blender’s Text Editor
Templates ‣ Python ‣ Driver Functions.
Since [Simple Expressions](drivers_panel.html#drivers-simple-expressions) cannot access
custom functions, using them only makes sense for complex computations.
user: Give a detailed overview of Node Math Items: syntax, arguments, return values, common patterns.

assistant: # Node Math Items

**Functions**

ADD:
:   Add.

    A + B.

SUBTRACT:
:   Subtract.

    A - B.

MULTIPLY:
:   Multiply.

    A \* B.

DIVIDE:
:   Divide.

    A / B.

MULTIPLY_ADD:
:   Multiply Add.

    A \* B + C.

---

POWER:
:   Power.

    A power B.

LOGARITHM:
:   Logarithm.

    Logarithm A base B.

SQRT:
:   Square Root.

    Square root of A.

INVERSE_SQRT:
:   Inverse Square Root.

    1 / Square root of A.

ABSOLUTE:
:   Absolute.

    Magnitude of A.

EXPONENT:
:   Exponent.

    exp(A).

**Comparison**

MINIMUM:
:   Minimum.

    The minimum from A and B.

MAXIMUM:
:   Maximum.

    The maximum from A and B.

LESS_THAN:
:   Less Than.

    1 if A < B else 0.

GREATER_THAN:
:   Greater Than.

    1 if A > B else 0.

SIGN:
:   Sign.

    Returns the sign of A.

COMPARE:
:   Compare.

    1 if (A == B) within tolerance C else 0.

SMOOTH_MIN:
:   Smooth Minimum.

    The minimum from A and B with smoothing C.

SMOOTH_MAX:
:   Smooth Maximum.

    The maximum from A and B with smoothing C.

**Rounding**

ROUND:
:   Round.

    Round A to the nearest integer. Round upward if the fraction part is 0.5.

FLOOR:
:   Floor.

    The largest integer smaller than or equal A.

CEIL:
:   Ceil.

    The smallest integer greater than or equal A.

TRUNC:
:   Truncate.

    The integer part of A, removing fractional digits.

---

FRACT:
:   Fraction.

    The fraction part of A.

MODULO:
:   Truncated Modulo.

    The remainder of truncated division using fmod(A,B).

FLOORED_MODULO:
:   Floored Modulo.

    The remainder of floored division.

WRAP:
:   Wrap.

    Wrap value to range, wrap(A,B).

SNAP:
:   Snap.

    Snap to increment, snap(A,B).

PINGPONG:
:   Ping-Pong.

    Wraps a value and reverses every other cycle (A,B).

**Trigonometric**

SINE:
:   Sine.

    sin(A).

COSINE:
:   Cosine.

    cos(A).

TANGENT:
:   Tangent.

    tan(A).

---

ARCSINE:
:   Arcsine.

    arcsin(A).

ARCCOSINE:
:   Arccosine.

    arccos(A).

ARCTANGENT:
:   Arctangent.

    arctan(A).

ARCTAN2:
:   Arctan2.

    The signed angle arctan(A / B).

---

SINH:
:   Hyperbolic Sine.

    sinh(A).

COSH:
:   Hyperbolic Cosine.

    cosh(A).

TANH:
:   Hyperbolic Tangent.

    tanh(A).

**Conversion**

RADIANS:
:   To Radians.

    Convert from degrees to radians.

DEGREES:
:   To Degrees.

    Convert from radians to degrees.
user: How do I use Instance Rotation Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Instance Rotation Node

[image reference removed]

The *Instance Rotation* outputs the XYZ [Euler](../../../glossary/index.html#term-Euler) rotation of each top-level instance in the
local space of the modifier object.

The [Instances](../instances.html) page contains more information about geometry instances.
user: Describe BlendDataWorkSpaces(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # BlendDataWorkSpaces(bpy_struct)

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

*class* bpy.types.BlendDataWorkSpaces(*bpy_struct*)
:   Collection of workspaces

    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: Provide the full official documentation entry for FloatProperty(Property), preserving all code examples.

assistant: # FloatProperty(Property)

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

*class* bpy.types.FloatProperty(*Property*)
:   RNA floating-point number (single precision) property definition

    array_dimensions
    :   Length of each dimension of the array

        Type:
        :   int array of 3 items in [0, inf], [default](#bpy.types.FloatProperty.default "bpy.types.FloatProperty.default") (0, 0, 0), (readonly)

    array_length
    :   Maximum length of the array, 0 means unlimited

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

    default
    :   Default value for this number

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

    default_array
    :   Default value for this array

        Type:
        :   float array of 3 items in [-inf, inf], [default](#bpy.types.FloatProperty.default "bpy.types.FloatProperty.default") (0.0, 0.0, 0.0), (readonly)

    hard_max
    :   Maximum value used by buttons

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

    hard_min
    :   Minimum value used by buttons

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

    is_array
    :   Type:
        :   boolean, default False, (readonly)

    precision
    :   Number of digits after the dot used by buttons. Fraction is automatically hidden for exact integer values of fields with unit ‘NONE’ or ‘TIME’ (frame count) and step divisible by 100.

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

    soft_max
    :   Maximum value used by buttons

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

    soft_min
    :   Minimum value used by buttons

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

    step
    :   Step size used by number buttons, for floats 1/100th of the step size

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Modifiers in complete detail according to the official Blender documentation.

assistant: ### Common Options

Mix
:   The modifier output can be mixed with the base property using the usual methods
    (see for example the [Mix compositing node](../../../../compositing/types/color/mix_color.xhtml)).

Influence
:   How much the result of this modifier affects the current property.

Color Ramp
:   Each modifier has [color ramp](../../../../interface/controls/templates/color_ramp.xhtml#ui-color-ramp-widget) that maps the property to a stroke color.

### Types

- [Along Stroke](modifiers/color/along_stroke.xhtml)
- [Crease Angle](modifiers/color/crease_angle.xhtml)
- [Curvature 3D](modifiers/color/curvature_3d.xhtml)
- [Distance from Camera](modifiers/color/distance_from_camera.xhtml)
- [Distance from Object](modifiers/color/distance_from_object.xhtml)
- [Material](modifiers/color/material.xhtml)
- [Noise](modifiers/color/noise.xhtml)
- [Tangent](modifiers/color/tangent.xhtml)
user: Provide the full official documentation entry for Examples, preserving all code examples.

assistant: [[image reference removed]](../../../_images/modeling_modifiers_generate_wireframe_result.jpg)

Wireframes on a displaced plane.

In this example, the wireframes carry a second (dark) material while the displaced plane uses its original one.

[[image reference removed]](../../../_images/modeling_modifiers_generate_wireframe_example-weights.png)

Vertex group weighting.

The weights of the vertex group gradually change from 0 to 1.

[[image reference removed]](../../../_images/modeling_modifiers_generate_wireframe_example-crease.png)

Wireframe and Subdivision Surface modifier.

Cube with enabled *Crease Edges* option. The *Crease Weight* is set to 0, 0.5 and 1.
user: What is Shaders and how is it used in Blender Python scripting?

assistant: A shader is a program that runs on the GPU (written in GLSL in our case).
There are multiple types of shaders.
The most important ones are *Vertex Shaders* and *Fragment Shaders*.
Typically multiple shaders are linked together into a *Program*.
However, in the Blender Python API the term *Shader* refers to an OpenGL Program.
Every `gpu.types.GPUShader` consists of a vertex shader, a fragment shader and an optional geometry shader.
For common drawing tasks there are some built-in shaders accessible from [`gpu.shader.from_builtin`](gpu.shader.html#gpu.shader.from_builtin "gpu.shader.from_builtin")
with an identifier such as `UNIFORM_COLOR` or `FLAT_COLOR`. There are specific builtin shaders for
drawing triangles, lines and points.

Every shader defines a set of attributes and uniforms that have to be set in order to use the shader.
Attributes are properties that are set using a vertex buffer and can be different for individual vertices.
Uniforms are properties that are constant per draw call.
They can be set using the `shader.uniform_*` functions after the shader has been bound.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Geometry
:   Standard geometry input.

Radius
:   Float value indicating the radius of the point geometry at each point.

Selection
:   Boolean input for selecting which points will have the radius value applied.
user: Provide the full official documentation entry for Property Subtype String Items, preserving all code examples.

assistant: # Property Subtype String Items

FILE_PATH:
:   File Path.

DIR_PATH:
:   Directory Path.

FILE_NAME:
:   File Name.

BYTE_STRING:
:   Byte String.

PASSWORD:
:   Password.

    A string that is displayed hidden (’\*\*\*\*\*\*\*\*’).

NONE:
:   None.
user: How do I use Deleting Vertex Groups in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Delete a vertex group.

You delete a vertex group by first making it the active group
(select it in the panel) and then `LMB`
the  button at the right panel border.

Deleting a vertex group only deletes the vertex assignments to the group.
The vertices themselves are not deleted.
user: Show practical ways to work with Rotate Edge in a Blender add-on or script – include code.

assistant: # Rotate Edge

Rotating an edge clockwise (CW) or counterclockwise (CCW) spins an edge between two faces around their vertices.
This is very useful for restructuring a mesh’s topology.

The tool operates on selected edges or the shared edge between selected faces.

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_edge_rotate-edge_face-mode1.png>   Two adjacent faces selected. | <../../../../_images/modeling_meshes_editing_edge_rotate-edge_face-mode2.png>   Selected edge rotated. |

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_edge_rotate-edge_flip-before.png>   Selected edge. | <../../../../_images/modeling_meshes_editing_edge_rotate-edge_flip-after.png>   Edge, rotated CW. |
user: Give a detailed overview of GeometryNodeScaleInstances(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeScaleInstances(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.GeometryNodeScaleInstances(*GeometryNode*)
:   Scale geometry instances in local or global space

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe MaskLayer(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # MaskLayer(bpy_struct)

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

*class* bpy.types.MaskLayer(*bpy_struct*)
:   Single layer used for masking pixels

    alpha
    :   Render Opacity

        Type:
        :   float in [-inf, inf], default 0.0

    blend
    :   Method of blending mask layers

        Type:
        :   enum in [`'MERGE_ADD'`, `'MERGE_SUBTRACT'`, `'ADD'`, `'SUBTRACT'`, `'LIGHTEN'`, `'DARKEN'`, `'MUL'`, `'REPLACE'`, `'DIFFERENCE'`], default `'ADD'`

    falloff
    :   Falloff type of the feather

        Type:
        :   enum in [Proportional Falloff Curve Only Items](bpy_types_enum_items/proportional_falloff_curve_only_items.html#rna-enum-proportional-falloff-curve-only-items), default `'SMOOTH'`

    hide
    :   Restrict visibility in the viewport

        Type:
        :   boolean, default False

    hide_render
    :   Restrict renderability

        Type:
        :   boolean, default False

    hide_select
    :   Restrict selection in the viewport

        Type:
        :   boolean, default False

    invert
    :   Invert the mask black/white

        Type:
        :   boolean, default False

    name
    :   Unique name of layer

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

    select
    :   Layer is selected for editing in the Dope Sheet

        Type:
        :   boolean, default False

    splines
    :   Collection of splines which defines this layer

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

    use_fill_holes
    :   Calculate holes when filling overlapping curves

        Type:
        :   boolean, default False

    use_fill_overlap
    :   Calculate self intersections and overlap before filling

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: ### Transform

Affect Only
:   Origins `Ctrl`-`Period`
    :   Directly transforms the object’s [origin](../origin.html).
        This only works for objects with data which can be transformed;
        i.e. it will not work on object lights.

        When enabled, the object axes are displayed.

        Take care using this option since it transforms the object-data which may cause linked
        duplicates to be moved unintentionally.

    Locations
    :   Changes the position of the object’s origin relative to another point during transformation.
        In other words, the pivot point and the origin cannot share the same location.
        This will not affect the object local transforms, just its position in world space.

        In the examples below, a comparison of the scaling and rotation of objects,
        when *Location* is enabled (middle) and disabled (right).

        [image reference removed]

        Rotation example.

        [image reference removed]

        Scaling example.

    Parents
    :   Transforms [Parent Objects](../editing/parent.html)
        while leaving their children objects unaffected.
user: What is Properties and how is it used in Blender Python scripting?

assistant: Mode
:   Storage mode for custom normal data:

    Sharpness:
    :   Store the sharpness of each face or edge. Similar to the “Shade Smooth” and “Shade Flat” operators.

    Free:
    :   Store custom normals as simple vectors in the local space of the mesh.
        This is efficient and fast to evaluate but does not support deformation.

    Tangent Space:
    :   Store normals in a deformation dependent custom transformation space.
        This method is slower, but can be better when subsequent operations
        change the mesh without handling normals specifically.

Domain Free mode
:   [Attribute domain](../../attributes_reference.xhtml#attribute-domains) to store free custom normals.

    Point:
    :   Store normals per vertex.

    Face:
    :   Store normals per face.

    Face Corner:
    :   Store normals per face corner, this domain is necessary to bake
        existing mixed sharp and smooth edges into the custom normal vectors.
user: How do I use Settings and Controls in Blender? Include parameters, examples, warnings and best practices.

assistant: For the precise list of options, see [Spline IK](../../../../constraints/tracking/spline_ik.xhtml) constraint.
This section is intended to introduce the workflow.

### Roll Control

To control the [Roll](../../../../../glossary/index.xhtml#term-Roll) of the Spline IK chain,
the standard methods of rotating the bones in the chain along their local Y axes still apply.
For example, start at the farthest bone and simply rotate the bones in the chain around their
local Y axes to adjust the roll of the chain from that point onward.

Applying Copy Rotation constraints on the bones also works.

### Offset Controls

The entire bone chain can be made to follow the shape of the curve while still being able to
be placed at an arbitrary point in 3D space when the *Chain Offset* option is enabled.
By default, this option is not enabled,
and the bones will be made to follow the curve in its untransformed position.

### Length Control

The *Y Scale Mode* setting can be used to choose the way bones are scaled length-wise.
The available options allow stretching the bone chain to fit the curve, using the pre-IK
scaling, or doing neither. In addition, the scale of the curve Object affects the result.

### Thickness Controls

The thickness of the bones in the chain is controlled using the constraint’s *XZ Scale Mode* setting.
This setting determines the method used for determining the scaling on
the X and Z axes of each bone in the chain.

The available modes are:

None
:   This option keeps the X and Z scaling factors as 1.0.

Volume Preserve
:   The X and Z scaling factors are taken as the inverse of the Y scaling factor (length of the bone),
    maintaining the ‘volume’ of the bone.

Bone Original
:   This options just uses the X and Z scaling factors the bone would have after being evaluated in the standard way.

In addition to these modes, there is an option, *Use Curve Radius*.
When this option is enabled, the average radius of the radii of the points on the curve where
the joints of each bone are placed, are used to derive X and Z scaling factors.
This allows the scaling effects, determined using the modes above,
to be tweaked as necessary for artistic control.
user: Give a detailed overview of Basic Operator Example: syntax, arguments, return values, common patterns.

assistant: This script shows simple operator which prints a message.

Since the operator only has an [`Operator.execute`](#bpy.types.Operator.execute "bpy.types.Operator.execute") function it takes no
user input.

The function should return `{'FINISHED'}` or `{'CANCELLED'}`, the latter
meaning that operator execution was aborted without making any changes, and
that no undo step will created (see next example for more info about undo).

```
import bpy

class HelloWorldOperator(bpy.types.Operator):
    bl_idname = "wm.hello_world"
    bl_label = "Minimal Operator"

    def execute(self, context):
        print("Hello World")
        return {'FINISHED'}

# Only needed if you want to add into a dynamic menu.
def menu_func(self, context):
    self.layout.operator(HelloWorldOperator.bl_idname, text="Hello World Operator")

# Register and add to the view menu (required to also use F3 search "Hello World Operator" for quick access).
bpy.utils.register_class(HelloWorldOperator)
bpy.types.VIEW3D_MT_view.append(menu_func)

# Test call to the newly defined operator.
bpy.ops.wm.hello_world()
```
user: What is Texture Space and how is it used in Blender Python scripting?

assistant: Each Object can have an automatically generated UV map, these maps can be adjusted here.

See [Generated UV Properties](../meshes/uv/uv_texture_spaces.xhtml#properties-texture-space) for more information.
user: What is Motionpath Range Items and how is it used in Blender Python scripting?

assistant: # Motionpath Range Items

KEYS_ALL:
:   All Keys.

    From the first keyframe to the last.

KEYS_SELECTED:
:   Selected Keys.

    From the first selected keyframe to the last.

SCENE:
:   Scene Frame Range.

    The entire Scene / Preview range.

MANUAL:
:   Manual Range.

    Manually determined frame range.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: The *Evaluate Closure* node does not have functional properties, but its input and output interface can be managed in
the *Node* tab of the Sidebar.

Sync Sockets
:   Updates the current node to match the socket signature of the connected nodes.
    Use this after renaming, adding, or removing sockets.

Define Signature
:   Marks the node as defining a closure signature to be used by other closure nodes. Ensures consistent input and output
    definitions across related closures.

### Input Items

List of input sockets
:   Displays one entry per socket defined in the closure. Double-click to rename.

Add Item
:   Add a new input socket to the closure interface.

Remove Item
:   Delete the selected input socket.

Type
:   The data type for the selected socket (e.g. Float, Vector, Geometry, Object, Bundle).
    For value types, a default value field appears and is used when the socket is unlinked.

Shape
:   Defines the data structure supported by the input socket, such as a *Single* value, *Field*, or *Grid*.
    The shape determines how the data is evaluated and passed through the node network.
    See [Socket Shape](../../../interface/controls/nodes/parts.html#interface-controls-nodes-socket-shape) for more information.

### Output Items

List of output sockets
:   Displays one entry per output socket. Double-click to rename.

Add Item
:   Add a new output socket to the node.

Remove Item
:   Delete the selected output socket.

Type
:   The data type for the selected socket (e.g. Float, Vector, Geometry, Object, Bundle).
    For value types, a default value field appears and is used when the socket is unlinked.
user: Describe Guides from the Blender manual or Python API, including usage steps and snippets.

assistant: The following properties are only available when displaying the *Viewer Node* image
in the *Image Editor* set to *View* or *Mask* mode.

Text Info
:   Displays overlay text showing information about the active Viewer node:

    - **Render Size**: The resolution of the final render output.
      This is defined in the [Output Properties](../../render/output/properties/format.html#bpy-types-rendersettings-resolution-x).
    - **Image Size**: The resolution of the image currently displayed in the Viewer node.

Render Region
:   Displays a border showing the final render region defined in the scene.
    Space outside the render region appear shaded for reference.

    Passepartout Alpha
    :   Controls the opacity of the shaded area outside the render region.
        Higher values darken the outside area more, making the render region stand out.
user: Provide the full official documentation entry for Drivers, preserving all code examples.

assistant: Upgrading to the latest graphics drivers often solves problems. Newer drivers have bug fixes that help Blender
function correctly.

On Windows, drivers are provided by the graphics card manufacturer. Windows Update automatically installs graphics
drivers, or your computer manufacturer may provide its own version of the graphics drivers.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

The Length modifier.

Mode
:   Absolute:
    :   Length is in geometry space.

    Relative:
    :   Length is in ratio to the stroke’s length.

Start
:   Added length to the start of the stroke. Negative value will shrink the stroke.

End
:   Added length to the end of the stroke. Negative value will shrink the stroke.

Used Length
:   Define what portion of the stroke is used to calculate the direction of the extension.

### Curvature

When enabled, the extension will follow the curvature of the stroke.

Point Density
:   Multiplied by Start/End for the total point count.

Segment Influence
:   Factor to determine how much the length of the individual segments
    should influence the final computed curvature. Higher factors makes
    small segments influence the overall curvature less.

Filter Angle
:   Ignore points on the stroke that deviate from their neighbors by more
    than this angle when determining the extrapolation shape.

Invert
:   Invert the curvature of the stroke’s extension.

### Random Offsets

Random Offset Start/End
:   Size of random length added to the start/end of each stroke.

Random Noise Offset
:   Smoothly offset each stroke’s random value.

Seed
:   Number used to generate different noise patterns.

#### Randomize

Re-randomizes values over time.

Step
:   Number of frames before recalculate random values again.

### Influence Filters

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

assistant: ### Unsupported Graphics Driver Error

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

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

### Crash on Startup

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

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

### Poor Performance

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

### Render Errors

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

### Wrong Selection in 3D Viewport

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

### Virtual Machines

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

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

Some VM hosts may require turning on GPU paravirtualization. Some GPU vendors restrict this function to higher-priced
cards or models.
user: Describe Viewport Display from the Blender manual or Python API, including usage steps and snippets.

assistant: # Viewport Display

This panel lets you configure display options for the 3D Viewport.

[image reference removed]

Viewport Display panel.

Show
:   Name
    :   Displays the object’s name in the 3D Viewport.

    Axes
    :   Displays an object similar to an empty that shows the object’s orientation.

    Wireframe
    :   Displays the object’s wireframe on top of the solid display.

    All Edges
    :   Displays all wireframe edges. This overrides the
        [wireframe threshold](../../../editors/3dview/display/overlays.xhtml#bpy-types-view3doverlay-wireframe-threshold)
        that you can set in the 3D Viewport’s overlay settings.

    Texture Space
    :   Displays the object’s [Texture Space](../../../glossary/index.xhtml#term-Texture-Space) in the 3D Viewport..
        The texture space overlay can be disabled for all objects using the
        [Extras Overlay](../../../editors/3dview/display/overlays.xhtml#bpy-types-view3doverlay-show-extras).

    Shadow
    :   Allows the object to cast shadows in the viewport.

    In Front
    :   Makes the object display in front of others. Unsupported for instanced objects.
        Limited support in the *Material Preview* and *Rendered* shading modes
        (works for e.g. armatures, but not for meshes).

Display As
:   Lets you display the object with less detail, going from removing the textures to
    only showing a bounding box. This can be useful if you have a high-poly object
    that is slowing down the viewport.

Color
:   The object’s color in the *Wireframe* and *Solid* viewport shading modes.
    Used when the viewport’s [(Wire) Color](../../../editors/3dview/display/shading.xhtml#viewport-shading-solid-color)
    shading option is set to *Object*.

Bounds
:   Displays a bounding shape around an object. You can choose between different
    primitive shapes that might be closer to what the original object looks like.
user: Describe Lightmap Pack from the Blender manual or Python API, including usage steps and snippets.

assistant: Places each selected face separately on the UV map. Lightmaps are commonly used for baking lighting information
into a texture for use in realtime rendering – as such, they prioritize using as much of the texture as possible,
typically resulting in a disconnected and distorted UV map that would be unsuitable for manual texturing work.

### Options

The [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel allows fine control over how the mesh is unwrapped:

Selection
:   Selected Faces
    :   Only unwraps the selected faces.

    All Faces
    :   Unwraps the whole mesh.

Share Texture Space
:   You can use [Multi-Object Editing](../../../editors/3dview/modes.xhtml#dview-multi-object-mode) to generate UV maps for multiple meshes at the same time.
    When *Share Texture Space* is enabled, the UV maps won’t overlap each other,
    so that you can later use the same lightmap texture for all the meshes.

New UV Map
:   Creates a new UV map instead of overwriting the currently selected one. See [UV Maps](../uv/uv_texture_spaces.xhtml#uv-maps-panel).

Pack Quality
:   Higher values result in a UV map that wastes less space (but also takes longer to calculate).

Margin
:   How much empty space to leave between the faces in the UV map.
user: What is Proxy Settings and how is it used in Blender Python scripting?

assistant: Contains scene-wide proxy settings.

Storage
:   How proxies are stored for the project.

    Per Strip:
    :   Each strip can specify where to store its proxies (see below).

    Project:
    :   All proxies are stored in one directory.

        Proxy Directory
        :   The location to store the proxies for the project.

Set Selected Strip Proxies
:   Shows a pop-over that lets you choose the resolution(s) to generate
    and whether to overwrite existing proxy files. Once you confirm with the *Set* button,
    your choices are applied to the selected strips. You can view and tweak the
    settings for individual strips in the *Strip Proxy & Timecode* panel (see below).

    In the *Preview* mode, where the *Proxy* tab is not available,
    this is instead done through the menu View ‣ Proxy ‣ Setup.

Rebuild Proxy and Timecode Indices
:   Generates proxies and time indices for the selected strips.

    In the *Preview* mode, where the *Proxy* tab is not available,
    this is instead done through the menu View ‣ Proxy ‣ Rebuild.
user: What is Brush Settings and how is it used in Blender Python scripting?

assistant: # Brush Settings

Painting needs paint brushes and Blender provides a Brush panel within the Toolbar
when in *Weight Paint Mode*.

Brush
:   In the [Data-Block menu](../../../../interface/controls/templates/data_block.xhtml#ui-data-block) you find predefined Brush presets.
    And you can create your own custom presets as needed.

Radius `F`
:   The radius defines the area of influence of the brush.

    (Size Pressure)
    :   Adjusts the radius based on the stylus pressure when using a [Graphics Tablet](../../../../getting_started/configuration/hardware.xhtml#hardware-tablet).

Strength
:   This is the amount of paint to be applied per brush stroke.

    (Strength Pressure)
    :   Adjusts the strength based on the stylus pressure when using a [Graphics Tablet](../../../../getting_started/configuration/hardware.xhtml#hardware-tablet).

Use Falloff
:   When enabled, use Strength falloff for the brush.
    Brush Strength decays with the distance from the center of the brush.

Weight `Ctrl`-`F`
:   The weight (visualized as a color) to be used by the brush.

    Using `Ctrl`-`RMB` you can set the weight to the value that’s under the cursor.

Direction `D`
:   Brush direction toggle, *Add* adds weight value while *Subtract* removes weight value.
    This setting can be toggled with `D`.
user: Describe Data from the Blender manual or Python API, including usage steps and snippets.

assistant: Fonts
:   Default location to browse for [text object](../../modeling/texts/index.xhtml) font files.

Textures
:   Default location to browse for image textures.

Sounds
:   Default location to browse for sound files.

Temporary Files
:   The directory for storing temporary save files. The path must reference an existing directory
    or it will be ignored and the systems temporary directory will be used instead.
    When left blank, the systems temporary directory will be used (see [Temporary Directory](../../advanced/blender_directory_layout.xhtml#temp-dir) for details).

### Render

Render Output
:   Where rendered images/videos are saved.

Render Cache
:   The location where cached render images are stored.
user: What is Editors and how is it used in Blender Python scripting?

assistant: # Editors

Blender provides a number of different editors for displaying and modifying different aspects of data.
An Editor is contained inside an [Area](../interface/window_system/areas.html)
which determines its size and placement within the Blender window.
Every area may contain any type of editor.

The *Editor Type* selector, the first button at the left side of a header,
allows you to change the Editor in that area.
It is also possible to open the same Editor type in different areas at the same time.

See [User Interface](../interface/index.html) for documentation on the general interface.

[image reference removed]

The Editor Type selector.
user: Provide the full official documentation entry for Stereo3dDisplay(bpy_struct), preserving all code examples.

assistant: # Stereo3dDisplay(bpy_struct)

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

*class* bpy.types.Stereo3dDisplay(*bpy_struct*)
:   Settings for stereo 3D display

    anaglyph_type
    :   Type:
        :   enum in [Stereo3D Anaglyph Type Items](bpy_types_enum_items/stereo3d_anaglyph_type_items.html#rna-enum-stereo3d-anaglyph-type-items), default `'RED_CYAN'`

    display_mode
    :   Type:
        :   enum in [Stereo3D Display Items](bpy_types_enum_items/stereo3d_display_items.html#rna-enum-stereo3d-display-items), default `'ANAGLYPH'`

    interlace_type
    :   Type:
        :   enum in [Stereo3D Interlace Type Items](bpy_types_enum_items/stereo3d_interlace_type_items.html#rna-enum-stereo3d-interlace-type-items), default `'ROW_INTERLEAVED'`

    use_interlace_swap
    :   Swap left and right stereo channels

        Type:
        :   boolean, default False

    use_sidebyside_crosseyed
    :   Right eye should see left image and vice versa

        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: Provide the full official documentation entry for PrimitiveBoolean(bpy_struct), preserving all code examples.

assistant: # PrimitiveBoolean(bpy_struct)

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

*class* bpy.types.PrimitiveBoolean(*bpy_struct*)
:   RNA wrapped boolean

    value
    :   Type:
        :   boolean, default False, (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Normal Map Node

[image reference removed]

The *Normal Map* node generates a perturbed normal from an RGB normal map image.
This is usually chained with an *Image Texture* node in the color input,
to specify the normal map image. For tangent space normal maps,
the UV coordinates for the image must match,
and the image texture should be set to *Non-Color* mode to give correct results.