PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is Inputs and how is it used in Blender Python scripting?

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

Factor
:   Controls the overall strength of the clumping effect.
    A value of 0.0 applies no clumping, while 1.0 fully pulls curves toward their guides.

Shape
:   Defines how the clumping influence changes along the length of each curve.
    A value of 0.0 applies a constant strength, while 0.5 results in a linear falloff from root to tip.

Tip Spread
:   Adds random variation to the positions of curve tips,
    preventing perfect convergence and helping clumps look more natural.

Clump Offset
:   Applies a random directional offset to entire clumps, introducing subtle variation between groups.

Distance Falloff
:   Defines how the influence of each guide curve decreases with distance.
    A value of 0.0 disables distance-based falloff, making all nearby curves equally affected.

Distance Threshold
:   Sets the maximum distance from a guide at which clumping has an effect.
    Curves farther than this threshold will not be influenced by that guide.

Seed
:   Controls the randomization used for offsets and variation.
    Changing this value alters the random distribution of clumping while keeping the same parameters.

Preserve Length
:   When enabled, maintains the original length of each curve during deformation.
    When disabled, curves may stretch or shrink slightly as they are pulled toward guides.

### Guide Map

Guide Index
:   A map that specifies which guide curve acts as the center for each clump.
    If provided, this takes priority over any existing `guide_curve_index` attribute,
    and the *Guide Distance* and *Guide Mask* inputs are ignored.

Guide Distance
:   The minimum distance between selected guide curves when generating a new guide map.
    Larger values produce fewer, larger clumps.

Guide Mask
:   Defines which curves can be used as guides during automatic guide map creation.

Existing Guide Map
:   When enabled, uses the existing guide map attribute if it is already available.
    If disabled and *Guide Index* is not provided, a new
    [guide map](create_guide_index_map.xhtml)
    is generated using *Guide Distance* and *Guide Mask*.
    Creating the guide map separately allows for finer control over guide placement and grouping.
user: Provide the full official documentation entry for Marker Display, preserving all code examples.

assistant: Determines how markers are displayed in the editor.

Pattern
:   Whether to show the pattern areas of tracks. Can be used to reduce clutter and
    check how good tracking is.

Search `Alt`-`S`
:   Whether to show the search areas of *selected* tracks. Can be used to reduce clutter and
    check how good tracking is.

Path
:   Shows past (red) and future (blue) positions of tracks relative to the current frame,
    visualizing how they move. This makes it easier to spot irregularities.

Length
:   Length (in frames) of the *Path*.

Show Disabled `Alt`-`D`
:   When unchecked, hides the tracks that are disabled on the current frame
    (except for the active track, i.e. the one that was selected last).
    This helps to make the view more clear and see if the tracking is accurate enough.

Info
:   Displays the name and status of each selected track.
    The status can be “keyframed,” “tracked,” “disabled” and so on.

3D Markers
:   Shows the result of [solving](../../../movie_clip/tracking/clip/toolbar/solve.xhtml) the
    markers’ 3D locations based on their 2D movement. Each 3D location is projected
    back to the movie clip and displayed as a small point, which is colored green if
    it’s close to the original 2D marker (meaning a good solve) or red if it’s far away
    (meaning it needs to be tweaked).

Display Thin
:   By default, marker areas are displayed as bright boxes with a black outline.
    This option displays them using thin dashed lines instead.
user: Describe Straighten Hair Curves from the Blender manual or Python API, including usage steps and snippets.

assistant: # Straighten Hair Curves

The *Straighten Hair Curves* node aligns the points of each hair curve along a straight line
between its root and tip.
This can be used to relax curly or noisy hair, create stylized grooms, or prepare curves
for further deformation or simulation.
user: Provide the full official documentation entry for Common Problems, preserving all code examples.

assistant: ### Unsupported Graphics Driver Error

This means your graphics card and driver do not have the minimum required OpenGL 3.3 version needed by Blender.

Installing the latest version of the correct driver can help upgrade the OpenGL version, though some graphics cards
are simply too old to run the latest Blender. In such cases, using Blender 2.79 or earlier is the only option.
Starting with Blender 2.8 (which added EEVEE), there is less support for older graphics hardware.

