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

assistant: |  |  |
| --- | --- |
| - [`bpy.context.edit_movieclip`](bpy.context.html#bpy.context.edit_movieclip "bpy.context.edit_movieclip") - [`BlendData.movieclips`](bpy.types.BlendData.html#bpy.types.BlendData.movieclips "bpy.types.BlendData.movieclips") - [`BlendDataMovieClips.load`](bpy.types.BlendDataMovieClips.html#bpy.types.BlendDataMovieClips.load "bpy.types.BlendDataMovieClips.load") - [`BlendDataMovieClips.remove`](bpy.types.BlendDataMovieClips.html#bpy.types.BlendDataMovieClips.remove "bpy.types.BlendDataMovieClips.remove") - [`CameraBackgroundImage.clip`](bpy.types.CameraBackgroundImage.html#bpy.types.CameraBackgroundImage.clip "bpy.types.CameraBackgroundImage.clip") - [`CameraSolverConstraint.clip`](bpy.types.CameraSolverConstraint.html#bpy.types.CameraSolverConstraint.clip "bpy.types.CameraSolverConstraint.clip") - [`CompositorNodeKeyingScreen.clip`](bpy.types.CompositorNodeKeyingScreen.html#bpy.types.CompositorNodeKeyingScreen.clip "bpy.types.CompositorNodeKeyingScreen.clip") - [`CompositorNodeMovieClip.clip`](bpy.types.CompositorNodeMovieClip.html#bpy.types.CompositorNodeMovieClip.clip "bpy.types.CompositorNodeMovieClip.clip") - [`CompositorNodeMovieDistortion.clip`](bpy.types.CompositorNodeMovieDistortion.html#bpy.types.CompositorNodeMovieDistortion.clip "bpy.types.CompositorNodeMovieDistortion.clip") - [`CompositorNodePlaneTrackDeform.clip`](bpy.types.CompositorNodePlaneTrackDeform.html#bpy.types.CompositorNodePlaneTrackDeform.clip "bpy.types.CompositorNodePlaneTrackDeform.clip") | - [`CompositorNodeStabilize.clip`](bpy.types.CompositorNodeStabilize.html#bpy.types.CompositorNodeStabilize.clip "bpy.types.CompositorNodeStabilize.clip") - [`CompositorNodeTrackPos.clip`](bpy.types.CompositorNodeTrackPos.html#bpy.types.CompositorNodeTrackPos.clip "bpy.types.CompositorNodeTrackPos.clip") - [`FollowTrackConstraint.clip`](bpy.types.FollowTrackConstraint.html#bpy.types.FollowTrackConstraint.clip "bpy.types.FollowTrackConstraint.clip") - [`MovieClipStrip.clip`](bpy.types.MovieClipStrip.html#bpy.types.MovieClipStrip.clip "bpy.types.MovieClipStrip.clip") - [`ObjectSolverConstraint.clip`](bpy.types.ObjectSolverConstraint.html#bpy.types.ObjectSolverConstraint.clip "bpy.types.ObjectSolverConstraint.clip") - [`Scene.active_clip`](bpy.types.Scene.html#bpy.types.Scene.active_clip "bpy.types.Scene.active_clip") - [`SpaceClipEditor.clip`](bpy.types.SpaceClipEditor.html#bpy.types.SpaceClipEditor.clip "bpy.types.SpaceClipEditor.clip") - [`StripsMeta.new_clip`](bpy.types.StripsMeta.html#bpy.types.StripsMeta.new_clip "bpy.types.StripsMeta.new_clip") - [`StripsTopLevel.new_clip`](bpy.types.StripsTopLevel.html#bpy.types.StripsTopLevel.new_clip "bpy.types.StripsTopLevel.new_clip") |
user: Explain Curves Handle Type Items in complete detail according to the official Blender documentation.

assistant: # Curves Handle Type Items

FREE:
:   Free.

    The handle can be moved anywhere, and does not influence the point’s other handle.

AUTO:
:   Auto.

    The location is automatically calculated to be smooth.

VECTOR:
:   Vector.

    The location is calculated to point to the next/previous control point.

ALIGN:
:   Align.

    The location is constrained to point in the opposite direction as the other handle.
user: Describe Life Time from the Blender manual or Python API, including usage steps and snippets.

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

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

### Protected

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

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

To protect a data-block, use the button with the shield icon next to its name.
The data-block will then never be silently deleted by Blender,
but you can still manually remove it if needed.
user: How do I use Inverse Kinematics in Blender? Include parameters, examples, warnings and best practices.

assistant: # Inverse Kinematics

[image reference removed]

The Inverse Kinematics panel.

This panel controls the way a bone or set of bones behave when linked in
an [inverse kinematic](../../posing/bone_constraints/inverse_kinematics/introduction.xhtml) chain.
user: Provide the full official documentation entry for Collection, preserving all code examples.

assistant: Include or exclude objects for line calculation,
based on their belonging to a [Collection](../../../scene_layout/collections/index.xhtml).

Line Set Collection
:   The name of the object collection to use.

Negation
:   Whether to include or exclude lines from those objects in this line set.
user: What is Scale and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| <../../../../_images/scene-layout_object_properties_instancing_faces_scale-enabled.png>   Scale enabled. | <../../../../_images/scene-layout_object_properties_instancing_faces_scale-changed.png>   Top face of cube scaled down. |

By enabling *Scale* for the parent object,
the scale of the child objects will be adapted to the size of each face in the parent object.

Thus, by rescaling the face of the parent object,
the size of the instanced object will change accordingly.
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: From Instancer Cycles Only
:   See the [From Instancer](texture_coordinate.xhtml#cycles-nodes-input-texture-coordinate-from-instancer)
    option of the [Texture Coordinate Node](texture_coordinate.xhtml).

UV Map
:   The name of the [UV map](../../../modeling/meshes/uv/uv_texture_spaces.xhtml#uv-maps-panel) to use.
    This list is populated from the UV maps available on the object’s mesh data-block.
    If left unset, the [Active Render](../../../modeling/meshes/uv/uv_texture_spaces.xhtml#bpy-types-meshuvlooplayer-active-render) UV map is used.
user: What is Select Edge Loop and how is it used in Blender Python scripting?

assistant: Holding `Alt` while clicking an edge selects that edge and then expands the selection as far as
possible in the two directions parallel to it. (While this of course works for selecting edge “loops”
that go all the way around a mesh, it also works if there’s no loop.)

You can additionally hold `Shift` to extend the current selection rather than replacing it.
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Image
:   Image data-block used as the image source.
    Additional settings can be found in Sidebar ‣ Item ‣ Properties:
    These include options to control the alpha channel along with addition options for the color space.
    These addition options are documented with the rest of
    [Common Image Settings](../../../editors/image/image_settings.html#editors-image-image-settings-common).

Color Space
:   Type of data that the image contains, either Color or Non-Color Data.
    For most color textures the default of Color should be used, but in case of e.g. a bump or alpha map,
    the pixel values should be interpreted as Non-Color Data, to avoid doing any unwanted color space conversions.

    The list of color spaces depends on the active [OCIO config](../../color_management/opencolorio.html#ocio-config).
    The default supported color spaces are described in detail here:
    [Default OpenColorIO Configuration](../../color_management/color_spaces.html#ocio-config-default-color-spaces)

Texture Interpolation
:   Interpolation method used for the environment texture. The following interpolations are available:

    Linear:
    :   Regular quality interpolation.

    Closest:
    :   No interpolation, use closest pixel.

    Cubic:
    :   Smoother, better quality interpolation.

    Smart:
    :   Bicubic when magnifying, otherwise Bilinear is used.
        This is only available for [OSL](../../cycles/osl/index.html).

Projection Method
:   Allows you to use different types of environmental maps. The following methods are supported:

    Equirectangular:
    :   Projection from an Equirectangular photo.

    Mirror Ball:
    :   Projection from an orthographic photo or mirror ball.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: The node can contain an arbitrary number of input sockets.
Each socket can be given a custom name and type. Supported types include (but not limited to):

- Geometry
- Objects
- Values (e.g. float, integer, boolean, vector, color)
- Fields
- Nested Bundles
user: How do I use Bones in Blender? Include parameters, examples, warnings and best practices.

assistant: This tool delete selected bones, selected *joints* are ignored.

If you delete a bone in a chain, its child(ren)
will be automatically re-parented to its own parent, but **not** connected,
to avoid deforming the whole armature.

Deletion example.

|  |  |
| --- | --- |
| ../../../../_images/animation_armatures_bones_editing_delete_example-1.png   An armature with two selected bones, just before deletion. | ../../../../_images/animation_armatures_bones_editing_delete_example-2.png   The two bones have been deleted. Note that Bone.002, previously connected to the deleted Bone.001, is now parented but not connected to Bone. |
user: Provide the full official documentation entry for Basic Operator Example, preserving all code examples.

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

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

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

```
import bpy

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

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

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

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

# Test call to the newly defined operator.
bpy.ops.wm.hello_world()
```
user: Explain Sampling in complete detail according to the official Blender documentation.

assistant: # Sampling

EEVEE uses a process called Temporal Anti-Aliasing (TAA) which reduces [Aliasing](../../../glossary/index.html#term-Aliasing).
TAA is sample based so the more samples the more aliasing is reduced at the cost of performance.
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: [image reference removed]

Normal Edit Modifier.

Radial
:   Aligns normals with the `(origin, vertex_coordinates)` vector, in other words all normals seems to radiate
    from the given center point, as if they were emitted from an ellipsoid surface.

Directional
:   Makes all normals point (converge) towards a given target object.

Target
:   Uses this object’s origin as reference point when generating normals.

    Optional in *Radial* mode, mandatory in *Directional* one.

Parallel Normals
:   Makes all normals parallel to the line between both objects’ origins,
    instead of converging towards target’s origin.

    Only relevant in *Directional* mode.

### Mix

Mix Mode
:   How to affect existing normals with newly generated ones.

    Note that the *Multiply* option is **not** a cross product, but a faster component-by-component multiplication.

Mix Factor
:   How much of the generated normals get mixed into existing ones.

Vertex Group
:   Allows per-item fine control of the mix factor. The vertex group influence can be inverted by using
    the arrow button to the right.

Max Angle
:   Forbids new generated normals to have an angle to the original normal above that given threshold.
    This is useful to prevent extreme changes, that can even lead to inverting the front/back sides of a face,
    and consequently to shading artifacts.

    / Lock Polygon Normals
    :   Prevents flipping (reversing front/back sides) of polygons which normal does not match anymore
        the side to which point its corners’ custom normals. Can also help to avoid shading issues.

### Offset

Gives modified object’s origin an offset before using it to generate normals.

Only relevant in *Radial* mode if no *Target Object* is set,
and in *Directional* mode when *Parallel Normals* is set.
user: Explain Downloading the Repository in complete detail according to the official Blender documentation.

assistant: Simply check out the Blender Manual’s repository using:

```
cd ~
git clone https://projects.blender.org/blender/blender-manual.git
```

The repository will now be downloaded which may take a few minutes depending on your internet connection.
user: Explain Inherited Properties in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`Paint.brush`](bpy.types.Paint.html#bpy.types.Paint.brush "bpy.types.Paint.brush") - [`Paint.brush_asset_reference`](bpy.types.Paint.html#bpy.types.Paint.brush_asset_reference "bpy.types.Paint.brush_asset_reference") - [`Paint.eraser_brush`](bpy.types.Paint.html#bpy.types.Paint.eraser_brush "bpy.types.Paint.eraser_brush") - [`Paint.eraser_brush_asset_reference`](bpy.types.Paint.html#bpy.types.Paint.eraser_brush_asset_reference "bpy.types.Paint.eraser_brush_asset_reference") - [`Paint.palette`](bpy.types.Paint.html#bpy.types.Paint.palette "bpy.types.Paint.palette") - [`Paint.show_brush`](bpy.types.Paint.html#bpy.types.Paint.show_brush "bpy.types.Paint.show_brush") - [`Paint.show_brush_on_surface`](bpy.types.Paint.html#bpy.types.Paint.show_brush_on_surface "bpy.types.Paint.show_brush_on_surface") - [`Paint.show_low_resolution`](bpy.types.Paint.html#bpy.types.Paint.show_low_resolution "bpy.types.Paint.show_low_resolution") - [`Paint.use_sculpt_delay_updates`](bpy.types.Paint.html#bpy.types.Paint.use_sculpt_delay_updates "bpy.types.Paint.use_sculpt_delay_updates") - [`Paint.use_symmetry_x`](bpy.types.Paint.html#bpy.types.Paint.use_symmetry_x "bpy.types.Paint.use_symmetry_x") - [`Paint.use_symmetry_y`](bpy.types.Paint.html#bpy.types.Paint.use_symmetry_y "bpy.types.Paint.use_symmetry_y") | - [`Paint.use_symmetry_z`](bpy.types.Paint.html#bpy.types.Paint.use_symmetry_z "bpy.types.Paint.use_symmetry_z") - [`Paint.use_symmetry_feather`](bpy.types.Paint.html#bpy.types.Paint.use_symmetry_feather "bpy.types.Paint.use_symmetry_feather") - [`Paint.cavity_curve`](bpy.types.Paint.html#bpy.types.Paint.cavity_curve "bpy.types.Paint.cavity_curve") - [`Paint.use_cavity`](bpy.types.Paint.html#bpy.types.Paint.use_cavity "bpy.types.Paint.use_cavity") - [`Paint.tile_offset`](bpy.types.Paint.html#bpy.types.Paint.tile_offset "bpy.types.Paint.tile_offset") - [`Paint.tile_x`](bpy.types.Paint.html#bpy.types.Paint.tile_x "bpy.types.Paint.tile_x") - [`Paint.tile_y`](bpy.types.Paint.html#bpy.types.Paint.tile_y "bpy.types.Paint.tile_y") - [`Paint.tile_z`](bpy.types.Paint.html#bpy.types.Paint.tile_z "bpy.types.Paint.tile_z") - [`Paint.show_strength_curve`](bpy.types.Paint.html#bpy.types.Paint.show_strength_curve "bpy.types.Paint.show_strength_curve") - [`Paint.show_size_curve`](bpy.types.Paint.html#bpy.types.Paint.show_size_curve "bpy.types.Paint.show_size_curve") - [`Paint.show_jitter_curve`](bpy.types.Paint.html#bpy.types.Paint.show_jitter_curve "bpy.types.Paint.show_jitter_curve") - [`Paint.unified_paint_settings`](bpy.types.Paint.html#bpy.types.Paint.unified_paint_settings "bpy.types.Paint.unified_paint_settings") |
user: Give a detailed overview of Average Island Scale: syntax, arguments, return values, common patterns.

assistant: Using the *Average Island Scale* tool, will scale each
UV island so that they are all approximately the same scale.

Non-Uniform
:   Reduces average texture stretching within islands by scaling the U and V axes independently.

Shear
:   Reduces average texture shearing within islands by shearing the U axis.
user: Provide the full official documentation entry for High Viscosity Solver, preserving all code examples.

assistant: The high viscosity liquid solver can be used to simulate fluids with increased viscosity,
replicating the behavior of substances like honey or molasses.
This specialized solver enhances the accuracy of slow-moving and thick liquid simulations.

Strength
:   The viscosity of the liquid. Higher values result in more viscous fluids.

    Rotating liquid inflow with varying viscosities.

    |  |  |
    | --- | --- |
    | ../../../../../_images/physics_fluid_type_domain_liquid_viscosity_0-2.png   Strength of 0.2 (at frame 65). | ../../../../../_images/physics_fluid_type_domain_liquid_viscosity_0-4.png   Strength of 0.4 (at frame 200). |
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`TextCurve.body_format`](bpy.types.TextCurve.html#bpy.types.TextCurve.body_format "bpy.types.TextCurve.body_format") | - [`TextCurve.edit_format`](bpy.types.TextCurve.html#bpy.types.TextCurve.edit_format "bpy.types.TextCurve.edit_format") |
user: What is Hinge Constraint and how is it used in Blender Python scripting?

assistant: # Hinge Constraint

The hinge permits one degree of freedom between two objects. Translation is completely constrained.
Rotation is permitted about the Z axis of the object hosting the Physics constraint
(usually an [Empty](../../../../glossary/index.xhtml#term-Empty), distinct from the two objects that are being linked).
Adjusting the position and rotation of the object hosting the constraint allows you to
control the anchor and axis of the hinge.

The Hinge is the only single-axis rotational constraint that uses the Z axis instead of the X axis.
If something is wrong with your hinge, check your other constraints to see if this might be the problem.

[image reference removed]

*Hinge* constraint options.
user: Describe Studio Lights from the Blender manual or Python API, including usage steps and snippets.

assistant: Studio Lights are used to illuminate the 3D Viewport during *Solid View* and will not be rendered.
Unlike lights in the scene, the lighting direction follows the viewport orientation.

### Editor

There are up to four virtual light sources.

The Light toggles allow you to enable or disable individual lights.
At least one of the four lights must remain enabled for the 3D Viewport.
The lights are equal, except for their direction and color.
You can control the direction of the lights, as well as their diffuse and specular colors.

Use Light
:   Toggles the specific light.

Diffuse
:   This is the constant color of the light.

Specular
:   This is the highlight color of the light.

Smooth
:   Smooth the shading from this light.

    *This has the effect of lighting to be less direct.*

Direction
:   The direction of the light, (see [Direction Buttons](../../interface/controls/buttons/buttons.xhtml#ui-direction-button)).

    The direction of the light will be the same as shown at the sphere surface.

Ambient Color
:   The color of unlit areas.
user: What is Viewport Overlays and how is it used in Blender Python scripting?

assistant: # Viewport Overlays

Clicking  (Show Overlays) toggles all overlays in the 3D Viewport.

The drop-down button displays a popover with more detailed settings, which are described below.

Depending on the current [object interaction mode](../modes.xhtml),
there may be a second button with yet more settings, which are also described here.
user: Describe Relations from the Blender manual or Python API, including usage steps and snippets.

assistant: Key Targets
:   The [list view](../../../../interface/controls/templates/list_view.html#ui-list-view) of keys (target particle systems).

Object
:   The name of a target object for the selected key. If empty it uses the current particle system.

System
:   Index of particle system on the target object.

Time
:   The time (frame number) at which the particles will be at the position of the selected system.
    Note also that the *Start* frame of the Keyed system adds an offset to this time.

Duration
:   How long (in frames) the particles stay on this system before they start moving to the next one.
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

assistant: [image reference removed]

Here, the handles are adjusted to the same position as the control points, but offset down in
the Z direction slightly. With the [Set Spline Type Node](set_spline_type.html),
the curve can be a poly spline in Edit Mode, to make adjustment simpler for the user of the node group.
user: Provide the full official documentation entry for Inherited Properties, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`ShaderFx.name`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.name "bpy.types.ShaderFx.name") - [`ShaderFx.type`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.type "bpy.types.ShaderFx.type") - [`ShaderFx.show_viewport`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.show_viewport "bpy.types.ShaderFx.show_viewport") | - [`ShaderFx.show_render`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.show_render "bpy.types.ShaderFx.show_render") - [`ShaderFx.show_in_editmode`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.show_in_editmode "bpy.types.ShaderFx.show_in_editmode") - [`ShaderFx.show_expanded`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.show_expanded "bpy.types.ShaderFx.show_expanded") |
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Data Type
:   Float:
    :   The node will average a *Float* field.

    Integer:
    :   The node will accumulate an *Integer* field.

    Vector:
    :   The node will average a *Vector* field.

Domain
:   The [attribute domain](../../attributes_reference.xhtml#attribute-domains) used for evaluate the *Value* input.
user: Describe Trimming from the Blender manual or Python API, including usage steps and snippets.

assistant: The trimming operators add or remove geometry from the mesh based on a gesture input.
These operators are especially useful for sketching an early base mesh for further
sculpting with the [voxel remesher](../tool_settings/remesh.xhtml).

[Line Project](../tools/line_project.xhtml)
:   Flattens the geometry along a plane determined by the camera view and a drawn line.
    The region of the mesh being flattened is visualized by the side of the line that is shaded.

[Box Trim](../tools/trim_tools.xhtml#tool-box-trim)
:   Removes geometry based on a [box selection](../../../interface/selecting.xhtml#tool-select-box).

[Lasso Trim](../tools/trim_tools.xhtml#tool-lasso-trim)
:   Removes geometry based on a [lasso selection](../../../interface/selecting.xhtml#tool-select-lasso).

[Box Add](../tools/trim_tools.xhtml#tool-box-trim)
:   Adds geometry based on a [box selection](../../../interface/selecting.xhtml#tool-select-box).

[Lasso Add](../tools/trim_tools.xhtml#tool-lasso-trim)
:   Adds geometry based on a [lasso selection](../../../interface/selecting.xhtml#tool-select-lasso).
user: Describe NodeTreeInterfaceSocketIntPercentage(NodeTreeInterfaceSocket) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeTreeInterfaceSocketIntPercentage(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.NodeTreeInterfaceSocketIntPercentage(*NodeTreeInterfaceSocket*)
:   Integer number socket of a node

    default_value
    :   Input value used for unconnected socket

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

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

        Type:
        :   int in [-inf, inf], default 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: What is Inputs and how is it used in Blender Python scripting?

assistant: Switch
:   - When it is unchecked, the first input labeled “Off” is passed to the output.
    - When checked, the second input labeled “On” is passed to the output.

Off
:   First image input.

On
:   Second image input.
user: Provide the full official documentation entry for Attribute Search, preserving all code examples.

assistant: [image reference removed]

Attribute Search.

The attribute search is shown when clicking on an attribute input in the modifier.
It contains a list of all the attributes that were available at that point in
the modifier or node execution.
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: [image reference removed]

Time Offset Modifier.

Mode
:   Regular:
    :   Offsets keyframes in the default animation playback direction (playhead moving from left to right).

    Reverse:
    :   Offsets keyframes in reversed animation playback direction (playhead moving from right to left).

    Fixed Frame:
    :   The Frame parameter determines which frame is displayed. This value needs to be animated in order to
        have the displayed frame change during playback.

        Frame
        :   The number of the frame to display.

    Ping Pong:
    :   Loop back and forth animation.

    Chain:
    :   It allows to combine the different Modes consecutively.

        Repeat
        :   Number of cycle repeats

Frame Offset
:   The number of frames to offset the original keyframes by.

Scale
:   Controls the speed of the frames playback. 1 is equal to the actual frame rate, could be positive (faster)
    or negative (slower).

Keep Loop
:   Moves end frame to the animation start to keep animation in a loop.

### Custom Range

When enabled, the animation playback is restricted only to a frame range.

Frame Start/End
:   Sets the range start and end frames.

### Influence

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Points
:   Standard geometry input.

Density
:   Value of voxels inside the generated fog volume.

Resolution Mode
:   How the voxel size is specified.

    Amount:
    :   Specify the approximate number of voxels along the diagonal.

    Size:
    :   Specify the voxel side length. It is recommended to be careful when tweaking this value,
        because small changes can have a large effect on the processing time.

Voxel Amount Amount
:   Specify the approximate number of voxels along the diagonal.

Voxel Size Size
:   Specify the voxel side length.

Radius
:   Specify the radius of the sphere generated at each point.
user: Describe Evaluate at Index Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Evaluate at Index Node

[image reference removed]

The *Evaluate at Index* node allows accessing data of other elements in the context geometry.
It is similar to the [Sample Index Node](../../geometry/sample/sample_index.xhtml).
The main difference is that this node does not require a geometry input, because the geometry
from the [field context](../../fields.xhtml#field-context) is used.

This node is also similar to the [Evaluate on Domain Node](evaluate_on_domain.xhtml) node,
except that the value to retrieve from the specified domain is specified by an index rather than
an automatic domain interpolation.
user: How do I use Swapping Contents in Blender? Include parameters, examples, warnings and best practices.

assistant: You can swap the contents of two areas by pressing `Ctrl`-`LMB`
on one of the corners of the initial area, dragging towards the target area,
and releasing the mouse there. The two areas do not need to be side-by-side,
though they must be inside the same window.
user: Show practical ways to work with Vertices in a Blender add-on or script – include code.

assistant: # Vertices

*Instance Vertices* allows you to replicate child objects
at the location of every vertex of the parent object.

Align to Vertex Normal
:   Rotates all instanced objects according to the corresponding vertex normals of the parent mesh.

    To change the axis of direction of the instanced objects,
    select the child object and change the [Tracking Axis](../relations.xhtml#bpy-types-object-track-axis).

There are actually two approaches to modeling using instanced vertices.
They can be used as an arranging tool,
allowing you to model geometrical arrangements of objects (e.g. the columns of a Greek temple,
the trees in a garden, the desks in a classroom).
The object can be of any object type which Blender supports.
The second approach is to use them to model an object starting from a single part of it
(e.g. the spikes in a club, the thorns of a sea-urchin, the tiles in a wall, the petals in a flower).
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Geometry
:   The input geometry containing the hair curves to trim.

Scale Uniform
:   When enabled, each curve is scaled uniformly to reach the target length.
    When disabled, trimming is applied progressively from root to tip.

Length Factor
:   Multiplies the original curve length by this factor.
    A value of 1.0 keeps the hair at its original length, while 0.5 halves it.

Replace Length
:   When enabled, the *Length* input fully replaces the original curve length
    instead of scaling it by the *Length Factor*.

Length
:   The target length for the operation.
    Used when *Replace Length* is enabled.

Mask
:   A per-curve mask that modulates the overall trimming effect.
    A value of 0.0 disables trimming for that curve, while 1.0 applies the full effect.

Random Offset
:   Adds random variation to the trimmed length of each curve,
    creating more natural-looking hair variation.

Pin at Parameter
:   Specifies a parameter along each curve to act as a pivot or anchor point during trimming.
    The trimming operation is performed relative to this point.

Seed
:   Sets the random seed used for the random offset.
    Changing this value produces different trimming variations while maintaining the same parameters.
user: Give a detailed overview of Set ID Node: syntax, arguments, return values, common patterns.

assistant: # Set ID Node

[image reference removed]

The *Set ID* node fills the `id` attribute on the input geometry. If the attribute does not
exist yet, it will be created with a default value of zero. The ID is also created by
the [Distribute Points on Faces](../../point/distribute_points_on_faces.xhtml), and it is used in
the [Random Value Node](../../utilities/random_value.xhtml) and other nodes if it exists.

The input node for this data is the [ID Node](../read/id.xhtml).
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`Context.region_data`](bpy.types.Context.html#bpy.types.Context.region_data "bpy.types.Context.region_data") - [`SpaceView3D.region_3d`](bpy.types.SpaceView3D.html#bpy.types.SpaceView3D.region_3d "bpy.types.SpaceView3D.region_3d") | - [`SpaceView3D.region_quadviews`](bpy.types.SpaceView3D.html#bpy.types.SpaceView3D.region_quadviews "bpy.types.SpaceView3D.region_quadviews") |
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

The Curve modifier.

Curve Object
:   The name of the curve object that will affect the deformed object.

Deformation Axis
:   This is the axis that the curve deforms along.

    X/Y/Z/-X/-Y/-Z

Vertex Group
:   If set, restrict the effect to the only vertices in that vertex group.

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

        The setting reverses the weight values of the group.
user: Give a detailed overview of Property Weights: syntax, arguments, return values, common patterns.

assistant: # Property Weights

This panel is used to constrain certain cloth properties to a certain vertex group.
The properties that they control can be found in a combination of the *Physical Properties* and *Shape* panels.

Structural Group
:   Defines a vertex group to control over structural stiffness.

Max Tension
:   Maximum tension stiffness value.

Max Compression
:   Maximum Compression stiffness value.

Shear Group
:   Vertex group for fine control over shear stiffness.

Max Shearing
:   Maximum shear scaling value.

Bending Group
:   Vertex group for fine control over bending stiffness.

Max Bending
:   Maximum bending stiffness value.

Shrinking Group
:   Vertex group for shrinking cloth.

Max Shrinking
:   Max amount to shrink cloth by, specifying a negative value controls the max amount for the cloth to grow.
user: Show practical ways to work with Asset Bundles in a Blender add-on or script – include code.

assistant: *Asset bundles* are blend-files that do not reference any other file,
and whose name ends in `_bundle.blend`. Any textures and other external
files need to be [packed](../files/blend/packed_data.xhtml) into the current blend-file.

Asset bundles can be copied to an asset library via the [Asset Browser](#bpy-ops-asset-bundle-install):

- Open the asset bundle blend-file.
- Switch its Asset Browser to *Current File* (if it’s not set to that already).
- Click on *Copy Bundle to Asset Library*.
- Choose the asset library to copy it to.
- A File Browser will open at the root folder of the selected asset library.
  Choose the desired location of the blend-file, and click the *Copy to Asset Library* button.
- The blend-file will be saved at the chosen location, and any [catalogs](../files/asset_libraries/catalogs.xhtml) of
  the asset bundle will be merged into the target asset library.
user: Provide the full official documentation entry for bpy_extras submodule (bpy_extras.id_map_utils), preserving all code examples.

assistant: # bpy_extras submodule (bpy_extras.id_map_utils)

bpy_extras.id_map_utils.get_id_reference_map()
:   Return a dictionary of direct data-block references for every data-block in the blend file.

bpy_extras.id_map_utils.get_all_referenced_ids(*id*, *ref_map*)
:   Return a set of IDs directly or indirectly referenced by id.
user: What is Action Editor and how is it used in Blender Python scripting?

assistant: # Action Editor

While the *Dope Sheet* mode lets you work with keyframes of all animation in the
scene at the same time, the *Action Editor* mode focuses on the keyframes inside
a single [action](../../../animation/actions.xhtml).

[image reference removed]

The Action Editor.

Actions are Blender’s container for animation data. Objects and other animatable
data-blocks reference actions to get animated by the animation data inside.
Data-blocks can reference one action as their *active action* and additional
actions through [Nonlinear Animation tracks](../../nla/tracks.xhtml).
user: How do I use Fast GI Approximation in Blender? Include parameters, examples, warnings and best practices.

assistant: Fast GI Approximation is a fallback to the ray-tracing pipeline for
BSDF with high roughness.
It produces a less noisy output and captures bounce lighting more efficiently than individually traced rays.

This is currently implemented as a screen space effect and will inherit all associated
[limitations](../limitations/limitations.xhtml#eevee-limitations-screenspace).

Threshold
:   Maximum roughness a BSDF can have to use ray-tracing.
    BSDFs with higher roughness will progressively use the *Fast GI Approximation*.
    A value of 1 will raytrace every surfaces and disable the Fast GI.

Method
:   Determine the method used to compute the fast GI approximation.

    Ambient Occlusion:
    :   Use scene intersections to shadow the distant lighting from light-probes.
        This is the fastest option.

    Global Illumination:
    :   Compute global illumination taking into account light bouncing off surrounding objects.

Resolution
:   Resolution at which the fast GI is computed.
    Lower options will be faster and use less memory but will produce blurrier results.

Rays
:   Number of GI rays per pixel at the specified *Resolution*.
    Higher values will reduce noise.

Steps
:   Number of screen samples per GI ray.
    Higher values will reduce the noise amount and increase the quality.

Precision
:   Higher values increase the precision of the scene intersections with the GI rays.
    Increased precision also increases performance cost.

Distance
:   If non-zero, the maximum distance at which other surfaces will contribute to the fast GI approximation.

Thickness Near
:   Geometric thickness of the surfaces when computing fast GI and ambient occlusion.
    Reduces light leaking and missing contact occlusion.
    The effectiveness decreases proportionally to the distance from the shading point,
    following the inverse square law.

Far
:   Angular thickness of the surfaces when computing fast GI and ambient occlusion.
    Reduces energy loss and missing occlusion of far geometry.
    Higher values will make the very thin objects block or reflect too much light.

Bias
:   Bias the shading normal to reduce self intersection artifacts.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`AOVs.add`](bpy.types.AOVs.html#bpy.types.AOVs.add "bpy.types.AOVs.add") - [`AOVs.remove`](bpy.types.AOVs.html#bpy.types.AOVs.remove "bpy.types.AOVs.remove") | - [`ViewLayer.active_aov`](bpy.types.ViewLayer.html#bpy.types.ViewLayer.active_aov "bpy.types.ViewLayer.active_aov") - [`ViewLayer.aovs`](bpy.types.ViewLayer.html#bpy.types.ViewLayer.aovs "bpy.types.ViewLayer.aovs") |
user: Give a detailed overview of Settings: syntax, arguments, return values, common patterns.

assistant: # Settings

[image reference removed]

Default rigid body panel.

Mass
:   Specifies how heavy the object is and “weights” irrespective of gravity.

Dynamic
:   Enables/disables rigid body simulation for the object.

Animated
:   Allows the rigid body to additionally be controlled by the animation system.
user: Give a detailed overview of Curve Display: syntax, arguments, return values, common patterns.

assistant: # Curve Display

When in Edit Mode, curves have special [overlays](../../editors/3dview/display/overlays.html)
to control how curves are displayed in the 3D Viewport.

Handles
:   Controls the visibility of Bézier curve handles in edit mode.

    None:
    :   Hides all Bézier curve handles, providing an unobstructed view of the curve.

    Selected:
    :   Displays the handles only for selected control points.

    All:
    :   Displays the handles for all control points in the curve.

Normals
:   Toggles the display of the curve normals.

    Normal Size
    :   Length of the axis that points the direction of the normal.
user: Show practical ways to work with Shade Auto Smooth in a Blender add-on or script – include code.

assistant: Adds a [Smooth By Angle Modifier](../../../modeling/modifiers/normals/smooth_by_angle.xhtml) to automatically set
the sharpness of mesh edges based on the angle between the neighboring faces.
Note, the modifier will be [pinned](../../../modeling/modifiers/introduction.xhtml#bpy-types-modifier-use-pin-to-last) to be the last modifier.

Auto Smooth
:   If disabled, any [Smooth By Angle Modifiers](../../../modeling/modifiers/normals/smooth_by_angle.xhtml) are removed.

Angle
:   Maximum angle between face normals that will be considered as smooth.
user: What is Notes and how is it used in Blender Python scripting?

assistant: In some configurations of the node, especially for low values of *Randomness*,
rendering artifacts may occur. This happens due to the same reasons described
in the [Notes section](../../../render/shader_nodes/textures/white_noise.xhtml#shader-white-noise-notes) in the White Noise Texture page
and can be fixed in a similar manner as described there.
user: Describe limbs.simple_tentacle from the Blender manual or Python API, including usage steps and snippets.

assistant: Will create a simple bendy and stretchy b-bones tentacle chain, which can optionally replicate local rotation
from preceding bones to the subsequent ones for use in cases like fingers.

Requirement: A chain of at least two connected bones.

Automation Axis (X, Y, Z, None)
:   Enables the automation on the selected axis. Multiple axis or none can be selected holding `Shift`-`LMB`.
    When enabled the subsequent control bones will copy the local rotations from the previous ones.
    The option is accessible in the controls of the final rig as a Copy Rotation constraint and
    can be disabled even after rig is generated, or at animation time.

Assign Tweak Layers
:   If enabled, allows placing the Tweak controls in different bone collections from the main controls.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Image
:   The final image with the generated glare added.

Glare
:   The generated glare effect isolated from the input image.
    Useful for further compositing or adjustments.

Highlights
:   The extracted bright areas used to generate the glare effect.
    Can be used to fine-tune the glare or as a base for custom effects.
user: Show practical ways to work with Import Nodes in a Blender add-on or script – include code.

assistant: # Import Nodes

Nodes used to import data from external file formats.

Geometry Nodes supports automatically creating import nodes by dragging supported file types into the node editor.

When dropping a supported file into a Geometry Node tree,
the corresponding import node is added automatically and configured with the file path.
user: How do I use FModifierFunctionGenerator(FModifier) in Blender? Include parameters, examples, warnings and best practices.

assistant: # FModifierFunctionGenerator(FModifier)

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

*class* bpy.types.FModifierFunctionGenerator(*FModifier*)
:   Generate values using a built-in function

    amplitude
    :   Scale factor determining the maximum/minimum values

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

    function_type
    :   Type of built-in function to use

        - `SIN`
          Sine.
        - `COS`
          Cosine.
        - `TAN`
          Tangent.
        - `SQRT`
          Square Root.
        - `LN`
          Natural Logarithm.
        - `SINC`
          Normalized Sine – sin(x) / x.

        Type:
        :   enum in [`'SIN'`, `'COS'`, `'TAN'`, `'SQRT'`, `'LN'`, `'SINC'`], default `'SIN'`

    phase_multiplier
    :   Scale factor determining the ‘speed’ of the function

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

    phase_offset
    :   Constant factor to offset time by for function

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

    use_additive
    :   Values generated by this modifier are applied on top of the existing values instead of overwriting them

        Type:
        :   boolean, default False

    value_offset
    :   Constant factor to offset values by

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Animation, preserving all code examples.

assistant: |  |  |
| --- | --- |
| `I` | Insert a [keyframe](../../animation/keyframes/introduction.html). |
| `Alt`-`I` | Clear the keyframe. |
| `Shift`-`Alt`-`I` | Clear all keyframes. |
| `Ctrl`-`D` | Assign a [driver](../../animation/drivers/introduction.html). |
| `Ctrl`-`Alt`-`D` | Clear the driver. |
| `K` | Add the property to the current [keying set](../../animation/keyframes/keying_sets.html). |
| `Alt`-`K` | Remove the property from the current keying set. |
user: Describe Rigid Body World from the Blender manual or Python API, including usage steps and snippets.

assistant: # Rigid Body World

The *Rigid Body World* is a group of rigid body objects,
which holds settings that apply to all rigid bodies in this simulation.

When you add rigid body physics to an object,
primary there is created a group of objects with default “RigidBodyWorld” name.
Rigid body objects automatically are added to this group when you add rigid body physics for them.
You can create several Rigid Body World [Collections](../../scene_layout/collections/collections.xhtml)
and allocate the rigid body objects with the [Collections panel](../../scene_layout/collections/collections.xhtml#scene-layout-collections-collections-panel).

Rigid body objects and constraints are only taken into account by the simulation
if they are in the collection specified in the *Collection* field of the *Rigid Body World* panel in the *Scene* tab.