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

assistant: When using the Stereo 3D scene view setup, a stereo pair is created
on-the-fly and used for rendering and previsualization.
For all the purposes this works as two cameras that share most parameters (focal length, clipping, …).
The stereo pair, however, is offset, and can have unique rotation and shift between itself.

[image reference removed]

Stereo 3D camera settings.

Interocular Distance
:   Set the distance between the camera pair.
    Although the convergence of a stereo pair can be changed in post-production,
    different interocular distances will produce different results
    due to the parts of the scene being occluded from each point of view.

Convergence Plane Distance
:   The converge point for the stereo cameras.
    This is often the distance between a projector and the projection screen.
    You can visualize this in the 3D Viewport.

Spherical Stereo
:   Render every pixel rotating the camera around the middle of the interocular distance.

Use Pole Merge
:   Fade interocular distance to 0 after the given cutoff angle.

    Pole Merge Start Angle
    :   Angle at which interocular distance starts to fade to 0.

    Pole Merge End Angle
    :   Angle at which interocular distance is 0.

### Convergence Mode

Off-Axis
:   The stereo camera pair is separated by the interocular distance,
    and shifted inwards so it converges in the convergence plane.
    This is the ideal format since it is the one closest to how the human vision works.

Parallel
:   This method produces two parallel cameras that do not converge.
    Since this method needs to be manually converged it cannot be used for viewing.
    This method is common when combining real footage with rendered elements.

Toe-in
:   A less common approach is to rotate the cameras instead of shifting their frustum.
    The Toe-in method is rarely used in modern 3D productions.

Pivot
:   The stereo pair can be constructed around the active camera with a new camera built for each eye
    (Center Pivot) or using the existing camera and creating (Left or Right).
    The latter is what is used when only one eye needs to be rendered for an existing mono 2D project.
user: Give a detailed overview of Node Types: syntax, arguments, return values, common patterns.

assistant: Nodes can be separated into two categories: data flow nodes that usually pass geometry,
and field nodes that operate on data per-element. Field nodes can be input nodes that
bring geometry data into the node tree, or function nodes that operate on that data.

### Data Flow Nodes

Nodes with a geometry input and a geometry output will almost always be data flow nodes.
Meaning that they actually change geometry data that will be outputted from the Geometry Nodes modifier.

### Function Nodes

Nodes with diamond socket inputs and outputs are field nodes, and resemble the instructions
that will be evaluated by data flow nodes. Examples of function nodes are the math nodes
and also more complex nodes like the [Geometry Proximity Node](geometry/sample/geometry_proximity.xhtml).

### Input Nodes

Input nodes provide data to the field evaluation process. By themselves, they mean nothing; they
must be evaluated within the context of a data flow node (geometry) to actually output a value.
Examples of input nodes are the built-in attribute input nodes like
[Position](geometry/read/position.xhtml) and
[ID](geometry/read/id.xhtml), but also selection nodes like
[Endpoint Selection](curve/read/endpoint_selection.xhtml).

