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

assistant: # TextureNodeTexture(TextureNode)

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

*class* bpy.types.TextureNodeTexture(*TextureNode*)
:   node_output
    :   For node-based textures, which output node to use

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

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Move

In Object Mode, the move option lets you move objects.
Translation means changing location of objects. It also lets you move any elements
that make up the object within the 3D space of the active 3D Viewport.

Pressing `G` activates “Move” transformation mode. The selected object
or element then moves freely according to the mouse pointer’s location and camera.
To confirm the action, press `LMB`.
While moving items, the amount of change along the X, Y, and Z axis is displayed in the header of the 3D Viewport.

[image reference removed]

Translation Display.
user: Provide the full official documentation entry for NodeTreeInterfaceSocketVectorEuler4D(NodeTreeInterfaceSocket), preserving all code examples.

assistant: # NodeTreeInterfaceSocketVectorEuler4D(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketVectorEuler4D(*NodeTreeInterfaceSocket*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

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

    dimensions
    :   Dimensions of the vector socket

        Type:
        :   int in [2, 4], default 0

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

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

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

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

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Sound Strip

As well as images and movies the Video Sequencer can also edit audio tracks.
You can add Waveform Audio format `WAV`, `mp3` and other audio formats files from your drive,
or from sound encoded within a movie, and mix them using an F-Curve as a volume control.

[image reference removed]

Example of sound editing.
user: Give a detailed overview of Interpolation: syntax, arguments, return values, common patterns.

