PGCRYPT/OpenBlender_Train huggingface dataset:
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Target Geometry
:   Geometry that rays are tested against.

Attribute
:   An optional field input evaluated on the *Target Geometry* that will be interpolated at the hit points.
    The resulting values are outputted with the *Attribute* output.

Interpolation
:   How attributes of the target mesh are mapped to the attribute values on the result geometry.

    Interpolated:
    :   Vertex and corner attributes are interpolated smoothly, with a bilinear function.

    Nearest:
    :   Choose the value of the closest vertex without interpolating.

Source Position
:   The position from where to start each ray. By default, this is the same as
    if the [Position Node](../read/position.xhtml) was connected.

Ray Direction
:   Direction of each ray from the starting position.
    The field is evaluated on the geometry from the context of the field evaluation, not the *Target Geometry*.

Ray Length
:   Maximum distance a ray can travel before being considered “no hit”.
user: Show practical ways to work with Displays in a Blender add-on or script – include code.

assistant: The color space of the display that images and video are being created for.

Regular compute displays support sRGB, and most images and videos are
stored in this color space. However moderns displays often support a wider
gamut and high dynamic range content.

Standard Dynamic Range (SDR)
:   sRGB:
    :   Basic display supported everywhere.

    Display P3:
    :   Wide gamut for Apple devices and other modern displays.

    Rec.1886:
    :   Used by many older TVs.

    Rec.2020:
    :   Even wider gamut than P3 supported by some displays.

High Dynamic Range (HDR)
:   Rec.2100 PQ:
    :   For HDR displays with Rec.2020 wide gamut, up to 10000 nits.

    Rec.2100 HLG:
    :   For HDR TVs with Rec.2020 wide gamut, up to 1000 nits.

### Wide Gamut

Select the “Display P3” or “Rec.2020” display to view wide gamut colors.

This should be used in conjunction with the “ACEScg” or “Linear Rec.2020” working space
for materials, lights, rendering and compositing.

Requirements:

- A P3 or Rec.2020 capable monitor.
- macOS: Any Apple Silicon device.
- Linux: Use Wayland, and set the Vulkan backend in the Blender system preferences.
- Windows: Enable “Automatically manage color for apps” in the Windows display settings,
  and set the Vulkan backend in the Blender system preferences.

### High Dynamic Range

Select the “Rec.2100 PQ” or “Rec.21000 HLG” display to view high dynamic range (HDR) colors.

With standard dynamic range (SDR), views must significantly lower bright colors to fit within the range.
With high dynamic range it is possible to go beyond and more accurately display the scene. HDR displays have limits
too, and there are separate views for 500, 1000, 2000 and 4000 nits to target displays with different maximum
luminance.

In Blender, HDR content automatically scales up and down along with display brightness. Seeing the full range often
requires lowering the display brightness, to make enough headroom above SDR white.

Requirements:

- A HDR capable monitor.
- macOS: Any Apple Silicon device.
- Linux: Use Wayland, and set the Vulkan backend in the Blender system preferences.
- Windows: Enable “Use HDR” in the Windows display settings, and set the Vulkan backend in the Blender system
  preferences.

### Display Emulation

Automatic:
:   Display images consistent with most other applications, to preview images and video
    for export. A best effort is made to emulate the chosen display on the actual
    display device.

Off:
:   Directly output image as produced by OpenColorIO. This is not correct in general,
    but may be used when the system configuration and actual display device is known
    to match the chosen display.