### Crash on Startup

Try running Blender from the [command line](../../../advanced/command_line/index.xhtml), to see if any helpful error messages
are printed.

On Windows, graphics drivers can sometimes get corrupted or incorrectly replaced by Windows Update. In this case, it
can help to uninstall all graphics drivers (there may be multiple sets installed from Intel, AMD and NVIDIA) and
perform a clean installation with drivers from the manufacturer’s website.

### Poor Performance

- Update your graphics drivers (see above).
- On laptops, make sure you are using a dedicated GPU (see above).
- Try lowering quality settings in Preferences ‣ System ‣ Memory & Limits.
- Try undoing settings in your graphics drivers, if you made any changes there.

### Render Errors

See [EEVEE](../../../render/eevee/limitations/index.xhtml) and [Cycles](../../../render/cycles/gpu_rendering.xhtml) documentation
respectively.

### Wrong Selection in 3D Viewport

See [Invalid Selection, Disable Anti-Aliasing](../../3d_view.xhtml#troubleshooting-3dview-invalid-selection).

### Virtual Machines

Running Blender inside a virtual machine is known to have problems when OpenGL drawing calls are forwarded to the host
operating system.

To resolve this, configure the system to use PCI passthrough.

Some VM hosts may require turning on GPU paravirtualization. Some GPU vendors restrict this function to higher-priced
cards or models.
user: Give a detailed overview of Outputs: syntax, arguments, return values, common patterns.

assistant: Volume
:   The resulting volume geometry after optionally removing the retrieved grid.

Grid
:   The extracted grid corresponding to the given *Name* and *Data Type*.
    This grid can be passed to other nodes such as
    [Sample Grid](../sample/sample_grid.xhtml) or
    [Grid to Mesh](../operations/grid_to_mesh.xhtml)
    for further manipulation or conversion.
user: What is Shortest Path and how is it used in Blender Python scripting?

assistant: Selects all the UV elements along the shortest path between two elements: the two selected elements when
activated using the menu, or the active one and the clicked one when activated using the shortcut.

Face Stepping
:   For vertices: allows the path to step across faces, following their diagonal rather than
    their edges.

    For edges: selects disconnected edges that are perpendicular to the path (edge ring),
    rather than connected edges along the path (edge loop).

    For faces: allows the path to go through faces that only share a vertex, rather than an edge.

Topology Distance
:   Calculates the distance by simply counting edges rather than measuring their lengths.

Fill Region `Shift`-`Ctrl`-`LMB`
:   Selects all shortest paths (rather than just one).

Dashed Line Options
:   Allows to only select elements at regular intervals, creating a “dashed line” rather
    than a continuous one.

    Deselected
    :   The number of deselected elements in the repetitive sequence.

    Selected
    :   The number of selected elements in the repetitive sequence.

    Offset
    :   The number of elements to offset the sequence by.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Point Index
:   The index of the input control point.

Offset
:   The number of points to move around the curve before finding the result.
    If the curve is [cyclic](../read/is_spline_cyclic.html)
    and the offset goes past the start or end point of the curve, it will wrap around
    to the other side.
user: Describe Inherited Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`Attribute.name`](bpy.types.Attribute.html#bpy.types.Attribute.name "bpy.types.Attribute.name") - [`Attribute.data_type`](bpy.types.Attribute.html#bpy.types.Attribute.data_type "bpy.types.Attribute.data_type") - [`Attribute.storage_type`](bpy.types.Attribute.html#bpy.types.Attribute.storage_type "bpy.types.Attribute.storage_type") | - [`Attribute.domain`](bpy.types.Attribute.html#bpy.types.Attribute.domain "bpy.types.Attribute.domain") - [`Attribute.is_internal`](bpy.types.Attribute.html#bpy.types.Attribute.is_internal "bpy.types.Attribute.is_internal") - [`Attribute.is_required`](bpy.types.Attribute.html#bpy.types.Attribute.is_required "bpy.types.Attribute.is_required") |
user: Explain Polyline Gestures in complete detail according to the official Blender documentation.

assistant: Clicking places a point in the viewport. Each time `LMB` is pressed, a new point of the polygon is created.
Pressing `LMB` on the starting point, pressing `LMB` twice,
or pressing `Return` closes the selection area.

### Controls

Move `Spacebar`
:   Hold to reposition the selection area.
user: Explain Asset Previews in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Preview panel in the Asset Browser.

Preview images are typically generated automatically when you [mark a data-block as an asset](../files/asset_libraries/introduction.xhtml#bpy-ops-asset-mark). Objects are captured from their local -Y axis, while collections are captured from the global
-Y axis (as these don’t have a local axis).

If the auto-generated preview image isn’t sufficient, you can replace it by a custom one.

For previews of pose assets, see [Controlling the Look of Preview Images](../animation/armatures/posing/editing/pose_library.xhtml#poselib-preview-images).

### Screenshot Capture for Previews

In case a specific preview is needed, a fast way to create it is with a screenshot.
The operator to do so is located under the Preview popover, see [Capture Screenshot Preview](#bpy-ops-asset-screenshot-preview).
It is only possible to take screenshots for editable assets,
so assets in the [Current File](../files/asset_libraries/introduction.xhtml#asset-library-current-file)
and [Asset System Files](../files/asset_libraries/introduction.xhtml#asset-system-files).

Once started, you can click and drag a rectangular area over any part of Blender to capture a preview image.
During dragging it is possible to move the whole capture area or to unlock the aspect ratio.
See the shortcut help in the status bar for information on which keys to press.

On a re-run of the operator, the previously captured area will be remembered.
Simply clicking allows you to easily take the same screenshot again.
user: How do I use AnnotationStroke(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # AnnotationStroke(bpy_struct)

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

*class* bpy.types.AnnotationStroke(*bpy_struct*)
:   Freehand curve defining part of a sketch

    points
    :   Stroke data points

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: When the annotation tool is enabled, the settings for managing multiple layers
can be found in the Sidebar ‣ View ‣ Annotations panel.

Opacity
:   Adjusts the opacity of existing and new strokes.

Thickness
:   Adjusts the thickness of existing and new strokes.

### Onion Skin

Shows a ghosted image of strokes made in frames before and after the current frame.
Onion skinning only works in the 3D Viewport and Sequencer.
See the Grease Pencil documentation for an explanation of
[Onion Skinning](../grease_pencil/properties/onion_skinning.xhtml).

Before/After
:   Color to use before and after the current frame on ghost frames.
    The number defines how many frames to show before and after the current frame.
user: Give a detailed overview of Recovering The Last Session: syntax, arguments, return values, common patterns.

assistant: The *Recover Last Session* will open the `quit.blend` file that is saved into the [Temporary Directory](../advanced/blender_directory_layout.html#temp-dir) when you quit
Blender under normal operation (see [Blender Session](../glossary/index.html#term-Blender-Session)). Note that files in your temporary directory may be
deleted when you reboot your computer (depending on your system configuration) or by scheduled disk cleanup tools or
scripts.
user: Provide the full official documentation entry for Opacity Modifier, preserving all code examples.

assistant: # Opacity Modifier

The *Opacity* Modifier change the opacity (alpha) value of the stroke points.

The alpha value in Grease Pencil is stored per-point.
The modifier can alter these values to go from totally transparent points to totally opaque points.
user: How do I use Precision in Blender? Include parameters, examples, warnings and best practices.

assistant: # Precision

Holding `Ctrl` during a transform operation (such as move, rotate or scale)
will toggle [Transform Snapping](../../../../../editors/3dview/controls/snapping.xhtml).
When using [Increment Snap](../../../../../editors/3dview/controls/snapping.xhtml#bpy-types-toolsettings-snap-elements-base)
this allows the transformation to be performed in discrete amounts.

Holding `Shift` during a transform operation will transform
the object at 1/10th the speed, allowing much finer control.

The magnitude of the transformation can be viewed in the 3D Viewport header.
Releasing `Ctrl` or `Shift` during the transformation will cause
the movement to revert back to its normal mode of operation.
user: Give a detailed overview of Examples: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

This example shows how to use the *Curves to Grease Pencil* node to create a Grease Pencil layer from a curve.

The *Set Curve Radius* node is used to set the radius of the Grease Pencil strokes.
user: Provide the full official documentation entry for Scripts in Blend-Files, preserving all code examples.

assistant: ### Auto Execution

Here are the different ways blend-files may automatically run scripts.

Registered Text-Blocks
:   A text data-block can have its *Register* option enabled which means it will load on start.

Animation Drivers
:   Python expressions can be used to *Drive* values and are often used in more advanced rigs and animations.

### Manual Execution

There are other ways scripts in a blend-file may execute that require user
interaction (therefore will run even when auto execution is off),
but you should be aware that this is the case since it is not necessarily obvious.

- Running a script in the Text editor.
- Rendering with Freestyle, because Freestyle uses scripts to control line styles.
user: Provide the full official documentation entry for Using the Test Grid, preserving all code examples.

assistant: If your image is a base uniform pattern and
you want the application of that image to your model to look like cloth,
you do **not** want any stretching (unless you want the cloth to look like spandex).
You may also need to test your UV mapping with a test image:

|  |  |
| --- | --- |
| ../../../_images/modeling_meshes_uv_applying-image_test-grid-uvs.png   The test grid applied to the UVs. | ../../../_images/modeling_meshes_uv_applying-image_test-grid-geometry.png   A preview of the texture on the geometry. |

When you render, the mesh will have the test grid as its colors,
and the UV texture will be the size image you specified.
Note that Blender has a built-in test image. To use it, press the New button of the data-block menu
in the Image editor header and change the *Generated Type* to UV Grid.

### Modifying Your Image Texture

The advantage to saving as a separate file is that you can easily switch textures just by
copying other image files over it, and you can use external editing programs to work on it.
The advantage of packing is that your whole project is kept in the blend-file,
and that you only have to manage one file.
user: Describe MaskSplinePointUW(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # MaskSplinePointUW(bpy_struct)

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

*class* bpy.types.MaskSplinePointUW(*bpy_struct*)
:   Single point in spline segment defining feather

    select
    :   Selection status

        Type:
        :   boolean, default False

    u
    :   U coordinate of point along spline segment

        Type:
        :   float in [0, 1], default 0.0

    weight
    :   Weight of feather point

        Type:
        :   float in [0, 1], default 0.0

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Distance from Object

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

Target
:   The object to measure distance from.

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

Fill Range by Selection
:   Set the min/max range values from the distances between the current selected mesh vertices and
    the camera or the target.
user: How do I use GeometryNodeInputImage(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeInputImage(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.GeometryNodeInputImage(*GeometryNode*)
:   Input an image data-block

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Snap to Deformed Surface
:   Re-attach curves to a deformed surface using the existing attachment information.
    This only works when the topology of the surface mesh has not changed.

Snap to Nearest Surface
:   Find the closest point on the surface for the root point of every curve and move the root there.
    This needs to be run after the surface mesh topology changed

Convert to Particle System
:   Add a new hair particle system, or update an system on the surface object.
    The operator is used for backwards compatibility with the old
    [hair type particle system](../../physics/particles/hair/introduction.html).
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`Image.stereo_3d_format`](bpy.types.Image.html#bpy.types.Image.stereo_3d_format "bpy.types.Image.stereo_3d_format") - [`ImageStrip.stereo_3d_format`](bpy.types.ImageStrip.html#bpy.types.ImageStrip.stereo_3d_format "bpy.types.ImageStrip.stereo_3d_format") - [`MovieStrip.stereo_3d_format`](bpy.types.MovieStrip.html#bpy.types.MovieStrip.stereo_3d_format "bpy.types.MovieStrip.stereo_3d_format") | - [`ImageFormatSettings.stereo_3d_format`](bpy.types.ImageFormatSettings.html#bpy.types.ImageFormatSettings.stereo_3d_format "bpy.types.ImageFormatSettings.stereo_3d_format") - [`UILayout.template_image_stereo_3d`](bpy.types.UILayout.html#bpy.types.UILayout.template_image_stereo_3d "bpy.types.UILayout.template_image_stereo_3d") |
user: Describe NodesModifierBakes(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodesModifierBakes(bpy_struct)

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

*class* bpy.types.NodesModifierBakes(*bpy_struct*)
:   Bake data for every bake node

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

assistant: This rig provides a simplistic [parent controller](#rigify-rigs-skin-skin-parents), which uses regular
translation, rotation, or scale to modify locations but not orientations or scale of its child chain controls.

Generate Control
:   Specifies whether to generate a visible control, or use the transformation of the ORG bone
    as a part of more complex and specific rig setup.
user: How do I use Pose Breakdowner in Blender? Include parameters, examples, warnings and best practices.

assistant: Creates a suitable breakdown pose on the current frame.

The Breakdowner tool can be constrained to work on specific transforms and axes,
by pressing the following keys while the tool is active:

- `G`, `R`, `S`: move, rotate, scale
- `B`: Bendy bones
- `C`: custom properties
- `X`, `Y`, `Z`: to the corresponding axes
user: Show practical ways to work with Introduction in a Blender add-on or script – include code.

assistant: # Introduction

EEVEE is Blender’s realtime render engine focused on speed and interactivity while achieving the
goal of rendering PBR materials.
EEVEE can be used interactively in the 3D Viewport but also produce high quality final renders.

[image reference removed]

EEVEE in the 3D Viewport – “Tiger” by Daniel Bystedt.

EEVEE materials are created using the same shader nodes as Cycles, making it easy to render existing
scenes. For Cycles users, this makes EEVEE work great for previewing materials in realtime.

EEVEE is based on rasterization and is not a path tracer.
Instead of computing each ray of light, rasterization determines what surface is visible from the camera.
It then estimates the way light interacts with these surfaces and materials using numerous algorithms.
While EEVEE is designed to use PBR principles,
it is not perfect and Cycles will always provide more physically accurate renders.
For these reasons, EEVEE has a set of [limitations](limitations/index.xhtml).

[image reference removed]

EEVEE final render – “Temple” by Dominik Graf.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`SpaceSpreadsheet.tables`](bpy.types.SpaceSpreadsheet.html#bpy.types.SpaceSpreadsheet.tables "bpy.types.SpaceSpreadsheet.tables") | - [`SpreadsheetTables.active`](bpy.types.SpreadsheetTables.html#bpy.types.SpreadsheetTables.active "bpy.types.SpreadsheetTables.active") |
user: What is UVs Explained and how is it used in Blender Python scripting?

assistant: The best analogy to understand UV mapping is cutting up a cardboard box.
If you were to take a pair of scissors and cut along its edges,
you would be able to spread it out flat on a tabletop. As you are looking down at the table,
we could say that U is the left-right direction, and V is the up-down direction.

As a next step, you could put the spread-out box on top of a poster, cut the poster
to match its shape, glue the poster to the box, and finally reassemble the box.
You now have a 3D box textured with a 2D image.

A UV map thus describes how the mesh’s faces are laid out on the texture.
You have complete freedom in how to do this: if you wanted to, you could cut each face loose
and position, rotate, scale, and even skew it on the texture independently of the others.
What’s more, faces can overlap in the UV map, making them share the same part of the texture.

### Example

[image reference removed]

3D space (XYZ) versus UV space.

In the above image, a dome in 3D space is flattened into a disc in UV space.
Each 3D face is then textured with the part of the image it covers in the UV map.

The image also demonstrates a common problem in UV maps: distortion. Notice how,
even though the checkered squares in the 2D texture are all the same size,
they get different sizes when applied to the 3D dome (they’re smaller at the base
than at the top). This is because the faces in the UV map have different relative
sizes than in 3D space, which is a result of the flattening process.

You’ll typically want to minimize this distortion by manually guiding and tweaking
the flattening, using [seams](../../modeling/meshes/uv/unwrapping/seams.xhtml) for example.
However, it’s not always possible to eliminate it completely.
user: How do I use Multi-View and Stereo 3D Image I/O in Blender? Include parameters, examples, warnings and best practices.

assistant: Multi-View and Stereo 3D
:   Multi-view images can be saved in special formats according to the production requirements.
    By default the system saves each view as an individual file,
    thus generating as many files as views to be rendered.
    In stereo 3D productions, for the final deployment or
    even intermediary previews it is convenient to save stereo 3D images,
    that are ready to use with 3D displays or simple anaglyph glasses.
    The formats supported match the display modes available for the window.

Lossy-Formats
:   Some stereo 3D formats represent a considerable loss of data.
    For example, the Anaglyph format will cap out entire color channels from the original image.
    The Top-Bottom compressed will discard half of your vertical resolution data.
    The Interlace will mash your data considerably.
    Once you export in those formats, you can still import the image
    back in Blender, for it to be treated as Stereo 3D.
    You will need to match the window stereo 3D display mode to the image stereo 3D format though.

Lossless Formats
:   Some formats will preserve the original data,
    leading to no problems on exporting and importing the files back in Blender.
    The Individual option will produce separate images that
    (if saved in a lossless encoding such as `PNG` or `OpenEXR`)
    can be loaded back in production with no loss of data.
    For the Stereo 3D formats the only lossless options are
    *Top-Bottom* and *Side-by-Side* without the Squeezed Frame option.

Multi-View OpenEXR
:   Another option is to use multi-view OpenEXR files. This format can save multiple views in
    a single file and is backward compatible with old OpenEXR viewers (you see only one view though).
    Multi-view native support is only available to OpenEXR.
user: Show practical ways to work with Nudge in a Blender add-on or script – include code.

assistant: # Nudge

Moves vertices in the direction of the brush stroke.

Similar to the [Snake Hook](snake_hook.xhtml) brush,
but instead only moves the geometry along the surface (using the area plane).
This is useful for grabbing geometry along curved surfaces,
without making too impactful changes to the overall object shape.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Image
:   Standard color input.

X, Y
:   Used to move the input image horizontally and vertically.

### Sampling

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

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

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

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

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

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

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

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

    Repeat:
    :   Areas outside of the image are filled with repetitions of the image.
user: Explain Inputs in complete detail according to the official Blender documentation.

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: What is Tool System and how is it used in Blender Python scripting?

assistant: # Tool System

Tools are accessed from the [Toolbar](#ui-region-toolbar).

This is a general introduction to tools. Individual tools have their own documentation.

There can only be one active tool per [Workspace](window_system/workspaces.xhtml)
and [mode](../editors/3dview/modes.xhtml).
This tool is remembered: if you’re in Edit Mode and have the Extrude tool selected,
then switch to Object Mode (which has no Extrude tool) and back to Edit Mode,
the Extrude tool will still be active.

Most tools are controlled using just `LMB`, though some also have modifier keys
(shown in the [Status Bar](window_system/status_bar.xhtml) while using the tool).
This can all be customized in the [Keymap Preferences](../editors/preferences/keymap.xhtml).

Some tools define gizmos (*Shear* and *Spin* for example) to help control them.
user: What is Cross References and Links and how is it used in Blender Python scripting?

assistant: Internal document links:

```
:doc:`Link Title </section/path/to/file>`
```

Link to a specific section using explicit labels:

```
.. _my-section-label:

Section Title
=============

Reference this section later with :ref:`Optional Title <my-section-label>`
```

Implicit references within the same document:

```
Section Title
=============

Reference it implicitly later using `Section Title`_
```

External website links:

```
`Blender's Official Website <https://www.blender.org>`__
```

### Context-Sensitive Manual Access

To link Blender UI properties and operators directly to manual entries:

1. Right-click the property/operator in Blender and select *Online Python Reference*
   to get the RNA tag (shown in the OS console).
2. In the documentation, use an external reference matching Blender’s RNA tag:

```
.. _bpy.types.FluidDomainSettings.use_fractions:

Fractional Obstacles
   Enables finer resolution in fluid/obstacle regions.
```

For operators:

```
.. _bpy.ops.curve.subdivide:

Subdivide
=========
```

Blender uses these tags to link UI elements directly to documentation entries via the “Online Manual” option.
user: Describe Bind Camera to Markers from the Blender manual or Python API, including usage steps and snippets.

assistant: *Bind Camera to Markers* allows markers to be used to set the active object as the active camera.

To use this operator, select the object to become the active camera
and select a marker to bind the active camera to.
If no marker is selected when the operator is applied, a marker will be added.
When an object is bound to a marker, the marker will be renamed to the name of the active object.
These markers also have a camera icon next to the left of the name
to easily distinguish them from other informative markers.

These markers can be moved to change the frame at which
the active camera is changed to the object the marker is bound to.
user: Describe TextureNodeTranslate(TextureNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # TextureNodeTranslate(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.TextureNodeTranslate(*TextureNode*)
:   *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 Troubleshooting macOS – Other GPU and how is it used in Blender Python scripting?

assistant: # Troubleshooting macOS – Other GPU

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

This section lists possible solutions for graphics glitches, problems with EEVEE and Cycles, and crashes related to
your GPU.
user: Explain Manual Lens Calibration in complete detail according to the official Blender documentation.

assistant: All cameras record distorted video.
Nothing can be done about this because of the manner in which optical lenses work.
For accurate camera motion,
the exact value of the focal length and the “strength” of distortion are needed.

Currently, focal length can be automatically obtained only from the camera’s settings or from the EXIF information.
There are some external tools which can help to find approximate values to compensate for distortion.
There are also fully manual tools where you can use a grid which is getting affected by distortion model and
deformed cells defines straight lines in the footage.

Within Blender you can use the Annotation tool for this – just draw a line which should be straight on
the footage using poly line brush and adjust the distortion values
to make the annotations match lines on the footage.

To calibrate your camera more accurately, use the Grid calibration tool from OpenCV.
OpenCV is using the same distortion model, so it should not be a problem.
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Axis
:   Local axis of the object that is to be rotated towards the vector input.

Pivot
:   The local axis to rotate around.

    Auto:
    :   The best rotation angle is computed automatically.
        This minimizes the angle of rotation.

    X, Y, Z:
    :   Rotate around a specific local axis.
user: Describe Transform from the Blender manual or Python API, including usage steps and snippets.

assistant: You can move the selected node(s) by clicking and dragging any empty part of them.
Alternatively, press `G`, move the mouse, and click `LMB` to confirm.

Dragging a node on top of an existing link will intelligently insert the selected node into the link path.
This generally uses the first socket that matches the link type.
The automatic node attachment feature can be toggled with `Alt`.
When a node is automatically attached, the surrounding nodes
will be offset to the right or left depending on the `T` toggle;
see [Auto-Offset](arranging.xhtml#editors-nodes-usage-auto-offset) for more information.

While dragging nodes, you can press `F` to toggle their parent [Frame](types/layout/frame.xhtml):

- If the nodes are inside a frame, they will be detached from it.
- If the nodes are not inside a frame and there is a frame under the cursor, they will be attached to that frame.

In general, it is recommended to arrange your nodes so that data flows from left to right, top to bottom.

The width of a node can be changed by dragging its left or right border.

Rotating (`R`) and scaling (`S`) only apply when multiple nodes are selected,
and only affect their positions.
user: How do I use Reload Library in Blender? Include parameters, examples, warnings and best practices.

assistant: When the Outliner is in the *Blender File* [Display Mode](../../editors/outliner/interface.html#bpy-types-spaceoutliner-display-mode),
you can right-click a linked blend-file and choose *Reload* to immediately update
the current blend-file with the latest version of the linked data-blocks,
without having to reopen the file.
user: Explain Laplacian Deform Modifier in complete detail according to the official Blender documentation.

assistant: # Laplacian Deform Modifier

The *Laplacian Deform* modifier allows you to pose a mesh while preserving
geometric details of the surface.

The user defines a set of “anchor” vertices, and then moves some of them around.
The modifier keeps the rest of the anchor vertices in fixed positions and
calculates the optimal locations of all the remaining vertices to preserve the original geometric details.

This modifier captures the geometric details with the use of differential coordinates.
The differential coordinates capture the local geometric information, the curvature and
direction of a vertex based on its neighbors.
user: Give a detailed overview of Custom Distance: syntax, arguments, return values, common patterns.

assistant: If enabled, uses [Distance](#bpy-types-light-cutoff-distance) as the custom attenuation distance
instead of global Light Threshold. In order to avoid long setup times, this distance is first computed
automatically based on a light threshold.
The distance is computed at the light origin and using the inverse square falloff.

Distance
:   Specifies where light influence will be set to 0.
user: Give a detailed overview of Flip Faces Node: syntax, arguments, return values, common patterns.

assistant: # Flip Faces Node

[image reference removed]

The *Flip Faces Node* reverses the order of the vertices and edges of each selected face.
The most common use of this node is to flip the normals of a face.
Any [face corner domain](../../attributes_reference.xhtml#attribute-domains) attributes of selected faces are also reversed.

Though this node is usually used to affect normals, it is not called “Flip Normals” for an important reason.
The node does not actually interact with normals directly. Normals are defined by the
[right hand rule](https://en.wikipedia.org/wiki/Right-hand_rule#Curve_orientation_and_normal_vectors),
so if a face’s vertex list is reversed, then its normal will point in the opposite direction.
user: Show practical ways to work with Creating Catalogs in a Blender add-on or script – include code.

assistant: New catalogs can be created in the [Asset Browser](../../editors/asset_browser.xhtml)
through Header ‣ Catalog ‣ New Asset Catalog.
Once the catalog is created you can double `LMB` on it’s name in the
*Source List* region of the editor to give the catalog a more descriptive name.
Catalogs can also be created in this region by clicking the plus icon found at the top of the tree view.
user: What is Deleting a Material and how is it used in Blender Python scripting?

assistant: To delete a material, select the material and click X in the Available Materials List entry.

Although the material will seem to disappear immediately,
the Delete action can depend on how the material is used elsewhere.

If the material is linked to the object and there are other objects which use this material,
then the material will be removed from that object (but remain on all its other objects).

If the “Fake User” button has been lit in the Available Materials list,
then the material will be retained when the file is saved, even if it has no users.

Only if it has 0 “real” users, and no “Fake” user, will the material be permanently deleted.
Note that it will still remain in the Materials list until the blend-file is saved,
but will have disappeared when the file is reloaded.
user: What is Use an External Editor and how is it used in Blender Python scripting?

assistant: Blender’s text editor is fine for small changes and writing tests but its not full featured,
for larger projects you’ll probably want to use a standalone editor or Python IDE.
Editing a text file externally and having the same text open in Blender does work
but isn’t that optimal so here are two ways you can use an external file from Blender.
Using the following examples you’ll still need text data-block in Blender to execute,
but reference an external file rather than including it directly.

### Executing External Scripts

This is the equivalent to running the script directly, referencing a script’s path from a two line code block.

```
filename = "/full/path/to/myscript.py"
exec(compile(open(filename).read(), filename, 'exec'))
```

You might want to reference a script relative to the blend-file.

```
import bpy
import os

filename = os.path.join(os.path.dirname(bpy.data.filepath), "myscript.py")
exec(compile(open(filename).read(), filename, 'exec'))
```

### Executing Modules

This example shows loading a script in as a module and executing a module function.

```
import myscript
import importlib

importlib.reload(myscript)
myscript.main()
```

Notice that the script is reloaded every time, this forces use of the modified version,
otherwise the cached one in `sys.modules` would be used until Blender was restarted.

The important difference between this and executing the script directly is it
has to call a function in the module, in this case `main()` but it can be any function,
an advantage with this is you can pass arguments to the function from this
small script which is often useful for testing different settings quickly.

The other issue with this is the script has to be in Python’s module search path.
While this is not best practice – for testing purposes you can extend the search path,
this following example adds the current blend-file’s directory to the search path
and then loads the script as a module.

```
import sys
import os
import bpy

blend_dir = os.path.dirname(bpy.data.filepath)
if blend_dir not in sys.path:
   sys.path.append(blend_dir)

import myscript
import importlib
importlib.reload(myscript)
myscript.main()
```
user: Explain Build Modifier in complete detail according to the official Blender documentation.

assistant: # Build Modifier

The *Build* modifier causes the faces of the mesh object to appear or disappear one after the other over time.

By default, faces appear in the order in which they are stored in memory (by default, the order of creation).
The face/vertex order can be altered in Edit Mode by using [Sort Mesh Elements](../../meshes/editing/mesh/sort_elements.xhtml#mesh-edit-sort-elements).