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

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

    default_value
    :   Input value used for unconnected socket

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

    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: Show practical ways to work with Wrap Methods in a Blender add-on or script – include code.

assistant: ### Nearest Surface Point

This will select the nearest point over the surface of the shrunk target.

### Project

[image reference removed]

Project mode.

This will project vertices along a chosen axis until they touch the shrink target.
Vertices that never touch the shrink target are left in their original position.

Limit
:   This is a distance limit between original point and surface.
    If the distance is larger than this limit point would not be projected onto the surface.

Subdivision Levels
:   This applies a (temporary) *Catmull-Clark* subdivision to the modified object’s geometry,
    before computing the wrap.

Axis
:   Along which local axis of the modified object the projection is done.
    These options can be combined with each other, yielding a “median axis” of projection.
    If none are selected, the normal direction is used.

Negative/Positive
:   This allows you to select the allowed direction(s) of the shrink along the selected axis.
    If both options are enabled, both ways are evaluated and the closest hit is selected.

Face Cull
:   Allows you to prevent any projection over the “front side”
    (respectively the “back side”) of the target’s faces. The “side” of a face is determined
    by its normal (front being the side “from where” the normal “originates”).

Invert Cull
:   If *Cull Faces* is enabled, and *Negative* direction along axis is allowed,
    this option can be used to invert the *Front* or *Back* cull choice
    for the *Negative* direction. This is useful when projecting in both directions.

Auxiliary Target
:   An additional object to project over.

### Nearest Vertex

This will snap vertices to the nearest vertex of the shrunk target. It adds no extra options.

This method doesn’t support the *Snap Mode* setting.

### Target Normal Project

This mode is similar to *Nearest Surface Point*, but produces a much smoother
projection in return for being significantly slower.

Instead of finding the closest point, it searches for the nearest point
that has its interpolated smooth normal pointing towards or away from the original point position.
Non-manifold boundary edges are specially handled as infinitely thin cylinders
that emit normals in all perpendicular directions; ignores flat shading.
user: Show practical ways to work with Rename Active Item in a Blender add-on or script – include code.

assistant: The *Rename Active Item* operator renames the active
[Bone](../../animation/armatures/bones/index.xhtml),
[Node](../../interface/controls/nodes/index.xhtml),
[Object](../../scene_layout/object/index.xhtml) and
[Sequence Strip](../../video_editing/edit/montage/strips/index.xhtml).

When the operator is executed, a pop-up dialog appears.
The text field shows the name of the current item and can be overwritten to rename the item.
`Return` confirms the name while `Esc` cancels the operator.
user: What is Socket Syncing and how is it used in Blender Python scripting?

assistant: Closure nodes use socket names to match their inputs and outputs.
If two closure nodes are connected but have mismatched signatures, Blender can offer to sync them automatically.

