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

assistant: The inputs are dynamic, they become available if needed depending on the node properties.

Vector
:   Texture coordinate to evaluate the noise at;
    defaults to *Generated* texture coordinates if the socket is left unconnected.

W
:   Texture coordinate to evaluate the noise at.

Scale
:   Scale of the noise.

Detail
:   Number of noise octaves.
    The fractional part of the input is multiplied by the magnitude of the highest octave.
    Higher number of octaves corresponds to a higher evaluation time.

Roughness
:   Blend between a smoother noise pattern, and rougher with sharper peaks.

Lacunarity
:   The difference between the scale of each two consecutive octaves.
    Larger values corresponds to larger scale for higher octaves.

Smoothness
:   The smoothness of the noise.

    |  |  |  |  |
    | --- | --- | --- | --- |
    | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-distance-zero.png   Smoothness: 0.0. | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-distance-quarter.png   Smoothness: 0.25. | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-distance-half.png   Smoothness: 0.5. | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-distance-one.png   Smoothness: 1.0. |
    | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-color-zero.png   Smoothness: 0.0. | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-color-quarter.png   Smoothness: 0.25. | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-color-half.png   Smoothness: 0.5. | ../../../_images/render_shader-nodes_textures_voronoi_smoothness-color-one.png   Smoothness: 1.0. |

Exponent
:   Exponent of the Minkowski distance metric.

    |  |  |  |  |
    | --- | --- | --- | --- |
    | ../../../_images/render_shader-nodes_textures_voronoi_minkowski-half.png   Exponent: 0.5. | ../../../_images/render_shader-nodes_textures_voronoi_minkowski-one.png   Exponent: 1.0. | ../../../_images/render_shader-nodes_textures_voronoi_minkowski-two.png   Exponent: 2.0. | ../../../_images/render_shader-nodes_textures_voronoi_minkowski-32.png   Exponent: 32.0. |

Randomness
:   The randomness of the noise.

    |  |  |  |  |
    | --- | --- | --- | --- |
    | ../../../_images/render_shader-nodes_textures_voronoi_randomness-one.png   Randomness: 1.0. | ../../../_images/render_shader-nodes_textures_voronoi_randomness-half.png   Randomness: 0.5. | ../../../_images/render_shader-nodes_textures_voronoi_randomness-quarter.png   Randomness: 0.25. | ../../../_images/render_shader-nodes_textures_voronoi_randomness-zero.png   Randomness: 0.0. |
user: Give a detailed overview of Position Offsetting: syntax, arguments, return values, common patterns.

