PGCRYPT/OpenBlender_Train huggingface dataset:
user: How do I use About Image-Based Texturing in Blender? Include parameters, examples, warnings and best practices.

assistant: Texture images take up precious memory space,
often being loaded into a special video memory bank that is very fast and very expensive,
so it is often very small. So, keep the images as small as possible.
A 64×64 image takes up only one fourth the memory of a 128×128 image.

For photorealistic rendering of objects in animations, often larger image textures are used,
because the object might be zoomed in on in camera moves. In general, you want to use
a texture sized proportionally to the number of pixels that it will occupy in the final render.
Ultimately, you only have a certain amount of physical RAM to hold an image texture and
the model and to provide workspace when rendering your image.

For the most efficient memory usage, image textures should be square, with dimensions as powers of 2,
such as 32×32, 64×64, 128×128, 256×256, 1024×1024, 2048×2048, and 4096×4096.

If you can reuse images across different meshes, this greatly reduces memory requirements.
You can reuse images if you map those areas of the meshes that “look alike” to a layout that
uses the common image.

When using file textures, it is very important that you have
[Mapped the UVs](../../../../modeling/meshes/uv/unwrapping/index.xhtml)
of the mesh, and they are laid out appropriately.

You do not have to UV map the *entire* mesh.
The sphere above on the left has some faces mapped,
but other faces use procedural materials and textures.
Only use UV textures for those portions of your mesh where you want very graphic,
precise detail. For example,
a model of a vase only needs UV texture for the rim where decorative artwork is incorporated.
A throw pillow does not need a different image for the back as the front;
in fact many throw pillows have a fabric (procedural material) back.

As another example, you should UV map both eyes of a head to the same image
(unless you want one bloodshot and the other clear).
Mapping both sides of a face to the same image might not be advisable,
because the location of freckles and skin defects are not symmetrical.
You could of course change the UV map for one side of the face to slightly offset,
but it might be noticeable.
Ears are another example where images or section of an image can be mapped to similar faces.
user: How do I use Corner Pin Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Corner Pin Node

[image reference removed]

