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

assistant: # Distance from Object

The *Distance from Object* modifier alters the base property with a new one
from a given range using the distance to the active *camera* or to a given *object* as the parameter.

Target
:   The object to measure distance from.

Range Min, Max
:   The limits of the mapping from “distance to camera” to “property in mapping”.
    If the current point of the stroke is at *Range Min* or less from the active camera or the object,
    it will take the start value. And conversely,
    if it is at *Max* or more from the camera/object, it will take the end value.
    These values are in the current scene’s units, not in pixels!

Fill Range by Selection
:   Set the min/max range values from the distances between the current selected mesh vertices and
    the camera or the target.
user: Provide the full official documentation entry for Touchpad, preserving all code examples.

assistant: Multi-touch Gestures
:   Use multi-touch gestures for navigation with touchpad, instead of scroll wheel emulation.
    For more detail on supported gestures,
    see [Configuring Peripherals](../../getting_started/configuration/hardware.html).

Scroll Direction
:   The direction scrolling responds to the scroll gestures.

    Only available on Linux using Wayland.

    Traditional:
    :   Scrolls content down when gestures move up.

    Natural:
    :   Scrolls content up when gestures move up.
user: How do I use Selecting in Blender? Include parameters, examples, warnings and best practices.

assistant: - Select single: `LMB`.
- Add to/remove from selection: `Shift`-`LMB`.
- All: `A`.
- None: `Alt`-`A`.
- Invert: `Ctrl`-`I`.
- Box select: `B`.
- Circle Select: `C`.
- Lasso Select: `Ctrl`-`Alt`-`LMB`.
- Select Linked: Move the mouse over a path and press `L` to add all its points to the selection.
- Unselect Linked: Move the mouse over a path and press `Shift`-`L` to remove all its points
  from the selection.
- Root/Tips: Select ‣ Roots / Tips.

### Select Random

Randomly selects particles.

Percent
:   Percent of particles to randomly select.

Random Seed
:   Seed value to use for the selection.

Action
:   Select random can be either used to select or deselect particles.

Type
:   Selects either hair or points. Here these terms can be confusing because
    hair/point does not refer to the particle type but the path/points of the hair/particle.

### Select Modes

[image reference removed]

Select Modes.

Path:
:   No keypoints are visible, you can select/deselect only all particles.

Point:
:   You see all of the keypoints.