assistant: The constraint uses its owner’s position and rotation in [World Space](../../../glossary/index.xhtml#term-World-Space)
as offsets to the position and rotation on the Curve. If *Follow Curve*
is disabled, the offsets are added in the Curve’s [Local Space](../../../glossary/index.xhtml#term-Local-Space).
If it’s enabled, the offsets are added in the space of the current curve point,
with the global Y axis corresponding to the tangent direction.

In both cases, the Curve’s scale acts as a multiplier for the position offset.

|  |  |  |
| --- | --- | --- |
| ../../../_images/animation_constraints_relationship_follow-path_offset-no-constraint.png   Before adding the constraint, the cone is offset along the world Y axis. | ../../../_images/animation_constraints_relationship_follow-path_offset-no-follow-curve.png   After adding the constraint, the cone is offset along the Curve’s local Y axis. | ../../../_images/animation_constraints_relationship_follow-path_offset-follow-curve.png   When enabling Follow Curve, the cone is offset along the curve point’s tangent. |

To have the owner perfectly positioned and aligned on the Curve, ensure its
world position and rotation are both zero. This can be done by pressing `Alt`-`G`
and `Alt`-`R` respectively.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: The *Closure* node does not have functional properties of its own, but its interface is configurable through the
*Node* tab in the Sidebar. Inputs and outputs can be added, removed, and renamed to define the closure’s signature.

Sync Sockets
:   Updates the current node to match the socket signature of the connected nodes.
    Use this after renaming, adding, or removing sockets.

Define Signature
:   Marks the current zone as the source of a closure signature that other nodes can reference. This ensures consistent
    input and output definitions across multiple closure instances.

### Input Items

List of input sockets
:   Displays one entry per socket defined in the closure. Double-click an entry to rename it.

Add Item
:   Add a new input socket to the closure.

Remove Item
:   Delete the selected input socket.

Type
:   Defines the data type for the selected socket (e.g. Float, Vector, Geometry, Object, Bundle).
    For value types, a default value control appears and is used when the socket is unlinked.

Shape
:   Defines the data structure supported by the input socket, such as a *Single* value, *Field*, or *Grid*.
    The shape determines how the data is evaluated and passed through the node network.
    See [Socket Shape](../../../../interface/controls/nodes/parts.xhtml#interface-controls-nodes-socket-shape) for more information.

### Output Items

Available when the closure’s output zone is selected.

List of output sockets
:   Displays one entry per socket defined in the closure output. Double-click to rename.

Add Item
:   Add a new output socket to the closure.

Remove Item
:   Delete the selected output socket.

Type
:   Defines the data type for the selected socket (e.g. Float, Vector, Geometry, Object, Bundle).
    For value types, a default value control appears and is used when the socket is unlinked.

Shape
:   Defines the data structure supported by the input socket, such as a *Single* value, *Field*, or *Grid*.
    The shape determines how the data is evaluated and passed through the node network.
    See [Socket Shape](../../../../interface/controls/nodes/parts.xhtml#interface-controls-nodes-socket-shape) for more information.
user: Show practical ways to work with Inline Shader Nodes in a Blender add-on or script – include code.

assistant: ```
import bpy

# The materials should be retrieved from the evaluated object to make sure that
# e.g. edits of Geometry Nodes are applied.
depsgraph = bpy.context.view_layer.depsgraph
ob = bpy.context.active_object
ob_eval = depsgraph.id_eval_get(ob)
material_eval = ob_eval.material_slots[0].material

# Compute the inlined shader nodes.
# Important: Do not loose the reference to this object while accessing the inlined
#   node tree. Otherwise there will be a crash due to a dangling pointer.
inline_shader_nodes = material_eval.inline_shader_nodes()

# Get the actual inlined `bpy.types.NodeTree`.
tree = inline_shader_nodes.node_tree

for node in tree.nodes:
    print(node.name)
```

*class* bpy.types.InlineShaderNodes
:   An inlined shader node tree.

    node_tree
    :   The inlined node tree.

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

    *static* from_light(*light*)
    :   Create an inlined shader node tree from a light.

        Parameters:
        :   **light** ([*bpy.types.Light*](bpy.types.Light.html#bpy.types.Light "bpy.types.Light")) – The light to online the node tree of.

    *static* from_material(*material*)
    :   Create an inlined shader node tree from a material.

        Parameters:
        :   **material** ([*bpy.types.Material*](bpy.types.Material.html#bpy.types.Material "bpy.types.Material")) – The material to inline the node tree of.

    *static* from_world(*world*)
    :   Create an inlined shader node tree from a world.

        Parameters:
        :   **world** ([*bpy.types.World*](bpy.types.World.html#bpy.types.World "bpy.types.World")) – The world to inline the node tree of.
user: Give a detailed overview of Source: syntax, arguments, return values, common patterns.

assistant: Emit From
:   Defines how and where the particles are emitted,
    giving precise control over their distribution.

    Vertices
    :   Emits particles from the vertices of a mesh.

    Faces
    :   Emits particles from the surface of a mesh’s faces.

    Volume
    :   Emits particles from the volume of an enclosed mesh.

Use Modifier Stack
:   Take any [Modifiers](../../../modeling/modifiers/introduction.xhtml) above the Particle Modifier
    in the [modifier stack](../../../modeling/modifiers/introduction.xhtml#modifier-stack) into account when emitting particles,
    else it uses the original mesh geometry.

Distribution
:   These settings control how the emissions of particles are distributed
    throughout the emission locations when emitting from either *Faces* or *Volume*.

    Jittered
    :   Particles are placed at jittered intervals on the emitter elements.

        Particles/Face
        :   Number of emissions per face (0 = automatic).

        Jittering Amount
        :   Amount of jitter applied to the sampling.

    Random
    :   Particles are emitted from random locations in the emitter’s elements.

    Grid
    :   Particles are set in a 3D grid and particles near/in the elements are kept.

        Invert Grid
        :   Invert what is considered the object and what is not.

        Hexagonal
        :   Uses a hexagonal-shaped grid instead of a rectangular one.

        Resolution
        :   Resolution of the grid.

        Random
        :   Add a random offset to grid locations.

Random Order
:   The emitter element indices are gone through
    in a random order instead of linearly (one after the other).

    Not available for *Grid* distribution.

Even Distribution
:   Particle distribution is made even based on surface area of the elements,
    i.e. small elements emit less particles than large elements, so that the particle density is even.
user: What is Mesh Filter and how is it used in Blender Python scripting?

assistant: # Mesh Filter

Applies a deformation to all vertices in the mesh at the same time.
Masking, auto-masking and visibility will be taken into account.

To use this tool, click and drag away from left to right
or from right to left for a negative effect.
user: Explain Mirror Modifier in complete detail according to the official Blender documentation.

assistant: # Mirror Modifier

The *Mirror* modifier mirrors the strokes along its local X, Y and/or Z axes, across the [Object Origin](../../../glossary/index.xhtml#term-Object-Origin).
It can also use another object as the mirror center, then use that object’s local axes instead of its own.
user: Give a detailed overview of Smart UV Project: syntax, arguments, return values, common patterns.

assistant: Examines the angles between the selected faces, cuts them along any sharp edges, then projects each separated group
of faces along its average normal and lays it out on the UV map. You can also set up
[seams](../uv/unwrapping/seams.html) for additional cutting. This is a good method for, say,
mechanical objects or architecture.

[image reference removed]

Smart UV project on a truncated pyramid.

### Options

The [Adjust Last Operation](../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel allows fine control over how the mesh is unwrapped:

Angle Limit
:   The maximum allowed angle between the normals of adjacent faces before they’re split off from each other.
    A low limit will create lots of small UV islands with little distortion, while a high limit will create
    a few large islands with potentially more distortion.

Margin Method
:   The meaning of the *Island Margin* parameter, which determines the size of the empty space between UV islands.

    Scaled
    :   The *Island Margin* is a more or less arbitrary measure with no direct relation to the sizes of the
        UV islands or the texture.

    Add
    :   As above, but without the internally calculated scaling factor.

    Fraction
    :   The *Island Margin* is a fraction of the UV unit square. This means that, if you have a 1024x1024
        texture and set the *Island Margin* to 1/1024, each UV island will have a margin of 1 pixel around it
        (and islands will be no closer than 2 pixels to each other).

Rotation Method
:   Axis-aligned
    :   Automatically rotate to avoid wasting space.

    Axis-aligned (Horizontal)
    :   Rotate islands to be aligned horizontally.

    Axis-aligned (Vertical)
    :   Rotate islands to be aligned vertically.

Island Margin
:   How much empty space to leave between islands. Controlled by *Margin Method*.

Area Weight
:   With a value of 0, the projection vector of each face group is simply the average of its face normals.
    With a value of 1, it’s an average that’s weighted using the faces’ areas. Other values blend between the two.

Correct Aspect
:   Adjusts the UV mapping to account for the aspect ratio of the image associated with the material.
    This ensures that UVs are scaled correctly when unwrapping onto non-square textures.

    For this option to work, the mesh must have a material with an
    [Image Texture node](../../../render/shader_nodes/textures/image.html), and this node must be selected in the
    [Shader Editor](../../../editors/shader_editor.html).

Scale to Bounds
:   Stretches the resulting UV map to fill the complete texture.
user: Provide the full official documentation entry for Navigating, preserving all code examples.

assistant: While performing a transformation, you can perform navigation actions such as zooming,
panning, or rotating by holding `Alt` then perform the desired action.

This behavior can be changed through the *Transform Navigation with Alt* setting
in the [Keymap](../../editors/preferences/keymap.xhtml) Preferences.
user: Explain Convex Hull in complete detail according to the official Blender documentation.

assistant: # Convex Hull

The Convex Hull operator takes a point cloud as input and outputs a convex hull surrounding those vertices.
If the input contains edges or faces that lie on the convex hull, they can be used in the output as well.
This operator can be used as a bridge tool as well.

[image reference removed]

Input mesh, point cloud, and Convex Hull result.

Delete Unused
:   Removes vertices, edges, and faces that were selected, but not used as part of the hull.
    Note that vertices and edges that are used
    by other edges and faces not part of the selection will not be deleted.

Use Existing Faces
:   Where possible, use existing input faces that lie on the hull.
    This allows the convex hull output to contain n-gons rather than triangles
    (or quads if the *Join Triangles* option is enabled).

Make Holes
:   Delete edges and faces in the hull that were part of the input too.
    Useful in cases like bridging to delete faces between the existing mesh and the convex hull.

Join Triangles
:   Joins adjacent triangles into quads.
    Has all the same properties as the [Triangles to Quads](../face/triangles_quads.html#bpy-ops-mesh-tris-convert-to-quads)
    operator (angle limit, compare UVs, etc.).

Max Face Angle, Max Shape Angle, Compare
:   See [Triangles to Quads](../face/triangles_quads.html#bpy-ops-mesh-tris-convert-to-quads).
user: Describe Sidebar from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Options

The Options panel in the Sidebar region contains the same [settings](../render/materials/settings.html)
that are also available in the Material tab in the Properties.
They differ depending on the selected render engine.
The settings are duplicated to make it possible to edit the entire material from the Shader editor.
user: How do I use Install from Zip in Blender? Include parameters, examples, warnings and best practices.

assistant: When choosing the zip-file, you have to manually extract Blender to the desired folder, where you can double-click the
executable to run Blender.

No start menu item will be created and no blend-file association will be registered,
but there is also no need for administrator rights. You can register the file association
manually by clicking [Register](../../editors/preferences/system.xhtml#bpy-ops-preferences-associate-blend) on the System tab of the
[Preferences](../../editors/preferences/system.xhtml). Alternatively, you can run `blender -r`
from the [Command Line](../../advanced/command_line/arguments.xhtml).

To make the installation and configuration fully self-contained, set up a
[Portable Installation](../../advanced/blender_directory_layout.xhtml#portable-installation).
user: Show practical ways to work with Saving Images in a Blender add-on or script – include code.

assistant: File Format
:   Choose the image file format to save to. Based on which format is used,
    other options such as channels, bit depth and compression level are available.

Color
:   The color format to save the image or video to.
    This setting is used by some formats to optimize how much data is written to the file.
    Note, *RGBA* is not available for all image formats, check the list above for details.

    BW:
    :   Saves the image using grayscale colors.

    RGB:
    :   Saves red, green and blue channels

    RGBA:
    :   Saves red, green, blue and alpha channels.

Color Depth
:   Defines the bit depth per color channel, determining how many color values can be represented.

    Higher bit depths reduce color banding and improve precision but also increase file size and memory usage.
    Note, not all file formats support all color depths.

    8:
    :   Most common for on-screen graphics, web, and standard video. Suitable for general-purpose use.

    10, 12, 16:
    :   Used by formats focused on photography and digital cinema (e.g., DPX, JPEG 2000).
        Provides more tonal range and color detail than 8-bit.

    32:
    :   32-bit floating point per channel. Provides the highest precision and dynamic range.
        Highest possible color depth, primarily used with OpenEXR for visual effects and compositing workflows.

    Float (Half):
    :   16-bit floating point per channel. Offers high dynamic range with lower memory and storage usage.
        Only supported for OpenEXR files.

    Float (Full):
    :   32-bit floating point per channel. Provides the highest precision and dynamic range.
        Only supported for OpenEXR files.

Compression
:   Used to reduce the size of the image file.
    How this is done may vary depending on the file format and settings used.

Quality
:   Controls the level of lossy compression applied to the image, expressed as a percentage.
    Lossy compression reduces file size by discarding some image data, which may result in a loss of detail.

    - **0%**: Maximum compression, producing the smallest file size but the most noticeable quality loss.
    - **100%**: No compression, preserving full image quality at the cost of a larger file size.

Save As Render
:   Save image with render [color management](../../render/color_management/index.html).
    For display image formats like PNG, apply view and display transform.
    For intermediate image formats like OpenEXR, use the default render output color space.

Copy
:   Defines if the data-block will reference the newly created file
    or the reference will be unchanged, maintaining it with the original one.

Color Space
:   To specify the color space of the source file.

    The list of color spaces depends on the active [OCIO config](../../render/color_management/opencolorio.html#ocio-config).
    The default supported color spaces are described in detail here:
    [Default OpenColorIO Configuration](../../render/color_management/color_spaces.html#ocio-config-default-color-spaces)
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: The *Evaluate Closure* node does not have functional properties, but its input and output interface can be managed in
the *Node* tab of the Sidebar.

Sync Sockets
:   Updates the current node to match the socket signature of the connected nodes.
    Use this after renaming, adding, or removing sockets.

Define Signature
:   Marks the node as defining a closure signature to be used by other closure nodes. Ensures consistent input and output
    definitions across related closures.

### Input Items

List of input sockets
:   Displays one entry per socket defined in the closure. Double-click to rename.

Add Item
:   Add a new input socket to the closure interface.

Remove Item
:   Delete the selected input socket.

Type
:   The data type for the selected socket (e.g. Float, Vector, Geometry, Object, Bundle).
    For value types, a default value field appears and is used when the socket is unlinked.

Shape
:   Defines the data structure supported by the input socket, such as a *Single* value, *Field*, or *Grid*.
    The shape determines how the data is evaluated and passed through the node network.
    See [Socket Shape](../../../../interface/controls/nodes/parts.xhtml#interface-controls-nodes-socket-shape) for more information.

### Output Items

List of output sockets
:   Displays one entry per output socket. Double-click to rename.

Add Item
:   Add a new output socket to the node.

Remove Item
:   Delete the selected output socket.

Type
:   The data type for the selected socket (e.g. Float, Vector, Geometry, Object, Bundle).
    For value types, a default value field appears and is used when the socket is unlinked.
user: Give a detailed overview of VertexGroupElement(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # VertexGroupElement(bpy_struct)

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

*class* bpy.types.VertexGroupElement(*bpy_struct*)
:   Weight value of a vertex in a vertex group

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

    weight
    :   Vertex Weight

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

assistant: Simply check out the Blender Manual’s repository using:

```
cd ~
git clone https://projects.blender.org/blender/blender-manual.git
```

The repository will now be downloaded which may take a few minutes depending on your internet connection.
user: What is Index – J and how is it used in Blender Python scripting?

assistant: # Index – J

|  |  |
| --- | --- |
| - [jitter (bpy.types.Brush attribute)](bpy.types.Brush.html#bpy.types.Brush.jitter) - [jitter_absolute (bpy.types.Brush attribute)](bpy.types.Brush.html#bpy.types.Brush.jitter_absolute) - [jitter_factor (bpy.types.ParticleSettings attribute)](bpy.types.ParticleSettings.html#bpy.types.ParticleSettings.jitter_factor) - [jitter_unit (bpy.types.Brush attribute)](bpy.types.Brush.html#bpy.types.Brush.jitter_unit) - [join() (aud.aud.Sound method)](aud.html#aud.aud.Sound.join)   - [(in module bpy.ops.node)](bpy.ops.node.html#bpy.ops.node.join)   - [(in module bpy.ops.object)](bpy.ops.object.html#bpy.ops.object.join)   - [(in module bpy.ops.palette)](bpy.ops.palette.html#bpy.ops.palette.join) - [join_named() (in module bpy.ops.node)](bpy.ops.node.html#bpy.ops.node.join_named) - [join_nodes() (in module bpy.ops.node)](bpy.ops.node.html#bpy.ops.node.join_nodes) - [join_selection() (in module bpy.ops.grease_pencil)](bpy.ops.grease_pencil.html#bpy.ops.grease_pencil.join_selection) - [join_shapes() (in module bpy.ops.object)](bpy.ops.object.html#bpy.ops.object.join_shapes) | - [join_tracks() (in module bpy.ops.clip)](bpy.ops.clip.html#bpy.ops.clip.join_tracks) - [join_triangles() (in module bmesh.ops)](bmesh.ops.html#bmesh.ops.join_triangles) - [join_uvs() (in module bpy.ops.object)](bpy.ops.object.html#bpy.ops.object.join_uvs) - [joint_bindings (bpy.types.SplineIKConstraint attribute)](bpy.types.SplineIKConstraint.html#bpy.types.SplineIKConstraint.joint_bindings) - [jpeg2k_codec (bpy.types.ImageFormatSettings attribute)](bpy.types.ImageFormatSettings.html#bpy.types.ImageFormatSettings.jpeg2k_codec) - [jump() (in module bpy.ops.text)](bpy.ops.text.html#bpy.ops.text.jump) - [jump_height (bpy.types.WalkNavigation attribute)](bpy.types.WalkNavigation.html#bpy.types.WalkNavigation.jump_height) - [jump_to_file_at_point() (in module bpy.ops.text)](bpy.ops.text.html#bpy.ops.text.jump_to_file_at_point) - [jump_to_target_button() (in module bpy.ops.ui)](bpy.ops.ui.html#bpy.ops.ui.jump_to_target_button) |
user: Explain Combine Color Node in complete detail according to the official Blender documentation.

assistant: # Combine Color Node

[image reference removed]

The *Combine Color Node* combines an image from its composite color channels.
The node can combine multiple [Color Models](../../../glossary/index.xhtml#term-Color-Model) depending on the Mode property.
user: What is B and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [**Baking**](glossary/index.xhtml#term-Baking) - [**Bevel**](glossary/index.xhtml#term-Bevel) - [**Bézier**](glossary/index.xhtml#term-Bezier) - [**Bit Depth**](glossary/index.xhtml#term-Bit-Depth) - [**Blend Modes**](glossary/index.xhtml#term-Blend-Modes) - [**Blender Session**](glossary/index.xhtml#term-Blender-Session) - [**Bone**](glossary/index.xhtml#term-Bone) - [**Bone Collection**](glossary/index.xhtml#term-Bone-Collection) | - [**Boolean**](glossary/index.xhtml#term-Boolean) - [**Bounding Box**](glossary/index.xhtml#term-Bounding-Box) - [**Bounding Volume Hierarchy**](glossary/index.xhtml#term-Bounding-Volume-Hierarchy) - bssrdf()   - [built-in function](render/cycles/osl/index.xhtml#id0) - built-in function   - [bssrdf()](render/cycles/osl/index.xhtml#id0) - [**Bump Mapping**](glossary/index.xhtml#term-Bump-Mapping) - [**BVH**](glossary/index.xhtml#term-BVH) |
user: Provide the full official documentation entry for Spline Types, preserving all code examples.

assistant: ### Poly

Poly splines are the simplest type, with no interpolation between control points.
They are used when [converting meshes to curves](../../scene_layout/object/editing/convert.xhtml#bpy-ops-object-convert)
for accurate representation of the original mesh.
While Poly splines are precise, [Bézier](#bezier) or [NURBS](#nurbs) splines are generally preferred for smooth curves.

### Bézier

Bézier splines use control points and handles to define their shape.
A curve segment exists between two control points, with the handles controlling the curvature.

In the illustration below, the control points are at the center of the pink lines, while the handles extend outward.
The arrows represent the curve normals, indicating direction and tilt.

[image reference removed]

Bézier Curve in Edit Mode.

#### Handle Types

Bézier curves support four handle types, which can be changed with `V`:

[image reference removed]

Bézier Curve Handle Types.

Automatic:
:   Automatically adjusts handle length and direction for the smoothest curve.
    Displayed as yellow handles. Converts to *Aligned* when moved.

Vector:
:   Handles point directly toward adjacent control points, enabling straight lines or sharp corners.
    Displayed as green handles. Converts to *Free* when moved.

Aligned:
:   Handles remain on a straight line, ensuring smooth, continuous curves.
    Displayed as purple handles.

Free:
:   Handles move independently, allowing for asymmetric curves.
    Displayed as black handles.

### NURBS

NURBS (Non-Uniform Rational B-Splines) are mathematically precise splines, offering exact shapes.
Unlike Bézier curves, which approximate shapes (e.g., a Bézier circle approximates a perfect circle),
NURBS can represent exact geometry.

For more information, refer to the [Wikipedia page](https://en.wikipedia.org/wiki/NURBS).

NURBS control points have a unique weight property that determines their influence on the curve.
This weight differs from the [Goal Weight](editing/transform_panel.xhtml#curves-weight) used in soft body simulations.
Weights can be adjusted in the *W* field of the [Transform panel](editing/transform_panel.xhtml).
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Is Camera Ray
:   1.0 if shading is executed for a camera ray, otherwise 0.0.

Is Shadow Ray
:   1.0 if shading is executed for a shadow ray, otherwise 0.0.

Is Diffuse Ray
:   1.0 if shading is executed for a diffuse ray, otherwise 0.0.

Is Glossy Ray
:   1.0 if shading is executed for a glossy ray, otherwise 0.0.

Is Singular Ray Cycles Only
:   1.0 if shading is executed for a singular ray, otherwise 0.0.

Is Reflection Ray Cycles Only
:   1.0 if shading is executed for a reflection ray, otherwise 0.0.

Is Transmission Ray Cycles Only
:   1.0 if shading is executed for a transmission ray, otherwise 0.0.

Is Volume Scatter Ray Cycles Only
:   1.0 if shading is executed for a volume scatter ray, otherwise 0.0.

Ray Length Cycles Only
:   Distance traveled by the light ray from the last bounce or camera.

Ray Depth
:   Number of times the ray has been reflected or transmitted on interaction with a surface.

Diffuse Depth Cycles Only
:   Number of times the ray has gone through diffuse reflection or transmission.

Glossy Depth Cycles Only
:   Number of times the ray has gone through glossy reflection or transmission.

Transparent Depth Cycles Only
:   Number of times the ray has gone through a transparent surface.

Transmission Depth Cycles Only
:   Number of times the ray has gone through a transmissive surface.
    A typical use case is to avoid black spots in the render (caused by rays hitting
    the bounce limit) by switching from a transmissive to a diffuse shader past a
    certain point. See [Mix Shader](../shader/mix.html).

Portal Depth: Cycles Only
:   Number of times the ray has passed through a [Ray Portal BSDF](../shader/ray_portal.html).
user: Describe SimulationZoneViewerPathElem(ViewerPathElem) from the Blender manual or Python API, including usage steps and snippets.

assistant: # SimulationZoneViewerPathElem(ViewerPathElem)

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

*class* bpy.types.SimulationZoneViewerPathElem(*ViewerPathElem*)
:   sim_output_node_id
    :   Type:
        :   int in [-inf, inf], default 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: What is FunctionNodeFloatToInt(FunctionNode) and how is it used in Blender Python scripting?

assistant: # FunctionNodeFloatToInt(FunctionNode)

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

*class* bpy.types.FunctionNodeFloatToInt(*FunctionNode*)
:   Convert the given floating-point number to an integer, with a choice of methods

    rounding_mode
    :   Method used to convert the float to an integer

        Type:
        :   enum in [Node Float To Int Items](bpy_types_enum_items/node_float_to_int_items.html#rna-enum-node-float-to-int-items), default `'ROUND'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # NodesModifierPanels(bpy_struct)

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

*class* bpy.types.NodesModifierPanels(*bpy_struct*)
:   State of all panels defined by the node group

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

assistant: The following table shows the available hotkeys for the animation player.

Playback

| Action | Hotkey |
| --- | --- |
| Start/Pause: | `Spacebar` |
| Start playback (when paused): | `Return` |
| Quit: | `Esc` |

Timeline

| Action | Hotkey |
| --- | --- |
| Scrub in time: | `LMB` |
| Step back one frame: | `Left` |
| Step forward one frame: | `Right` |
| Step back 10 frames: | `Down` |
| Step forward 10 frames: | `Up` |
| Manual frame stepping: | `NumpadPeriod` |

Playback Options

| Action | Hotkey |
| --- | --- |
| Backward playback: | `Shift`-`Down` |
| Forward playback | `Shift`-`Up` |
| Slow down playback: | `NumpadMinus` |
| Speed up playback: | `NumpadPlus` |
| Toggle looping: | `Numpad0` |
| Toggle frame skipping: | `A` |
| Toggle ping-pong: | `P` |

Display

| Action | Hotkey |
| --- | --- |
| Toggle Playhead (Indicator): | `I` |
| Flip image on the X axis: | `F` |
| Flip image on the Y axis: | `Shift`-`F` |
| Hold to show frame numbers: | `Shift` |
| Zoom in: | `Ctrl`-`NumpadPlus` |
| Zoom out: | `Ctrl`-`NumpadMinus` |

Frame Rate

| Action | Hotkey |
| --- | --- |
| 60 fps | `Numpad1` |
| 50 fps | `Numpad2` |
| 30 fps | `Numpad3` |
| 25 fps | `Numpad4` |
| 24 fps | `Shift`-`Numpad4` |
| 20 fps | `Numpad5` |
| 15 fps | `Numpad6` |
| 12 fps | `Numpad7` |
| 10 fps | `Numpad8` |
| 6 fps | `Numpad9` |
| 5 fps | `NumpadSlash` |
user: Provide the full official documentation entry for Named Layer Selection Node, preserving all code examples.

assistant: # Named Layer Selection Node

[image reference removed]

The *Named Layer Selection* node outputs a Boolean field whose index value is true
for [Grease Pencil layers](../../../../grease_pencil/properties/layers.html) whose name matches a string input.
user: Describe ShaderNodeRGBToBW(ShaderNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ShaderNodeRGBToBW(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.ShaderNodeRGBToBW(*ShaderNode*)
:   Convert a color’s luminance to a grayscale value

    *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 Views Format Items in complete detail according to the official Blender documentation.

assistant: # Views Format Items

INDIVIDUAL:
:   Individual.

    Individual files for each view with the prefix as defined by the scene views.

STEREO_3D:
:   Stereo 3D.

    Single file with an encoded stereo pair.
user: Provide the full official documentation entry for Waveform, preserving all code examples.

assistant: The waveform of the audio is shown depending on two options:

Overlay
:   The Sequencer Overlay menu has options to show all strip wave-forms, none of them, or to use the per-strip option
    described below.

Strip
:   Each strip has an option *Display Waveform*.
    It is only visible when the above overlay option is set to *Use Strip Option*.

Clipping audio, i.e. values over 100% amplitude, will be shown in red in the waveform.

More strip options are documented in [Sound Sidebar Panel](../../../../editors/video_sequencer/sequencer/sidebar/strip.html#vse-sidebar-strip-sound).
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: [image reference removed]

The Hook modifier.

Object
:   The name of the object to hook points to.

Strength
:   Adjust this hooks influence on the stroke points, were (0.0 to 1.0) (no change to fully follow the hook).

### Falloff

Type
:   This can be used to adjust the type of curve for the Strength attenuation.
    You can also define a custom curve to get a much higher level of control.

Radius
:   The size of the hooks influence.

Uniform Falloff
:   This setting is useful when using hooks on scaled objects,
    especially in cases where non-uniform scale would stretch the result of the hook.

### Influence

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: Give a detailed overview of SDF Grid Boolean Node: syntax, arguments, return values, common patterns.

assistant: # SDF Grid Boolean Node

[image reference removed]

The *SDF Grid Boolean* node performs boolean operations between two or more
**Signed Distance Field (SDF)** grids.
This allows combining, subtracting, or intersecting volumetric shapes directly
in grid space, similar to mesh boolean operations but with smooth and continuous results.

The node computes the resulting signed distance field by applying mathematical
operations to the input grids, preserving the SDF property where each voxel
stores the shortest distance to the nearest surface.
This makes it useful for blending or sculpting complex volumes procedurally.
user: How do I use Rendering in Blender? Include parameters, examples, warnings and best practices.

assistant: With Cycles you can render hair with specialized hair BSDFs
[Hair BSDF](../../../render/shader_nodes/shader/hair.html) or
[Principled Hair BSDF](../../../render/shader_nodes/shader/hair_principled.html).

Hair can also be used as a basis for
the [Particle Instance Modifier](../../../modeling/modifiers/physics/particle_instance.html),
which allows you to have a mesh be deformed along the curves,
which is useful for thicker strands, or things like grass, or feathers, which may have a more specific look.
user: Explain Show/Hide in complete detail according to the official Blender documentation.

assistant: # Show/Hide

You do not have to use bone layers to show/hide some bones. As with objects,
vertices or control points, you can use `H`:

- `H` will hide the selected bone(s).
- `Shift`-`H` will hide all bones *but the selected one(s)*.
- `Alt`-`H` will show all hidden bones.

You can also use the *Hide* checkbox of the Bone tab ‣ Viewport Display panel.

Note that hidden bones are specific to a mode,
i.e. you can hide some bones in *Edit Mode*,
they will still be visible in *Pose Mode*, and vice versa.
Hidden bones in *Pose Mode* are also invisible in *Object Mode*.
And in *Edit Mode*, the bone to hide must be fully selected,
not just its root or tip.
user: Explain Documentation in complete detail according to the official Blender documentation.

assistant: - [Quickstart](info_quickstart.html): New to Blender or scripting and want to get your feet wet?
- [API Overview](info_overview.html): A more complete explanation of Python integration.
- [API Reference Usage](info_api_reference.html): Examples of how to use the API reference docs.
- [Best Practice](info_best_practice.html): Conventions to follow for writing good scripts.
- [Tips and Tricks](info_tips_and_tricks.html): Hints to help you while writing scripts for Blender.
- [Gotchas](info_gotcha.html): Some of the problems you may encounter when writing scripts.
- [Advanced](info_advanced.html): Topics which may not be required for typical usage.
- [Change Log](change_log.html): List of changes since last Blender release
user: Explain Physics Menu in complete detail according to the official Blender documentation.

assistant: Also you can create *Rigid Body Constraint* on one of the two constrained objects with
*Rigid Body Constraint* button of the *Physics* tab in the Properties.
This constraint is dependent on the object location and rotation on which it was created.
This way, there are no empty object created for the constraint.
The role of the empty object is put on this object.
The constrained object can be then be set as a *Passive* type for better driving of the constraint.

Additional parameters appear in the *Rigid Body Constraint* panel of the *Physics* tab in the Properties
for the selected empty object or the one of the two constrained objects with the created constraint.
user: How do I use Inherited Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`NodeTreeInterfaceItem.item_type`](bpy.types.NodeTreeInterfaceItem.html#bpy.types.NodeTreeInterfaceItem.item_type "bpy.types.NodeTreeInterfaceItem.item_type") - [`NodeTreeInterfaceItem.parent`](bpy.types.NodeTreeInterfaceItem.html#bpy.types.NodeTreeInterfaceItem.parent "bpy.types.NodeTreeInterfaceItem.parent") | - [`NodeTreeInterfaceItem.position`](bpy.types.NodeTreeInterfaceItem.html#bpy.types.NodeTreeInterfaceItem.position "bpy.types.NodeTreeInterfaceItem.position") - [`NodeTreeInterfaceItem.index`](bpy.types.NodeTreeInterfaceItem.html#bpy.types.NodeTreeInterfaceItem.index "bpy.types.NodeTreeInterfaceItem.index") |
user: Explain Proxy in complete detail according to the official Blender documentation.

assistant: # Proxy

As projects involve increasingly high-resolution footage,
the performance of the video preview can decrease drastically.
To combat this, Blender can generate proxies – copies of the original footage stored at a
lower quality and/or resolution – to maintain a smooth editing experience without
compromising visual fidelity in the end result.

The quickest way to set up proxies for videos is to simply select a
[Proxy Render Size](../../preview/sidebar.html#bpy-types-spacesequenceeditor-proxy-render-size)
in the *View* tab (visible when the editor is in *Preview* or
*Sequencer & Preview* mode). This will automatically enable the selected
proxy resolution in all the strips and start generating the downscaled video files.

You can use the *Proxy* tab if you want to configure proxies in more detail
(or create proxies for image sequences).
user: What is Smooth Corrective Modifier and how is it used in Blender Python scripting?

assistant: # Smooth Corrective Modifier

The *Smooth Corrective* modifier is used to reduce highly distorted areas of a mesh by smoothing the deformations.

This is typically useful *after* an [Armature modifier](armature.xhtml),
where distortion around joints may be hard to avoid, even with careful weight painting.

To use this modifier effectively, it is important to understand the basics of how it works.

Rest State
:   Used as a reference to detect highly distorted areas.
    The original vertex locations are used by default.

Smoothing
:   Many options for this modifier relate to smoothing which is used internally
    to correct the distorted regions.
user: Describe ShaderFxWave(ShaderFx) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ShaderFxWave(ShaderFx)

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

*class* bpy.types.ShaderFxWave(*ShaderFx*)
:   Wave Deformation effect

    amplitude
    :   Amplitude of Wave

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

    orientation
    :   Direction of the wave

        Type:
        :   enum in [`'HORIZONTAL'`, `'VERTICAL'`], default `'HORIZONTAL'`

    period
    :   Period of Wave

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

    phase
    :   Phase Shift of Wave

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type