- Sync happens automatically when a node is connected for the first time.
- Existing sockets are never changed automatically to avoid overwriting user data.
- A  button (*Sync Sockets*) button appears in the node header when a mismatch is detected, allowing manual synchronization.
user: How do I use Stereo 3D Camera in Blender? Include parameters, examples, warnings and best practices.

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: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`BlendData.workspaces`](bpy.types.BlendData.html#bpy.types.BlendData.workspaces "bpy.types.BlendData.workspaces") - [`Context.workspace`](bpy.types.Context.html#bpy.types.Context.workspace "bpy.types.Context.workspace") | - [`Window.workspace`](bpy.types.Window.html#bpy.types.Window.workspace "bpy.types.Window.workspace") |
user: What is Options and how is it used in Blender Python scripting?

assistant: [image reference removed]

Two different caches stored simultaneously.

Caches List
:   Blender allows for storing and managing multiple caches at once for the same physics object.
    You can manage the caches with this [list view](../interface/controls/templates/list_view.xhtml#ui-list-view).
    Double-click the cache entry to give it a name.

    Each cache can have a name. Double-click the cache entry to give it a name.
    If this name is given, any disk cache will be stored in files starting with that name.
    For example, a cache named `MyCache` will be stored in `MyCache_xxxxxx_yy.bphys`.

    If the cache does not have a name (which is the default),
    the filename of the cache will depend on the object it is attached to,
    although this is not immediately obvious. For example, a cache on
    an object `Cube` will be stored in `43756265_xxxxxx_yy.bphys`,
    where `43756265` is determined by the object name.

External
:   Allows you to read the cache from a drive using a user-specified file path.

    Index
    :   The index number of cache files. (The last two digits of the files name.)

    Path
    :   Select the directory path to the cache files.

Disk Cache
:   The cache of a baked simulation will be stored inside the blend-file when you save it.
    When *Disk Cache* is checked, Blender will save the cache separately to
    the drive in a folder named `blendcache_[filename]` alongside the blend-file.
    (The blend-file must be saved first.)

Use Library Path
:   Share the disk cache when the physics object is
    [linked](../files/linked_libraries/index.xhtml) into another blend-file.
    When this option is enabled, linked versions of the object will reference the same disk cache.
    Otherwise linked versions of the object will use independent caches.

Start
:   Frame on which to start the simulation.

End
:   Frame on which to stop the simulation.

Cache Step
:   Interval for storing simulation data.
user: How do I use Smooth in Blender? Include parameters, examples, warnings and best practices.

assistant: Softens strokes by reducing the differences in the locations of the points along the line,
while trying to maintain similar values that make the line fluid and smoother.

Iterations
:   The number of times to repeat the procedure.

Factor
:   The amount of the smoothness to apply.

Smooth Endpoints
:   Smooths the stroke’s endpoints.

Keep Shape
:   Preserves the strokes shape.

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

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

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

assistant: With *Alpha Under*, this is the contrary:
The first strip selected is the foreground, and the second one, the background.
Moreover, the *Opacity* controls the transparency of the *background*, i.e. an *Opacity* of 0.0;
will only show the foreground (the background is completely transparent),
and an *Opacity* of 1.0 will give the same results as with *Alpha Over*.
user: What is Attribute Domains and how is it used in Blender Python scripting?

assistant: The domain of an attribute refers to what type of geometry element the attribute corresponds to.
Knowing the domain of an attribute is important because it defines how it may be interpolated and
used in nodes and shading. You can use the [Spreadsheet Editor](../../editors/spreadsheet.xhtml)
to determine the domains of attributes.

- **Point** domain attributes are associated with single locations in space with a position:
  :   - Vertices of a mesh
      - Points of a point cloud
      - Curve control points
- **Edge** domain attributes are associated with the edges of a mesh.
- **Face** domain attributes are associated with the faces of a mesh.
- **Face Corner** domain attributes are associated with the corners of the faces of the mesh.
  An example is a UV map attribute.
- **Spline** domain attributes are associated with a group of connected
  curve control points.
- **Instance** domain attributes exist on the [Instances](instances.xhtml) in a geometry.
  They can be used to store different values on copies of geometry data. Instance domain attributes are
  only supported in geometry nodes.
- **Layer** domain attributes are associated with a [Grease Pencil Layer](../../grease_pencil/properties/layers.xhtml).

Attributes are automatically interpolated to other domains. For example, when the
[Position Node](geometry/read/position.xhtml) is connected to the selection input of
the [Set Material Node](geometry/material/set_material.xhtml) node, the values are interpolated
from the *Point* domain to the *Face* domain. Normally, domain conversions use simple averages
for values, but *Boolean* data type attributes have special rules for interpolation:

### Boolean Domain Interpolation

| From | To | Conversion |
| --- | --- | --- |
| Point | Edge | An edge is selected if both of its vertices were selected. |
| Point | Face | A face is selected if all of its vertices were selected too. |
| Point | Corner | Each corner’s value is simply a copy of the value at its vertex. |
| Point | Spline | A spline is selected if all of its control points were selected. |
|  |  |  |
| Edge | Point | A vertex is selected if any connected edge was selected. |
| Edge | Face | A face is selected if all of its edges are selected. |
| Edge | Corner | A corner is selected if its two adjacent edges were selected. |
|  |  |  |
| Face | Point | A vertex is selected if any of the connected faces were selected. |
| Face | Edge | An edge is selected if any connected face was selected. |
| Face | Corner | Each corner’s value is simply a copy of the value at its face. |
|  |  |  |
| Corner | Point | A vertex is selected if all connected face corners were selected and it is not a loose vertex. |
| Corner | Edge | An edge is selected if all corners on adjacent faces were selected. |
| Corner | Face | A face is selected if all of its corners were selected. |
|  |  |  |
| Spline | Point | Each point’s value is simply a copy of the corresponding value of the spline. |
user: What is Image Coordinates Node and how is it used in Blender Python scripting?

assistant: # Image Coordinates Node

[image reference removed]

The *Image Coordinates* node outputs various coordinate fields for an input image.
These outputs provide information about each pixel’s location in different coordinate spaces,
which can be useful for procedural texturing, compositing effects, or image-based masking.

The coordinate outputs are calculated per pixel based on the image resolution and placement
within the compositor’s virtual space.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Curve
:   Standard geometry input, containing curves.

Selection
:   Whether or not to change the value on each curve.

Mode
:   The method for evaluation of the curve’s normals

    Minimum Twist:
    :   The final normals are calculated to have the smallest twist around
        the curve tangent across the whole curve.

    Z-Up:
    :   The final normals are calculated so that they are perpendicular to the Z axis and the tangent.
        If a series of points is vertical, the X axis is used.

    Free:
    :   Use the stored custom normal attribute (`custom_normal`) as the final normals.

        This mode adds a *Normal* input that can be used to set the value of the custom normal.

Normal Free
:   Input for the custom normal attribute (`custom_normal`) when using *Free* mode.
user: Describe Symmetry from the Blender manual or Python API, including usage steps and snippets.

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: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Mesh
:   The resulting mesh extracted from the grid’s isosurface.
    The mesh follows the region where the grid’s scalar values equal the
    specified *Threshold*, and can be used for further geometry processing or rendering.
user: How do I use BlendDataFonts(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # BlendDataFonts(bpy_struct)

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

*class* bpy.types.BlendDataFonts(*bpy_struct*)
:   Collection of fonts

    load(*filepath*, *\**, *check_existing=False*)
    :   Load a new font into the main database

        Parameters:
        :   - **filepath** (string, (never None, blend relative `//` prefix supported)) – path of the font to load
            - **check_existing** (*boolean**,* *(**optional**)*) – Using existing data-block if this file is already loaded

        Returns:
        :   New font data-block

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

    remove(*vfont*, *\**, *do_unlink=True*, *do_id_user=True*, *do_ui_user=True*)
    :   Remove a font from the current blendfile

        Parameters:
        :   - **vfont** ([`VectorFont`](bpy.types.VectorFont.html#bpy.types.VectorFont "bpy.types.VectorFont"), (never None)) – Font to remove
            - **do_unlink** (*boolean**,* *(**optional**)*) – Unlink all usages of this font before deleting it
            - **do_id_user** (*boolean**,* *(**optional**)*) – Decrement user counter of all data-blocks used by this font
            - **do_ui_user** (*boolean**,* *(**optional**)*) – Make sure interface does not reference this font

    tag(*value*)
    :   tag

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Topology
:   The reference grid whose voxel layout, resolution, and transform define
    where the input fields will be evaluated.

Additional input sockets can be added for each field to be evaluated.
Each field defines a scalar or vector value to sample on the topology grid.

Fields can be added by dragging them into the blank socket area.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Mesh Cache Modifier.

Format
:   Specifies the input file format. The modifier currently supports `.mdd` and `.pc2`.

File Path
:   Path to the external cache file containing the animation data.

Influence
:   Controls the strength of the deformation. Lower values blend the cached animation with the original mesh shape.

Deform Mode
:   Determines how the cache data influences the mesh:

    Overwrite:
    :   Replaces vertex positions with those from the cache file.

    Integrate:
    :   Blends the cache deformation with existing deformations, such as shape keys or modifiers.

Interpolation
:   Controls how frames between cache data are handled:

    None:
    :   Uses only the raw frame data from the cache without interpolation.

    Linear:
    :   Blends between frames for smoother transitions, useful when cache frames do not align perfectly with the scene
        frames.

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

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

        The setting reverses the weight values of the group.

### Time Remapping

Time Mode
:   Defines how animation time is interpreted:

    Frame:
    :   Ignores timing data from the cache and plays back frames directly.
        This mode provides direct control over playback speed.

    Time:
    :   Uses the cache’s timing data, including offsets and frame durations.

    Factor:
    :   Maps the entire animation to a range between `0` and `1` for precise control.

Play Mode
:   Specifies how playback timing is determined:

    Scene:
    :   Uses the scene’s current frame for playback.

        Frame Start
        :   Defines the starting frame for playback.

        Frame Scale
        :   Adjusts the playback speed by scaling time.

    Custom:
    :   Allows manual control of animation timing.

        Evaluation Value
        :   Determines animation playback position, which can be animated for precise control.

### Axis Mapping

Forward/Up Axis
:   Specifies the forward and up axes of the imported animation, ensuring proper orientation.

Flip Axis
:   Flips the animation along a chosen axis if the imported data requires correction.
user: Show practical ways to work with ShaderNodeMixShader(ShaderNode) in a Blender add-on or script – include code.

assistant: # ShaderNodeMixShader(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.ShaderNodeMixShader(*ShaderNode*)
:   Mix two shaders together. Typically used for material layering

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: There are several transformation operations included in Blender.
Here are some of the main operations available:

### Move

This operations allows you to move elements along the X, Y, and Z axes in the scene.

### Rotate

You can use this function to rotate elements around the X, Y, and Z axes.

### Scale

Scaling allows you to increase or decrease the size of an object along the X, Y, and Z axes.

### Align to View

This is useful for aligning objects with the view from the camera or another specific viewpoint.

### Mirror

Mirrors objects along one or more axes.
user: Describe GeometryNodeRotateInstances(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeRotateInstances(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.GeometryNodeRotateInstances(*GeometryNode*)
:   Rotate geometry instances in local or global space

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

assistant: # Import OBJ Node

[image reference removed]

The *Import OBJ* node loads geometry data from a .obj file and outputs it as instances.

Each object defined in the OBJ file is imported as a separate instance,
which helps to preserve scene structure and optimize performance.
This approach allows for efficient manipulation and reuse of the geometry within Geometry Nodes workflows.

This node is useful for importing static 3D assets created in other modeling software.
user: Provide the full official documentation entry for Mesh Island Node, preserving all code examples.

assistant: # Mesh Island Node

[image reference removed]

The *Mesh Island* node outputs information about separate connected regions, or “islands” of a mesh.
Whenever two vertices are connected together by an edge, they are considered as part of the same island,
and will have the same *Island Index* output.

This node’s behavior is similar to the [Select Linked](../../../meshes/selecting/linked.xhtml#bpy-ops-mesh-select-linked) operator
in edit mode, or the *Random per Island* output of the
[Geometry shader node](../../../../render/shader_nodes/input/geometry.xhtml).
user: Describe Shadow from the Blender manual or Python API, including usage steps and snippets.

assistant: EEVEE uses a technique called *Virtual Shadow Mapping* along with *Shadow Map Raytracing*.
*Virtual Shadow Mapping* produces more accurate results than traditional shadow mapping by putting resolution
only where it is needed. It also includes a very efficient caching mechanism.
This technique offers better performance than ray tracing and is compatible
with any [Render Method](material_settings.xhtml#bpy-types-material-surface-render-method).

Jitter
:   Enable jittered soft shadows to increase shadow precision.
    Has a high performance impact as the shadow map cannot be cached and needs to be updated for each render sample.

Overblur
:   Apply shadow tracing to each jittered sample to reduce under-sampling artifacts.

Filter
:   Blur shadow aliasing using PCF with a circular kernel.
    The effective world scale of the filter depends on the shadow map resolution at the shadowed pixel position.

Resolution Limit
:   Minimum size of a shadow map pixel. Higher values use less memory at the cost of shadow quality.
    Higher values also speed-up rendering of heavy scenes.
    Each shadow is scaled depending on the shadowed pixel on screen. This can create very sharp shadows
    but also requires a lot of memory if the shadowed pixel is close to the camera.
    This property limits the maximum amount of detail that the shadow map can capture.

Absolute Resolution Limit
:   Limit the resolution at 1 unit from the light origin instead of relative to the shadowed pixel.
    This makes [Resolution Limit](#bpy-types-light-shadow-maximum-resolution)
    act as a regular shadow map pixel size.
user: Explain Group Input Node in complete detail according to the official Blender documentation.

assistant: # Group Input Node

[image reference removed]

The *Group Input* node provides access to input sockets of a node group.
It acts as the entry point for data passed into the group from the outside,
such as images, values, or other data types.

Additional input sockets can be added or removed from the *Group Input* node
through the *Group* panel in the Sidebar or by using the group interface editor
in the Node Editor header. When the node group is used in another compositor tree,
the sockets defined in *Group Input* appear as input sockets on the *Group* node itself.
user: What is Action Strips and how is it used in Blender Python scripting?

assistant: An action strip plays the keyframes inside an [action](../../animation/actions.xhtml).
You can create one using Add ‣ Action. Another way is to click
[Push Down Action](tracks.xhtml#bpy-ops-nla-action-pushdown) in the NLA’s Action Track –
this will create a strip based on the object’s active action.

Multiple strips can reference the same action, so that you can potentially change
multiple parts of the animation by editing a single set of keyframes.

A strip can be shorter than its underlying action, be it through cropping,
speeding up, or both. It can also be longer than its underlying action,
be it through extending, slowing down, or both. See the
[Sidebar](sidebar.xhtml#nla-sidebar-action-clip) for details.
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Data Type
:   The [data type](../../attributes_reference.xhtml#attribute-data-types) to use for the retrieved values.

Domain
:   The [attribute domain](../../attributes_reference.xhtml#attribute-domains) that the attribute is transferred from, or in other words,
    the domain used to evaluate the *Attribute* input. For example, it is possible to transfer data from the
    faces of one geometry to the points of another.

Clamp
:   Clamp the indices to the size of the attribute domain instead of outputting a default value for invalid indices.
user: What is Perspective/Orthographic and how is it used in Blender Python scripting?

assistant: # Perspective/Orthographic

This operator changes the projection of the viewport camera.
Each 3D Viewport supports two different types of projection.
These are demonstrated in the Fig. below.

|  |  |
| --- | --- |
| <../../../_images/editors_3dview_navigate_projections_view-orthographic.png>   Orthographic projection. | <../../../_images/editors_3dview_navigate_projections_view-perspective.png>   Perspective projection. |

Our eyes are used to perspective viewing where distant objects appear smaller.
Orthographic projection often seems a bit odd at first,
because objects stay the same size regardless of their distance.
It is like viewing the scene from an infinitely distant point.
Nevertheless, orthographic viewing can be very useful,
because it provides a more “technical” insight into the scene,
making it easier to model and judge proportions.
user: Give a detailed overview of Outputs: syntax, arguments, return values, common patterns.

assistant: Grid
:   The resulting grid with all active tiles converted into individual voxels.

    For fog volumes, this means that interior sparse tiles are expanded into
    voxels with individually adjustable values. For SDF grids, this produces a
    fully dense voxel representation suitable for precise sampling and editing.
user: What is Should I Translate... ? and how is it used in Blender Python scripting?

assistant: ### Maybe

Hyperlinks
:   May be translated, but only as an addition, not as a replacement.
    Keep the original link text and add the translation alongside.
    See also [Adding Text](#adding-text).

Technical Terms
:   Translate only if the localized expression is commonly used and well understood.
    Otherwise, keep the English term.
    See also [Technical Terms](#technical-terms).

Unclear Text
:   If you are not sure you understood the meaning, mark the text as *fuzzy* and/or add a translator comment.
    Another translator may be able to clarify it.

UI Elements
:   UI elements should use the same translation as in Blender’s user interface.
    If the UI element has not yet been translated, keep the English term
    and add the translation in parentheses.

### Never

Images
:   You probably will not find the original scene if it is a screenshot of a file and it is too much load on the server
    (and too much work for you).
user: How do I use TextureNodeCurveTime(TextureNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # TextureNodeCurveTime(TextureNode)

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

*class* bpy.types.TextureNodeCurveTime(*TextureNode*)
:   curve
    :   Type:
        :   [`CurveMapping`](bpy.types.CurveMapping.html#bpy.types.CurveMapping "bpy.types.CurveMapping"), (readonly)

    *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 NlaTracks(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NlaTracks(bpy_struct)

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

*class* bpy.types.NlaTracks(*bpy_struct*)
:   Collection of NLA Tracks

    active
    :   Active NLA Track

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

    new(*\**, *prev=None*)
    :   Add a new NLA Track

        Parameters:
        :   **prev** ([`NlaTrack`](bpy.types.NlaTrack.html#bpy.types.NlaTrack "bpy.types.NlaTrack"), (optional)) – NLA Track to add the new one after

        Returns:
        :   New NLA Track

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

    remove(*track*)
    :   Remove a NLA Track

        Parameters:
        :   **track** ([`NlaTrack`](bpy.types.NlaTrack.html#bpy.types.NlaTrack "bpy.types.NlaTrack"), (never None)) – NLA Track to remove

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Holdout

[image reference removed]

The *Holdout* shader node is used to create a “hole” in the image with zero alpha
transparency, which is useful for compositing (see [Alpha Channel](../../../glossary/index.xhtml#term-Alpha-Channel)).
user: What is Attributes and how is it used in Blender Python scripting?

assistant: Layers can store [Custom Attributes](../../modeling/geometry_nodes/attributes_reference.xhtml).
The attributes are stored on the [Layer](../../modeling/geometry_nodes/attributes_reference.xhtml#attribute-domains) domain.

For example, the [Layer Adjustments](layers.xhtml#layer-adjustments) are stored as layer attributes.

Attributes
:   [List view](../../interface/controls/templates/list_view.xhtml#ui-list-view) of all the attributes stored on the layers.

    Name
    :   Name of the layer attribute.

    Data Type
    :   The [Data Type](../../modeling/geometry_nodes/attributes_reference.xhtml#attribute-data-types) of the attribute.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Maintain Volume constraint.

Mode
:   Specifies how the constraint handles scaling of the non-free axes.

    Strict:
    :   Adjusts the scales of the non-free axes so that the volume is always exactly maintained.
        Scaling up the free axis will scale down both non-free axes. Scaling up a non-free axis
        will scale down the other non-free axis.

    Uniform:
    :   Unlike *Strict*, this mode only maintains the volume correctly as long as the object
        is scaled equally along all three axes.

        Scaling up the free axis alone will also scale down the non-free axes, but
        in an exaggerated manner that results in a loss of volume. As such, this is
        not recommended.

        Scaling up a non-free axis has no effect on the other non-free axis. This
        makes it possible to deviate from the target volume.

    Single Axis:
    :   Similar to *Uniform*, except the mode only maintains the volume correctly as long
        as the object is scaled purely along the free axis. Because only one axis needs to
        be adjusted to keep the volume instead of three, this may reduce the number of
        animation curves needed.

        Changing the scale of a non-free axis again has no effect on the other non-free axis.

Free Axis
:   The axis that should keep its user-specified scale. The other two (non-free) axes will
    be adjusted to maintain the volume.

Volume
:   The target volume as a ratio of the original volume (when all axes have a scale of 1).

    If all three axes have a default scale of 2 and this should be maintained, *Volume* should
    be set to 2×2×2 = 8.

[Owner](../interface/common.xhtml#rigging-constraints-interface-common-space)
:   The space for determining and adjusting the scale of the owner.

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: Describe MovieReconstructedCamera(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # MovieReconstructedCamera(bpy_struct)

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

*class* bpy.types.MovieReconstructedCamera(*bpy_struct*)
:   Match-moving reconstructed camera data from tracker

    average_error
    :   Average error of reconstruction

        Type:
        :   float in [-inf, inf], default 0.0, (readonly)

    frame
    :   Frame number marker is keyframed on

        Type:
        :   int in [-inf, inf], default 0, (readonly)

    matrix
    :   Worldspace transformation matrix

        Type:
        :   [`mathutils.Matrix`](mathutils.html#mathutils.Matrix "mathutils.Matrix") of 4 \* 4 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)), (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: Describe LineStyleGeometryModifier_SinusDisplacement(LineStyleGeometryModifier) from the Blender manual or Python API, including usage steps and snippets.

assistant: # LineStyleGeometryModifier_SinusDisplacement(LineStyleGeometryModifier)

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

*class* bpy.types.LineStyleGeometryModifier_SinusDisplacement(*LineStyleGeometryModifier*)
:   Add sinus displacement to stroke backbone geometry

    amplitude
    :   Amplitude of the sinus displacement

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    phase
    :   Phase of the sinus displacement

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

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Geometry Modifier Type Items](bpy_types_enum_items/linestyle_geometry_modifier_type_items.html#rna-enum-linestyle-geometry-modifier-type-items), default `'2D_OFFSET'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

    wavelength
    :   Wavelength of the sinus displacement

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.LineStyleGeometryModifier_SinusDisplacement.type "bpy.types.LineStyleGeometryModifier_SinusDisplacement.type")
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Radius
:   Width of the bevel effect on edges.

Normal
:   Normal to apply bevel on top of, to be combined with a [Bump Node](../displacement/bump.html)
    for example. When not connected, uses the surface normal.
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: SDF Grid
:   A float grid representing the signed distance field of the mesh.
    Each voxel contains the shortest signed distance to the nearest surface
    point of the mesh, with negative values inside and positive values outside.
user: Give a detailed overview of Separate Bones: syntax, arguments, return values, common patterns.

assistant: # Separate Bones

You can, as with meshes, separate the selected bones in a new armature object
Armature ‣ Separate, `Ctrl`-`Alt`-`P` and of course,
in *Object Mode*, you can join all selected armatures in one
Object ‣ Join Objects, `Ctrl`-`J`.
user: Give a detailed overview of OperatorProperties(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # OperatorProperties(bpy_struct)

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

*class* bpy.types.OperatorProperties(*bpy_struct*)
:   Input properties of an operator

    bl_system_properties_get(*\**, *do_create=False*)
    :   DEBUG ONLY. Internal access to runtime-defined RNA data storage, intended solely for testing and debugging purposes. Do not access it in regular scripting work, and in particular, do not assume that it contains writable data

        Parameters:
        :   **do_create** (*boolean**,* *(**optional**)*) – Ensure that system properties are created if they do not exist yet

        Returns:
        :   The system properties root container, or None if there are no system properties stored in this data yet, and its creation was not requested

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

    *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