Tip:
:   You can see and edit (including the brushes) only the tip of the particles, i.e. the last keypoint.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`Object.vertex_groups`](bpy.types.Object.html#bpy.types.Object.vertex_groups "bpy.types.Object.vertex_groups") - [`VertexGroups.active`](bpy.types.VertexGroups.html#bpy.types.VertexGroups.active "bpy.types.VertexGroups.active") | - [`VertexGroups.new`](bpy.types.VertexGroups.html#bpy.types.VertexGroups.new "bpy.types.VertexGroups.new") - [`VertexGroups.remove`](bpy.types.VertexGroups.html#bpy.types.VertexGroups.remove "bpy.types.VertexGroups.remove") |
user: Provide the full official documentation entry for Attributes, preserving all code examples.

assistant: When merging attributes from multiple geometry inputs, the highest complexity data type is chosen
for the output attribute. For example, if a `weight` attribute is a Boolean on one geometry input
and a vector on another, the `weight` attribute on the output geometry will use the vector data type.
user: Provide the full official documentation entry for Filters, preserving all code examples.

assistant: These filters are available in the funnel dropdown button in the header.

Summary
:   Toggles the “Summary” row at the top of the Channels region.
    This row shows the union of all keyframes across all channels.

Only Show Selected
:   Only show keyframes belonging to objects/bones/… that are selected.

Show Hidden
:   Show keyframes from objects/bones/… that are hidden.

Only Show Errors
:   Only show channels that have errors (for example, because they try to animate a property that doesn’t
    exist on the object).

Search
:   Filters the channel list by a search term (or multiple search terms if *Multi-Word Match Search*
    is enabled).

Filtering Collection
:   Select a collection to only show keyframes from objects in that collection.

Filter by Type
:   Filter curves by property type.

Sort Data-Blocks
:   Sorts data-blocks alphabetically to make them easier to find.

    If your playback speed suffers because of this
    (should only really be an issue when working with lots of objects),
    you can turn it off.
user: Give a detailed overview of Solve: syntax, arguments, return values, common patterns.

assistant: Tripod
:   Tripod Motion can be used for footage where the camera does not move and only rotates.
    Such footage can’t be tracked with a generic solver approach, and
    it is impossible to determine the actual feature points in space due to a lack of information.
    So this solver will solve only the relative camera rotation and then reproject the feature points into a sphere,
    with the same distance between feature and camera for all feature points.

Keyframe
:   Automatically select keyframes for initial reconstruction.
    This option enables complex algorithms which tries to find a keyframe pair
    with minimal reconstruction error and best scene scale guess.

Keyframe A/B
:   Start (A) and End (B) frame of the range used for reconstruction.

Refine
:   Specifies which parameters should be refined during solve.
    Such refining is useful when you are not sure about some camera intrinsics,
    and solver should try to find the best parameter for those intrinsics.
    But you still have to know approximate initial values –
    it will fail to find correct values if they were set completely incorrectly initially.

    Focal Length
    :   Refine the camera’s [Focal Length](../sidebar/track/camera.html#bpy-types-movietrackingcamera-focal-length).

    Optical Center
    :   Refine the camera’s [Optical Center](../sidebar/track/camera.html#bpy-types-movietrackingcamera-principal-point).

    Radial Distortion
    :   Refine the camera’s [Radial Distortion Parameters](../sidebar/track/camera.html#bpy-types-movietrackingcamera-k).

    Tangential Distortion
    :   Refine the camera’s [Tangential Distortion Parameters](../sidebar/track/camera.html#bpy-types-movietrackingcamera-brown-p).

Solve Camera/Object Motion
:   See [Solve Camera/Object Motion](../editing/track.html#bpy-ops-clip-solve-camera).
user: What is Outline and how is it used in Blender Python scripting?

assistant: The *Outline* operator converts selected Grease Pencil strokes into closed perimeter shapes.
It creates new strokes around the outer boundary of the original stroke,
effectively generating a filled outline with adjustable thickness.

View
:   Defines the projection method used to generate the outline:

    View:
    :   Use the current viewport perspective as the projection plane.

    Front:
    :   Use the X-Z axes as the projection plane (front view).

    Side:
    :   Use the Y-Z axes as the projection plane (side view).

    Top:
    :   Use the X-Y axes as the projection plane (top view).

    Camera:
    :   Use the active camera’s perspective as the projection plane.

Radius
:   Sets the thickness of the outline on both sides of the original stroke.
    Higher values result in a wider perimeter.

Offset Factor
:   Scales the stroke outline inward or outward.
    - Positive values push the perimeter outward.
    - Negative values pull it inward.
    - A value of 0 centers the perimeter on the original stroke.

Corner Subdivisions
:   Number of subdivisions used to smooth corners at stroke endpoints and joints.
    Higher values result in smoother corners but increase stroke complexity.

|  |  |
| --- | --- |
| <../../../_images/grease-pencil_modes_edit_stroke-menu_outline-1.png>   Original stroke. | <../../../_images/grease-pencil_modes_edit_stroke-menu_outline-2.png>   Stroke after applying the *Outline* operator. |
user: Provide the full official documentation entry for Field Visualization, preserving all code examples.

assistant: Socket shapes are used to convey which sockets are fields and which are regular data.
There are three possible socket shapes, each visualizing its “field status”:

Circle:
:   The socket requires a single value, it cannot accept a field input.
    For output sockets, this means the node always outputs a single value.

Diamond:
:   The socket can accept a field input, or it outputs a field. A constant single
    value can be connected to these sockets, but then the output will often not
    vary per element.

Diamond with Dot:
:   The socket can be a field, but it is currently a single value. This is helpful
    because it allows tracking where single values are calculated, instead of a field
    with many different results. It also means that [Socket Inspection](inspection.xhtml#socket-inspection) will show
    the value instead of field input names.

[image reference removed]

The socket shape is a diamond with a dot, meaning the field has the same value
for every element. Every point will be moved up by 5 m.

[image reference removed]

The socket shape is a diamond and the field input now has a varying input. In other words,
the value can be different for every element. In this case, the position will be doubled,
since the offset for every point is the point’s position.

When a connection is made between two node sockets that support
fields the node connection will be drawn as a dashed line.
If you make the mistake of connecting a non-field socket to a field socket,
the connection will be drawn as a solid red line indicating that there is an error.
user: Explain Calculate Mass in complete detail according to the official Blender documentation.

assistant: Calculate mass values for rigid body objects based on their volume and density.
The volume is calculated automatically, the density needs to be given based on the object you want to simulate.

Material Preset
:   A list of preset density values for real-world materials,
    if a material is not given you can research the density and use the *Custom* preset to input the density manually.

Density
:   When the *Custom* *Material Preset* is selected, this is the input density, in kg/m3, to use.
user: Provide the full official documentation entry for S-Curves, preserving all code examples.

assistant: # S-Curves

The curve type used for creating mask splines is almost a Bézier curve, but with some differences.
Smooth edges of the mask are defined by feathering.
The curve needed to support feathering in a way that stuck to the curve as you edited it,
for ease of editing an animation. These are called S-curves.

Besides the handles, every control point also has points that define the feather between
the current point and the next point on the spline.
Each feather point is stored in UW space,
where U means position across spline segment, and W (weight) means distance between main spline and feather points.

[[image reference removed]](../../_images/movie-clip_masking_scurve_schematic.svg)

S-Curve explained.

This allows for deforming the main spline in almost any way,
and the feather will be updated automatically to reflect that change.

For example if there is just rotation of the spline,
feather would stay completely unchanged. If one point’s feather is moved,
the other feathers will be automatically stretched uniformly along that segment
and the overall shape will be almost the same as artists would want it to be.
user: How do I use VIEW3D_FH_vdb_volume(FileHandler) in Blender? Include parameters, examples, warnings and best practices.

assistant: # VIEW3D_FH_vdb_volume(FileHandler)

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

*class* bpy.types.VIEW3D_FH_vdb_volume(*FileHandler*)
:   *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 NodeTreeInterfaceSocketVectorVelocity2D(NodeTreeInterfaceSocket) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeTreeInterfaceSocketVectorVelocity2D(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.NodeTreeInterfaceSocketVectorVelocity2D(*NodeTreeInterfaceSocket*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-inf, inf], default (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: How do I use Relative Shape Keys in Blender? Include parameters, examples, warnings and best practices.

assistant: [[image reference removed]](../../_images/animation_shape-keys_shape-keys-panel_relative.png)

Relative Shape Keys options.

See [Relative or Absolute Shape Keys](introduction.html#animation-shapekeys-relative-vs-absolute).

With relative shape keys, the value shown for each shape in the list represents
the current weight or influence of that shape in the current *Mix*.

(Clear Shape Keys)
:   Set all influence values, or weights, to zero.
    Useful to quickly guarantee that the result shown in the 3D Viewport is not affected by shapes.

Value
:   The weight of the blend between the shape key and its reference key (usually the Basis shape).

    A value of 0.0 denotes 100% influence of the reference key and 1.0 of the shape key.

Range
:   Minimum and maximum range for the influence value of the active shape key.
    Blender can extrapolate results when the *Value* goes lower than 0.0 or above 1.0.

Vertex Group
:   Limit the active shape key deformation to a vertex group.
    Useful to break down a complex shape into components by assigning temporary vertex groups
    to the complex shape and copying the result into new simpler shapes.

Relative To
:   Select the shape key to deform from. This is called the *Reference Key* for that shape.
user: Explain Save and Override in complete detail according to the official Blender documentation.

assistant: The workspaces are saved in the blend-file.
When you open a file, enabling [Load UI](../../files/blend/open_save.html#file-load-ui) in the File Browser indicates that Blender should
use the file’s screen layout rather than the current one.

A custom set of workspaces can be saved as a part of the [Defaults](../../getting_started/configuration/defaults.html).
user: Describe Creating a Rigid Body from the Blender manual or Python API, including usage steps and snippets.

assistant: Only mesh objects can be part of a rigid body simulation.
To create rigid bodies, either click on the *Rigid Body* button in the *Physics* tab of
the Properties or use *Add Active*/*Add Passive* in the Object ‣ Rigid Body menu.

There are two types of rigid bodies: active and passive. *Active* bodies are dynamically simulated, while *passive*
bodies remain static. Both types can be driven by the animation system when using the *Animated* option.

During the simulation,
the rigid body system will override the position and orientation of dynamic rigid body objects.
Note however, that the location and rotation of the objects are not changed,
so the rigid body simulation acts similar to a constraint.
To apply the rigid body transformations you can use
the *Apply Object Transform* operator.

The scale of the rigid body object also influences the simulation, but is always controlled by the animation system.

Rigid body physics on the object can be *removed* with the *Rigid Body* button
in the *Physics* tab in the Properties or in the Object ‣ Rigid Body menu.
user: What is Surfaces and how is it used in Blender Python scripting?

assistant: # Surfaces

The surface shader defines the light interaction at the surface of the mesh.
One or more BSDFs specify
if incoming light is reflected back, refracted into the mesh, or absorbed.

Emission defines how light is emitted from the surface,
allowing any surface to become a light source.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Grid
:   The input grid that defines the volume within which points are distributed.
    The grid’s values determine where points can be placed—typically based on
    density or occupancy.

Density Random
:   A scaling factor applied to the voxel values that determines the expected
    number of points to generate per unit volume.
    Higher values produce denser distributions of points.

Seed Random
:   The seed value used by the random number generator for reproducible results.
    Changing this value alters the random point distribution without affecting
    other parameters.

Spacing Grid
:   The distance between points when using the *Grid* distribution method.
    Controls how tightly points are packed inside the volume.

Threshold Grid
:   The minimum voxel density value required for a point to be generated.
    Voxels below this threshold are ignored, which can be used to restrict
    point placement to denser or more meaningful regions.
user: Show practical ways to work with Realizing Instances in a Blender add-on or script – include code.

assistant: The term “realizing” instances referes to converting the instances into unique geometry.
When instances are realized they will take up more memory and manipulation to geometry
will have to be processed individually rather the once per instancing geometry.

To realize instance use the [Realize Instances Node](instances/realize_instances.html).
user: Give a detailed overview of Distance Key Node: syntax, arguments, return values, common patterns.

assistant: # Distance Key Node

[image reference removed]

The Distance Key node determines a pixel’s alpha value based on the three-dimensional
distance between the image pixel color and the key color in a 3D color space.

This key works well when trying to single out a specific color in a background
(not necessarily green).
user: Show practical ways to work with SurfaceModifier(Modifier) in a Blender add-on or script – include code.

assistant: # SurfaceModifier(Modifier)

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

*class* bpy.types.SurfaceModifier(*Modifier*)
:   Surface modifier defining modifier stack position used for surface fields

    *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 Drivers Panel and how is it used in Blender Python scripting?

assistant: # Drivers Panel

[image reference removed]

Edit Driver popover.

This panel is visible in Sidebar of the [Drivers Editor](../../editors/drivers_editor.xhtml)
or as a popover when adding a driver to a property.

It shows the property that is being driven, followed by a series of settings
that determine how the driver works.
user: Provide the full official documentation entry for UIPieMenu(bpy_struct), preserving all code examples.

assistant: # UIPieMenu(bpy_struct)

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

*class* bpy.types.UIPieMenu(*bpy_struct*)
:   layout
    :   Type:
        :   [`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (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 Basic Panel Example in complete detail according to the official Blender documentation.

assistant: This script is a simple panel which will draw into the object properties
section.

Notice the ‘CATEGORY_PT_name’ [`Panel.bl_idname`](#bpy.types.Panel.bl_idname "bpy.types.Panel.bl_idname"), this is a naming
convention for panels.

```
import bpy

class HelloWorldPanel(bpy.types.Panel):
    bl_idname = "OBJECT_PT_hello_world"
    bl_label = "Hello World"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "object"

    def draw(self, context):
        self.layout.label(text="Hello World")

bpy.utils.register_class(HelloWorldPanel)
```
user: Give a detailed overview of Move: syntax, arguments, return values, common patterns.

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

assistant: # Introduction

Grease Pencil has a special set of viewport real-time visual effects that can be apply to the object.

These effects treat the object as if it was just an image, for that reason they
have effect on the whole object and cannot limit their influence
on certain parts like layers, materials or vertex group as with modifiers.
Also unlike modifiers, they can not be applied to the object.

Their main purpose is to have a quick way to apply visual effects on your drawings
like blurring, pixelation, wave distortion, among others.
user: How do I use Troubleshooting Windows – NVIDIA in Blender? Include parameters, examples, warnings and best practices.

assistant: # Troubleshooting Windows – NVIDIA

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

This section lists possible solutions for graphics glitches, problems with EEVEE and Cycles, and crashes related to
your GPU.
user: Describe Backward Compatibility from the Blender manual or Python API, including usage steps and snippets.

assistant: Opening older files and converting them for the current version of Blender is usually straight-forward.
It is expected to give very good and usable results.

There can be major feature changes, for which the backward compatibility will only be ensured for
a limited amount of time. For example the changes to the animation system that happened during the
Blender 2.5x project. This will never be less than a full major release cycle (i.e. two years at least).
user: Show practical ways to work with GeometryNodeGeometryToInstance(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeGeometryToInstance(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.GeometryNodeGeometryToInstance(*GeometryNode*)
:   Convert each input geometry into an instance, which can be much faster than the Join Geometry node when the inputs are large

    *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 Boid Brain from the Blender manual or Python API, including usage steps and snippets.

assistant: The Boid Brain panel controls how the boids particles will react with each other.
The boids’ behavior is controlled by a list of rules.
Only a certain amount of information in the list can be evaluated.
If the memory capacity is exceeded, the remaining rules are ignored.

The rules are by default parsed from top-list to bottom-list
(thus giving explicit priorities),
and the order can be modified using the little arrows buttons on the right side.

Rule Evaluation
:   There are three ways to control how rules are evaluated:

    Average
    :   All rules are averaged.

    Random
    :   A random rule is selected for each boid.

    Fuzzy
    :   Uses fuzzy logic to evaluate rules. Rules are gone through top to bottom.
        Only the first rule that affect above the *Rule Fuzziness* threshold is evaluated.
        The value should be considered how hard the boid will try to respect a given rule
        (a value of 1 means the Boid will always stick to it, a value of 0 means it will never).
        If the boid meets more than one conflicting condition at the same time,
        it will try to fulfill all the rules according to the respective weight of each.

In Air
:   The current rule affects boids while they are flying.

On Land
:   The current rule affects boids while they are not flying.

### Goal Rule

Seek goal.

Object
:   Specifies the goal object. If not specified, Boid force fields with negative Strength are used as goals.

Predict
:   Predict target’s movements.

### Avoid Rule

Avoid “predators”.

Object
:   Specifies the object to avoid.
    If not specified, Boid force fields with positive Strength are used as predators.

Predict
:   Predict target’s movements.

Fear Factor
:   Avoid object if danger from it is above this threshold.

### Avoid Collision Rule

Avoid objects with activated Deflection.

Boids
:   Avoid collision with other boids.

Deflectors
:   Avoid collision with deflector objects.

Look Ahead
:   Time to look ahead in seconds.

### Separate Rule

Boids move away from each other.

### Flock Rule

Copy movements of neighboring boids, but avoid each other.

### Follow Leader Rule

Follows a leader object instead of a boid.

Distance
:   Distance behind leader to follow.

Line
:   Follow the leader in a line.

    Queue Size
    :   How many boids that are allowed to follow in a line.

### Average Speed Rule

Maintain average velocity.

Speed
:   Percentage of maximum speed.

Wander
:   How fast velocity’s direction is randomized.

Level
:   How much velocity’s Z component is kept constant.

### Fight Rule

Move toward nearby boids.

Fight Distance
:   Attack boids at a maximum of this distance.

Flee Distance
:   Flee to this distance.
user: Provide the full official documentation entry for Vertex Groups for Bones, preserving all code examples.

assistant: This is one of the main uses of weight painting. While you can have Blender
generate the weights automatically (see the
[skinning section](../../animation/armatures/skinning/index.xhtml)),
you may want to tweak them or even create them from scratch,
especially around joints.

The process is as follows:

1. Select the armature and bring it into *Pose Mode* by pressing `Ctrl`-`Tab`.
2. Make sure that Edit ‣ Lock Object Modes is unchecked
   in the topbar.
3. Select the mesh and bring it into *Weight Paint Mode*.
4. Make sure that *Bone Selection* is checked in the 3D Viewport’s header.
5. Select a bone using `Alt`-`LMB` (or `Shift`-`Ctrl`-`LMB`).
   This will activate the bone’s vertex group and display its current weights on the mesh.
6. Paint weights for the bone using `LMB`.

If a bone doesn’t have a vertex group yet when you start painting,
Blender will create one automatically.

If you have a symmetrical mesh and a symmetrical armature, you can use
[Mirror Vertex Groups](tool_settings/symmetry.xhtml#bpy-types-mesh-use-mirror-vertex-groups)
to automatically create vertex groups and weights for the other side.
user: Provide the full official documentation entry for Editing Weight Paint, preserving all code examples.

assistant: # Editing Weight Paint

[image reference removed]

Weight Paint Tools.

Blender provides a set of helper tools for Weight Painting.

The Subset Option

Some of the tools also provide a Subset filter to restrict their functionality to only specific vertex groups
(in the [Adjust Last Operation](../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel, displayed after the tool is called)
with following options:

- Active Group
- Selected Pose Bones
- Deform Pose Bones
- All Groups

All tools also work with Vertex Selection Masking and Face Selection Masking.
In these modes the tools operate only on selected vertices or faces.
user: How do I use 3D Cursor in Blender? Include parameters, examples, warnings and best practices.

assistant: Cursor – Surface Project
:   When placing the cursor by clicking,
    the cursor is projected onto the surface under the cursor.

Cursor – Lock Adjust
:   When the viewport is locked to the cursor,
    moving the cursor avoids the view *jumping* based on the new offset.
user: Explain Color Management in complete detail according to the official Blender documentation.

assistant: # Color Management

Color management is important to create renders and assets that are physically accurate and look great
on multiple display devices. It is used both to ensure all parts of the pipeline interpret colors correctly,
and to make artistic choices about the look.
user: How do I use Boid in Blender? Include parameters, examples, warnings and best practices.

assistant: # Boid

The *Boid* force fields do not affect physics,
and are used together with the [Boids Particles](../../../particles/emitter/physics/boids.xhtml)
to define boid predators and goals for the *Boid Brain* rules.

[image reference removed]

UI for a Boid force field.
user: Describe Mesh Boolean Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Mesh Boolean Node

[image reference removed]

The *Mesh Boolean Node* allows you to cut, subtract, and join the geometry of two inputs.
This node offers the same operations as the [Boolean modifier](../../../modifiers/generate/booleans.xhtml).
user: Explain Light Falloff in complete detail according to the official Blender documentation.

assistant: In reality light in a vacuum will always fall off at a rate of 1/(distance^2).
However, as distance goes to zero,
this value goes to infinity and we can get very bright spots in the image.
These are mostly a problem for indirect lighting, where the probability of hitting such
a small but extremely bright spot is low and so happens only rarely.
This is a typical recipe for [Fireflies](../../../glossary/index.xhtml#term-Fireflies).

|  |  |
| --- | --- |
| ../../../_images/render_cycles_optimizations_reducing-noise_falloff-hard.jpg   Hard Falloff. | ../../../_images/render_cycles_optimizations_reducing-noise_falloff-soft.jpg   Soft Falloff. |

To reduce this problem, the [Light Falloff](../../shader_nodes/color/light_falloff.xhtml)
node has a *Smooth factor*, that can be used to reduce the maximum intensity
a light can contribute to nearby surfaces. The images above show default falloff and smooth value 1.0.
user: Explain Settings in complete detail according to the official Blender documentation.

assistant: Stiffness
:   The spring stiffness for *Goal*. A low value creates very weak springs
    (more flexible “attachment” to the goal), a high value creates a strong spring
    (a stiffer “attachment” to the goal).

Damping
:   The friction coefficient for *Goal*. Higher values give damping of the spring effect (little jiggle),
    and the movement will soon come to an end.
user: Describe DepsgraphUpdate(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # DepsgraphUpdate(bpy_struct)

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

*class* bpy.types.DepsgraphUpdate(*bpy_struct*)
:   Information about ID that was updated

    id
    :   Updated data-block

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

    is_updated_geometry
    :   Object geometry is updated

        Type:
        :   boolean, default False, (readonly)

    is_updated_shading
    :   Object shading is updated

        Type:
        :   boolean, default False, (readonly)

    is_updated_transform
    :   Object transformation is updated

        Type:
        :   boolean, default False, (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # GeometryNodeRaycast(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.GeometryNodeRaycast(*GeometryNode*)
:   Cast rays from the context geometry onto a target geometry, and retrieve information from each hit point

    data_type
    :   Type of data stored in attribute

        Type:
        :   enum in [Attribute Type Items](bpy_types_enum_items/attribute_type_items.html#rna-enum-attribute-type-items), 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: Provide the full official documentation entry for Alpha Over, preserving all code examples.

assistant: With *Alpha Over*, the strips are layered up in the order selected; the first strip selected is the background,
and the second one goes *over* the first one selected.
The *Opacity* controls the transparency of the *foreground*, i.e. *Opacity* of 0.0;
will only show the background, and an *Opacity* of 1.0 will completely override the background with the foreground
(except in the transparent areas of this one, of course!)

[image reference removed]

Alpha Over Effect.
user: What is Inset Faces and how is it used in Blender Python scripting?

assistant: # Inset Faces

This tool takes the currently selected faces and creates an inset of them,
with adjustable thickness and depth. Think of it as like creating an edge loop,
but relative to the selected edges, even in complex meshes.

The tool is modal, such that when you activate it,
you may adjust the thickness with your mouse position.
You may also adjust the depth of the inset during the modal operation by holding `Ctrl`.

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_face_inset-faces_before.png>   Selection to inset. | <../../../../_images/modeling_meshes_editing_face_inset-faces_after.png>   Result of inset with *Select Outer* enabled. |
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Value
:   The values the minimum and maximum will be calculated from

Group ID
:   An index used to group values together for multiple separate averages.
    This can be thought of as a choice of the “bin” in which to place each value.
    This input has no effect when it is only a single value.
user: Explain Gradient (Radial) in complete detail according to the official Blender documentation.

assistant: Applies a radial weight gradient;
this is useful at times when painting gradual changes in weight becomes difficult.
Blends the weights of selected vertices with unselected vertices.

Weight
:   The gradient starts at the current selected weight value, blending out to nothing.

Strength
:   Lower values can be used so the gradient mixes in with the existing weights (just like with the brush).

Type
:   The shape of the gradient.

    Linear:
    :   Create gradient that forms a straight line.

    Radial:
    :   Create gradient that forms a circle.
user: Describe Transform from the Blender manual or Python API, including usage steps and snippets.

assistant: [Move](../../scene_layout/object/editing/transform/move.xhtml) `G`
:   Change the location of control points. Control points can also be moved with `LMB`.
    The whole spline can be moved by dragging the center dot with `LMB`.

[Rotate](../../scene_layout/object/editing/transform/rotate.xhtml) `R`
:   Change the location of control points by rotating about a pivot point.

[Scale](../../scene_layout/object/editing/transform/scale.xhtml) `S`
:   Change the location of control points by expanding the distance between points.

[To Sphere](../../modeling/meshes/editing/mesh/transform/to_sphere.xhtml) `Shift`-`Alt`-`S`
:   Morphs the control points to the shape of a circle.

[Shear](../../modeling/meshes/editing/mesh/transform/shear.xhtml) `Shift`-`Ctrl`-`Alt`-`S`
:   Shifts control points along a defined axis so parallel control points move past one another.

[Push/Pull](../../modeling/meshes/editing/mesh/transform/push_pull.xhtml)
:   Moves the control points closer together (Push) or further apart (Pull).

Scale Feather `Alt`-`S`
:   Will scale the feather size.
user: Explain Setup in complete detail according to the official Blender documentation.

assistant: - Select the light or emissive mesh object and go to the
  [Cycles Shading panel](../cycles/object_settings/object_data.xhtml#render-cycles-object-light-linking-settings) or
  [EEVEE Shading panel](../eevee/object_settings/object_data.xhtml#render-eevee-object-light-linking-settings).
- Create a new light/shadow linking collection.
- Drag & drop objects or collections from the [Outliner](../../editors/outliner/introduction.xhtml)
  onto the list.

You can also use the [Link Data](../../scene_layout/object/editing/link_transfer/link_data.xhtml) menu for this:
select the objects, add the light to the selection, press `Ctrl`-`L`, and choose
Link Receivers/Blockers to Emitter.

Multiple light objects can use the same linking collection. They can also use an existing scene collection,
but in general, it’s recommended to create dedicated linking collections so you can change these
without affecting the scene layout.
user: Describe BlendDataPointClouds(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # BlendDataPointClouds(bpy_struct)

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

*class* bpy.types.BlendDataPointClouds(*bpy_struct*)
:   Collection of point clouds

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

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

        Returns:
        :   New point cloud data-block

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

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

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

    tag(*value*)
    :   tag

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Domain
:   Which [attribute domain](../attributes_reference.xhtml#attribute-domains) to process.

Inspection Index
:   Geometry element index that is used by inspection features like the [Viewer Node](../output/viewer.xhtml)
    or [socket inspection](../inspection.xhtml).
user: What is Keyframe Paste Offset Value Items and how is it used in Blender Python scripting?

assistant: # Keyframe Paste Offset Value Items

LEFT_KEY:
:   Left Key.

    Paste keys with the first key matching the key left of the cursor.

RIGHT_KEY:
:   Right Key.

    Paste keys with the last key matching the key right of the cursor.

CURRENT_FRAME:
:   Current Frame Value.

    Paste keys relative to the value of the curve under the cursor.

CURSOR_VALUE:
:   Cursor Value.

    Paste keys relative to the Y-Position of the cursor.

NONE:
:   No Offset.

    Paste keys with the same value as they were copied.