The Corner Pin node uses explicit corner values for a plane warp transformation.
It works like the [Plane Track Deform](../tracking/plane_track_deform.xhtml) node,
but without using “plane track” data from the Movie Clip Editor.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`CompositorNodeOutputFile.file_output_items`](bpy.types.CompositorNodeOutputFile.html#bpy.types.CompositorNodeOutputFile.file_output_items "bpy.types.CompositorNodeOutputFile.file_output_items") |  |
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

The Explode modifier, with a Particle System above it.

Particle UV
:   If set, the U value of the coordinates in that [UV Map](../../../glossary/index.xhtml#term-UV-Map) will be overwritten
    with the age of the particle attached to the matching mesh face
    (in proportion, from 0 for not yet born particles, to 1 for dead ones).

    The V value is set to a constant 0.5 value.

    You can for example vary the color of a fragment (face) during the explosion phase,
    by using a texture with a color gradient along its *U* axis.

Show
:   Unborn
    :   Show faces when their attached particles are unborn.

    Alive
    :   Show faces when their attached particles are alive.

    Dead
    :   Show faces when their attached particles are dead.

Cut Edges
:   Split the mesh in pieces based on location of emitted particles, instead of using existing faces.
    This will typically results in a splitting that appears more random.

Size
:   Scale each face using the size of its attached particle, once that particle is alive.

Vertex Group
:   Vertices in this group may not be affected by the *Explode* modifier.
    Vertices with full weight are not affected at all,
    while vertices with less weight have a higher chance of being affected.

    Vertices with null weight will be treated like those which do not belong to the group at all,
    and explode normally.

    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.

Protect
:   Clean vertex group edges. Depending on the weights assigned to that vertex group,
    either completely protect those faces from being affected by the *Explode* modifier
    (which would happen if the faces had a weight value of 1),
    or completely remove protection from those faces
    (which would happen if the faces had a weight value of 0).

Refresh
:   Refresh data in the *Explode* modifier.
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Clamp Type
:   Method to clamp.

    Min Max:
    :   Constrain values between Min and Max.

    Range:
    :   Constrain values between Min and Max. When Min is greater than Max,
        constrain between Max and Min instead.
user: Give a detailed overview of Usage: syntax, arguments, return values, common patterns.

assistant: The lattice should be scaled and moved to fit around your object in Object Mode.
Any scaling applied to the object in Edit Mode will result in the object deforming.
This includes applying its scale with `Ctrl`-`A` as this will achieve the same result as
scaling the lattice in Edit Mode, and therefore the object.

[image reference removed]

Lattice around the cube object in Object Mode.
user: Describe Application Icons (bpy.app.icons) from the Blender manual or Python API, including usage steps and snippets.

assistant: # Application Icons (bpy.app.icons)

bpy.app.icons.new_triangles(*range*, *coords*, *colors*)
:   Create a new icon from triangle geometry.

    Parameters:
    :   - **range** (*tuple**[**int**,* *int**]*) – Pair of ints.
        - **coords** (*bytes*) – Sequence of bytes (6 floats for one triangle) for (X, Y) coordinates.
        - **colors** (*bytes*) – Sequence of bytes (12 for one triangles) for RGBA.

    Returns:
    :   Unique icon value (pass to interface `icon_value` argument).

    Return type:
    :   int

bpy.app.icons.new_triangles_from_file(*filepath*)
:   Create a new icon from triangle geometry.

    Parameters:
    :   **filepath** (*str* *|* *bytes.*) – File path.

    Returns:
    :   Unique icon value (pass to interface `icon_value` argument).

    Return type:
    :   int

bpy.app.icons.release(*icon_id*)
:   Release the icon.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: The inputs of the node are dynamic. Some inputs are only available in certain operations.
For instance, the *Scale* input is only available in the *Scale* operator.

Vector
:   Input vector \(A = \begin{pmatrix} A_x \\ A_y \\ A_z \end{pmatrix}\).

Vector
:   Input vector \(B = \begin{pmatrix} B_x \\ B_y \\ B_z \end{pmatrix}\).

Scale
:   Input Scale \(s\).
user: Provide the full official documentation entry for Generate Hair Curves, preserving all code examples.

assistant: # Generate Hair Curves

The *Generate Hair Curves* node procedurally creates new hair curves on the surface of a mesh.
It generates curves from scratch at sampled point locations rather than using existing hair data.
For cases where curves should interpolate or follow existing guides, use the
[Interpolate Hair Curves](interpolate_hair_curves.html) node instead.
user: Describe Bpy.Types.Dynamicpaintbrushsettings from the Blender manual or Python API, including usage steps and snippets.

assistant: BrushSettings.paint_color DynamicPaintBrushSettings.paint_distance DynamicPaintBrushSettings.paint_ramp DynamicPaintBrushSettings.paint_source DynamicPaintBrushSettings.paint_wetness DynamicPaintBrushSettings.particle_system DynamicPaintBrushSettings.proximity_falloff DynamicPaintBrushSettings.ray_direction DynamicPaintBrushSettings.smooth_radius DynamicPaintBrushSettings.smudge_strength DynamicPaintBrushSettings.solid_radius DynamicPaintBrushSettings.use_absolute_alpha DynamicPaintBrushSettings.use_negative_volume DynamicPaintBrushSettings.use_paint_erase DynamicPaintBrushSettings.use_particle_radius DynamicPaintBrushSettings.use_proximity_project DynamicPaintBrushSettings.use_proximity_ramp_alpha DynamicPaintBrushSettings.use_smudge DynamicPaintBrushSettings.use_velocity_alpha DynamicPaintBrushSettings.use_velocity_color DynamicPaintBrushSettings.use_velocity_depth DynamicPaintBrushSettings.velocity_max DynamicPaintBrushSettings.velocity_ramp DynamicPaintBrushSettings.wave_clamp DynamicPaintBrushSettings.wave_factor DynamicPaintBrushSettings.wave_type DynamicPaintBrushSettings.bl_rna_get_subclass() DynamicPaintBrushSettings.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Give a detailed overview of Edge Bevel Weight: syntax, arguments, return values, common patterns.

assistant: Sets the value for the `bevel_weight_edge` attribute, a value between (0.0 to 1.0).

This attribute is used by the [Bevel Modifier](../../../modifiers/generate/bevel.xhtml)
to control the bevel intensity of the edges.

This operator enters an interactive mode (a bit like transform tools),
where by moving the mouse (or typing a value with the keyboard)
you can set the bevel weight of selected edges. If more than one edge is selected,
this operator alters the average weight of the edges.
user: Give a detailed overview of Sensor Noise Node: syntax, arguments, return values, common patterns.

assistant: # Sensor Noise Node

[image reference removed]

The *Sensor Noise* node simulates the random noise patterns produced by digital camera sensors.
This can be used to match real footage, add realism to rendered images, or stylistically mimic
the imperfections of digital imaging systems.
user: Give a detailed overview of Usage: syntax, arguments, return values, common patterns.

assistant: First define the base of the object by dragging with `LMB`.
Next, release `LMB` and move the mouse to define the height of the object.
Finally, click `LMB` to confirm the shape of the object.

You can use the following hotkeys to temporarily change a setting
(for as long as the key is held):

|  |  |
| --- | --- |
| `Ctrl` | Toggles snapping. |
| `Alt` | Toggles the *Origin* setting. |
| `Shift` | Toggles the *Aspect* setting. |
user: Provide the full official documentation entry for Extensions Tags, preserving all code examples.

assistant: # Extensions Tags

A different set of tags is available for the different extensions types.
This is the list of the tags currently supported by the [Blender Extensions Platform](https://extensions.blender.org/):
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Divergence
:   A float grid representing the divergence of the input field.

    Positive values correspond to regions where vectors spread apart (sources),
    while negative values represent regions where vectors converge (sinks).
user: What is Format Options and how is it used in Blender Python scripting?

assistant: `-F`, `--render-format` `<format>`
:   Set the render format.
    Valid options are:
    `TGA` `RAWTGA` `JPEG` `IRIS` `PNG` `BMP` `HDR` `TIFF`.

    Formats that can be compiled into Blender, not available on all systems:
    `OPEN_EXR` `OPEN_EXR_MULTILAYER` `FFMPEG` `CINEON` `DPX` `JP2` `WEBP`.

`-x`, `--use-extension` `<bool>`
:   Set option to add the file extension to the end of the file.
user: Show practical ways to work with Link Data in a Blender add-on or script – include code.

assistant: # Link Data

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

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

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

---

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

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

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

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

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

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

---

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

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

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

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

---

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

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

---

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

Link Blockers to Emitter
:   Adds the selected objects to the [Shadow Linking](../../../../render/lights/light_linking.html)
    collection of the active light object.
user: Explain Sync Selection in complete detail according to the official Blender documentation.

assistant: When enabled (the default), the UV Editor and 3D Viewport share a synchronized selection state.
Selecting components (vertices, edges, or faces) in one editor will automatically select the
corresponding elements in the other.

With *Sync Selection* enabled, all faces are visible in the UV Editor at all times. Selecting a
vertex, edge, or face in the 3D Viewport selects its corresponding UV elements. However, when a
single 3D vertex or edge corresponds to multiple UV vertices or edges (for example, along a UV seam),
you cannot select them individually—selecting one selects all of them.

When disabled, only the UVs belonging to the currently selected faces in the 3D Viewport are shown.
Selections in the UV Editor are independent, allowing individual UV vertices and edges to be selected
even if they correspond to the same mesh vertex or edge. Selecting in one editor no longer affects
the other.
user: Give a detailed overview of Evaluate at Index Node: syntax, arguments, return values, common patterns.

assistant: # Evaluate at Index Node

[image reference removed]

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

This node is also similar to the [Evaluate on Domain Node](evaluate_on_domain.html) node,
except that the value to retrieve from the specified domain is specified by an index rather than
an automatic domain interpolation.
user: Show practical ways to work with Sound to Samples in a Blender add-on or script – include code.

assistant: Creates a sampled curve based on a sound file. Use *Samples to Keys* if you need to edit it.

Lowest Frequency
:   Cutoff frequency of a high-pass filter that is applied to the audio data.

Highest Frequency
:   Cutoff frequency of a low-pass filter that is applied to the audio data.

Attack Time
:   Value for the hull curve calculation that tells how fast the hull curve can rise.
    The lower the value, the steeper it can rise.

Release Time
:   Value for the hull curve calculation that tells how fast the hull curve can fall.
    The lower the value, the steeper it can fall.

Threshold
:   Minimum amplitude value needed to influence the hull curve.

Accumulate
:   Only the positive differences of the hull curve amplitudes are summarized to produce the output.

Additive
:   The amplitudes of the hull curve are summarized. If *Accumulate* is enabled,
    both positive and negative differences are accumulated.

Square
:   Gives the output as a square curve.
    Negative values always result in -1, and positive ones in 1.

    Square Threshold
    :   All values lower than this threshold result in 0.
user: How do I use PaintModeSettings(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # PaintModeSettings(bpy_struct)

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

*class* bpy.types.PaintModeSettings(*bpy_struct*)
:   Properties of paint mode

    canvas_image
    :   Image used as painting target

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

    canvas_source
    :   Source to select canvas from

        Type:
        :   enum in [`'COLOR_ATTRIBUTE'`, `'MATERIAL'`, `'IMAGE'`], default `'MATERIAL'`

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

assistant: Object
:   Determine which objects will be included in the export.

    Active:
    :   Export only the active Grease Pencil object.

    Selected:
    :   Export all selected Grease Pencil objects.

    Visible:
    :   Export all visible Grease Pencil object in the scene.
user: Explain ShaderNodeLightPath(ShaderNode) in complete detail according to the official Blender documentation.

assistant: # ShaderNodeLightPath(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.ShaderNodeLightPath(*ShaderNode*)
:   Retrieve the type of incoming ray for which the shader is being executed.
    Typically used for non-physically-based tricks

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Randomize in complete detail according to the official Blender documentation.

assistant: # Randomize

The *Randomize* tool in Edit Mode allows you to displace the vertices of a mesh
along their normal.

Amount
:   Distance of the displacement.

Uniform
:   Adds a random offset of the amount.

Normal
:   Adds a random offset to the displacement normal.

Random Seed
:   The random seed is an offset to the random transformation.
    A different seed will produce a new result.
user: Describe Node Compositor Interpolation Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Node Compositor Interpolation Items

NEAREST:
:   Nearest.

    Use Nearest interpolation.

BILINEAR:
:   Bilinear.

    Use Bilinear interpolation.

BICUBIC:
:   Bicubic.

    Use Cubic B-Spline interpolation.

ANISOTROPIC:
:   Anisotropic.

    Use Anisotropic interpolation.
user: Explain Volumes in complete detail according to the official Blender documentation.

assistant: # Volumes

Biased
:   Default volume rendering algorithm is based on null scattering, which is unbiased and has less artifacts,
    but could be noisier. Biased option uses ray marching, with controls for steps size and max steps.

Volume *Step* size is the distance between volume shader samples.
Cycles automatically estimates this distance based on voxel size in
volume objects and smoke simulations.

Render time can be reduced by increasing the step size, at the cost of
potentially losing some volume detail. For procedural volume shaders
that add detail, step size can be increased per object, material or world.

Step Rate Render Biased
:   Global multiplier on the step size for all volumes in renders.
    Increase to reduce render time, at the cost of losing detail.

Viewport Biased
:   Global multiplier on the step size for all volumes in the viewport.
    Increase for more responsive viewport rendering.

Max Steps Biased
:   Maximum number of steps through the volume before giving up,
    to protect from extremely long render times with big objects or small step sizes.
user: What is Quality and how is it used in Blender Python scripting?

assistant: Viewport Anti-Aliasing
:   Control the [Anti-Aliasing](../../glossary/index.xhtml#term-Anti-Aliasing) for higher quality rendering.

Smooth Wires
:   Overlay
    :   Display overlays with smooth wire, without this wires will be rendered aliased.
        To increase the visibility you can disable this for Edit Mode specificity (see below),
        since edges do not blend into other shaded regions.

    Edit Mode
    :   Display smooth wire in Edit Mode, without this wires will be rendered aliased.
user: How do I use Displacement in Blender? Include parameters, examples, warnings and best practices.

assistant: # Displacement

Detail can be added to the shape of a surface with displacement shaders.

To create displacement, connect a [Displacement](../../shader_nodes/displacement/displacement.xhtml)
or [Vector Displacement](../../shader_nodes/displacement/vector_displacement.xhtml) node
to the displacement input of the Material Output node. Procedural, painted or baked textures can
then be connected to these nodes.

[image reference removed]

Typical displacement node setup.

Three displacement methods exist, with varying accuracy, performance and memory usage.
The displacement method can be set per material in the
[Material Settings](../../eevee/material_settings.xhtml#bpy-types-material-displacement-method).

[image reference removed]

Bump only, displacement only, and displacement and bump combined.
user: Explain Mirror in complete detail according to the official Blender documentation.

assistant: The *Mirror Vertex Group* tool mirrors the weights
from one side of a perfectly symmetrical mesh to the opposite side.
Those vertices that have no corresponding vertex on the other side will not be affected.
But note, the weights are not transferred to the corresponding opposite bone weight group.

[image reference removed]

Mirror example.

Mirror Weights
:   With this option checked, every selected vertex receives
    the weight information of its symmetrical counterpart.
    If both vertices are selected, it will be a weight information exchange;
    if only one is selected, information from the unselected will overwrite the selected one.
    Information on weight is passed for the active group only,
    unless *All Groups* is checked, in which case it is passed for all groups.

Flip Group Names
:   Works with selected vertices that belong to vertex groups with “symmetrical names”
    (with components like “L”, “R”, “right”, “left”).
    All selected vertices that belong to the active group, or to the symmetrical of the active group,
    will have their assignation to that group replaced by an assignation to the symmetrical one;
    however, its weight will be preserved.
    If *All Groups* is checked, all assignations to these kind of groups
    will be replaced by the symmetrical counterpart, also keeping the old weights.

All Groups
:   Operate on all vertex groups, instead of the active one.

Topology Mirror
:   Mirror for meshes which are not fully symmetric (approximate mirror).
    See [here](../../modeling/meshes/tools/tool_settings.xhtml#bpy-types-mesh-use-mirror-topology) for more information.
user: Explain Brushes in complete detail according to the official Blender documentation.

assistant: # Brushes

This is a list of all provided ‘Essentials’ brush assets that come with Blender.
These are based on various [Brush Types](../../brush/brush_settings.xhtml#sculpt-tool-settings-brush-type) which are mentioned for each brush..
user: How do I use Snap Target in Blender? Include parameters, examples, warnings and best practices.

assistant: Increment
:   Snaps to grid points.

    This option snaps to an imaginary grid that starts at the selection’s original location and has the same
    resolution as the grid displayed in the editor. In other words, it lets you move the selection in
    “increments” of the grid cell size.

Grid
:   Snaps to grid points.

Vertex
:   Snaps to the vertex that’s closest to the mouse cursor.
user: Provide the full official documentation entry for Snake Hook, preserving all code examples.

assistant: # Snake Hook

Pulls vertices along with the movement of the brush to create long, snake-like forms.
During the stroke, geometry will be dynamically picked up & let go.

When the *Rake* setting is used,
the brush can also be used to rotate geometry via dragging.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Mask
:   A grayscale image.

Size
:   The size of the surrounding area to look at for each pixel; or in other words, how much to
    dilate (for positive values) or erode (for negative values) the mask.

Type
:   Steps:
    :   Sets each pixel to the maximum (for dilation) or minimum (for erosion) value that’s found
        within a square surrounding it. This approach keeps the original gray levels and is best
        suited for masks that contain sharp corners; rounded shapes such as circles will look more
        square-like in the output.

        Despite the name, this is not an iterative process; the dilation/erosion is only performed
        once regardless of the chosen *Size*.

    Threshold:
    :   Makes all the pixels fully black or white depending on whether they’re darker or brighter
        than 50% gray. Then, sets each pixel to the maximum (for dilation) or minimum
        (for erosion) value that’s found within a circle surrounding it. This approach loses the
        original gray levels. Shape wise, it’s well-suited for masks that contain rounded corners;
        sharp ones will be rounded off.

    Distance:
    :   Sets each pixel to the maximum (for dilation) or minimum (for erosion) value that’s found
        within a circle surrounding it. This approach preserves the original gray levels and
        is well-suited for masks that contain rounded corners.

    Feather:
    :   Blurs the image.

Falloff Size Threshold
:   Determines how much to blur the edges after dilation/erosion.

Falloff Feather
:   Determines the brightness curve of the blurred edges.
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: [image reference removed]

Flip Visual Effect.

Axis
:   Which axis or axes to flip the object about.

    Horizontal:
    :   When enabled, shows the object flipped horizontally.

    Vertical:
    :   When enabled, shows the object flipped vertically.
user: Explain Spline IK Constraint in complete detail according to the official Blender documentation.

assistant: # Spline IK Constraint

The *Spline IK* constraint fits a chain of bones to the shape of a
[Curve](../../../modeling/curves/introduction.xhtml).
It’s particularly well suited for rigging flexible body parts such as tails, tentacles,
and spines, as well as inorganic objects such as ropes.
user: Explain World Settings in complete detail according to the official Blender documentation.

assistant: # World Settings

The world environment can emit light, ranging from a single solid color
to arbitrary textures.

In EEVEE, the world lighting contribution is stored into an internal
[Light Probe](light_probes/index.html).
This makes the lighting less precise than Cycles.

EEVEE considers the world lighting contribution as indirect lighting
whereas Cycles considers it as direct lighting.
user: Provide the full official documentation entry for Motion Blur, preserving all code examples.

assistant: # Motion Blur

Blender’s animations are by default rendered as a sequence of *perfectly still* images.
While great for stop-motion and time-lapses, this is unrealistic, since fast-moving
objects do appear to be blurred in the direction of motion,
both in a movie frame and in a photograph from a real-world camera.

Position
:   Controls at what point the shutter opens in relation to the current frame.

    Start on Frame:
    :   Shutter is starting to open at the current frame.

    Center on Frame:
    :   Shutter is fully opened at the current frame.

    End on Frame:
    :   Shutter is fully closed at the current frame.

Shutter
:   Time (in frames) taken between shutter open and close.

Bleeding Bias
:   Used by the post-process blur to avoid blurring the background over the foreground.
    Lower values will reduce background bleeding onto foreground elements.

Max Blur
:   Max Blur is intended to act as an optimization tool by
    limiting the number of pixels across which the blur is calculated.

Steps
:   This controls the number of steps used by the accumulation blur and thus its accuracy.
    More steps means longer render time.

    EEVEE splits the render into multiple time steps and accumulates the result
    which is known as Accumulation Motion Blur.
    This technique is precise but requires many steps for clean gradients.
    This is used in combination with the post-process blur to handle the inter-step gaps.
    Each step corresponds to a full scene re-evaluation and can add a lot of overhead to the render time.
    By adding more steps you can also reduce the *Max Blur* options because the post-process blur
    has to cover a smaller distance.

Shutter Curve
:   Use a custom shutter curve.
user: Describe Expand Active Face Set from the Blender manual or Python API, including usage steps and snippets.

assistant: Expands an existing face set with a geodesic falloff.
This operator uses the same internal operator as [Expand](#bpy-ops-sculpt-expand)
meaning all the hotkeys and functionality works the same as that tool.

### Usage

Resizing Face Sets
:   Resize a Face Set along the surface distances.
    It is an alternative to [Grow/Shrink Face Sets](face_sets.xhtml#bpy-ops-sculpt-face-set-edit)
    which follows the topology instead of geodesic distances.

Joining Face Sets
:   When holding `Ctrl` the expansion will instead snap to other Face Sets.
    This is a fast way of joining multiple face sets into one.
user: What is Tool Settings and how is it used in Blender Python scripting?

assistant: Steps
:   Specifies how many copies will be extruded along the “sweep”.

Use Duplicates
:   When enabled, will keep the original selected elements as separated islands in the mesh
    (i.e. unlinked to the result of the spin extrusion).

Axis
:   Specifies the axis to use as the pivot of the spin operation.
user: Explain Save As in complete detail according to the official Blender documentation.

assistant: Choose a file path to save the blend-file to.

### Options

Compress
:   Reduces the file size of the resulting blend-file but takes longer to save and load.
    This option is useful for distributing files online and saving drive space for large projects.
    But it can cause slowdowns when quitting Blender,
    or under normal operation when auto-saving backup files.
    See [Compression & Memory Use](../linked_libraries/link_append.xhtml#files-linked-libraries-known-limitations-compression) for more information.

Remap Relative
:   This option remaps [Relative Paths](#files-blend-relative-paths)
    (such as linked libraries and images) when saving a file in a new location.

Save Copy
:   Saves a copy of the actual working state but does not make the saved file active.
user: How do I use Edge Slide in Blender? Include parameters, examples, warnings and best practices.

assistant: # Edge Slide

Slides one or more edges across adjacent faces with a few restrictions involving the selection
of edges (i.e. the selection *must* define a valid loop, see below).

Even `E`
:   Forces the edge loop to match the shape of the adjacent edge loop.
    You can flip to the opposite vertex using `F`.

Flipped `F`
:   When Even mode is active, this flips between the two adjacent edge loops the active edge loop will match.

Clamp `Alt` or `C`
:   Toggle clamping the slide within the edge extents.

Factor
:   Determines the amount of slide performed.
    Negative values correspond to slides toward one face, while positive ones, refer to the other one.
    It is also displayed in the 3D Viewport footer.

Mirror Editing
:   Lets you propagate the operation to the symmetrical elements of the mesh (if present, in local X direction).

Correct UVs
:   Corrects the corresponding UV coordinates, if these exist, to avoid image distortions.
user: What is BlendDataCameras(bpy_struct) and how is it used in Blender Python scripting?

assistant: # BlendDataCameras(bpy_struct)

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

*class* bpy.types.BlendDataCameras(*bpy_struct*)
:   Collection of cameras

    new(*name*)
    :   Add a new camera to the main database

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – New name for the data-block

        Returns:
        :   New camera data-block

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

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

        Parameters:
        :   - **camera** ([`Camera`](bpy.types.Camera.html#bpy.types.Camera "bpy.types.Camera"), (never None)) – Camera to remove
            - **do_unlink** (*boolean**,* *(**optional**)*) – Unlink all usages of this camera before deleting it (WARNING: will also delete objects instancing that camera data)
            - **do_id_user** (*boolean**,* *(**optional**)*) – Decrement user counter of all data-blocks used by this camera
            - **do_ui_user** (*boolean**,* *(**optional**)*) – Make sure interface does not reference this camera

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

assistant: Data Type
:   The [data type](../../attributes_reference.html#attribute-data-types) used for the evaluated data.

Mode
:   How to find endpoint positions for the trimmed spline.
    The option acts the same as it does in the [Trim Curve Node](../operations/trim_curve.html).

    Factor:
    :   Find the endpoint positions using a factor of each spline’s length.
        The input values should be between 0 or 1.

    Length:
    :   Find the endpoint positions using a length from the start of each spline.
        The input values should be between 0 and the length of the splines.

All Curves
:   Sample lengths based on the total length of all curves, rather than using a length inside each selected curve.
user: Show practical ways to work with Spin in a Blender add-on or script – include code.

assistant: # Spin

The *Spin* tool extrudes (or duplicates it if the selection is manifold) the selected elements,
rotating around a specific point and axis.

Use the tool to create the sort of objects that you would produce on a lathe
(this tool is often called “lathe” tool or “sweep” tool in the literature, for this reason).
In fact, it does a sort of circular extrusion of your selected elements,
centered on the 3D cursor, and around the axis perpendicular to the working view…

- The point of view will determine around which axis the extrusion spins…
- The position of the 3D cursor will be the center of the rotation.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Geometry
:   Standard geometry input.

Selection
:   Boolean field indicating which elements to scale.

Scale
:   The scaling factor for each element.

Center
:   The pivot point for each element.

Axis Single Axis Mode Only
:   Axis along which to scale each element. This vector is normalized internally, so the length does not matter.

Scale Mode
:   Uniform:
    :   Scale elements by the same factor in every direction.

    Single Axis:
    :   Scale elements in a single direction defined by the *Axis* input.
user: Give a detailed overview of Distribute Points on Faces: syntax, arguments, return values, common patterns.

assistant: # Distribute Points on Faces

[image reference removed]

The *Distribute Points on Faces* node places points on the surface of the input geometry object.
Point, corner, and polygon attributes of the input geometry are transferred to the generated points.
That includes vertex weights and UV maps.
Additionally, the node has *Normal* and *Rotation* outputs.

The node also generates a stable ID, stored in the built-in `id` attribute, used as
a stable identifier for each point. When the mesh is deformed or the density changes
the values will be consistent for each remaining point. This attribute is used in
the [Random Value](../utilities/random_value.html) and
[Instance on Points](../instances/instance_on_points.html) nodes.
user: What is Propagate and how is it used in Blender Python scripting?

assistant: # Propagate

The Propagate tool copies the pose of the selected bones on the current frame over
to the keyframes delimited by the *Termination Mode*.
It automates the process of copying and pasting.

Termination Mode
:   Modes which determine how it decides when to stop overwriting keyframes.

    To Next Keyframe
    :   Simply copies the pose to the first keyframe after (but not including any keyframe on) the current frame.

    To Last Keyframe
    :   Will simply replace the last keyframe (i.e. making action cyclic).

    Before Frame
    :   To all keyframes between current frame and the *End frame* option.
        This option is best suited for use from scripts due to the difficulties in setting this frame value,
        though it is possible to set this manually
        via the [Adjust Last Operation](../../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel if necessary.

    Before Last Keyframe
    :   To all keyframes from current frame until no more are found.

    On Selected Keyframes
    :   Will apply the pose of the selected bones to all selected keyframes.

    On Selected Markers
    :   To all keyframes occurring on frames with Scene Markers after the current frame.

End Frame
:   Defines the upper-bound for the frame range within which keyframes
    will be affected (with the lower bound being the current frame).
user: Give a detailed overview of Known Issues: syntax, arguments, return values, common patterns.

assistant: ### Dense Meshes

Selecting dense meshes with X-Ray disabled, has a limitation where dense meshes may not have
all the elements selected.
When selecting regions with Box, Circle and Lasso select, vertices may overlap each other causing
some vertices not to be selected.
This is a limitation with the current selection method, you may workaround this by zooming in or enabling X-Ray.

### N-Gons in Face Select Mode

[image reference removed]

N-gon face having its center dot inside another face.

As already noted, in X-Ray and Wireframe mode faces are marked with a dot in the middle.
With n-gons that can lead in certain cases to a confusing display.
The example shows the center dot of the U-shaped n-gon being inside of the oblong face inside the “U”.
It is not easy to identify which dot belongs to which face (the orange dot in the image is the object origin).
user: What is Inherited Properties and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`StripModifier.name`](bpy.types.StripModifier.html#bpy.types.StripModifier.name "bpy.types.StripModifier.name") - [`StripModifier.type`](bpy.types.StripModifier.html#bpy.types.StripModifier.type "bpy.types.StripModifier.type") - [`StripModifier.mute`](bpy.types.StripModifier.html#bpy.types.StripModifier.mute "bpy.types.StripModifier.mute") - [`StripModifier.enable`](bpy.types.StripModifier.html#bpy.types.StripModifier.enable "bpy.types.StripModifier.enable") - [`StripModifier.show_expanded`](bpy.types.StripModifier.html#bpy.types.StripModifier.show_expanded "bpy.types.StripModifier.show_expanded") | - [`StripModifier.input_mask_type`](bpy.types.StripModifier.html#bpy.types.StripModifier.input_mask_type "bpy.types.StripModifier.input_mask_type") - [`StripModifier.mask_time`](bpy.types.StripModifier.html#bpy.types.StripModifier.mask_time "bpy.types.StripModifier.mask_time") - [`StripModifier.input_mask_strip`](bpy.types.StripModifier.html#bpy.types.StripModifier.input_mask_strip "bpy.types.StripModifier.input_mask_strip") - [`StripModifier.input_mask_id`](bpy.types.StripModifier.html#bpy.types.StripModifier.input_mask_id "bpy.types.StripModifier.input_mask_id") - [`StripModifier.is_active`](bpy.types.StripModifier.html#bpy.types.StripModifier.is_active "bpy.types.StripModifier.is_active") |
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`XrActionMapItem.user_paths`](bpy.types.XrActionMapItem.html#bpy.types.XrActionMapItem.user_paths "bpy.types.XrActionMapItem.user_paths") - [`XrUserPaths.find`](bpy.types.XrUserPaths.html#bpy.types.XrUserPaths.find "bpy.types.XrUserPaths.find") | - [`XrUserPaths.new`](bpy.types.XrUserPaths.html#bpy.types.XrUserPaths.new "bpy.types.XrUserPaths.new") - [`XrUserPaths.remove`](bpy.types.XrUserPaths.html#bpy.types.XrUserPaths.remove "bpy.types.XrUserPaths.remove") |
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Shader
:   Shaders to mix, such that incoming rays hit either with the specified probability in the *Factor* socket.

Factor
:   Blend weight to use for mixing two shaders;
    at zero it uses the first shader entirely and at one the second shader.
user: Show practical ways to work with limbs.arm in a Blender add-on or script – include code.

assistant: Will create a fully featured bendy and stretchy arm depending on the user-defined options.

Requirement: A chain of three connected bones (upper_arm, forearm, hand).

[image reference removed]

Arm required bones.

IK Wrist Pivot
:   Generates an extra child of the hand IK control that rotates around the tail of the hand bone.

Rotation Axis (Automatic, X, Z)
:   Defines the bend axis for the IK chain. FK chains will have a totally free degree of rotation on all axes.

Limb Segments (integer)
:   Defines the number of additional tweak controls each limb bone will have on the final rig.

B-Bone Segments (integer)
:   Defines the number of b-bone segments each tweak control will be split into.

Custom IK Pivot
:   Generates an extra control for the end of the IK limb that allows rotating it around an arbitrarily placed pivot.

Assign FK Layers
:   If enabled, allows placing the FK chain in different bone collections from the IK bones.

Assign Tweak Layers
:   If enabled, allows placing the Tweak controls in different bone collections from the IK bones.
user: Show practical ways to work with face.basic_tongue in a Blender add-on or script – include code.

assistant: Generates a simple tongue, extracted from the original PitchiPoy [super_face](faces.html#rigify-rigs-faces-super-face) rig.

B-Bone Segments (integer)
:   Defines the number of b-bone segments each tweak control will be split into.

Primary Control Layers
:   Optionally specifies bone collections for the main control.
user: Explain SDF Grid Offset Node in complete detail according to the official Blender documentation.

assistant: # SDF Grid Offset Node

[image reference removed]

The *SDF Grid Offset* node offsets the surface of a Signed Distance Field (SDF)
by a specified world-space distance.
This operation effectively dilates (expands) or erodes (contracts) the
surface while maintaining the correct signed distance values across the field.

A positive offset increases the surface thickness by pushing it outward,
while a negative offset shrinks it inward. This is a fundamental operation in
volumetric modeling, useful for adjusting wall thickness, creating shells,
expanding collision volumes, or controlling blend margins between shapes.