Emulation is not supported with older [OpenColorIO configurations](opencolorio.xhtml#ocio-config).
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Armature constraint.

Preserve Volume
:   Prevents the owner from shrinking when the target bones rotate relative to each other.

Use Envelopes
:   Uses [Envelopes](../../armatures/bones/properties/deform.xhtml#armature-bones-envelope) to weaken the influence of
    target bones that are further away. For best results, set the *Weight*
    of all bones to 1.0.

Use Current Location Bone constraint only
:   By default, the constraint uses the rest location of the owner bone to
    find nearby envelopes and [B-Bone](../../armatures/bones/properties/bendy_bones.xhtml)
    segments. This option uses the bone’s current location instead (so including
    the pose transformation and prior constraints).

    Objects don’t have a rest location, so for them, the constraint always uses
    the current location.

Add Target Bone
:   Adds a new entry to the *Bones* list.

Normalize Weights
:   Normalizes the *Weights* in the *Bones* list so they add up to 1.0.

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.

### Bones

The list of target bones used to transform the owner.

[Target](../interface/common.xhtml#rigging-constraints-interface-common-target)
:   The armature object containing the bone. Unlike the modifier, the constraint can use bones
    from different armatures.

Sub-Target
:   The name of the bone.

(Remove Target)
:   Removes the entry from the list.

Weight
:   Weight associated with the bone. With the modifier, this weight would come from a vertex
    group instead.
user: Give a detailed overview of CurveMap(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # CurveMap(bpy_struct)

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

*class* bpy.types.CurveMap(*bpy_struct*)
:   Curve in a curve mapping

    points
    :   Type:
        :   [`CurveMapPoints`](bpy.types.CurveMapPoints.html#bpy.types.CurveMapPoints "bpy.types.CurveMapPoints") [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`CurveMapPoint`](bpy.types.CurveMapPoint.html#bpy.types.CurveMapPoint "bpy.types.CurveMapPoint"), (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: ### General

Normal Radius
:   Higher by default. This ensures that the brush does not change directions to sporadically during a stroke.
    More info at [Normal Radius](../../brush/brush_settings.xhtml#bpy-types-brush-normal-radius-factor)

Tip Roundness
:   Very low by default for a square shape for more deliberate shaping.
    More info at [Tip Roundness](../../brush/brush_settings.xhtml#bpy-types-brush-tip-roundness)
user: How do I use Connect in Blender? Include parameters, examples, warnings and best practices.

assistant: The quickest way to constrain two objects is to select both and
click the *Connect* button in Object ‣ Rigid Body.
This creates a new empty object (named “Constraint”) with a physics constraint
already attached and pointing at the two selected objects.
user: Provide the full official documentation entry for Bpy.Ops, preserving all code examples.

assistant:  Operators File Operators Fluid Operators Font Operators Geometry Operators Gizmogroup Operators Gpencil Operators Graph Operators Grease Pencil Operators Image Operators Import Anim Operators Import Curve Operators Import Scene Operators Info Operators Lattice Operators Marker Operators Mask Operators Material Operators Mball Operators Mesh Operators Nla Operators Node Operators Object Operators Outliner Operators Paint Operators Paintcurve Operators Palette Operators Particle Operators Pointcloud Operators Pose Operators Poselib Operators Preferences Operators Ptcache Operators Render Operators Rigidbody Operators Scene Operators Screen Operators Script Operators Sculpt Operators Sculpt Curves Operators Sequencer Operators Sound Operators Spreadsheet Operators Surface Operators Text Operators Text Editor Operators Texture Operators Transform Operators Ui Operators Uilist Operators Uv Operators View2D Operators View3D Operators Wm Operators Workspace Operators World Operators Next Action Operators Previous Message Bus (bpy.msgbus) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page Operators (bpy.ops) Calling Operators Keywords and Positional Arguments Overriding Context Execution Context
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Mode
:   Element-Wise:
    :   Compare each axis of the input vectors separately, and output true only when the result is true
        for each axis.

    Length:
    :   Compare the length of the two input vectors.

    Average:
    :   Compare the average of the elements of the input vectors. This is the same as the implicit
        conversion used when setting the node’s data type to *Float*.

    Dot Product:
    :   Compare the dot product of the two vectors with the separate *C* input, using the selected operation.
        The dot product outputs a single value that says how much the two vectors “agree”.

    Direction:
    :   Compare the angle between the two vectors with the separate *Angle* input, using the selected operation.
        The vectors are normalized, so their length does not matter.

Operation
:   Less Than:
    :   True when the first input is smaller than second input.

    Less Than or Equal:
    :   True when the first input is smaller than the second input or equal.

    Greater Than:
    :   True when the first input is greater than the second input.

    Greater Than or Equal:
    :   True when the first input is greater than the second input or equal.

    Equal:
    :   True when both the difference between the two inputs is smaller than the *Epsilon* input.

    Not Equal:
    :   True when both the difference between the two inputs is larger than the *Epsilon* input.

    Brighter:
    :   True when the first color input is brighter than the second.

    Darker:
    :   True when the first color input is darker than the second.
user: Show practical ways to work with Speaker Objects in a Blender add-on or script – include code.

assistant: # Speaker Objects

Speaker objects are used to play sound within the 3D Viewport.
They allow for spatial audio playback, making them useful for animations and interactive scenes.
Once added, a speaker’s properties can be adjusted in the Properties editor.

[image reference removed]

Speaker object.
user: What is PoseBoneConstraints(bpy_struct) and how is it used in Blender Python scripting?

assistant: # PoseBoneConstraints(bpy_struct)

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

*class* bpy.types.PoseBoneConstraints(*bpy_struct*)
:   Collection of pose bone constraints

    active
    :   Active PoseChannel constraint

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

    new(*type*)
    :   Add a constraint to this object

        Parameters:
        :   **type** (enum in [Constraint Type Items](bpy_types_enum_items/constraint_type_items.html#rna-enum-constraint-type-items)) – Constraint type to add

        Returns:
        :   New constraint

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

    remove(*constraint*)
    :   Remove a constraint from this object

        Parameters:
        :   **constraint** ([`Constraint`](bpy.types.Constraint.html#bpy.types.Constraint "bpy.types.Constraint"), (never None)) – Removed constraint

    move(*from_index*, *to_index*)
    :   Move a constraint to a different position

        Parameters:
        :   - **from_index** (*int in* *[**-inf**,* *inf**]*) – From Index, Index to move
            - **to_index** (*int in* *[**-inf**,* *inf**]*) – To Index, Target index

    copy(*constraint*)
    :   Add a new constraint that is a copy of the given one

        Parameters:
        :   **constraint** ([`Constraint`](bpy.types.Constraint.html#bpy.types.Constraint "bpy.types.Constraint"), (never None)) – Constraint to copy - may belong to a different object

        Returns:
        :   New constraint

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

    *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 Common Editing Keys in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| `Backspace` | Delete the selected item with a confirmation dialog |
| `Delete` | Delete the selected item without a confirmation dialog |
| `Ctrl`-`D` | Duplicate |
| `P` | Set Parent |
| `B` | [Proportional Editing](../../editors/3dview/controls/proportional_editing.xhtml) (a.k.a. Soft Selection) |
user: Provide the full official documentation entry for Other Considerations, preserving all code examples.

assistant: In axis-angle and quaternion modes we can lock rotations in interactive modes in a per component basis,
instead of doing it by axis. To do so we can activate this locking ability using the lock buttons next to
the corresponding *Rotation* transform buttons.

Regarding rotation animations, all keyframes must be defined in the same rotation mode,
which must be the selected rotation mode for the object throughout the entire animation.
user: Give a detailed overview of Decimate Modifier: syntax, arguments, return values, common patterns.

assistant: # Decimate Modifier

The *Decimate* modifier allows you to reduce the vertex/face count of a mesh with minimal shape changes.

This is not usually used on meshes which have been created by modeling carefully and economically
(where all vertices and faces are necessary to correctly define the shape).
But if the mesh is the result of complex modeling,
sculpting and/or applied [Subdivision Surface](subdivision_surface.xhtml)/
[Multiresolution](multiresolution.xhtml) modifiers,
the *Decimate* one can be used to reduce the polygon count for a performance increase,
or simply remove unnecessary vertices and edges.

Unlike the majority of existing modifiers, this one does not allow
you to visualize your changes in Edit Mode.

The modifier displays the number of remaining faces as a result of the *Decimate* modifier.
user: What is Properties and how is it used in Blender Python scripting?

assistant: Mode
:   Rectangle:
    :   Generate a rectangle-shaped curve with a width and a height.

    Parallelogram:
    :   Generate a rectangle with an offset for the different X values of the top and bottom edges.

    Trapezoid:
    :   Generate a trapezoid-shaped curve with a height, a width for the top and bottom, and an offset.

    Kite:
    :   Generate a kite shape with a width, and the top and bottom points distance from the X axis.

    Points:
    :   Generate a four point cyclic poly spline by inputting the position vectors directly.
user: Give a detailed overview of GREASE_PENCIL_UL_masks(UIList): syntax, arguments, return values, common patterns.

assistant: # GREASE_PENCIL_UL_masks(UIList)

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

*class* bpy.types.GREASE_PENCIL_UL_masks(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *item*, *icon*, *_active_data*, *_active_propname*, *_index*)

    *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 Asset System Files (.asset.blend Extension) and how is it used in Blender Python scripting?

assistant: Some types of assets can be edited without having to open a blend-file inside of an asset library.
Blender saves these assets to libraries in special files using the .asset.blend extension. They
are entirely managed by Blender’s asset system, and only contain a single asset and its
dependencies.

It is still possible to save a normal file with the .asset.blend extension. This will then not
be treated as an asset system file, Blender knows the difference.

Asset system files have one more special characteristic: You can open, but not save them. The
[Save As](../blend/open_save.html#bpy-ops-wm-save-as-mainfile) operator can still be used to create a new file from
them, which will then be just a normal blend-file. Thus contained assets cannot be edited without
opening the file itself. Blender shows some clear warnings to communicate that asset system files
cannot be changed and saved the normal way.

The reason these files are special is that the asset system might need to regenerate them. Any
additional changes done by the user might be lost then. To prevent this data-loss, these files are
protected from user modifications.

Currently, only brush assets support this feature.
user: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

View Layers allow you to separate a render into multiple layers, which can then be composited together.
This is useful for rendering scene elements independently—such as characters, lighting variations, or background
elements—without duplicating the entire scene or re-rendering everything after each change.

For example, you can:

- Apply different compositing effects to foreground and background elements.
- Render characters separately from the environment for post-processing.
- Generate multiple lighting passes without modifying the original scene setup.

View Layers also improve performance and flexibility during iteration by letting you re-render only the layers
that have changed.

[image reference removed]

View Layers and collections.

Each View Layer references a combination of [Collections](../../scene_layout/collections/introduction.xhtml),
which define the visibility, selectability, and contribution of scene objects in the final render.
Multiple View Layers can use the same or different collections, allowing for tailored layer setups.
user: Provide the full official documentation entry for NodeSocketVectorFactor(NodeSocketStandard), preserving all code examples.

assistant: # NodeSocketVectorFactor(NodeSocketStandard)

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

*class* bpy.types.NodeSocketVectorFactor(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   float array of 3 items in [0, 1], default (0.0, 0.0, 0.0)

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use Noise in Blender? Include parameters, examples, warnings and best practices.

assistant: # Noise

Adding noise to the gas simulation creates a finer detailed looking simulation on top of the base.
This makes it possible to add more details to gases (i.e. fire or smoke or both) without changing
the overall fluid motion.

Besides enabling parts of the interface, checking *Noise* lets the cache know
which simulation data to read. If, for example, *Noise* is enabled but
there is no noise simulation data to read it will show an empty domain.
The checkbox does not reset the cache and can be used to switch
the view between base resolution and noise view.

Upres Factor
:   Factor by which to enhance the resolution of the noise. The scaling factor is coupled
    to the [Resolution Divisions](../settings.html#bpy-types-fluiddomainsettings-resolution-max).

Strength
:   Strength of the noise. Higher values result in more turbulent vortices.

Scale
:   Scale of the noise. Greater values result in larger vortices.

Time
:   Animation time of the noise. This value has an influence on where the noise field is evaluated.
    It can be used as a seed to give wavelet noise a slightly different look in two domains that are
    otherwise the same.

    Smoke plume with varying animation time. While the fluid motion of all four smoke
    plumes are alike each example has a unique look.

    |  |  |
    | --- | --- |
    | ../../../../../_images/physics_fluid_type_domain_gas_noise_timeanim-0-1.png   Animation Time: 0.1 | ../../../../../_images/physics_fluid_type_domain_gas_noise_timeanim-1-0.png   Animation Time: 1.0 |
    | ../../../../../_images/physics_fluid_type_domain_gas_noise_timeanim-2-5.png   Animation Time: 2.5 | ../../../../../_images/physics_fluid_type_domain_gas_noise_timeanim-10-0.png   Animation Time: 10.0 |

    Comparison of fire simulations with and without noise at the same grid
    resolution.

    |  |  |
    | --- | --- |
    | ../../../../../_images/physics_fluid_type_domain_gas_noise_base-res-1.png   Resolution Divisions: 200, without noise | ../../../../../_images/physics_fluid_type_domain_gas_noise_base-res-2.png   Resolution Divisions: 100, Noise scale: 2. |

    Low division simulations with lots of *Upres Factor* divisions generally appear smaller in
    real-world scale and can be used to achieve pyroclastic plumes such as in the following image:

    [image reference removed]

Bake Noise, Free Noise
:   This option is only available when using the [Modular](../cache.html#bpy-types-fluiddomainsettings-cache-type) cache type.

    The progress will be displayed in the status bar. Pressing `Esc` will pause the simulation.

    Once the simulation has been baked, the cache can be deleted by pressing *Free Noise*.
    It is possible to pause or resume a *Bake Noise* process.
user: What is Context Mode Items and how is it used in Blender Python scripting?

assistant: # Context Mode Items

EDIT_MESH:
:   Mesh Edit.

EDIT_CURVE:
:   Curve Edit.

EDIT_CURVES:
:   Curves Edit.

EDIT_SURFACE:
:   Surface Edit.

EDIT_TEXT:
:   Text Edit.

EDIT_ARMATURE:
:   Armature Edit.

EDIT_METABALL:
:   Metaball Edit.

EDIT_LATTICE:
:   Lattice Edit.

EDIT_GREASE_PENCIL:
:   Grease Pencil Edit.

EDIT_POINTCLOUD:
:   Point Cloud Edit.

POSE:
:   Pose.

SCULPT:
:   Sculpt.

PAINT_WEIGHT:
:   Weight Paint.

PAINT_VERTEX:
:   Vertex Paint.

PAINT_TEXTURE:
:   Texture Paint.

PARTICLE:
:   Particle.

OBJECT:
:   Object.

PAINT_GPENCIL:
:   Grease Pencil Paint.

EDIT_GPENCIL:
:   Grease Pencil Edit.

SCULPT_GPENCIL:
:   Grease Pencil Sculpt.

WEIGHT_GPENCIL:
:   Grease Pencil Weight Paint.

VERTEX_GPENCIL:
:   Grease Pencil Vertex Paint.

SCULPT_CURVES:
:   Curves Sculpt.

PAINT_GREASE_PENCIL:
:   Grease Pencil Paint.

SCULPT_GREASE_PENCIL:
:   Grease Pencil Sculpt.

WEIGHT_GREASE_PENCIL:
:   Grease Pencil Weight Paint.

VERTEX_GREASE_PENCIL:
:   Grease Pencil Vertex Paint.
user: Provide the full official documentation entry for Snap to Symmetry, preserving all code examples.

assistant: # Snap to Symmetry

The Snap to Symmetry tool lets you snap a mesh vertices to their mirrored neighbors.

Useful when dealing with meshes which are mostly symmetrical,
but have vertices which have been moved enough that Blender
does not detect them as mirrored (when X Mirror option is enabled for example).

This can be caused by accident when editing without X Mirror enabled. Sometimes models
imported from other applications are asymmetrical enough that mirror fails too.

Direction
:   Specify the axis and direction to snap. Can be any of the three axes,
    and either positive to negative, or negative to positive.

Threshold
:   Specify the search radius to use when finding matching vertices.

Factor
:   Support for blending mirrored locations from one side to the other (0.5 is an equal mix of both).

Center
:   Snap vertices along the center axis to zero.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_mesh_snap-symmetry_before.png   Before Snap to Symmetry. | ../../../../_images/modeling_meshes_editing_mesh_snap-symmetry_after.png   After Snap to Symmetry. |
user: Give a detailed overview of Sampling: syntax, arguments, return values, common patterns.

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

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

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

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

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

Extension X/Y
:   The extension mode applied to the X axis.

    Clip:
    :   Areas outside of the image are filled with transparency.

    Extend:
    :   Areas outside of the image are filled with the closest boundary pixel in the image.

    Repeat:
    :   Areas outside of the image are filled with repetitions of the image.
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Repeat Items
:   [List View](../../../interface/controls/templates/list_view.xhtml#ui-list-view) for adding, removing, reordering, and renaming the inputs of the zone.

    Socket Type
    :   The [data type](../../../modeling/geometry_nodes/attributes_reference.xhtml#attribute-data-types) of the selected input.

Inspection Index
:   The number of the iteration to show in [socket inspection](../../../modeling/geometry_nodes/inspection.xhtml#socket-inspection)
    and in the [Viewer Node](../../../modeling/geometry_nodes/output/viewer.xhtml).
user: Describe FFmpeg Audio Codecs from the Blender manual or Python API, including usage steps and snippets.

assistant: No Audio:
:   For video-only encoding.

[AAC](https://en.wikipedia.org/wiki/Advanced_Audio_Coding):
:   Advanced Audio Codec, a standardized, lossy compression and encoding scheme for digital audio.
    AAC generally achieves better sound quality than MP3 at similar bit rates.

[AC3](https://en.wikipedia.org/wiki/Dolby_Digital):
:   Audio Codec 3, an audio compression technology developed by Dolby Laboratories.

[FLAC](https://en.wikipedia.org/wiki/FLAC):
:   Free Lossless Audio Codec.
    Digital audio compressed by FLAC’s algorithm can typically be reduced to 50-60% of its original size.

[MP2](https://en.wikipedia.org/wiki/MPEG-1_Audio_Layer_II):
:   A lossy audio compression format.

[MP3](https://en.wikipedia.org/wiki/MP3):
:   A lossy audio compression format, widely used as final audio format.

[Opus](https://en.wikipedia.org/wiki/Opus_(audio_format)):
:   A lossy audio compression format, designed to encode speech or general audio
    and is intended to replace the *Vorbis* codec.

[PCM](https://en.wikipedia.org/wiki/PCM):
:   Pulse Code Modulation, a method used to digitally represent sampled analog signals.
    It is the standard form for digital audio in computers and various Blu-ray,
    Compact Disc and DVD formats, as well as other uses such as digital telephone systems.

[Vorbis](https://en.wikipedia.org/wiki/Vorbis):
:   An open-standard, highly-compressed format comparable to MP3 or AAC.
    Vorbis generally achieves better sound quality than MP3 at similar bit rates.
user: What is Collection Exporters and how is it used in Blender Python scripting?

assistant: This exporter can be used as a collection exporter.
See [Collections](../../scene_layout/collections/collections.xhtml) for more information about collections and their exporters.

Here are the options & specificity for collection export:

- Include part of options are not available for collection exporter (like every other exporter).
- Option to export at collection center (at center of mass of all root objects of the collection).
- Custom Properties of the collection are exported as Scene glTF extras.
user: Show practical ways to work with Fix to Camera in a Blender add-on or script – include code.

assistant: [image reference removed]

Also known as “bake to camera”, this operator will ensure selected objects/bones
remain static (relative to the camera) on unkeyed frames.

This is done by generating new keys. These keys will be of [type
‘Generated’](../../../animation/keyframes/introduction.xhtml#keyframe-type) so that it remains clear which keys were manually
created, and which were generated. This way the tool can be re-run to
re-generate the keys.

1. Ensure your animation is keyed using constant interpolation. If this is not
   the case yet, bake your animation (at least the transform channels). This
   tool does _not_ work with the [“Stepped” F-Curve modifier](../../graph_editor/fcurves/modifiers.xhtml#bpy-types-fmodifierstepped)
2. Choose which of the Location/Rotation/Scale channels you want to fix to the
   camera. When unsure, make sure they are all checked.
3. Press the “Fix to Camera” button.

To undo the effect of the “Fix to Camera” operator, click on the trash bin
button. That will remove all the generated keys in either the scene range or the
frame range.

The tool operates on the scene frame range, or on the preview range if that is
active. Keys outside that range are ignored, both when fixing to the camera and
when removing generated keys.

### Limitations

Pasting a transform adjusts the Object/Bone’s location, rotation, and
scale. This means that when copying a skewed transform, this skew is lost.

If there are constraints on the Object/Bone, the resulting visual transformation
may not be the same as the pasted one. To give a concrete example: if you have a
constraint that adds a rotation, it will always add that rotation on top of the pasted transform.
user: Explain CompositorNodeColorSpill(CompositorNode) in complete detail according to the official Blender documentation.

assistant: # CompositorNodeColorSpill(CompositorNode)

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

*class* bpy.types.CompositorNodeColorSpill(*CompositorNode*)
:   Remove colors from a blue or green screen, by reducing one RGB channel compared to the others

    *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")

    update()

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

assistant: # Image or Movie

The term *Image Texture* simply means that a graphic image,
which is a pixel grid composed of R, G, B, and sometimes Alpha values.
It is used as the input source to the texture.
As with other types of textures, this information can be used in a number of ways,
not only as a simple “decal”.

*Video textures* are a some kind of Image textures and
based on movie file or sequence of successive numbered separate images.
They are added in the same way that image textures are.

When the Texture Type *Image or Movie* is selected, three new panels present
themselves allowing to control most aspects of how image textures are applied:
*Image*, *Image Sampling*, and *Image Mapping*.
user: Describe Visualization from the Blender manual or Python API, including usage steps and snippets.

assistant: They all become a color-coded strip in the Video Sequencer:

- Scene strip: Light green.
- Clip strip: Dark blue.
- Mask strip: Red.
- Movie strip: Aquamarine.
- Image strip: Purple.
- Sound strip: Turquoise.

Each of the effect strips has its own color.

Besides each of these default colors you can also assign individual strips an alternative color in
the [Strip Properties](../../../../editors/video_sequencer/sequencer/sidebar/strip.xhtml#bpy-ops-sequencer-strip-color-tag-set).
user: Describe Particle Instance Modifier from the Blender manual or Python API, including usage steps and snippets.

assistant: # Particle Instance Modifier

When a Particle Instance modifier is added to an object,
the mesh of this object will be duplicated
at the location of the particles of the selected particle system from another target object.
This means that to use this modifier, you must have at least one other object
that has a [Particles System](../../../physics/particles/index.xhtml) on it.

Because of the correlation in which the Particle Instance modifier is
influenced by the underlying particle systems on other objects, some of the apparent effects
generated by the modifier can look and act vastly different,
depending on the underlying settings of the particle systems it is associated with.
This is worth taking account of, when it seems that the Particle Instance modifier settings
do not return the expected results.
user: Provide the full official documentation entry for Chromatic Aberration Node, preserving all code examples.

assistant: # Chromatic Aberration Node

[image reference removed]

The *Chromatic Aberration* node simulates the dispersion of light caused by a camera lens,
where different wavelengths (colors) of light are refracted by slightly different amounts.
This effect produces subtle color fringing near edges or high-contrast transitions
and can be used for both realistic lens simulation and stylistic distortion effects.

It can also be combined with other post-processing effects such as
[Vignette](vignette.xhtml) or
[Lens Distortion](../transform/lens_distortion.xhtml)
to create convincing camera imperfections.
user: Give a detailed overview of Stabilize Stroke: syntax, arguments, return values, common patterns.

assistant: *Stabilize Stroke* makes the stroke lag behind the cursor
and creates a smoothed curve to the path of the cursor.
This can be enabled pressing `Shift` `S` or by clicking the checkbox found in the header.

Radius
:   Minimum distance from the last point before the stroke continues.

Factor
:   A smooth factor, where higher values result in smoother strokes but the drawing sensation
    feels like as if you were pulling the stroke.
user: Describe Bake Target Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Bake Target Items

IMAGE_TEXTURES:
:   Image Textures.

    Bake to image data-blocks associated with active image texture nodes in materials.

VERTEX_COLORS:
:   Active Color Attribute.

    Bake to the active color attribute on meshes.
user: Provide the full official documentation entry for Start & End Mapping, preserving all code examples.

assistant: Factor Start, End
:   The percentages along the length of the curve where the geometry should start
    and end. By default, these are set to 0 and 1, making the geometry cover the full length;
    but if you change them to 0.5 and 0.75, the geometry will only cover the third quarter
    of the curve.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_curves_properties_geometry_bevel.png   A curve with Factor Start set to 0 and End to 1. | ../../../_images/modeling_curves_properties_geometry_bevel-start-end-factor.png   Factor End changed to 0.6. |

Mapping Start, End
:   How to map the *Factor Start, End* percentages to positions on the curve.

    Resolution:
    :   Only count control points, disregarding the lengths of the spline segments (pieces of
        spline between two control points). If a spline has three control points and *Factor Start*
        is set to 0.5, the geometry will always start at the second control point,
        even if its distances to the first and third control points are completely different.

    Segments:
    :   Calculate an approximate percentage along the length of the spline by assuming that
        all the subdivisions within each segment are evenly distributed.

    Spline:
    :   Calculate an accurate percentage along the length of the spline.
user: Show practical ways to work with Symmetrize in a Blender add-on or script – include code.

assistant: # Symmetrize

The Symmetrize operator mirrors selected bones along the X axis using Blender’s bone
[naming convention](naming.xhtml#armature-editing-naming-conventions) for symmetrical armatures.
Bones can be mirrored from left to right or right to left, depending on the selection.

- If matching bones are selected on both sides, mirroring happens from right to left.
- Bones with opposite names that don’t exist are created, and existing ones are overwritten.
- Bones that cannot be determined as left or right are ignored.

Symmetrized bone and constraint properties are adjusted to mirror their behaviors.
For bones with [Action Constraints](../../../constraints/relationship/action.xhtml),
keyframes are added to the target Action, ensuring symmetrical motion when the Action is activated.

Bone Collections

Bone collection assignments are also symmetrized. Collections that follow the
[naming convention](naming.xhtml#armature-editing-naming-conventions) are mirrored.
If a collection does not exist, it is created and parented to the same collection as the original.
user: Give a detailed overview of Nla Mode Extend Items: syntax, arguments, return values, common patterns.

assistant: # Nla Mode Extend Items

NOTHING:
:   Nothing.

    Strip has no influence past its extents.

HOLD:
:   Hold.

    Hold the first frame if no previous strips in track, and always hold last frame.

HOLD_FORWARD:
:   Hold Forward.

    Only hold last frame.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: String
:   Standard string input.

Size
:   The size of each character. The values of the other inputs are scaled by this value.

Character Spacing
:   A factor by which the space between each character (kerning) is scaled on the X axis.

Word Spacing
:   A factor by which whitespace between words is scaled on the X axis.

Line Spacing
:   The distance between separate lines in the output. Scaled by the *Size* input.

Text Box Width
:   The maximum width of each line, though individual words will not be wrapped.

Text Box Height
:   The maximum height for all the lines of the text.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.view_layer`](bpy.context.html#bpy.context.view_layer "bpy.context.view_layer") - [`Context.view_layer`](bpy.types.Context.html#bpy.types.Context.view_layer "bpy.types.Context.view_layer") - [`Depsgraph.view_layer`](bpy.types.Depsgraph.html#bpy.types.Depsgraph.view_layer "bpy.types.Depsgraph.view_layer") - [`Depsgraph.view_layer_eval`](bpy.types.Depsgraph.html#bpy.types.Depsgraph.view_layer_eval "bpy.types.Depsgraph.view_layer_eval") - [`ID.override_hierarchy_create`](bpy.types.ID.html#bpy.types.ID.override_hierarchy_create "bpy.types.ID.override_hierarchy_create") - [`IDOverrideLibrary.resync`](bpy.types.IDOverrideLibrary.html#bpy.types.IDOverrideLibrary.resync "bpy.types.IDOverrideLibrary.resync") - [`LayerCollection.has_selected_objects`](bpy.types.LayerCollection.html#bpy.types.LayerCollection.has_selected_objects "bpy.types.LayerCollection.has_selected_objects") - [`Object.hide_get`](bpy.types.Object.html#bpy.types.Object.hide_get "bpy.types.Object.hide_get") - [`Object.hide_set`](bpy.types.Object.html#bpy.types.Object.hide_set "bpy.types.Object.hide_set") - [`Object.holdout_get`](bpy.types.Object.html#bpy.types.Object.holdout_get "bpy.types.Object.holdout_get") - [`Object.indirect_only_get`](bpy.types.Object.html#bpy.types.Object.indirect_only_get "bpy.types.Object.indirect_only_get") | - [`Object.select_get`](bpy.types.Object.html#bpy.types.Object.select_get "bpy.types.Object.select_get") - [`Object.select_set`](bpy.types.Object.html#bpy.types.Object.select_set "bpy.types.Object.select_set") - [`Object.visible_get`](bpy.types.Object.html#bpy.types.Object.visible_get "bpy.types.Object.visible_get") - [`RenderEngine.register_pass`](bpy.types.RenderEngine.html#bpy.types.RenderEngine.register_pass "bpy.types.RenderEngine.register_pass") - [`RenderEngine.update_render_passes`](bpy.types.RenderEngine.html#bpy.types.RenderEngine.update_render_passes "bpy.types.RenderEngine.update_render_passes") - [`Scene.statistics`](bpy.types.Scene.html#bpy.types.Scene.statistics "bpy.types.Scene.statistics") - [`Scene.view_layers`](bpy.types.Scene.html#bpy.types.Scene.view_layers "bpy.types.Scene.view_layers") - [`ViewLayers.new`](bpy.types.ViewLayers.html#bpy.types.ViewLayers.new "bpy.types.ViewLayers.new") - [`ViewLayers.remove`](bpy.types.ViewLayers.html#bpy.types.ViewLayers.remove "bpy.types.ViewLayers.remove") - [`Window.view_layer`](bpy.types.Window.html#bpy.types.Window.view_layer "bpy.types.Window.view_layer") |
user: Give a detailed overview of Image Context: syntax, arguments, return values, common patterns.

assistant: bpy.context.edit_image
:   Type:
    :   [`bpy.types.Image`](bpy.types.Image.html#bpy.types.Image "bpy.types.Image")

bpy.context.edit_mask
:   Type:
    :   [`bpy.types.Mask`](bpy.types.Mask.html#bpy.types.Mask "bpy.types.Mask")
user: Describe GeometryNodeCurvePrimitiveBezierSegment(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeCurvePrimitiveBezierSegment(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.GeometryNodeCurvePrimitiveBezierSegment(*GeometryNode*)
:   Generate a 2D Bézier spline from the given control points and handles

    mode
    :   Method used to determine control handles

        - `POSITION`
          Position – The start and end handles are fixed positions.
        - `OFFSET`
          Offset – The start and end handles are offsets from the spline’s control points.

        Type:
        :   enum in [`'POSITION'`, `'OFFSET'`], default `'POSITION'`

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

assistant: [image reference removed]

The Cube object was duplicated.

The object `Cube` was duplicated, using `Shift`-`D`. Both these cubes have
separate meshes with unique names: `Cube` and `Cube.001`.

- The original left cube is being edited, the duplicated right cube remains unchanged.
  The mesh data has been copied, not linked.
- Likewise, if one cube is edited in Object Mode, the other cube remains
  unchanged. The new object’s transform properties or data-block is a copy, not linked.
- When the cube was duplicated, it inherited the material of the original cube.
  The material properties were linked, not copied.

See above if you want separate copies of the data-blocks normally linked.