Field inputs may also come from other nodes that process geometry like
the [Distribute Points on Faces](point/distribute_points_on_faces.xhtml),
in the form of [Anonymous Attributes](attributes_reference.xhtml#anonymous-attributes).
user: What is Sound and how is it used in Blender Python scripting?

assistant: This panel contains the sound settings for live playback
within Blender and are only available with a device other than *None*.
To control these settings for exporting sound
see the [Encoding Panel](../../render/output/properties/output.xhtml#render-output-video-encoding-panel)
and [Audio Panel](../../scene_layout/scene/properties.xhtml#data-scenes-audio).

Audio Device
:   Sets the audio engine to use to process and output audio.

    None:
    :   No audio playback support (audio strips can still be loaded and rendered normally).

    CoreAudio:
    :   On macOS, CoreAudio is the native audio API.
        This is the default setting for macOS users and should be preferred.

    PulseAudio:
    :   PulseAudio is the most commonly used sound server on modern Linux distributions.
        If PulseAudio is available, this should be the preferred setting on Linux.

    WASAPI:
    :   On Windows, WASAPI is the native audio API introduced with Windows Vista.
        This is the default setting for Windows users and should be preferred.

    Jack:
    :   High quality professional audio engine that needs a properly configured server running on your system.
        Supports accurate synchronization with other professional audio applications using Jack.

    OpenAL:
    :   Available on all platforms in case the native engines do not work.
        The played back 3D audio might sound different than when rendered.

    SDL:
    :   Uses Simple Direct Media Layer API from [libsdl.org](https://www.libsdl.org)
        which supports all platforms. Might be of lower quality and thus should only be used as backup.

Channels
:   The number of audio source “locations” to output.

    Mono:
    :   Output a single audio channel.

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

    4 Channels:
    :   Output a four audio channels.

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

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

Mixing Buffer
:   Sets the number of samples used by the audio mixing buffer.
    Higher buffer sizes can cause latency issues,
    but if you hear clicks or other problems, try to increase the size.

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

Sample Format
:   Sets the audio sample format.
user: Show practical ways to work with ShaderNodeMix(ShaderNode) in a Blender add-on or script – include code.

assistant: # ShaderNodeMix(ShaderNode)

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

*class* bpy.types.ShaderNodeMix(*ShaderNode*)
:   Mix values by a factor

    blend_type
    :   Type:
        :   enum in [Ramp Blend Items](bpy_types_enum_items/ramp_blend_items.html#rna-enum-ramp-blend-items), default `'MIX'`

    clamp_factor
    :   Clamp the factor to [0,1] range

        Type:
        :   boolean, default False

    clamp_result
    :   Clamp the result to [0,1] range

        Type:
        :   boolean, default False

    data_type
    :   Type:
        :   enum in [`'FLOAT'`, `'VECTOR'`, `'RGBA'`, `'ROTATION'`], default `'FLOAT'`

    factor_mode
    :   - `UNIFORM`
          Uniform – Use a single factor for all components.
        - `NON_UNIFORM`
          Non-Uniform – Per component factor.

        Type:
        :   enum in [`'UNIFORM'`, `'NON_UNIFORM'`], default `'UNIFORM'`

    *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: Explain Bpy.Types.Spacesequenceeditor in complete detail according to the official Blender documentation.

assistant: type the callback draws in; usually WINDOW . ( bpy.types.Region.type ) draw_type ( str ) – Usually POST_PIXEL for 2D drawing and POST_VIEW for 3D drawing. In some cases PRE_VIEW can be used. BACKDROP can be used for backdrops in the node editor. Returns : Handler that can be removed later on. Return type : object classmethod draw_handler_remove ( handler , region_type ) ¶ Remove a draw handler that was added previously. Parameters : handler ( object ) – The draw handler that should be removed. region_type ( str ) – Region type the callback was added to. Inherited Properties ¶ bpy_struct.id_data Space.type Space.show_locked_time Space.show_region_header Inherited Functions ¶ bpy_struct.as_pointer bpy_struct.driver_add bpy_struct.driver_remove bpy_struct.get bpy_struct.id_properties_clear bpy_struct.id_properties_ensure bpy_struct.id_properties_ui bpy_struct.is_property_hidden bpy_struct.is_property_overridable_library bpy_struct.is_property_readonly bpy_struct.is_property_set bpy_struct.items bpy_struct.keyframe_delete bpy_struct.keyframe_insert bpy_struct.keys bpy_struct.path_from_id bpy_struct.path_from_module bpy_struct.path_resolve bpy_struct.pop bpy_struct.property_overridable_library_set bpy_struct.property_unset bpy_struct.rna_ancestors bpy_struct.type_recast bpy_struct.values Space.bl_rna_get_subclass Space.bl_rna_get_subclass_py Space.draw_handler_add Space.draw_handler_remove Next SpaceSpreadsheet(Space) Previous SpaceProperties(Space) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page SpaceSequenceEditor(Space) SpaceSequenceEditor SpaceSequenceEditor.annotation SpaceSequenceEditor.cache_overlay SpaceSequenceEditor.cursor_location SpaceSequenceEditor.display_channel SpaceSequenceEditor.display_mode SpaceSequenceEditor.overlay_frame_type SpaceSequenceEditor.preview_channels SpaceSequenceEditor.preview_overlay SpaceSequenceEditor.proxy_render_size SpaceSequenceEditor.show_frames SpaceSequenceEditor.show_gizmo SpaceSequenceEditor.show_gizmo_context SpaceSequenceEditor.show_gizmo_navigate SpaceSequenceEditor.show_gizmo_tool SpaceSequenceEditor.show_markers SpaceSequenceEditor.show_overexposed SpaceSequenceEditor.show_overlays SpaceSequenceEditor.show_region_channels SpaceSequenceEditor.show_region_footer SpaceSequenceEditor.show_region_hud SpaceSequenceEditor.show_region_tool_header SpaceSequenceEditor.show_region_toolbar SpaceSequenceEditor.show_region_ui SpaceSequenceEditor.show_seconds SpaceSequenceEditor.show_transform_preview SpaceSequenceEditor.timeline_overlay SpaceSequenceEditor.use_clamp_view SpaceSequenceEditor.use_marker_sync SpaceSequenceEditor.use_proxies SpaceSequenceEditor.use_zoom_to_fit SpaceSequenceEditor.view_type SpaceSequenceEditor.zoom_percentage SpaceSequenceEditor.bl_rna_get_subclass() SpaceSequenceEditor.bl_rna_get_subclass_py() SpaceSequenceEditor.draw_handler_add() SpaceSequenceEditor.draw_handler_remove() Inherited Properties Inherited Functions
user: Explain AssetLibraryCollection(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # AssetLibraryCollection(bpy_struct)

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

*class* bpy.types.AssetLibraryCollection(*bpy_struct*)
:   Collection of user asset libraries

    *classmethod* new(*\**, *name=''*, *directory=''*)
    :   Add a new Asset Library

        Parameters:
        :   - **name** (*string**,* *(**optional**,* *never None**)*) – Name
            - **directory** (*string**,* *(**optional**,* *never None**)*) – Directory

        Returns:
        :   Newly added asset library

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

    *classmethod* remove(*library*)
    :   Remove an Asset Library

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Symmetry

Mirror
:   Mirror the brush strokes across the selected local axes.
    Note that if you want to alter the directions the axes point in,
    you must rotate the model in Edit Mode and not in Object Mode.

Lock
:   These three buttons allow you to block any modification/deformation
    of your model along selected local axes, while you are sculpting it.

Tiling
:   Using this option allows you to seamlessly tile your strokes along the given axes.
    This allows to create repeating patterns.

Feather
:   Reduces the strength of the stroke where it overlaps the planes of symmetry.

Radial X, Y, Z
:   These settings allow for radial symmetry in the desired axes.
    The number determines how many times the stroke will be repeated
    within 360 degrees around the central axes.

Tile Offset X, Y, Z
:   The offset allows the option to alter the tile size along all three axes.
    The default tile size is set to one unit.

Symmetrize

Direction
:   Determines which direction the model will be symmetrized.

Merge Distance
:   A parameter of the *Symmetrize* operator to control
    the distance within which symmetrical vertices are merged.

Symmetrize
:   Uses direction orientation to symmetrize. Since Dyntopo adds
    details dynamically it may happen that the model becomes asymmetric,
    so this a good tool for that.
user: Give a detailed overview of Visualization: syntax, arguments, return values, common patterns.

assistant: ### Bone State Colors

The color of the bones are based on their state.
There are six different color codes, ordered here by precedence
(i.e. the bone will be of the color of the bottom-most valid state):

- Gray: Default.
- Blue wire-frame: in Pose Mode.
- Green: with Constraint.
- Yellow: with [IK Solver constraint](../../constraints/tracking/ik_solver.xhtml).
- Orange: with Targetless Solver constraint.
user: How do I use Introduction in Blender? Include parameters, examples, warnings and best practices.

assistant: # Introduction

The first step is to unwrap your mesh. Generally, it is recommended to start unwrapping
when only minor adjustments to the geometry of your model are required.
If you do add faces or subdivide existing faces when a model is already unwrapped,
Blender will add those new faces for you,
but you may need to do additional mapping or editing. In this fashion,
you can use the UV texture image to guide additional geometry changes.
user: Give a detailed overview of Relative: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

The “Relative” panel has copy/paste buttons that work relative to a chosen
object. When copying, the world-space transform is determined, and then adjusted
to become relative to the world-space transform of the chosen object. When
pasting, this happens in reverse.

If no object is chosen, the copy/paste will happen relative to the active scene
camera. What is the active scene camera is determined for every action, so when
you paste it can be different from when you copied. This can help to keep an
object visually in the same place when switching cameras, or when switching
between scenes.
user: Provide the full official documentation entry for Overview, preserving all code examples.

assistant: To display an image, it must be converted from
[scene linear](color_spaces.xhtml#color-management-linear-space) to a display color space.
This involves both technical and artistic choices.

The technical choice of [display color space](#bpy-types-colormanageddisplaysettings-display-device)
depends on the target display device and its capabilities. sRGB works for all
computer displays, but different choices may be made for digital cinema, HD TVs,
and computers with wide gamut or HDR support.

Because display devices cannot display the full spectrum of colors and only have
limited brightness, colors must be fitted to the gamut of the device. Blender
includes a choice of [views](#bpy-types-colormanagedviewsettings-view-transform),
each resulting in a different look.

Further artistic choices can be made with color management settings like exposure and
white balance, and color grading in the compositor.
.

[image reference removed]

Conversion from linear to display device space.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Geometry
:   Standard geometry input.

Radius
:   Float value indicating the radius of the point geometry at each point.

Selection
:   Boolean input for selecting which points will have the radius value applied.
user: What is NoiseTexture(Texture) and how is it used in Blender Python scripting?

assistant: # NoiseTexture(Texture)

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

*class* bpy.types.NoiseTexture(*Texture*)
:   Procedural noise texture

    users_material
    :   Materials that use this texture

        Type:
        :   tuple of [`Material`](bpy.types.Material.html#bpy.types.Material "bpy.types.Material")

        (readonly)

    users_object_modifier
    :   Object modifiers that use this texture

        Type:
        :   tuple of [`Object`](bpy.types.Object.html#bpy.types.Object "bpy.types.Object")

        (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: Give a detailed overview of Space: syntax, arguments, return values, common patterns.

assistant: The *Target Space* is the reference frame for retrieving the location coordinates,
rotation angles, and scale factors of the *Target*. The *Owner Space* is the
reference frame for applying those numbers to the object or bone that owns the constraint.

[image reference removed]

Using *World Space* for both *Target* and *Owner* places the constrained object
at the same location as the target regardless of their parents.

### Space Types

World Space
:   Use the transformation relative to the world axes.

Custom Space
:   Use the transformation relative to an arbitrary object or bone.

Pose Space Bones Only
:   Use the transformation relative to the armature object.

Local Space
:   For an object, use the transformation relative to its parent.

    For a bone, use the transformation relative to its rest state, after that rest state was
    transformed by the bone’s ancestors. (If the bone has no other constraints, this is its
    transformation as shown in the [Properties Editor](../../../editors/properties_editor.xhtml) while in Pose Mode.)

Local with Parent Bones Only
:   Use the transformation relative to the bone’s rest state. Unlike *Local Space*, this includes
    the rotation and location difference caused by rotating any ancestor bone.

Local Space (Owner Orientation) Bone Targets Only
:   This space is intended to be used with the *Owner* set to *Local Space*. It retrieves the *Local Space*
    of the Target bone, adjusted to work with the rest orientation of the Owner bone. The result is that,
    if the parent bones of both the Target and the Owner are in their rest pose, the Owner will
    undergo the same transformation as the Target *in armature space*. The following image
    demonstrates this:

    [image reference removed]

    - The left hand armature contains the Target bone which we rotate manually.
    - The middle armature has a constraint that copies the *Local Space* rotation of the Target bone.
      If the Target bone is rotated around its Y axis, this Owner bone rotates by the same amount around
      *its own* Y axis.
    - The right hand armature has a constraint that copies the *Local Space (Owner Orientation)* rotation
      of the Target bone. If the Target bone is rotated around its Y axis, the Owner bone rotates around
      *that same* axis in armature space. Initially this is the same as using *Pose Space* or even
      *World Space*, but if the parent bones are rotated as well, the result will be different.
user: Describe Grid Info Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Grid Info Node

[image reference removed]

The *Grid Info* node retrieves structural and metadata information about a voxel grid.
It provides details such as the grid’s spatial transform and background value,
which describe how the grid is positioned in space and what value is stored in
inactive (empty) voxels.

This node is useful for inspecting or reusing grid parameters in other grid
operations, such as aligning transforms, matching resolutions, or reconstructing
fields with consistent background values.
user: What is Children and how is it used in Blender Python scripting?

assistant: # Children

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

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

assistant:  bpy_struct.items bpy_struct.keyframe_delete bpy_struct.keyframe_insert bpy_struct.keys bpy_struct.path_from_id bpy_struct.path_from_module bpy_struct.path_resolve bpy_struct.pop bpy_struct.property_overridable_library_set bpy_struct.property_unset bpy_struct.rna_ancestors bpy_struct.type_recast bpy_struct.values References ¶ Material.grease_pencil Next MaterialLineArt(bpy_struct) Previous Material(ID) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page MaterialGPencilStyle(bpy_struct) MaterialGPencilStyle MaterialGPencilStyle.alignment_mode MaterialGPencilStyle.alignment_rotation MaterialGPencilStyle.color MaterialGPencilStyle.fill_color MaterialGPencilStyle.fill_image MaterialGPencilStyle.fill_style MaterialGPencilStyle.flip MaterialGPencilStyle.ghost MaterialGPencilStyle.gradient_type MaterialGPencilStyle.hide MaterialGPencilStyle.is_fill_visible MaterialGPencilStyle.is_stroke_visible MaterialGPencilStyle.lock MaterialGPencilStyle.mix_color MaterialGPencilStyle.mix_factor MaterialGPencilStyle.mix_stroke_factor MaterialGPencilStyle.mode MaterialGPencilStyle.pass_index MaterialGPencilStyle.pixel_size MaterialGPencilStyle.show_fill MaterialGPencilStyle.show_stroke MaterialGPencilStyle.stroke_image MaterialGPencilStyle.stroke_style MaterialGPencilStyle.texture_angle MaterialGPencilStyle.texture_clamp MaterialGPencilStyle.texture_offset MaterialGPencilStyle.texture_scale MaterialGPencilStyle.use_fill_holdout MaterialGPencilStyle.use_overlap_strokes MaterialGPencilStyle.use_stroke_holdout MaterialGPencilStyle.bl_rna_get_subclass() MaterialGPencilStyle.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Provide the full official documentation entry for Outputs, preserving all code examples.

assistant: Projection Matrix
:   A 4x4 matrix that represents the camera’s projection transform, combining focal length,
    sensor size, shift, and clipping range. Can be used to project 3D coordinates into screen space.

Focal Length
:   The focal length of the camera in millimeters. Affects field of view in perspective cameras.

Sensor
:   The physical size of the camera sensor in millimeters, as a 2D vector (X and Y dimensions).
    This value is influenced by the sensor fit properties.

Shift
:   Horizontal and vertical shift of the camera view, expressed as a 2D vector.

Clip Start
:   The near clipping distance of the camera.

Clip End
:   The far clipping distance of the camera.

Focus Distance
:   The distance from the camera to the focus point, in Blender units.
    Typically used for depth of field calculations.

Is Orthographic
:   A boolean output that is *true* when the camera is in orthographic mode, and *false* when in perspective mode.

Orthographic Scale
:   The orthographic scale used when the camera is set to orthographic mode.
    Controls the size of the view area instead of using focal length.
user: Show practical ways to work with Box Selection Node in a Blender add-on or script – include code.

assistant: # Box Selection Node

[image reference removed]

The *Box Selection* node creates a selection of elements located within a defined 3D box.
It can be used to isolate geometry inside a specific region of space, such as selecting
points, faces, or instances within a bounded area.
user: Give a detailed overview of Scripting & Security: syntax, arguments, return values, common patterns.

assistant: # Scripting & Security

The ability to include Python scripts within blend-files is valuable for advanced tasks
such as rigging and automation. However, it poses a security risk since
Python does not restrict what a script can do.
Therefore, you should only run scripts from sources you know and trust.
Automatic execution is disabled by default;
however, some blend-files need this to function properly.

When a blend-file tries to execute a script and is not allowed, a dialog will appear.
In it, you can choose to *Allow Execution* or to *Ignore* the scripts.

[image reference removed]

An Auto-run warning in the Info editor’s header.
user: Provide the full official documentation entry for GeometryNodeInputMeshFaceNeighbors(GeometryNode), preserving all code examples.

assistant: # GeometryNodeInputMeshFaceNeighbors(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.GeometryNodeInputMeshFaceNeighbors(*GeometryNode*)
:   Retrieve topology information relating to each face of a mesh

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe Magic from the Blender manual or Python API, including usage steps and snippets.

assistant: # Magic

The Magic Texture node is used to add a psychedelic color texture.
It can be used for “Thin Film Interference” if you set *Mapping*
to *Reflection* and use a relatively high *Turbulence*.
The RGB components are generated independently with a sine formula.

[image reference removed]

Magic Texture panels.
user: Give a detailed overview of BioVision Motion Capture (BVH): syntax, arguments, return values, common patterns.

assistant: # BioVision Motion Capture (BVH)

Imports or exports bvh-files or files with BioVision Hierarchical data
or data of a skeleton (rig) including its animation.
Useful for importing data from motion capture devices.
user: Describe Blend-Files Previews from the Blender manual or Python API, including usage steps and snippets.

assistant: # Blend-Files Previews

A blend-file can store previews, both for itself, and for some of its [data-blocks](../data_blocks.xhtml).
You can disable writing any previews when saving a blend-file using the *Save Preview Images* setting
from the [Save & Load](../../editors/preferences/save_load.xhtml#prefs-save-load) section of the Preferences.
user: Provide the full official documentation entry for Blender 2.9, preserving all code examples.

assistant: - [Blender 2.93 LTS](https://docs.blender.org/manual/en/2.93/)
- [Blender 2.92](https://docs.blender.org/manual/en/2.92/)
- [Blender 2.91](https://docs.blender.org/manual/en/2.91/)
- [Blender 2.90](https://docs.blender.org/manual/en/2.90/)
user: Provide the full official documentation entry for Link Data, preserving all code examples.

assistant: # Link Data

Performs various assignments: adding an object to a scene, giving an object the same
data or modifiers as another, and so on.

When you link two objects to the same data, changes made to one will also appear in the other.
Should you no longer want this, you can use [Making Single User](../../../../files/data_blocks.xhtml#data-system-datablock-make-single-user)
to once again give each object its own data.

Link Objects to Scene
:   Adds the selected objects to the specified scene. Objects can exist in multiple scenes
    at once and have the same position/animation in all of them.

---

Link Object Data
:   Replaces the [object data](../../introduction.xhtml) of the
    selected objects by that of the [active object](../../selecting.xhtml#object-active).

Link Materials
:   Replaces the [materials](../../../../render/materials/introduction.xhtml) of the selected
    objects by those of the active object.

Link Animation Data
:   Replaces the [actions](../../../../animation/actions.xhtml) and [tracks](../../../../editors/nla/tracks.xhtml)
    of the selected objects by those of the active object.

Link Collections
:   Moves the selected objects into the same
    [collections](../../../collections/introduction.xhtml) as the active object.

Link Instance Collection
:   Replaces the [instance collection](../../properties/instancing/collection.xhtml)
    of the selected objects by that of the active object.

Link Fonts to Text
:   Replaces the font of the selected [text objects](../../../../modeling/texts/introduction.xhtml) by that
    of the active text object.

---

Copy Modifiers
:   Replaces the [modifiers](../../../../modeling/modifiers/introduction.xhtml) of the selected objects
    by those of the active object.

Copy Grease Pencil Effects
:   Replaces the [visual effects](../../../../grease_pencil/visual_effects/introduction.xhtml) of the selected
    Grease Pencil objects by those of the active object.

Copy UV Maps
:   Replaces the active [UV map](../../../../editors/uv/introduction.xhtml) of each selected mesh object
    by the active UV map of the active object. If a selected object doesn’t have any UV maps,
    one is created.

    All objects must have matching geometry and face order. You can ensure the latter using
    [Sort Elements](../../../../modeling/meshes/editing/mesh/sort_elements.xhtml), but even then, this operator is really
    only useful if the destination is a deformed copy of the source. Use
    [Transfer Mesh Data](transfer_mesh_data.xhtml) for other cases.

---

Transfer Mesh Data
:   See [Transfer Mesh Data](transfer_mesh_data.xhtml).

Transfer Mesh Data Layout
:   See [Transfer Mesh Data Layout](transfer_mesh_data_layout.xhtml).

---

Link Receivers to Emitter
:   Adds the selected objects to the [Light Linking](../../../../render/lights/light_linking.xhtml)
    collection of the active light object.

Link Blockers to Emitter
:   Adds the selected objects to the [Shadow Linking](../../../../render/lights/light_linking.xhtml)
    collection of the active light object.
user: Show practical ways to work with FModifierGenerator(FModifier) in a Blender add-on or script – include code.

assistant: # FModifierGenerator(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.FModifierGenerator(*FModifier*)
:   Deterministically generate values for the modified F-Curve

    coefficients
    :   Coefficients for ‘x’ (starting from lowest power of x^0)

        Type:
        :   float array of 32 items in [-inf, inf], default (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)

    mode
    :   Type of generator to use

        Type:
        :   enum in [`'POLYNOMIAL'`, `'POLYNOMIAL_FACTORISED'`], default `'POLYNOMIAL'`

    poly_order
    :   The highest power of ‘x’ for this polynomial (number of coefficients - 1)

        Type:
        :   int in [1, 100], default 0

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

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Similarly to other [Filter Tools](../introduction/filters.xhtml),
mask filters are operations that are applied to the whole mask.

Type
:   Smooth/Sharpen Mask
    :   Changes the sharpness of the mask edge.
        Using this can be faster and more consistent than smoothing the mask
        with the [Mask](../brushes/mask.xhtml) brush.

    Grow/Shrink Mask
    :   Further grow or shrink the mask along the surface of the mesh.

    Increase/Decrease Contrast
    :   Changes the contrast of the mask.

In the [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel there are further options
to add iterations for a stronger effect.

Iterations
:   The number of times the filter is applied.

Auto Iteration Count
:   Use an automatic number of iterations based on the number of vertices of the sculpt.
    Disable this option to set the Iterations manually.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`NodeClosureInputItems.new`](bpy.types.NodeClosureInputItems.html#bpy.types.NodeClosureInputItems.new "bpy.types.NodeClosureInputItems.new") - [`NodeClosureInputItems.remove`](bpy.types.NodeClosureInputItems.html#bpy.types.NodeClosureInputItems.remove "bpy.types.NodeClosureInputItems.remove") | - [`NodeClosureOutput.input_items`](bpy.types.NodeClosureOutput.html#bpy.types.NodeClosureOutput.input_items "bpy.types.NodeClosureOutput.input_items") |
user: Give a detailed overview of Triangulate Node: syntax, arguments, return values, common patterns.

assistant: # Triangulate Node

[image reference removed]

The *Triangulate* node converts all faces in a mesh (quads and n-gons) to triangular faces.
It functions the same as the [Triangulate](../../../meshes/editing/face/triangulate_faces.html#bpy-ops-mesh-quads-convert-to-tris) tool in Edit Mode.
user: Explain Extrude Curve and Move in complete detail according to the official Blender documentation.

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

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

### Example

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

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

Then, we extrude a few times:

[image reference removed]

Control points extruded twice
user: Show practical ways to work with Operating System Settings in a Blender add-on or script – include code.

assistant: Make this installation your default Blender (MS-Windows & Linux only).

On Linux, if Blender is installed from a package manager such as Snap,
file association is handled by the package manager.

Register
:   Make the currently in use Blender installation the default
    for generating thumbnails and the default for opening blend-files.

Unregister
:   Remove file association & thumbnailer.

For All Users
:   Register Blender for all users, requires escalated privileges.
user: Show practical ways to work with Usage in a Blender add-on or script – include code.

assistant: [image reference removed]

Curve Pen Preferences

The following preferences can be configured from:
Preferences ‣ Keymap ‣ 3D View ‣ Curve ‣ 3D View Tool: Edit Curve, Curve Pen.

Extrude Point
:   `LMB` click to add a new point connected to an existing point.

Extrude Handle Type
:   The [handle type](../structure.xhtml#curve-bezier-handle-type) of the extruded points.
    Can be either *Vector* or *Auto*.
    However, the handle type switches to *Align* when handles are moved (See *Move Point*).

Delete Point
:   `Ctrl`-`LMB` click on an existing point to delete it.

Insert Point
:   `Ctrl`-`LMB` click on a [Curve Segment](../../../glossary/index.xhtml#term-Curve-Segment) to insert a new control point between the two
    adjacent control points. `Ctrl`-`LMB` click and drag to control the handles of the inserted points.

Move Segment
:   `LMB` drag on a segment in between two control points to adjust the handles, changing the shape of the
    curve without affecting the location of any control points.

Select Point
:   `LMB` click to select a single point or handle at a time.

Move point
:   `LMB` drag to move existing points or handles. With an endpoint of a spline selected,
    click and drag on empty space to *Extrude Point* and move the handle at the same time.

Close Spline
:   Make the spline [Cyclic](../../../glossary/index.xhtml#term-Cyclic) by clicking the endpoints consecutively.

Close Spline Method
:   The condition for *Close Spline* to activate.

    None:
    :   Turn off the Close Spline functionality.

    On Press:
    :   Close the spline on mouse down. With this option, you may click and drag to adjust the handles of the endpoint.

    On Click:
    :   Activate on mouse release. With this option, the *Close Spline* functionality will not be
        triggered on click and drag.

Toggle Vector
:   Double `LMB` click on a handle to switch handle between *Vector* and *Auto* handle types.
    Can be used to easily switch between sharp corners and smooth curves.

Cycle Handle Type
:   Double `LMB` click on the control point to cycle through all handle types.
user: Provide the full official documentation entry for – Material Preview, preserving all code examples.

assistant: Render the 3D Viewport with [EEVEE](../../../render/eevee/introduction.xhtml) and an HDRI environment.
This mode is particularly suited for previewing materials and painting textures.
You can select different lighting conditions to test your materials.

### Lighting

Scene Lights
:   Use the lights in the scene. When disabled (or when the scene contains no lights),
    a virtual light is used instead.

Scene World
:   Use the World of the scene.
    When disabled, a world will be constructed with the following options:

    HDRI Environment
    :   The environment map used to light the scene.

    Rotation
    :   The rotation of the environment on the Z axis.

        World Space Lighting
        :   Makes the lighting rotation fixed and not follow the camera.

    Strength
    :   Light intensity of the environment.

    World Opacity
    :   Opacity of the HDRI as a background image in the viewport.

    Blur
    :   Factor to unfocus the HDRI.
        Note that this does not change the diffusion of the lighting,
        only the appearance of the background.

Render Pass
:   Instead of the combined render, show a specific
    [render pass](../../../render/layers/passes.xhtml).
    Useful to analyze and debug geometry, materials and lighting.

Compositor
:   When to preview the result of [compositing](../../../compositing/introduction.xhtml) in the 3D Viewport.

    Disabled:
    :   Never show the compositing output.

    Camera:
    :   Only show the compositing output when in [Camera View](../navigate/camera_view.xhtml),
        which gives the best vantage point for previewing the final result.

    Always:
    :   Always show the compositing output.
user: Describe Swap from the Blender manual or Python API, including usage steps and snippets.

assistant: The *Swap* operator replaces the selected node with another node type chosen from the menu.

All existing links are automatically reconnected where possible,
matching input and output sockets by name and type.
If a connection cannot be matched, it is left unconnected.
user: Provide the full official documentation entry for Bone Colors, preserving all code examples.

assistant: Bones can be individually colored. You can either choose a color set from the predefined
[theme](../../../../editors/preferences/themes.xhtml#bpy-types-theme) list or define a custom one.

[image reference removed]

When selecting *Custom Color Set*, you need to define three colors:
Regular (for when the bone is not selected), Selected, and Active.

You can temporarily disable all the color assignments by unchecking
[Bone Colors](../../properties/display.xhtml#bpy-types-armature-show) in the armature’s Viewport Display panel.

Bone Color
:   The bone’s primary color, affecting both Edit Mode and Pose Mode.

    This color is stored on the armature data-block, so that if you have
    multiple armature objects that share this data-block, they will all use
    the same color.

    Copy Bone Color to Selected
    :   Copy the bone color of the [Active](../../../../glossary/index.xhtml#term-Active) bone to all selected bones.

Pose Bone Color Pose Mode
:   Lets you optionally override the above *Bone Color* in Pose Mode
    (by setting it to something else than *Default Colors*).

    This color is stored on the [Pose Bone](../../../../glossary/index.xhtml#term-Pose-Bone), meaning it can be different
    in every armature object – even ones that reference the same data-block.

    Copy Bone Color to Selected
    :   Copy the bone color of the [Active](../../../../glossary/index.xhtml#term-Active) bone to all selected bones.
user: Give a detailed overview of Edit an Override: syntax, arguments, return values, common patterns.

assistant: Essentially, an override is edited the same way as a regular local data-block.
You can use operators on them, edit their properties from various editors, etc.
There are some limitations however, most notably Edit Mode is not allowed for overrides.
In most cases, as soon as you edit a property, you can see that it’s overridden by its teal blue
outline/background.

You can also animate overrides, animated properties just replace/supersede overrides then.
Note that you cannot override/edit an existing animation, you’ll have to create a new action.
You can manually define or remove an override from the context menu of the relevant property.
If an override is not editable, you have to make it editable first.

### Add Overrides

Mark a property to be overridden in the local blend file. For array properties
all elements will be overridden.

### Add Single Override

Mark a property to be overridden in the local blend file. For array properties only
the selected element will be overridden.

### Remove Overrides

Remove the property from the overrides. The value of the linked in data-block will be used.
For array properties all elements will be removed from the override.

### Remove Single Override

Remove the property from the overrides. The value of the linked in data-block will be used.
For array properties only the selected elements will be removed from the override.