PGCRYPT/OpenBlender_Train huggingface dataset:
user: How do I use Exporting to USD Files in Blender? Include parameters, examples, warnings and best practices.

assistant: Universal Scene Description (USD) files can contain complex layering, overriding, and references to other files.
Blender’s USD Exporter takes a much simpler approach. When exporting, all visible, supported objects in
the scene are exported, optionally limited by their selection state. Blender does not (yet) support exporting
invisible objects, USD layers, variants, etc.

The following objects can be exported to USD:

- Meshes (of different kinds, see below).
- Cameras (perspective cameras only at the moment, not orthogonal ones).
- Curves
- Text (exported as meshes).
- Lights
- Hair (exported as curves, and limited to parent strands).
- Point Clouds
- Metaballs (exported as animated meshes).
- Volumes
- Armatures

When exporting an animation, the final, evaluated mesh is written to USD.
This means that the following meshes can be exported:

- Static meshes.
- Deforming meshes; here the topology of the mesh does not change,
  but the locations of the vertices change over time. Examples are animated characters or
  bouncing (but not cracking) objects.
- Arbitrarily animated meshes; here the topology does change.
  An example is the result of a fluid simulation, where splashes of fluid can break off the main body.

[image reference removed]

Shot from [Spring](https://studio.blender.org/films/spring/) exported to USD and opened in USDView.
user: What is Rendering and how is it used in Blender Python scripting?

assistant: ### Depth Buffer Glitches

Sometimes when setting a large [clipping range](../editors/3dview/sidebar.xhtml#bpy-types-spaceview3d-clip-start) will allow you to see both
near and far objects, but reduces the depth precision resulting in artifacts.

|  |  |  |
| --- | --- | --- |
| ../_images/troubleshooting_3d-view_graphics-z-fighting-none.png   Model with no clipping artifacts. | ../_images/troubleshooting_3d-view_graphics-z-fighting-example.png   Model with clipping artifacts. | ../_images/troubleshooting_3d-view_graphics-z-fighting-example-editmode.png   Mesh with artifacts in Edit Mode. |

To avoid this:

- Increase the near clipping when working on large scenes.
- Decrease the far clipping when objects are not viewed at a distance.

When perspective is disabled only the far Clip End is used, very high values can still result in artifacts. This is
**not** specific to Blender, all graphics applications have these same limitations.

### Objects Invisible in Camera View

If you have a large scene, viewing it through Camera View may not display all of the objects in the scene. One
possibility may be that the [clipping distance](../render/cameras.xhtml#camera-clipping) of the camera is too low. The camera will only
show objects that fall within the clipping range.
user: Describe Animation Playback Options from the Blender manual or Python API, including usage steps and snippets.

assistant: `-a` `<options>` `<file(s)>`
:   Instead of showing Blender’s user interface, this runs Blender as an animation player,
    to view movies and image sequences rendered in Blender (ignored if `-b` is set).

    Playback Arguments:

    `-p` `<sx>` `<sy>`
    :   Open with lower left corner at `<sx>`, `<sy>`.

    `-m`
    :   Read from disk (Do not buffer).

    `-f` `<fps>` `<fps_base>`
    :   Specify FPS to start with.

    `-j` `<frame>`
    :   Set frame step to `<frame>`.

    `-s` `<frame>`
    :   Play from `<frame>`.

    `-e` `<frame>`
    :   Play until `<frame>`.

    `-c` `<cache_memory>`
    :   Amount of memory in megabytes to allow for caching images during playback.
        Zero disables (clamping to a fixed number of frames instead).
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.collection`](bpy.context.html#bpy.context.collection "bpy.context.collection") - [`Context.layer_collection`](bpy.types.Context.html#bpy.types.Context.layer_collection "bpy.types.Context.layer_collection") - [`LayerCollection.children`](#bpy.types.LayerCollection.children "bpy.types.LayerCollection.children") | - [`ViewLayer.active_layer_collection`](bpy.types.ViewLayer.html#bpy.types.ViewLayer.active_layer_collection "bpy.types.ViewLayer.active_layer_collection") - [`ViewLayer.layer_collection`](bpy.types.ViewLayer.html#bpy.types.ViewLayer.layer_collection "bpy.types.ViewLayer.layer_collection") |
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`ActionLayer.strips`](bpy.types.ActionLayer.html#bpy.types.ActionLayer.strips "bpy.types.ActionLayer.strips") - [`ActionStrips.new`](bpy.types.ActionStrips.html#bpy.types.ActionStrips.new "bpy.types.ActionStrips.new") | - [`ActionStrips.remove`](bpy.types.ActionStrips.html#bpy.types.ActionStrips.remove "bpy.types.ActionStrips.remove") |
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Mesh 1/2
:   Standard geometry input.

Self Intersection Exact Solver
:   Correctly calculates cases when one or both operands have self-intersections.
    This involves more calculations making the node slower.

Hole Tolerant Exact Solver
:   Optimizes the Boolean output for [Non-manifold](../../../../glossary/index.xhtml#term-Non-manifold) geometry
    at the cost of increased computational time.
    Because of the performance impact, this option should only be enabled
    when the solver demonstrates errors with non-manifold geometry.
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Display
:   The target display device as defined in the current OCIO configuration.
    See [Display](../../../render/color_management/displays_views.html#bpy-types-colormanageddisplaysettings-display-device) for an explanation of all options.

View
:   The view transform to apply for the selected display.
    See [View](../../../render/color_management/displays_views.html#bpy-types-colormanagedviewsettings-view-transform) for an explanation of all options.

Look
:   The look transform to apply.
    Optional, and may be *None* depending on the configuration.
    See [Look](../../../render/color_management/displays_views.html#bpy-types-colormanagedviewsettings-look) for an explanation of all options.
user: Describe Shade Smooth from the Blender manual or Python API, including usage steps and snippets.

assistant: Sets an entire object as smooth or faceted.
This forces the assignment of the “smoothing” attribute to each face in the mesh,
including when you add or delete geometry.

This operator will also remove any [Smooth By Angle Modifiers](../../../modeling/modifiers/normals/smooth_by_angle.xhtml).

Notice that the outline of the object is still strongly faceted.
Activating the smoothing features does not actually modify the object’s geometry;
it changes the way the shading is calculated across the surfaces (normals will be interpolated),
giving the illusion of a smooth surface.

Using [Shade Flat](#bpy-ops-object-shade-flat) will revert the shading back (normals will be constant)
to that shown in the first image below.

Example mesh flat (left) and smooth-shaded (right).
[Sample blend-file](https://archive.blender.org/wiki/2015/index.php/File:25-manual-meshsmooth-example.blend).

|  |  |
| --- | --- |
| ../../../_images/scene-layout_object_editing_shading_example-flat.png | ../../../_images/scene-layout_object_editing_shading_example-smooth.png |

Keep Sharp Edges
:   Do not clear sharp edges (which are redundant with objects shaded as flat).
    This option is useful to not destroy data in case you want to revert changes later.
user: Describe Rendering Technologies from the Blender manual or Python API, including usage steps and snippets.

assistant: Blender supports different technologies to render on the GPU depending on the particular GPU manufacturer
and operating system.

### CUDA – NVIDIA

CUDA is supported on Windows and Linux and requires a
NVIDIA graphics cards with compute capability 5.0 and higher. To make sure your GPU is supported,
see the [list of NVIDIA graphics cards](https://developer.nvidia.com/cuda-gpus#compute)
with the compute capabilities and supported graphics cards.

### OptiX – NVIDIA

OptiX is supported on Windows and Linux and requires a NVIDIA graphics cards with compute capability 5.0 and higher
and a driver version of at least 535. To make sure your GPU is supported,
see the [list of NVIDIA graphics cards](https://developer.nvidia.com/cuda-gpus#compute).

OptiX takes advantage of hardware ray-tracing acceleration in RTX graphics cards, for improved performance.

GPU acceleration for OpenImageDenoise is available for compute capability 7.0 and higher, which includes
all NVIDIA RTX cards.

### HIP – AMD

HIP is supported on Windows and Linux and requires a
AMD graphics card with the RDNA1 architecture or newer. Both discrete GPUs and APUs are supported.

Supported GPUs include:

- Radeon RX 5000 Series
- Radeon RX 6000 Series
- Radeon RX 7000 Series
- Radeon RX 9000 series
- Radeon Pro W6000 Series
- Radeon Pro W7000 Series

Minimum driver versions:

- Windows: Radeon Software 24.9.1 or Radeon PRO Software 24.Q4
- Linux: Radeon Software 23.40 or ROCm 6.0

Please refer to [AMD’s website](https://www.amd.com/en/products/specifications.html) for more
information about AMD graphics cards and their architectures.

Hardware ray-tracing support is available with the most recent drivers.
This can be enabled in the preferences, and is supported on Radeon RX 6000 and newer.

GPU accelerated denoising is available on discrete Radeon RX 6000 and Radeon RX 7000 GPUs.

### oneAPI – Intel

oneAPI is a computation library that is supported on Windows and Linux and requires a
Intel® Arc™ graphics card with the Xe HPG architecture.
Hardware acceleration for ray-tracing and denoising is supported.

Supported GPUs include:

- Intel® Arc™ A-Series
- Intel® Arc™ B-Series

Minimum driver versions:

- Windows: Intel Graphics Driver XX.X.101.5518
- Linux: `intel-level-zero-gpu` package 1.3.27642,
  typically available through the `intel-compute-runtime` package XX.XX.34666.3

Please refer to [Intel’s website](https://www.intel.com/content/www/us/en/products/details/discrete-gpus.html)
for more information about Intel graphics cards and their architectures.

GPU accelerated denoising is available on all supported GPUs.

### Metal – Apple (macOS)

Metal is supported on Apple computers with Apple Silicon.
macOS 13.0 or newer is required to support all features.

GPU accelerated denoising is available on Apple Silicon.
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: ### Customized triangulation

One or many “single point spline” can be used to customize the triangulation of the filled-in curves.

[image reference removed]

This is the default behavior of the *Fill Curve* node applied to the star primitive.

[image reference removed]

Here, a single curve point is joined to the star primitive to customize the triangulation.

[image reference removed]

Here, 300 single curve point are joined to the star primitive to customize the triangulation.

### Group ID

The following figures display diverse application of the Group ID.

[image reference removed]

Here, the 4 curves share the same Group ID, resulting in 1 mesh island (default behavior).

[image reference removed]

Here, the 4 curves have different Group ID, resulting in 4 mesh islands.

[image reference removed]

Here, the 4 curves are seperated into two groups based on their positions, resulting in 2 mesh islands.
user: What is Inverse Kinematics and how is it used in Blender Python scripting?

assistant: # Inverse Kinematics

Inverse Kinematics (IK) simplifies the animation process,
and makes it possible to make more advanced animations with lesser effort.

Inverse Kinematics allow you to position the last bone in a bone chain and
the other bones are positioned automatically.
This is like how moving someone’s finger would cause their arm to follow it.
By normal posing techniques, you would have to start from the root bone,
and set bones sequentially until you reach the tip bone:
When each parent bone is moved, its child bone would inherit its location and rotation.
Thus making tiny precise changes in poses becomes harder farther down the chain,
as you may have to adjust all the parent bones first.

This effort is effectively avoided by use of IK.

IK is mostly done with bone constraints although there is also
a simple [Auto IK](../../tool_settings.html#bpy-types-pose-use-auto-ik) feature in Pose Mode.
They work by the same method but the constraints offer more options and control.
Please refer to the following pages for details about these constraints:

- [Inverse Kinematics Constraint](../../../../constraints/tracking/ik_solver.html)
- [Spline IK Constraint](../../../../constraints/tracking/spline_ik.html)
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: [image reference removed]

The Displace modifier.

Texture
:   The name of the texture from which the displacement for each vertex is derived.
    If this field is empty, the modifier defaults to 1.0 (white).

    Coordinates
    :   The texture coordinate system to use when retrieving values from the texture for each vertex.

        See [common masking options](../common_options.xhtml#modifiers-common-options-masking) for a complete reference.

Direction
:   The direction along which to displace the vertices.
    Can be one of the following:

    X, Y, Z
    :   Displace along an axis.

    Normal
    :   Displace along the vertex normal.

    Custom Normal
    :   Displace along (averaged) [custom normals](../../meshes/structure.xhtml#modeling-meshes-normals-custom), instead of vertex normals.

    RGB to XYZ
    :   Displace along local XYZ axes individually using the RGB components of the texture
        (Red values displaced along the X axis, Green along the Y, Blue along the Z).

Space
:   With a direction set to X, Y, Z, or XYZ the modifier can either displace along local or global axes.

Strength
:   The strength of the displacement. After offsetting by the *Midlevel* value,
    the displacement will be multiplied by the *Strength* value to give the final vertex offset.

    \(vertex\_offset = displacement × Strength\)

    A negative strength can be used to invert the effect of the modifier.

Midlevel
:   The texture value which will be treated as no displacement by the modifier.
    Texture values below this threshold will result in negative displacement along the selected direction,
    while texture values above it will result in positive displacement.

    \(displacement = texture\_value - Midlevel\)

    Recall that color/luminosity values are typically between (0.0 to 1.0) in Blender,
    and not between (0 to 255).

Vertex Group
:   The name of a vertex group which is used to control the influence of the modifier.
    If left empty, the modifier affects all vertices equally.

    Invert
    :   Inverts the influence of the selected vertex group, meaning that the group
        now represents vertices that will not be deformed by the modifier.

        The setting reverses the weight values of the group.
user: Provide the full official documentation entry for ID Property Access (idprop.types), preserving all code examples.

assistant: # ID Property Access (idprop.types)

*class* idprop.types.IDPropertyArray
:   to_list()
    :   Return the array as a list.

    typecode
    :   The type of the data in the array {‘f’: float, ‘d’: double, ‘i’: int, ‘b’: bool}.

*class* idprop.types.IDPropertyGroup
:   clear()
    :   Clear all members from this group.

    get(*key*, *default=None*)
    :   Return the value for key, if it exists, else default.

    items()
    :   Iterate through the items in the dict; behaves like dictionary method items.

    keys()
    :   Return the keys associated with this group as a list of strings.

    pop(*key*, *default*)
    :   Remove an item from the group, returning a Python representation.

        Raises:
        :   **KeyError** – When the item doesn’t exist.

        Parameters:
        :   - **key** (*str*) – Name of item to remove.
            - **default** (*Any*) – Value to return when key isn’t found, otherwise raise an exception.

    to_dict()
    :   Return a purely Python version of the group.

    update(*other*)
    :   Update key, values.

        Parameters:
        :   **other** (`IDPropertyGroup` | dict[str, Any]) – Updates the values in the group with this.

    values()
    :   Return the values associated with this group.

    name
    :   The name of this Group.

*class* idprop.types.IDPropertyGroupIterItems

*class* idprop.types.IDPropertyGroupIterKeys

*class* idprop.types.IDPropertyGroupIterValues

*class* idprop.types.IDPropertyGroupViewItems

*class* idprop.types.IDPropertyGroupViewKeys

*class* idprop.types.IDPropertyGroupViewValues
user: How do I use Basic Handler Example in Blender? Include parameters, examples, warnings and best practices.

assistant: This script shows the most simple example of adding a handler.

```
import bpy

def my_handler(scene):
    print("Frame Change", scene.frame_current)

bpy.app.handlers.frame_change_pre.append(my_handler)
```
user: Describe Run a Function n times every x seconds from the Blender manual or Python API, including usage steps and snippets.

assistant: ```
import bpy

counter = 0

def run_10_times():
    global counter
    counter += 1
    print(counter)
    if counter == 10:
        return None
    return 0.1

bpy.app.timers.register(run_10_times)
```
user: Explain Convolve Node in complete detail according to the official Blender documentation.

assistant: # Convolve Node

[image reference removed]

The *Convolve* node performs a 2D convolution operation on an image
using a custom [Image Kernel](../../image_kernels.xhtml).
This allows for a wide range of effects such as blurring, sharpening,
and edge detection, depending on the kernel values provided.

The node multiplies a neighborhood of pixels around each image pixel by the kernel values
and sums the results to compute the output pixel color.
This process is often used in image processing to emphasize or suppress certain spatial features.
user: What is Tool Settings and how is it used in Blender Python scripting?

assistant: If your tool requires any input from the user apart from the geometry to transform,
you can [add sockets](../../interface/controls/nodes/groups.xhtml#bpy-ops-node-interface-item-new) to the *Group Input* node.
These will be exposed in the [Adjust Last Operation](../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel when running the tool.
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Data Type
:   The [data type](../../attributes_reference.xhtml#attribute-data-types) used for the evaluated data.

Mode
:   How to find endpoint positions for the trimmed spline.
    The option acts the same as it does in the [Trim Curve Node](../operations/trim_curve.xhtml).

    Factor:
    :   Find the endpoint positions using a factor of each spline’s length.
        The input values should be between 0 or 1.

    Length:
    :   Find the endpoint positions using a length from the start of each spline.
        The input values should be between 0 and the length of the splines.

All Curves
:   Sample lengths based on the total length of all curves, rather than using a length inside each selected curve.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`NodeClosureOutput.output_items`](bpy.types.NodeClosureOutput.html#bpy.types.NodeClosureOutput.output_items "bpy.types.NodeClosureOutput.output_items") - [`NodeClosureOutputItems.new`](bpy.types.NodeClosureOutputItems.html#bpy.types.NodeClosureOutputItems.new "bpy.types.NodeClosureOutputItems.new") | - [`NodeClosureOutputItems.remove`](bpy.types.NodeClosureOutputItems.html#bpy.types.NodeClosureOutputItems.remove "bpy.types.NodeClosureOutputItems.remove") |
user: How do I use Shade Smooth & Flat in Blender? Include parameters, examples, warnings and best practices.

assistant: # Shade Smooth & Flat

The appearance of the mesh edges are determined to be evened out or well defined within the 3D Viewport and render.
In Edit Mode, individual faces can be selected to determine which faces are smoothed or flattened.
user: Show practical ways to work with Limitations in a Blender add-on or script – include code.

assistant: The following selections are not supported by the rip operator and will give an error message:

- Face(s), including when selecting vertices or edges that form up a face.
- Edges or vertices that are not “between” two faces (non [Manifold](../../../../glossary/index.html#term-Manifold)).
- Two vertices that aren’t connected to each other.
user: Give a detailed overview of Examples: syntax, arguments, return values, common patterns.

assistant: Below are some examples illustrating edge subdivision in various scenarios.

[image reference removed]

The sample mesh.

### One Edge

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_one-edge.png   One edge. | ../../../../_images/modeling_meshes_editing_edge_subdivide_one-edge-tri.png   *Create N-Gons* unchecked. |

### Two Tri Edges

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-tri.png   Two tri edges. | ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-tri-tri.png   *Create N-Gons* unchecked. |

### Two Opposite Quad Edges

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-opposite.png   Two quad edges. | ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-opposite-tri.png   *Create N-Gons* unchecked. |

### Two Adjacent Quad Edges

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-quad-innervert.png   Inner Vertices corner type. | ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-quad-innervert-tri.png   *Create N-Gons* unchecked. |

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-quad-path.png   Path corner type. | ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-quad-path-tri.png   *Create N-Gons* unchecked. |

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-quad-straight_cut.png   Straight Cut corner type. | ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-quad-innervert-tri.png   *Create N-Gons* unchecked. |

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-quad-fan2.png   Fan cut type. | ../../../../_images/modeling_meshes_editing_edge_subdivide_two-edges-quad-fan.png   *Create N-Gons* unchecked. |

### Three Quad Edges

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_three-edges.png   Three edges. | ../../../../_images/modeling_meshes_editing_edge_subdivide_three-edges-tri.png   *Create N-Gons* unchecked. |

### Full Triangle

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_three-edges-tri2.png   Full triangle. | ../../../../_images/modeling_meshes_editing_edge_subdivide_three-edges-tri-tri.png   *Create N-Gons* unchecked. |

### Full Quad

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_four-edges.png   Full quad. | ../../../../_images/modeling_meshes_editing_edge_subdivide_four-edges-tri.png   *Create N-Gons* unchecked. |

### Multiple Cuts

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_subdivide_tri-multi.png   Triangle with two cuts. | ../../../../_images/modeling_meshes_editing_edge_subdivide_quad-multi.png   Quad with two cuts. |
user: Describe Tool Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: Create Quads
:   When creating a new triangle that shares an edge with an existing one,
    automatically [dissolves](../editing/mesh/delete.xhtml#bpy-ops-mesh-dissolve) this edge so you’re left with a quad.
user: Give a detailed overview of Extrude Curve and Move: syntax, arguments, return values, common patterns.

assistant: Extruding is the main way of adding new control points to a surface. It’s not possible
to do this directly as would be the case with Curves.

Start by selecting a complete border of the surface grid. Then press `E` to duplicate
the control points, and move the mouse to bring them to the desired position.
Finally, click `LMB` to confirm. (Alternatively, click `RMB` or press `Esc`
to cancel the move and keep the new control points at their original position.)

### Example

First, we select a border control point and expand the selection to the complete row
using [Select Control Point Row](../selecting.xhtml#bpy-ops-curve-select-row).

|  |  |
| --- | --- |
| ../../../_images/modeling_surfaces_editing_control-points_selecting-point.png   Selecting control point | ../../../_images/modeling_surfaces_editing_control-points_selecting-row.png   Selecting remaining control points in the row |

Then, we extrude a few times:

[image reference removed]

Control points extruded twice
user: Explain GeometryNodeFieldVariance(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeFieldVariance(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.GeometryNodeFieldVariance(*GeometryNode*)
:   Calculate the standard deviation and variance of a given field

    data_type
    :   Type of data the outputs are calculated from

        - `FLOAT`
          Float – Floating-point value.
        - `FLOAT_VECTOR`
          Vector – 3D vector with floating-point values.

        Type:
        :   enum in [`'FLOAT'`, `'FLOAT_VECTOR'`], default `'FLOAT'`

    domain
    :   Type:
        :   enum in [Attribute Domain Items](bpy_types_enum_items/attribute_domain_items.html#rna-enum-attribute-domain-items), default `'POINT'`

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

assistant: The *Parent Inverse* transform defines how the child object’s local space
is offset relative to its parent. It ensures that when parenting is created,
the child keeps its current world position, even though it now inherits
transforms from the parent.

The matrix is displayed decomposed into **Location**, **Rotation**, and **Scale** values.
These represent the offset needed to maintain the child’s position relative to its parent.
The values are read-only and shown for inspection only.

The *Rotation Mode* determines how the rotation component is displayed,
and can be switched between systems such as *XYZ Euler*, *Axis Angle*, or *Quaternion*.
This behaves identically to the [Rotation Mode](#bpy-types-object-rotation-mode) selector used in the main transform panel.

### Clear Parent Inverse Transform

Clears the *Parent Inverse* matrix from the selected objects. With an empty matrix,
the location, rotation, and scale properties of the children are interpreted
directly in the coordinate space of the parent.

This effectively makes the child’s transforms relative to the parent’s origin,
potentially moving the object in world space.

See [Clear Parent](../editing/parent.html#bpy-ops-object-parent-clear) for additional methods to clear or manage parent-child relationships.
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Kernel Data Type
:   Determines how the kernel is defined:

    Float:
    :   A numeric kernel defined by the *Kernel* input socket.

    Image:
    :   A full image used as the kernel, allowing for more complex filtering patterns.
user: What is UV Warp Modifier and how is it used in Blender Python scripting?

assistant: # UV Warp Modifier

The *UV Warp* modifier transforms an object’s UV map based on values or two objects.
Its purpose is to give you direct control over the object’s UVs in the 3D Viewport,
allowing you to directly move, rotate, and scale existing UV coordinates
using defined values or a controller object or bone.
user: Describe Proportional Falloff Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Proportional Falloff Items

SMOOTH:
:   Smooth.

    Smooth falloff.

SPHERE:
:   Sphere.

    Spherical falloff.

ROOT:
:   Root.

    Root falloff.

INVERSE_SQUARE:
:   Inverse Square.

    Inverse Square falloff.

SHARP:
:   Sharp.

    Sharp falloff.

LINEAR:
:   Linear.

    Linear falloff.

CONSTANT:
:   Constant.

    Constant falloff.

RANDOM:
:   Random.

    Random falloff.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Value
:   Special gizmo value socket.
    Everything that linked into this socket will be modified when the gizmo is rotated.

Position
:   Position of the gizmo in the local space of the object.

Up
:   Up or normal direction of the gizmo in the viewport.

Screen Space
:   If enabled, the gizmo will always have the same size in the viewport independent of the zoom level.
    This affects the meaning of the radius input.

Radius
:   In screen space mode, this is a factor on top of the default radius.
    Otherwise, this is the radius of the gizmo in Blender units.
user: Give a detailed overview of Overriding Context: syntax, arguments, return values, common patterns.

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

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

```
# Remove all objects in scene rather than the selected ones.
import bpy
from bpy import context
context_override = context.copy()
context_override["selected_objects"] = list(context.scene.objects)
with context.temp_override(**context_override):
    bpy.ops.object.delete()
```
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Gradient Type
:   Controls the type of gradient generated.

    Linear:
    :   Directly outputs the input X coordinate.

    Quadratic:
    :   Interpolates the input X coordinate quadratically.

    Easing:
    :   Uses a combination of quadratic and linear interpolation
        to generate a smooth gradient from the input X coordinate.

    Diagonal:
    :   Averages the input X and Y coordinates.

    Spherical:
    :   Creates an inverse gradient using the length of the input vector; the maximum value is at (0, 0, 0).

    Quadratic Sphere:
    :   The same as Spherical, except interpolated quadratically.

    Radial:
    :   Outputs a value based on the angle of the input around the Z axis.
user: How do I use Field Weights in Blender? Include parameters, examples, warnings and best practices.

assistant: # Field Weights

These settings determine how much gravity and
[Force Fields](../../../forces/force_fields/index.xhtml) affect the fluid.

Effector Collection
:   When set, fluid can only be influenced by force fields in the specified collection.

Gravity
:   How much the fluid is affected by Gravity.

All
:   Overall influence of all force fields.

The other settings determine how much influence individual force field types have.
user: What is Camera & Lens Effects Nodes and how is it used in Blender Python scripting?

assistant: # Camera & Lens Effects Nodes

The *Camera & Lens Effects* nodes simulate real-world imperfections and optical
characteristics of cameras and lenses. These effects can be used to add realism,
match rendered imagery with live-action footage, or achieve specific cinematic looks.

These nodes are typically applied near the end of a compositing chain to stylize or enhance
the final image. They include effects such as sensor noise, chromatic aberration,
and vignetting, all of which help replicate the subtleties of physical camera systems.
user: Give a detailed overview of Movie Distortion Node: syntax, arguments, return values, common patterns.

assistant: # Movie Distortion Node

[image reference removed]

In the real world, all camera lenses produce some or the other sort of lens distortion.
But, whatever we render has got no distortion. So, this node helps in removing distortion from movies
or adding distortion to render to make our render blend in with the movie clip.

Usually, it is used while motion tracking.
user: How do I use Snap Target for Individual Elements in Blender? Include parameters, examples, warnings and best practices.

assistant: Type of element for individual transformed elements to snap to.

Face Project:
:   Snaps to the face that’s under the mouse cursor.
    This can be used for bending a flat sheet so it snugly fits against a curved surface, for example.

    This works similar to the [Shrinkwrap Modifier](../../../modeling/modifiers/deform/shrinkwrap.html).

Face Nearest:
:   Individually snaps each object (in Object Mode) or vertex (in Edit Mode) to the face that’s closest
    to its new location. This makes it possible to snap to occluded geometry.
user: Show practical ways to work with SpreadsheetTableIDGeometry(SpreadsheetTableID) in a Blender add-on or script – include code.

assistant: # SpreadsheetTableIDGeometry(SpreadsheetTableID)

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

*class* bpy.types.SpreadsheetTableIDGeometry(*SpreadsheetTableID*)
:   attribute_domain
    :   Attribute domain to display

        Type:
        :   enum in [Attribute Domain Items](bpy_types_enum_items/attribute_domain_items.html#rna-enum-attribute-domain-items), default `'POINT'`, (readonly)

    geometry_component_type
    :   Part of the geometry to display data from

        Type:
        :   enum in [Geometry Component Type Items](bpy_types_enum_items/geometry_component_type_items.html#rna-enum-geometry-component-type-items), default `'MESH'`, (readonly)

    layer_index
    :   Index of the Grease Pencil layer

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

    object_eval_state
    :   - `EVALUATED`
          Evaluated – Use data from fully or partially evaluated object.
        - `ORIGINAL`
          Original – Use data from original object without any modifiers applied.
        - `VIEWER_NODE`
          Viewer Node – Use intermediate data from viewer node.

        Type:
        :   enum in [`'EVALUATED'`, `'ORIGINAL'`, `'VIEWER_NODE'`], default `'EVALUATED'`, (readonly)

    viewer_path
    :   Path to the data that is displayed

        Type:
        :   [`ViewerPath`](bpy.types.ViewerPath.html#bpy.types.ViewerPath "bpy.types.ViewerPath"), (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: What is Cloth with Wind and how is it used in Blender Python scripting?

assistant: [image reference removed]

Flag with wind applied.

Regression blend-file for Cloth with wind and self-collisions (also the blend for the image above):
[Cloth flag with wind and self-collisions](https://archive.blender.org/wiki/2015/index.php/File:Cloth-flag2.blend).
user: Show practical ways to work with Simplification in a Blender add-on or script – include code.

assistant: # Simplification

The *Simplification* modifier merges stroke vertices that lie close to one another,
like the *Decimate* modifier for meshes.

Tolerance
:   Measure for how close points have to be to each other to be merged.
    A higher tolerance means more vertices are merged.

[image reference removed]
user: Provide the full official documentation entry for ByteIntAttribute(Attribute), preserving all code examples.

assistant: # ByteIntAttribute(Attribute)

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

*class* bpy.types.ByteIntAttribute(*Attribute*)
:   Geometry attribute that stores 8-bit integers

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

assistant: Grid
:   The input signed distance field to be smoothed.

Iterations
:   The number of Laplacian smoothing iterations to apply.
    Each iteration progressively diffuses high-frequency surface variations,
    reducing surface noise.
    Higher values increase smoothness but may cause slight surface shrinkage.
user: Give a detailed overview of FunctionNodeStringToValue(FunctionNode): syntax, arguments, return values, common patterns.

assistant: # FunctionNodeStringToValue(FunctionNode)

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

*class* bpy.types.FunctionNodeStringToValue(*FunctionNode*)
:   Derive a numeric value from a given string representation

    data_type
    :   - `FLOAT`
          Float – Floating-point value.
        - `INT`
          Integer – 32-bit integer.

        Type:
        :   enum in [`'FLOAT'`, `'INT'`], default `'FLOAT'`

    *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 QuaternionAttribute(Attribute) from the Blender manual or Python API, including usage steps and snippets.

assistant: # QuaternionAttribute(Attribute)

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

*class* bpy.types.QuaternionAttribute(*Attribute*)
:   Geometry attribute that stores rotation

    data
    :   Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`QuaternionAttributeValue`](bpy.types.QuaternionAttributeValue.html#bpy.types.QuaternionAttributeValue "bpy.types.QuaternionAttributeValue"), (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 Setting up the Build Environment in complete detail according to the official Blender documentation.

assistant: - Open a Terminal window.
- Enter the `blender-manual` folder which was just added by `git clone`:

  ```
  cd C:\blender-manual
  ```
- Install dependencies:

  ```
  make setup
  ```
- If all goes well, you should see the following message when it is finished:

  ```
  Successfully installed Jinja2 MarkupSafe Pygments Sphinx docutils sphinx-rtd-theme Cleaning up...
  ```

During setup, some warnings may be shown, but do not worry about them. However, if any errors occur, they may cause
some problems.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Grease Pencil
:   Grease Pencil geometry input.

Selection
:   A boolean field that controls which stroke points are affected.
    Only elements where the selection is true will be modified.
    By default, all strokes are affected.

Softness
:   The softness value to assign. Higher values increase the fade at stroke edges.
    This input sets the value for the `softness` attribute.
user: Explain Separate in complete detail according to the official Blender documentation.

assistant: Separate different elements into new Grease Pencil objects based on specific criteria.

Selection
:   Separates the selected points or strokes into a new object.

By Material
:   Separates the geometry by creating a new object for each material.

By Layer
:   Separates the geometry by creating a new object for each layer.
    See [2D Layers](../../properties/layers.xhtml) for more information.
user: How do I use Box Selection Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Box Selection Node

[image reference removed]

The *Box Selection* node creates a selection of elements located within a defined 3D box.
It can be used to isolate geometry inside a specific region of space, such as selecting
points, faces, or instances within a bounded area.
user: Provide the full official documentation entry for Make Single User, preserving all code examples.

assistant: Duplicates actions where necessary so that each selected strip has its own action that’s not used
by any others. This way, you can edit the keyframes in the selected strips knowing that you won’t
affect any other part of the animation.
user: Give a detailed overview of Separate: syntax, arguments, return values, common patterns.

assistant: Disconnects the selected sub grid from the rest of the surface and moves it into
a new Surface object. The control points at the border are duplicated so that both
the original surface and the disconnected surface have them.

The sub grid must consist of one or more complete rows or columns of the surface grid.
user: How do I use Transform in Blender? Include parameters, examples, warnings and best practices.

assistant: Strokes can be edited by transforming the locations of points.

### Move, Rotate & Scale

Like other elements in Blender, points and strokes can be
moved `G`, rotated `R` or scaled `S` as described in
the [Basic Transformations](../../../scene_layout/object/editing/transform/introduction.xhtml) section.
When in *Edit Mode*,
[Proportional Editing](../../../editors/3dview/controls/proportional_editing.xhtml)
is also available for the transformation actions.

### Transform Snapping

Basic move, rotate and scale transformations for selected points/strokes.
See [Move, Rotate, Scale Basics](../../../modeling/meshes/editing/mesh/transform/basic.xhtml) for more information.

### Tools

The *Bend*, *Shear*, *To Sphere*, *Extrude* and *Shrink Fatten* transform tools are described
in the [Editing tools](tools/index.xhtml) section.
user: Provide the full official documentation entry for Transparent BSDF, preserving all code examples.

assistant: # Transparent BSDF

[image reference removed]

The *Transparent* BSDF
is used to add transparency without refraction, passing straight through the surface,
as if there were no geometry there. Useful with alpha maps, for example.
This shader [affects light paths somewhat differently](../../cycles/render_settings/light_paths.xhtml#render-cycles-light-paths-transparency)
than other BSDFs.
Note that only pure white transparent shaders are completely transparent.