assistant: Keyframe interpolation is represented and controlled by
[animation curves](../../editors/graph_editor/fcurves/introduction.xhtml),
also known as [F-Curves](../../glossary/index.xhtml#term-F-Curve). These curves can be viewed and modified
via the [Graph Editor](../../editors/graph_editor/index.xhtml).

[image reference removed]

Constant, Linear, Quadratic and Bézier interpolation, with Linear extrapolation.

The X axis of the curve corresponds to time, while Y represents the value of the property.
Keyframes themselves define points of the curve, while interpolation is controlled by additional parameters.

The [Interpolation Mode](../../editors/graph_editor/fcurves/properties.xhtml#editors-graph-fcurves-settings-interpolation) is the main setting
that specifies for each keyframe how the curve is interpolated from that key to
the next one. There are a number of modes with fixed shapes,
e.g. *Constant*, *Linear*, *Quadratic* etc, and a free form *Bézier* mode.

[Extrapolation](../../editors/graph_editor/channels/editing.xhtml#editors-graph-fcurves-settings-extrapolation) specifies how
the curve extends before the first, and after the last keyframe.
The main available choices are *Constant* and *Linear*;
it is also possible to configure the curve to loop.

*Bézier* interpolation is controlled by handles, which have
a [handle type](../../editors/graph_editor/fcurves/properties.xhtml#editors-graph-fcurves-settings-handles) and position.
The position of *Free* and *Aligned* handles must be set manually from the Graph editor,
while *Vector*, *Automatic* and *Auto Clamped* handles are computed automatically from
keyframe values.

Interpolation, Extrapolation and Handle Type can also be changed from
the [Dope Sheet](../../editors/dope_sheet/index.xhtml) editor.

[image reference removed]

Handle smoothing modes. Red: *None*, Green: *Continuous Acceleration*.

The method how the three automatic handle types are computed is controlled by
the per-curve [Auto Handle Smoothing](../../editors/graph_editor/fcurves/properties.xhtml#bpy-types-fcurve-auto-smoothing) setting.
The *None* mode resembles how most other software works and only considers the values
of the immediately adjacent keys. The *Continuous Acceleration* mode considers the shape
of the whole curve, which produces smoother results out of the box, but means that changes
in one key affect interpolation over a larger section of the curve; it also tends to
overshoot more with *Automatic* handles.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Transform Space
:   The transformation of the output instances. The instances are transformed, but not the geometry of the
    collection in them.

    Original:
    :   Output the instances relative to the collection offset.

    Relative:
    :   Join the input collection instances with the modified object as geometry,
        maintaining the relative position between the objects in the scene.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Domain
:   The [attribute domain](../../attributes_reference.html#attribute-domains) used for evaluation of the *Value* input.
    This is useful because it can be a different domain than the domain from the
    [field context](../../fields.html#field-context), i.e. to choose a vertex for each face.
user: Provide the full official documentation entry for Examples, preserving all code examples.

assistant: |  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_vertex_rip-vertices_before.png>   Selected vertex. | <../../../../_images/modeling_meshes_editing_vertex_rip-vertices_after.png>   Hole created after using rip on vertex. |
| <../../../../_images/modeling_meshes_editing_vertex_rip-vertices_edges-before.png>   Edges selected. | <../../../../_images/modeling_meshes_editing_vertex_rip-vertices_edges-after.png>   Result of rip with edge selection. |
| <../../../../_images/modeling_meshes_editing_vertex_rip-vertices_complexselection-before.png>   A complex selection of vertices. | <../../../../_images/modeling_meshes_editing_vertex_rip-vertices_complexselection-after.png>   Result of rip operation. |
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: Clear Delta
:   Clear the [delta transform](../properties/transforms.xhtml#bpy-types-object-delta) in addition to clearing the primary transforms.
    (Appears in the [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel.)
user: Give a detailed overview of Deform Curves on Surface Node: syntax, arguments, return values, common patterns.

assistant: # Deform Curves on Surface Node

[image reference removed]

The *Deform Curves on Surface* node translates and rotates each curve based on the
difference in its root position. The root position is defined by UV coordinates stored
on each curve and the [UV Map](../../../../glossary/index.xhtml#term-UV-Map) selected for the purpose in the
[Curves surface settings](../../../curves_new/properties.xhtml#bpy-types-curves-surface).

The transformation is calculated based on the difference of the original mesh
(before shape keys and modifiers are evaluated), and the final mesh.

Unlike other geometry nodes, this node has quite a few implicit inputs:

- The original and evaluated mesh are retrieved from the modifier object’s [surface](../../../curves_new/properties.xhtml#bpy-types-curves-surface)
  property. This means the node only works for curves objects.
- The original and evaluated UV map are also retrieved from the object’s surface property.
- A 3D vector attribute named `rest_position`, used for calculating tangents for rotating
  curves that are consistent with the tangents calculated on the original mesh (the rotation
  needs to be calculated from the normal and tangent of the original and evaluated meshes).
- A 2D vector attribute on the curve domain named `surface_uv_coordinate` to store the
  location of the root positions on the surface mesh’s UV map.

In future development, this node will be generalized so the setup is more flexible.

Parts of the internal operation are similar to the [Sample UV Surface Node](../../mesh/sample/sample_uv_surface.xhtml).
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Image
:   Standard color input.

Bokeh
:   This is an input for the [Bokeh Image](../../input/bokeh_image.xhtml) node.

Size
:   The amount of blur, measured in pixels.
    Size can either be a single value across the entire image or a variable value controlled by an input image.

Bounding Box
:   This can be used with a [Box Mask](../../mask/box_mask.xhtml)
    matte node or with a [Mask](../../input/mask.xhtml)
    input node to restrict the area of the image the blur is applied to. This could be helpful, for example,
    when developing a node system by allowing only a small area of the image to be filtered
    thus saving composite time each time adjustments are made.
user: How do I use Light Linking in Blender? Include parameters, examples, warnings and best practices.

assistant: # Light Linking

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

This adds more artistic control by breaking the laws of physics. For example, you could
have a rim light that *only* illuminates a character in a scene (light linking) and is
not blocked by any objects in the scene (shadow linking).
user: Describe Transform Panel from the Blender manual or Python API, including usage steps and snippets.

assistant: # Transform Panel

This panel contains the properties of the selected control points.
If multiple points are selected, it shows the averages of the values,
and allows changing those values for all the points in one go.

Control Point
:   X, Y, Z
    :   The coordinates of the control point.

    W
    :   The [weight](../structure.html#modeling-surfaces-weight) of the control point.
        The higher the weight, the more the control point pulls the surface towards itself.

Space
:   Whether the coordinates are in object space (Local) or in world space (Global).

Weight
:   The “goal weight” when using [Soft Body](../../../physics/soft_body/index.html) physics.
    Higher values make the surface “stiffer” at that control point (as in, the control
    point will stay close to its original location, preventing deformation).

Radius
:   Not applicable for Surface objects.

Tilt
:   Not applicable for Surface objects.
user: Provide the full official documentation entry for Outputs, preserving all code examples.

assistant: Geometry
:   The resulting geometry containing the interpolated hair curves.

Guide Index
:   An integer attribute storing the index of the main guide curve used to generate each interpolated curve.

Surface Normal
:   The surface normal direction at each curve’s root attachment point.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Fill Type
:   How the circles at the top and bottom are filled with faces when their radius is larger than zero.

    None:
    :   Do not fill the circles.

    N-Gon:
    :   Fill the innermost circles with a single face.

    Triangles:
    :   Fill the innermost circles with triangles connected to a vertex in the center.
user: Explain GPU Options in complete detail according to the official Blender documentation.

assistant: `--gpu-backend`
:   Force to use a specific GPU backend. Valid options: `vulkan`, `metal`, `opengl`.

`--gpu-vsync`
:   Set the VSync.
    Valid options are: `on`, `off` & `auto` for adaptive sync.

    - The default settings depend on the GPU driver.
    - Disabling VSync can be useful for testing performance.
    - `auto` is only supported by the OpenGL backend.

`--gpu-compilation-subprocesses`
:   Override the Max Compilation Subprocesses setting (OpenGL only).

`--profile-gpu`
:   Enable CPU & GPU performance profiling for GPU debug groups
    (Outputs a profile.json file in the Trace Event Format to the current directory)
user: Give a detailed overview of Children: syntax, arguments, return values, common patterns.

assistant: # Children

*Children* are *Hair* or *Emitter* particles originating from individual particles.
They make it possible to work primarily with a relatively low amount of Parent particles,
for whom the physics are calculated. The children are then aligned to their parents.
The number and visualization of the children can be changed without a recalculation of the physics.

If you activate children, the parents are no longer rendered. This can be enabled in the Render panel
[Parent Particles](render.html#bpy-types-particlesettings-use-parent-particles). By default, parent particles
are not rendered because the shape of the children can be quite different from that of their parents.
user: How do I use Examples in Blender? Include parameters, examples, warnings and best practices.

assistant: Below are examples of blending modes, as well as some practical use cases.

[image reference removed]

Blending a colored pattern with a flat color (top row) and a circular mask (bottom row).

### Fixing overexposure

The Compositing setup below shows how to fix an overexposed render by
darkening it and increasing contrast.

[image reference removed]

Example node setup showing two RGB Curves nodes and a Mix node for composition.

The top [RGB Curves Node](adjust/rgb_curves.xhtml) darkens the image by linearly scaling each
color value to a smaller one.

The bottom curve node increases contrast by making small values smaller and large values larger.

Finally, the Mix node blends the two together.

### Watermark Images

In the old days, a pattern was pressed into the paper mush as it dried,
creating a mark that identified who made the paper and where it came from.
The mark was barely perceptible except in just the right light.
Probably the first form of subliminal advertising.

Nowadays, people watermark their images to identify them as personal intellectual property,
for subliminal advertising of the author or hosting service,
or simply to track their image’s proliferation throughout the web.

Blender provides a complete set of tools for you to both encode your watermark
and to tell if an image has your watermark.

#### Encoding your Watermark in an Image

First, construct your own personal watermark.
You can use your name, a word, or a shape or image not easily replicated.
While neutral gray works best using the encoding method suggested,
you are free to use other colors or patterns.
It can be a single pixel or a whole gradient; it is up to you.

In the example below, we are encoding the watermark in a specific location
in the image using the *Translate* node;
this helps later because we only have to look at a specific location for the mark.
We then use the *RGB to BW node* to convert the color image to grayscale numbers,
which we then feed into the *Map Range* node to reduce the mark to one-tenth of
its original intensity.

The *Add* node (*Mix* node with blending mode *Add*) adds the corresponding pixels,
making the ones containing the mark ever-so-slightly brighter.

[image reference removed]

Embedding a watermark in an image.

Of course, if you *want* people to notice your mark, do not scale it so much,
or make it a contrasting color. There are also many other ways,
using other mix settings and fancier rigs. Feel free to experiment!

#### Decoding an Image for your Watermark

When you see an image that you think might be yours,
use the node tree below to compare it to your stock image (non-watermarked original).
In this tree, the *Mix* node is set to Difference,
and the *Map Value* node amplifies any difference.
You can see how the original mark clearly stands out.

[image reference removed]

Checking an image for your watermark.
user: How do I use Selecting in Blender? Include parameters, examples, warnings and best practices.

assistant: # Selecting

By default, Blender uses `LMB` to select items.
This can be changed to `RMB` in the [Preferences](../editors/preferences/keymap.xhtml).

Blender has several selection tools that can be used across the different editors.

Most selection tools come in two variants, where one variant is available in the Toolbar
and the other in the *Select* menu. While the variants’ names are almost identical
(such as *Select Box* in the Toolbar versus *Box Select* in the menu),
the way they work is a bit different. New users coming from other applications
will find the Toolbar variants to be the most familiar.
user: Give a detailed overview of Brush Settings: syntax, arguments, return values, common patterns.

assistant: ### General

### Unique

Height
:   Determines the range of influence of the brush above the brush plane.
    Increasing the height affects vertices farther above the plane.

Depth
:   Determines the range of influence of the brush below the brush plane.
    Increasing the depth affects vertices farther below the plane.

Inversion Mode
:   Determines the behavior of the brush when inverted.

    Invert Displacement
    :   When inverted, the brush displaces vertices away from the brush plane, resulting in increased contrast.

    Swap Height and Depth
    :   When inverted, the roles of the *Height* and *Depth* parameters are exchanged.

        For example, if *Height* is set to 0.7 and *Depth* to 0.3, inverting the brush causes the roles of these
        parameters to be exchanged, resulting in an effective *Height* of 0.3 and *Depth* of 0.7.

Stabilize Normal
:   Controls the stability of the brush plane’s orientation. The normal of the plane is averaged over the last few
    stroke steps, with the number of steps and blending factor determined by the parameter’s value.

    When set to 0, the brush reacts immediately to changes in the in surface orientation.

    When set to 1, the plane’s orientation remains constant throughout the stroke.

    Intermediate values provide a gradual transition between these behaviors, resulting in a weighted moving average of
    plane normals.

Stabilize Plane
:   Controls the stability of the brush plane’s position. Similar to *Stabilize Normal*, it works by averaging the
    position over the previous stroke steps.

    Each position is calculated as the interpolated between the unstabilized position and its projection onto the plane
    of the previous stroke step.
user: What is FunctionNodeTransposeMatrix(FunctionNode) and how is it used in Blender Python scripting?

assistant: # FunctionNodeTransposeMatrix(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.FunctionNodeTransposeMatrix(*FunctionNode*)
:   Flip a matrix over its diagonal, turning columns into rows and vice-versa

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

assistant: You can alter the radius that a bone has by selecting the head, body or tail of a bone,
and then press `Alt`-`S` and move the mouse left or right.
If the body is selected the mean radius will be scaled.
And as usual, with connected bones, you scale at the same time the radius
of the parent’s tip and of the children’s roots.

You can also alter the bone radius by selecting the tail or head of the bone you wish to alter,
then navigate to Properties ‣ Bone ‣ Deform ‣ Radius Section
and entering new values for the *Tail* and *Head* number fields.

Bone Scale and Scale Radius comparison.

|  |  |
| --- | --- |
| ../../../../_images/animation_armatures_bones_selecting_single-bone.png   A single selected bone in Octahedron visualization. | ../../../../_images/animation_armatures_bones_editing_transform_scaling-bone-radius-2.png   After normal scale. |
| ../../../../_images/animation_armatures_bones_editing_transform_scaling-bone-radius-3.png   A single selected bone in Envelope visualization. | ../../../../_images/animation_armatures_bones_editing_transform_scaling-bone-radius-4.png   After Scaled Radius. Its length remains the same, but its joints’ radius are bigger. |

Note that, when you resize a bone (either by directly scaling it, or by moving one of its joints),
Blender automatically adjusts the end-radii of its envelope proportionally to the size of the modification.
Therefore, it is advisable to place all the bones first, and only then edit their properties.
user: Show practical ways to work with CameraStereoData(bpy_struct) in a Blender add-on or script – include code.

assistant: # CameraStereoData(bpy_struct)

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

*class* bpy.types.CameraStereoData(*bpy_struct*)
:   Stereoscopy settings for a Camera data-block

    convergence_distance
    :   The converge point for the stereo cameras (often the distance between a projector and the projection screen)

        Type:
        :   float in [1e-05, inf], default 1.95

    convergence_mode
    :   - `OFFAXIS`
          Off-Axis – Off-axis frustums converging in a plane.
        - `PARALLEL`
          Parallel – Parallel cameras with no convergence.
        - `TOE`
          Toe-in – Rotated cameras, looking at the same point at the convergence distance.

        Type:
        :   enum in [`'OFFAXIS'`, `'PARALLEL'`, `'TOE'`], default `'OFFAXIS'`

    interocular_distance
    :   Set the distance between the eyes - the stereo plane distance / 30 should be fine

        Type:
        :   float in [0, inf], default 0.065

    pivot
    :   Type:
        :   enum in [`'LEFT'`, `'RIGHT'`, `'CENTER'`], default `'LEFT'`

    pole_merge_angle_from
    :   Angle at which interocular distance starts to fade to 0

        Type:
        :   float in [0, 1.5708], default 1.0472

    pole_merge_angle_to
    :   Angle at which interocular distance is 0

        Type:
        :   float in [0, 1.5708], default 1.309

    use_pole_merge
    :   Fade interocular distance to 0 after the given cutoff angle

        Type:
        :   boolean, default False

    use_spherical_stereo
    :   Render every pixel rotating the camera around the middle of the interocular distance

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

assistant: Subdivides and smooths the strokes by inserting points between the selected points.

Number of Cuts
:   The number of subdivisions to perform.

Selected Points
:   When enabled, limits the effect to only the selected points within the stroke.

Iterations
:   Number of times to repeat the procedure.

Factor
:   The amount of the smoothness on subdivided points.

Smooth Endpoints
:   Smooths the stroke’s endpoints.

Keep Shape
:   Preserves the strokes shape.

Position
:   When enabled, the operator affect the points location.

Radius
:   When enabled, the operator affect the points thickness.

Opacity
:   When enabled, the operator affect the points strength (alpha).
user: Show practical ways to work with Miscellaneous in a Blender add-on or script – include code.

assistant: Sculpt Overlay Color
:   Defines a color to be used in the inner part of
    the brushes circle when in Sculpt Mode, and it is placed as an overlay to the brush,
    representing the focal point of the brush influence.
    The overlay color is visible only when the overlay visibility is selected
    (clicking at the *eye* to set its visibility), and the transparency of the overlay is
    controlled by the alpha slider located at the Tool tab ‣ Display panel in the Sidebar.
user: What is Distribute Points in Volume and how is it used in Blender Python scripting?

assistant: # Distribute Points in Volume

[image reference removed]

The *Distribute Points in Volume* node creates points inside of volume grids.
The node has two basic modes of operation: distributing points randomly, or in
a regular grid. Both methods operate on all of the float grids in the volume.
user: Give a detailed overview of VIEW3D_AST_brush_weight_paint(AssetShelf): syntax, arguments, return values, common patterns.

assistant: # VIEW3D_AST_brush_weight_paint(AssetShelf)

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

*class* bpy.types.VIEW3D_AST_brush_weight_paint(*AssetShelf*)
:   *classmethod* brush_type_poll(*context*, *asset*)

    *static* draw_popup_selector(*layout*, *context*, *brush*, *show_name=True*)

    *static* get_shelf_name_from_context(*context*)

    *classmethod* has_tool_with_brush_type(*context*, *brush_type*)

    *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 Making an Instanced Collection Real from the Blender manual or Python API, including usage steps and snippets.

assistant: If you want to make further edits on an instanced collection select the *Instance Collection*.
Then call [Make Instances Real](../../editing/apply.xhtml#bpy-ops-object-duplicates-make-real) to convert
the collection into regular objects that can be transformed and animated normally.
user: What is Arm Rig Example and how is it used in Blender Python scripting?

assistant: This arm uses two bones to overcome the twist problem for the forearm.
IK locking is used to stop the forearm from bending,
but the forearm can still be twisted manually by pressing `R` `Y` `Y` in *Pose Mode*,
or by using other constraints.

[image reference removed]

[IK Arm Example](https://archive.blender.org/wiki/2015/index.php/File:IK_Arm_Example.blend).

Note that, if a *Pole Target* is used, IK locking will not work on the root bone.
user: Give a detailed overview of Select Boundary Loop: syntax, arguments, return values, common patterns.

assistant: *Select Boundary Loop* does the opposite of *Select Loop Inner-Region*,
based on all regions currently selected, it selects only the edges at the border (contour) of these islands.
It can operate in any select mode, but when in *Face* mode it will switch to *Edge* select mode after running.

All this is much more simple to illustrate with examples:

[image reference removed]

Select Boundary Loop does the opposite and forces into Edge Select Mode.
user: How do I use Limit Total in Blender? Include parameters, examples, warnings and best practices.

assistant: Reduce the number of weight groups per vertex to the specified Limit.
The tool removes lowest weights first until the limit is reached.

Subset
:   Restrict the tool to a subset.
    See above [The Subset Option](#sculpt-paint-weight-paint-editing-subset) for how subsets are defined.

Limit
:   Maximum number of weights allowed on each vertex.
user: Explain Getting Started in complete detail according to the official Blender documentation.

assistant: Before contributing, you need an account at [projects.blender.org](https://projects.blender.org/).
Click the “Sign In” button and follow the prompts to create an account if you don’t already have one.

Once logged in, you can start editing directly from your browser.
user: What is Options and how is it used in Blender Python scripting?

assistant: Relative Path
:   Select the file path relative to the blend-file.

Accuracy
:   Sample accuracy, important for animation data (the lower the value, the more accurate).

Container
:   See [here](../../../files/media/video_formats.html).

Channels
:   The number of audio source “locations” to encode.
    Each channel can be mixed to a separate file by enabling *Split Channels* (see below).

    Mono:
    :   Output a single audio channel.

    Stereo:
    :   Output two audio channels; typically a left and right channel.

    Stereo LFE:
    :   Output a two audio channels with a “low-frequency effects” channel for frequencies below 120.

    4 Channels:
    :   Output a four audio channels.

    5.1 Surround:
    :   Output a five audio channels with one LFE channel.

    6.1 Surround:
    :   Output a six audio channels with one LFE channel.

    7.1 Surround:
    :   Output a seven audio channels with one LFE channel.

Format
:   Some *Audio Containers* also have option to choose a codec.
    For more information see [here](../../../files/media/video_formats.html).

Sample Rate
:   Sets the audio [sampling rate](https://en.wikipedia.org/wiki/Sampling_(signal_processing)#Sampling_rate).

Split Channels
:   Each audio channel will be rendered into a separate file.
user: What is Bpy.Types.Greasepencilarraymodifier and how is it used in Blender Python scripting?

assistant: count GreasePencilArrayModifier.invert_layer_filter GreasePencilArrayModifier.invert_layer_pass_filter GreasePencilArrayModifier.invert_material_filter GreasePencilArrayModifier.invert_material_pass_filter GreasePencilArrayModifier.layer_pass_filter GreasePencilArrayModifier.material_filter GreasePencilArrayModifier.material_pass_filter GreasePencilArrayModifier.offset_object GreasePencilArrayModifier.open_constant_offset_panel GreasePencilArrayModifier.open_influence_panel GreasePencilArrayModifier.open_object_offset_panel GreasePencilArrayModifier.open_randomize_panel GreasePencilArrayModifier.open_relative_offset_panel GreasePencilArrayModifier.random_offset GreasePencilArrayModifier.random_rotation GreasePencilArrayModifier.random_scale GreasePencilArrayModifier.relative_offset GreasePencilArrayModifier.replace_material GreasePencilArrayModifier.seed GreasePencilArrayModifier.tree_node_filter GreasePencilArrayModifier.use_constant_offset GreasePencilArrayModifier.use_layer_group_filter GreasePencilArrayModifier.use_layer_pass_filter GreasePencilArrayModifier.use_material_pass_filter GreasePencilArrayModifier.use_object_offset GreasePencilArrayModifier.use_relative_offset GreasePencilArrayModifier.use_uniform_random_scale GreasePencilArrayModifier.bl_rna_get_subclass() GreasePencilArrayModifier.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: What is Select Random and how is it used in Blender Python scripting?

assistant: Randomly selects unselected points or strokes.

Ratio
:   The likelihood of an unselected elements being selected.
    Note that, this is not the percentage amount of elements that will be selected.

Random Seed
:   [Seed](../../../glossary/index.xhtml#term-Seed) used by the pseudo-random number generator.

Action
:   Selection or deselection of elements.
user: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

Dynamic paint is a modifier and physics system that can turn objects into paint canvases
and brushes, creating Color Attributes, image sequences, or displacement.
This makes many effects possible like, for example footsteps in the snow,
raindrops that make the ground wet, paint that sticks to walls, or objects that gradually freeze.
user: Describe Viewport from the Blender manual or Python API, including usage steps and snippets.

assistant: Samples
:   The number of samples to use in the 3D Viewport.
    When setting this to zero the viewport will be resampled continuously.

Temporal Reprojection
:   Reduces noise while moving the viewport or during animation playback. Can leave some ghosting.

Jittered Shadows
:   Enable jittered shadows on the viewport.
    Jittered shadows are always enabled for final renders.
    This also affects any transparent shadows.
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Distribution
:   Sheen shading model.

    Ashikhmin:
    :   Classic Ashikhmin velvet, used in Blender versions prior to 4.0

    Microfiber:
    :   Microflake-based model of multiple scattering between normal-oriented fibers.
user: What is Snap and how is it used in Blender Python scripting?

assistant: The toggle button enables/disables automatic keyframe snapping.
The dropdown button shows a popover with the following options:

Snap To
:   Type of element to snap to.

    Frame:
    :   Snap to full frames.

    Second:
    :   Snap to seconds.

    Nearest Marker:
    :   Snap to the nearest [Marker](../../animation/markers.xhtml).

Absolute Time Snap
:   When disabled, keyframes will move in increments of *Snap To*.
    For example, if you selected *Second* and have a keyframe that’s currently on
    0:06+5, dragging it to the right will snap it to 0:07+5. Its time
    increases by a second, and its subsecond offset of 5 frames remains the same.

    When enabled, keyframes will snap to multiples of *Snap To*.
    Taking the above example, the keyframe would snap to 0:07+0,
    removing the subsecond offset.
user: How do I use Details in Blender? Include parameters, examples, warnings and best practices.

assistant: macOS uses “files” with the `.app` extension called *applications*.
These files are actually folders that appear as files in Finder.
In order to run Blender you will have to specify that path to the Blender executable inside this folder,
to get all output printed to the terminal.
You can start a terminal from Applications ‣ Utilities.
The path to the executable in the `.app` folder is `./Blender.app/Contents/MacOS/Blender`.

If you have Blender installed in the Applications folder, the following command can be used:

```
/Applications/Blender.app/Contents/MacOS/Blender
```

[image reference removed]

Starting Blender from a macOS console window.
user: Give a detailed overview of Navigating: syntax, arguments, return values, common patterns.

assistant: While performing a transformation, you can perform navigation actions such as zooming,
panning, or rotating by holding `Alt` then perform the desired action.

This behavior can be changed through the *Transform Navigation with Alt* setting
in the [Keymap](../../editors/preferences/keymap.xhtml) Preferences.
user: Give a detailed overview of Driver Configuration: syntax, arguments, return values, common patterns.

assistant: The [Drivers panel](drivers_panel.xhtml) shows the setup for a driver.

A driver can have zero, one, or more **variables**. Variables specify which properties,
object transformation channels, or relative distances between objects, are used as inputs
by the driver.

The driver **type** determines how the variables are used. The type can be:

- a built-in function: for example, the sum of the variables’ values, or
- a scripted expression: an arbitrary Python expression that refers to the variables by their names.

This driver configuration outputs a single value which changes when the variables change.
This value is then evaluated through the driver function curve to produce the result
to be applied to the driven property.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`Object.constraints`](bpy.types.Object.html#bpy.types.Object.constraints "bpy.types.Object.constraints") - [`ObjectConstraints.active`](bpy.types.ObjectConstraints.html#bpy.types.ObjectConstraints.active "bpy.types.ObjectConstraints.active") - [`ObjectConstraints.copy`](bpy.types.ObjectConstraints.html#bpy.types.ObjectConstraints.copy "bpy.types.ObjectConstraints.copy") - [`ObjectConstraints.copy`](bpy.types.ObjectConstraints.html#bpy.types.ObjectConstraints.copy "bpy.types.ObjectConstraints.copy") - [`ObjectConstraints.new`](bpy.types.ObjectConstraints.html#bpy.types.ObjectConstraints.new "bpy.types.ObjectConstraints.new") - [`ObjectConstraints.remove`](bpy.types.ObjectConstraints.html#bpy.types.ObjectConstraints.remove "bpy.types.ObjectConstraints.remove") - [`Panel.custom_data`](bpy.types.Panel.html#bpy.types.Panel.custom_data "bpy.types.Panel.custom_data") | - [`PoseBone.constraints`](bpy.types.PoseBone.html#bpy.types.PoseBone.constraints "bpy.types.PoseBone.constraints") - [`PoseBoneConstraints.active`](bpy.types.PoseBoneConstraints.html#bpy.types.PoseBoneConstraints.active "bpy.types.PoseBoneConstraints.active") - [`PoseBoneConstraints.copy`](bpy.types.PoseBoneConstraints.html#bpy.types.PoseBoneConstraints.copy "bpy.types.PoseBoneConstraints.copy") - [`PoseBoneConstraints.copy`](bpy.types.PoseBoneConstraints.html#bpy.types.PoseBoneConstraints.copy "bpy.types.PoseBoneConstraints.copy") - [`PoseBoneConstraints.new`](bpy.types.PoseBoneConstraints.html#bpy.types.PoseBoneConstraints.new "bpy.types.PoseBoneConstraints.new") - [`PoseBoneConstraints.remove`](bpy.types.PoseBoneConstraints.html#bpy.types.PoseBoneConstraints.remove "bpy.types.PoseBoneConstraints.remove") - [`UILayout.template_constraint_header`](bpy.types.UILayout.html#bpy.types.UILayout.template_constraint_header "bpy.types.UILayout.template_constraint_header") |
user: Explain Compositor in complete detail according to the official Blender documentation.

assistant: # Compositor

The Compositor lets you manage [nodes](../interface/controls/nodes/index.xhtml)
for compositing.

[image reference removed]

Nodes in the Compositor.

The use of the Compositor is explained in [Compositing](../compositing/index.xhtml).
user: How do I use Collisions in Blender? Include parameters, examples, warnings and best practices.

assistant: # Collisions

[image reference removed]

Rigid Body Collisions panel.

Shape
:   Determines the collision shape of the object;
    these can be broken into two categories: primitive shapes and mesh based shapes.

    Primitive shapes (*Box*, *Sphere*, *Capsule*, *Cylinder*, and *Cone*)
    are best in terms of memory and performance but do not
    necessarily reflect the actual shape of the object.
    The size of the shape is calculated based on the object’s bounding box.
    The center of gravity is always in the geometric center of the shape.
    Primitive shapes can be shown in the 3D Viewport by enabling
    [Extras Overlay](../../../editors/3dview/display/overlays.xhtml#bpy-types-view3doverlay-show-extras).

    Mesh based shapes (*Convex Hull* and *Mesh*) are calculated based on the geometry of the object
    so they are a better representation of the object.
    The center of gravity for these shapes is the object origin.

    Box:
    :   Box-like shapes (e.g. cubes), including planes (e.g. ground planes).
        The size per axis is calculated from the bounding box.

    Sphere:
    :   Sphere-like shapes. The radius is the largest axis of the bounding box.

    Capsule:
    :   This points up the Z axis.

    Cylinder:
    :   This points up the Z axis.
        The height is taken from the Z axis, while the radius is the larger of the X or Y axes.

    Cone:
    :   This points up the Z axis.
        The height is taken from the Z axis, while the radius is the larger of the X or Y axes.

    Convex Hull:
    :   A mesh-like surface encompassing (e.g. shrink-wrapped over) all vertices (best results with fewer vertices).
        A convex approximation of the object, which has good performance and stability.

    Mesh:
    :   [Mesh](../../../glossary/index.xhtml#term-Mesh) consisting of triangles only, allowing for more detailed interactions than convex hulls.
        Allows simulating concave objects, but is rather slow and unstable.

    Compound Parent:
    :   Takes the collision shapes from the object’s [children](../../../scene_layout/object/editing/parent.xhtml)
        and combines them. This makes it possible to create concave shapes from primitive shapes.
        This usually results in a faster simulation than the *Mesh* collision shape
        while also being generally more stable.

Source
:   Source of the mesh used to create the collision shape.

    Base:
    :   The base mesh of the object.

    Deform:
    :   Includes any deformations added to the mesh (shape keys, deform modifiers).

    Final:
    :   Includes all deformations and modifiers.

Deforming
:   Mesh shapes can deform during simulation.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Image
:   Standard color input.

Invert
:   Invert the stabilization. If the stabilization calculated is to move the movie clip up by 5 units,
    this will move the movie clip down by 5 units.

### Sampling

Filter
:   Determines how pixel values are interpolated when scaling or transforming images.

    Nearest:
    :   Uses the value of the closest pixel with no smoothing.
        This is the fastest method and is well-suited for pixel art or low-resolution images
        where sharp, blocky edges are desirable.
        In animations, motion appears in single-pixel steps, which can cause visible jittering.

    Bilinear:
    :   Averages the values of surrounding pixels to create a smoother result than *Nearest*.
        Provides a good balance between performance and visual quality.

    Bicubic:
    :   Computes a weighted average of a larger neighborhood of pixels for even smoother results.
        Ideal for photographic images or gradients where preserving fine detail is important.

    Anisotropic:
    :   Adjusts interpolation based on the direction and scale of the transformation.
        Helps reduce blurring or aliasing when scaling at steep angles or uneven resolutions,
        especially useful in textures viewed at oblique angles or in detailed 3D projections.