PGCRYPT/OpenBlender_Train huggingface dataset:
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [[image reference removed]](../../../_images/modeling_modifiers_generate_volume-to-mesh_panel.png)

The Volume to Mesh modifier.

Object
:   The source volume object.

Grid Name
:   The name of the grid that will be converted.
    This has to be a scalar grid.

Resolution Mode
:   Mode for how the resolution of the final mesh is controlled.

    Grid
    :   This makes the resolution dependent on the resolution of the grid that is converted.
        Higher resolution grids result in a higher resolution mesh.
        In many cases, that is the most efficient mode.

    Voxel Amount
    :   Specifies the approximate resolution of the final mesh.
        The voxel size is adapted to the size of the entire volume.

    Voxel Size
    :   Use a fixed resolution that does not change when the volume changes.

Threshold
:   Voxels with a larger value are considered to be inside the mesh and all other voxels outside.
    The mesh will be generated on the boundary of inside and outside voxels.
    This is sometimes also called the “iso value”.

Adaptivity
:   This is similar to decimating the final to reduce resolution where it is not needed.

Smooth Shading
:   Enables smooth shading on the generated mesh.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Image
:   Standard color input.

Size
:   The optional Size input will be multiplied with the X and Y blur radius values.
    It also accepts a value image, to control the blur radius with a mask.
    The values should be mapped between (0 to 1) for an optimal effect.

Type
:   The difference between the types is in the way they handle sharp edges,
    smooth gradients and preserve the highs and the lows.

    Flat:
    :   Simply blurs everything uniformly.

    Tent:
    :   Preserves the high and the lows better by making a linear falloff.

    Quadratic:
    :   Looks similar to *Gaussian* but can be a little faster but slightly worse looking.

    Cubic:
    :   Preserve the highs, but give an almost out-of-focus blur while smoothing sharp edges.

    Gaussian:
    :   Gives the best looking results but tends to be the slowest.

    Fast Gaussian:
    :   An approximation of the Gaussian.

    Catmull-Rom:
    :   Catmull-Rom keeps sharp contrast edges crisp.

    Mitch:
    :   Preserve the highs, but give an almost out-of-focus blur while smoothing sharp edges.

Extend Bounds
:   Allows the image, that is being blurred, to extend past its original dimension.

Separable
:   Use faster approximation by blurring along the horizontal and vertical directions independently.
user: Explain Closure in complete detail according to the official Blender documentation.

assistant: # Closure

The *Closure* node defines a zone that encapsulates a reusable section of nodes behaving like a function.
It specifies inputs, outputs, and internal logic that can be executed elsewhere in the node tree using an
[Evaluate Closure](../../../../interface/controls/nodes/types/utilities/closure/evaluate_closure.html) node.

Closures allow users to pass custom procedural logic into node groups, making tools more modular and adaptable.
Instead of duplicating or editing an existing group, a closure can expose user-defined behavior while preserving
the structure of the main system.

[image reference removed]

An empty closure zone.
user: Explain Clump Hair Curves in complete detail according to the official Blender documentation.

assistant: # Clump Hair Curves

The *Clump Hair Curves* node gathers nearby hair curves together around designated guide curves,
creating clump formations commonly seen in real hair, fur, and grass.
It is a key step in grooming workflows for adding realism and structure by simulating
how strands naturally group due to moisture, product, or physical interaction.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Instances
:   Standard geometry input.

Selection
:   Boolean field used to determine if an instance will be scaled.

Scale
:   The scale factor to apply to the instance’s transform on each axis.

Center
:   The position from which the instance origins are scaled. Each instance will move away from this location.
    When the *Local Space* input is enabled, this location is relative to the initial transform
    of each instance.

Local Space
:   If enabled, the instances are scaled in local space. In other words,
    they are scaled in the directions the described by the initial transform of each instance.
    When the input is disabled, the *Center* and *Scale* inputs are specified in
    the local space of the modifier object.
user: Show practical ways to work with Inverse Kinematics Constraint in a Blender add-on or script – include code.

assistant: # Inverse Kinematics Constraint

The *Inverse Kinematics* constraint makes not just one bone, but a whole chain
of bones rotate to follow a target. A common example is automatically rotating
the bones in a character’s arm to achieve a desired hand position.
See [Inverse Kinematics](../../armatures/posing/bone_constraints/inverse_kinematics/introduction.xhtml) for details.

The constraint can be added quickly using the shortcut `Shift`-`I`.
See [Add IK to Bone](../../armatures/posing/editing/inverse_kinematics.xhtml#bpy-ops-pose-ik-add).
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Mesh
:   Standard geometry output.

UV Map
:   A 2D vector representing the default X/Y coordinates of the [UV Map](../../../../glossary/index.xhtml#term-UV-Map) for the primitive’s shape.
    This can be connected to the [Store Named Attribute Node](../../attribute/store_named_attribute.xhtml),
    to be used once the Geometry Nodes Modifier get applied.
    The UV map must be stored on the face corner in order to be accessed.
user: Describe ShaderNodeBsdfHair(ShaderNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ShaderNodeBsdfHair(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.ShaderNodeBsdfHair(*ShaderNode*)
:   Reflection and transmission shaders optimized for hair rendering

    component
    :   Hair BSDF component to use

        - `Reflection`
          Reflection – The light that bounces off the surface of the hair.
        - `Transmission`
          Transmission – The light that passes through the hair and exits on the other side.

        Type:
        :   enum in [`'Reflection'`, `'Transmission'`], default `'Reflection'`

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

assistant: Image
:   Standard color input.
    If only the image input is connected, the node blurs the image depending on the edges present in the source image.

Determinator
:   If connected, it serves as the source for defining edges/borders for the blur in the image.
    This has great advantage in case the source image is too noisy,
    but normals in combination with Z-buffer can still define exact borders/edges of objects.

Size
:   The size of the blur in pixels.

Threshold
:   Pixels are considered in the blur area if the average difference between their
    determinator and the determinator of the center pixel is less than this threshold.
user: Give a detailed overview of Edited Action: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Edited Action panel.

Contains settings for the object’s active action. Only visible if the
[Action Track](tracks.html#nla-action-track) is selected.

Action
:   A [data-block](../../interface/controls/templates/data_block.html#ui-data-block) menu where you can see, change, and clear the active action.
    See also the Action Editor’s [Action](../dope_sheet/modes/action.html#dopesheet-action-action).

Slot
:   The slot within the active action to use.

Extrapolation
:   Determines whether the action will influence the frames before/after its boundaries
    once it has been pushed down into a strip. (As long as it’s still the active action,
    *Hold* is used regardless of the choice.)

    Hold
    :   The property values at the action’s first keyframe also apply to the earlier frames
        (if the strip is the first in the track). The values at its last keyframe also
        apply to the later frames (up to the next strip).

    Hold Forward
    :   The property values at the action’s last keyframe also apply to the later frames
        (up to the next strip).

    Nothing
    :   The animated properties return to their default values outside of the strip boundaries.

Blending
:   How to combine the action’s property values with those of the tracks below.

    Replace
    :   Overwrites the values produced by the lower tracks. If *Influence* is less than 1,
        a linear interpolation between the previous and new values is used instead.

    Multiply, Subtract, Add
    :   Blends the action’s values with those of the lower tracks using a simple calculation.
        If *Influence* is less than 1, a linear interpolation between the previous values
        and these calculated values is used.

        \(result = mix(previous, previous (+-×) value, influence)\)

    Combine
    :   Depending on the type of each property, one of the following methods is automatically chosen:

        Axis/Angle Rotation
        :   \(result = previous + value × influence\)

            This results in averaging the axis and adding the amount of rotation.

        Quaternion Rotation
        :   Quaternion math is applied to all four channels of the property at once:

            \(result = {previous} × {value} ^ {influence}\)

        Proportional (Scale)
        :   \(result = previous × (value / default) ^ {influence}\)

        Others
        :   \(result = previous + (value - default) × {influence}\)

Influence
:   How much the action contributes to the result of the NLA stack.
user: Give a detailed overview of Strip Color Items: syntax, arguments, return values, common patterns.

assistant: # Strip Color Items

NONE:
:   None.

    Assign no color tag to the collection.

COLOR_01:
:   Color 01.

COLOR_02:
:   Color 02.

COLOR_03:
:   Color 03.

COLOR_04:
:   Color 04.

COLOR_05:
:   Color 05.

COLOR_06:
:   Color 06.

COLOR_07:
:   Color 07.

COLOR_08:
:   Color 08.

COLOR_09:
:   Color 09.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: The node can contain an arbitrary number of input sockets.
Each socket can be given a custom name and type. Supported types include (but not limited to):

- Geometry
- Objects
- Values (e.g. float, integer, boolean, vector, color)
- Fields
- Nested Bundles
user: How do I use Sun Light in Blender? Include parameters, examples, warnings and best practices.

assistant: A sun light provides light of constant intensity emitted in a single direction from infinitely far away.
It can be very handy for a uniform clear daylight open-space illumination. In the 3D Viewport,
the sun light is represented by an encircled black dot with rays emitting from it,
plus a dashed line indicating the direction of the light.

Strength
:   Strength of the lights. See more details at [Power of Lights](#power-of-lights).

Angle
:   The size of the sun light according to its
    [angular diameter](https://en.wikipedia.org/wiki/Angular_diameter#Use_in_astronomy)
    as seen from earth.
user: Show practical ways to work with Operator Menus in a Blender add-on or script – include code.

assistant: Each operator should receive its own heading or page based on the length of the content. At the start should be a
reference admonition documenting the context of the operator:

```
.. reference::

   :Mode:      Edit Mode
   :Menu:      :menuselection:`Curve --> Snap`
   :Shortcut:  :kbd:`Shift-S`
```
user: What is Options and how is it used in Blender Python scripting?

assistant: As the modifier is only a container its actual options are configured in the *Particle Properties* tab.
See the [Particle Systems Properties](../../../physics/particles/index.xhtml) for more information.
user: What is TextureNodeTexClouds(TextureNode) and how is it used in Blender Python scripting?

assistant: # TextureNodeTexClouds(TextureNode)

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

*class* bpy.types.TextureNodeTexClouds(*TextureNode*)
:   *classmethod* is_registered_node_type()
    :   True if a registered node type

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Parent
:   Select a Parent object to manipulate the layer.
    The layer will inherit the transformations of the parent,
    this is especially useful when rigging for cut-out animation.

Pass Index
:   The layer index number can be used with some modifiers to restrict changes to only certain areas.

    See [Modifiers](../modifiers/introduction.html) for more information.

View Layer
:   Defines the View Layer to use for the Grease Pencil layer.
    If empty, the layer will be included in all View Layers.
    This is useful to separate drawings parts for [compositing](../../compositing/introduction.html).

Use Masks in Render
:   If disabled, no masks on the layer are included in the view layer render.
user: Give a detailed overview of ReadOnlyInteger(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # ReadOnlyInteger(bpy_struct)

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

*class* bpy.types.ReadOnlyInteger(*bpy_struct*)
:   value
    :   Type:
        :   int in [-inf, inf], default 0, (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain PreferencesKeymap(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # PreferencesKeymap(bpy_struct)

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

*class* bpy.types.PreferencesKeymap(*bpy_struct*)
:   Shortcut setup for keyboards and other input devices

    active_keyconfig
    :   The name of the active key configuration

        Type:
        :   string, default “”, (never None)

    show_ui_keyconfig
    :   Type:
        :   boolean, default True

    *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 Wireframe Node in complete detail according to the official Blender documentation.

assistant: # Wireframe Node

[image reference removed]

The Wireframe node is used to retrieve the edges of an object as it appears to Cycles.
As meshes are triangulated before being processed by Cycles,
topology will always appear triangulated when viewed with the Wireframe node.
user: Provide the full official documentation entry for Merge, preserving all code examples.

assistant: # Merge

This tool allows you to merge all selected vertices to a unique one, dissolving all others.
You can choose the location of the remaining vertex in the menu this tool pops up before executing:

At Center
:   It will place the remaining vertex at the center of the selection.
    Available in all select modes.

At Cursor
:   It will place the remaining vertex at the 3D Cursor.
    Available in all select modes.

Collapse
:   Every island of selected vertices (connected by selected edges) will merge on its own median center,
    leaving one vertex per island.

At First
:   It will place the remaining vertex at the location of the first one selected.
    Only available in *Vertex* select mode.

At Last
:   It will place the remaining vertex at the location of the last one selected (the active one).
    Only available in *Vertex* select mode.

Merging vertices of course also deletes some edges and faces. But Blender will do everything
it can to preserve edges and faces only partly involved in the reunion.

UVs
:   If *UVs* is ticked in the [Adjust Last Operation](../../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel,
    the UV mapping coordinates, if existing, will be corrected to avoid image distortion.
user: What is Python Wheels and how is it used in Blender Python scripting?

assistant: # Python Wheels

[Python wheels](https://pythonwheels.com/) (`*.whl`) are the standard way of distributing Python modules.
They are supported in Blender to make self-contained Python [Extensions](index.xhtml#extensions-index).
user: What is Getting Support and how is it used in Blender Python scripting?

assistant: Blender’s community is one of its greatest features, so apart from this user manual, there are many different ways to
get support from other users, such as [Chat](#blender-chat), [Stack Exchange](https://blender.stackexchange.com/),
and [Reddit](https://www.reddit.com/r/blender/).

For studios and organizations there is [Enterprise support](https://www.blender.org/support/), and for studios
looking to add Blender to their pipeline, [Blender Studio](https://studio.blender.org/) contains documentation and
training material around this topic. If you think you have found an issue with Blender, please [report a bug](https://projects.blender.org/blender/blender/issues/new?template=.gitea%2fissue_template%2fbug.yaml).

More details about support can be found on the [support page](https://www.blender.org/support/).
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

The Displace modifier.

Texture
:   The name of the texture from which the displacement for each vertex is derived.
    If this field is empty, the modifier defaults to 1.0 (white).

    Coordinates
    :   The texture coordinate system to use when retrieving values from the texture for each vertex.

        See [common masking options](../common_options.xhtml#modifiers-common-options-masking) for a complete reference.

Direction
:   The direction along which to displace the vertices.
    Can be one of the following:

    X, Y, Z
    :   Displace along an axis.

    Normal
    :   Displace along the vertex normal.

    Custom Normal
    :   Displace along (averaged) [custom normals](../../meshes/structure.xhtml#modeling-meshes-normals-custom), instead of vertex normals.

    RGB to XYZ
    :   Displace along local XYZ axes individually using the RGB components of the texture
        (Red values displaced along the X axis, Green along the Y, Blue along the Z).

Space
:   With a direction set to X, Y, Z, or XYZ the modifier can either displace along local or global axes.

Strength
:   The strength of the displacement. After offsetting by the *Midlevel* value,
    the displacement will be multiplied by the *Strength* value to give the final vertex offset.

    \(vertex\_offset = displacement × Strength\)

    A negative strength can be used to invert the effect of the modifier.

Midlevel
:   The texture value which will be treated as no displacement by the modifier.
    Texture values below this threshold will result in negative displacement along the selected direction,
    while texture values above it will result in positive displacement.

    \(displacement = texture\_value - Midlevel\)

    Recall that color/luminosity values are typically between (0.0 to 1.0) in Blender,
    and not between (0 to 255).

Vertex Group
:   The name of a vertex group which is used to control the influence of the modifier.
    If left empty, the modifier affects all vertices equally.

    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.
user: Explain Node Closures in complete detail according to the official Blender documentation.

assistant: # Node Closures

A *closure* allows passing custom functionality into a node group.
It acts like a function input, enabling user-defined behavior to be evaluated inside another node tree.

Closures make node groups more flexible and reusable by letting users inject part of a node network into another.
This allows building higher-level tools where specific parts of a process can be customized without modifying the
group itself.

[image reference removed]

Using a closure to customize tree scattering within a terrain generator.
user: How do I use Example in Blender? Include parameters, examples, warnings and best practices.

assistant: Closures are useful when part of a node group’s logic should be user-defined.
For example, a terrain generator can use a closure to define tree placement:

- The [Evaluate Closure](../../../../interface/controls/nodes/types/utilities/closure/evaluate_closure.xhtml)
  node is placed where tree instances are distributed.
- A closure input is exposed on the group’s interface.
- A [Closure](../../../../interface/controls/nodes/types/utilities/closure/closure.xhtml)
  node is connected defining any custom placement logic.

When the closure is evaluated, the contents of the connected node graph
are executed inside the context of the terrain generator.
This allows the generator to provide stable infrastructure
(e.g., scattering, masks, attributes) while users supply their own functional behavior.

[image reference removed]

A terrain generator node group using closures for custom tree placement.
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: SDF Grid
:   A float grid representing the signed distance field of the mesh.
    Each voxel contains the shortest signed distance to the nearest surface
    point of the mesh, with negative values inside and positive values outside.
user: Provide the full official documentation entry for TextBox(bpy_struct), preserving all code examples.

assistant: # TextBox(bpy_struct)

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

*class* bpy.types.TextBox(*bpy_struct*)
:   Text bounding box for layout

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

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

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

    y
    :   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
user: How do I use Knife Project in Blender? Include parameters, examples, warnings and best practices.

assistant: # Knife Project

Knife Project is a non-interactive tool where you can use objects to cookie-cut into
one or more meshes rather than hand drawing the line. The outline of the selected objects
that *are not* in Edit Mode is projected along the view axis onto the meshes that *are*
in Edit Mode, and then cuts into the faces there. Afterwards, the resulting geometry
inside the cut gets selected.

Keep in mind that Knife Project works from the current view’s perspective. For best results, make sure
to rotate your view to exactly the position you require before using this tool. Orthographic views such
as Right, Front, and Top are commonly used for this.

To use Knife Project, select the objects to be cut, switch to *Edit Mode*,
select the cutting objects in the Outliner (`Ctrl`-`LMB`),
and choose Mesh ‣ Knife Project.

If Blender switches back to *Object Mode* when selecting the cutting objects,
make sure that Edit ‣ Lock Object Modes is checked in the topbar.
Alternatively, if you have only one cutting object, you can select it in the
viewport with `Ctrl`-`LMB`.
user: What is Align and how is it used in Blender Python scripting?

assistant: Moves the selected UV vertices to a line, where that line is specified in different ways by *Axis*.

Axis
:   Straighten:
    :   Positions UV vertices along the line defined by the endpoints.

    Straighten X:
    :   Positions UV vertices horizontally along the line defined by the endpoints.

    Straighten Y:
    :   Positions UV vertices vertically along the line defined by the endpoints.

    Align Auto:
    :   Positions UV vertices automatically chooses the direction based on which is most alignment already.

    Align Vertically:
    :   Positions UV vertices vertically along the line defined by the midpoint of the selection.

    Align Horizontally:
    :   Positions UV vertices horizontally along the line defined by the midpoint of the selection.

Position Mode Align Vertically: / Align Horizontally:
:   Determines how the final alignment line position is calculated.

    Mean:
    :   Aligns UVs along the average (mean) position of the selection.

    Minimum:
    :   Aligns UVs along the smallest coordinate value.

    Maximum:
    :   Aligns UVs along the largest coordinate value.
user: Explain Status Messages in complete detail according to the official Blender documentation.

assistant: The middle of the Status Bar displays information about in-progress operations.

[image reference removed]

Running Task
:   Shows the progress of the currently running task (such as rendering or baking).
    Hovering the mouse pointer over the progress bar will display a time estimate.
    The task can be aborted by clicking the cancel button ().

Report Message
:   Informational messages or warnings, such as after saving a file.
    They disappear after a short time.
    Click them to show the full message in the [Info Editor](../../editors/info_editor.html).
user: What is UvSculpt(bpy_struct) and how is it used in Blender Python scripting?

assistant: # UvSculpt(bpy_struct)

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

*class* bpy.types.UvSculpt(*bpy_struct*)
:   curve_distance_falloff
    :   Type:
        :   [`CurveMapping`](bpy.types.CurveMapping.html#bpy.types.CurveMapping "bpy.types.CurveMapping"), (readonly)

    curve_distance_falloff_preset
    :   Type:
        :   enum in [Brush Curve Preset Items](bpy_types_enum_items/brush_curve_preset_items.html#rna-enum-brush-curve-preset-items), default `'CUSTOM'`

    size
    :   Type:
        :   int in [1, 10000], default 0

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: The Build modifier can be used to make a large number of items to progressively appear,
without resorting to animating the visibility of each one by one. Examples of this include
a mesh containing vertices only, which is used as
an [Instancing Vertex emitter](../../../scene_layout/object/properties/instancing/verts.xhtml),
and has the Build modifier on it. Such a setup is a workaround/technique for being able to art-direct
a semi-random layout of a collection of objects (e.g. leaves/balls forming a carpet).
This can be preferable to particles e.g. due to undesirable distribution of items leaving random gaps
and overlapping in other places.
user: Explain Symmetry in complete detail according to the official Blender documentation.

assistant: # Symmetry

Mirror
:   Mirror the brush strokes across the selected local axes.
    Note that if you want to alter the directions the axes point in,
    you must rotate the model in Edit Mode and not in Object Mode.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Mode
:   The location to load the IES file from.

    Internal:
    :   Use IES profile from a file embedded in a text data-block in the blend-file, for easy distribution.

    External:
    :   Load IES profile from a file on the drive.
user: Provide the full official documentation entry for Line Style, preserving all code examples.

assistant: # Line Style

In Freestyle, the line style settings define the appearance of a line set using five main aspects:
Stroke, Color, Alpha, Thickness, Geometry, and Texture with each on a separate tab.
These allow you to get many different styles of renders
(technical draw, rough sketch, cartoon, calligraphy, etc.).

You can create as many line styles as you wish, and reuse a given line style for several line
sets by selecting it from the select menu next to its name.

[image reference removed]

Line Style Example ([blend-file](https://archive.blender.org/wiki/2015/index.php/File:LineStyles.zip)).
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Iterations
:   Number of times to execute the zone. The *Iteration* socket gives the index of
    the current iteration, starting from 0.

Geometry
:   Default geometry input. Further inputs can be added by connecting a node’s output
    to the zone’s blank input, or by using the *Repeat Items* list in the node’s
    *Properties* panel.

    The inputs can be renamed by clicking them with `Ctrl`-`LMB` in the zone
    itself or in the *Repeat Items* list. The latter also accepts double clicking.
user: How do I use Brush Settings in Blender? Include parameters, examples, warnings and best practices.

assistant: # Brush Settings

[image reference removed]

Brush settings panel.

Information on brush settings for every mode can be found in these pages:

[Brush](../../brush/brush_settings.xhtml)
:   General and advanced settings.

[Stroke](../../brush/stroke.xhtml)
:   Stroke methods and settings.

[Falloff](../../brush/falloff.xhtml)
:   Falloff curves and settings.

[Cursor](../../brush/cursor.xhtml)
:   Cursor and appearance settings.
user: Show practical ways to work with Workflow in a Blender add-on or script – include code.

assistant: At least a [Domain](type/domain/index.xhtml) object and
one [Flow](type/flow.xhtml) object are required to create a fluid simulation.

1. Create a [Domain object](type/domain/index.xhtml)
   that defines the bounds of the simulation volume.
2. Set up [Flow](type/flow.xhtml) objects which will emit fluid.
3. Set up [Effector](type/effector.xhtml) objects to make
   the fluid interact with objects in the scene.
4. Assign a [material](material.xhtml) to the domain object.
5. Save the blend-file.
6. [Bake the Cache](type/domain/cache.xhtml) for the simulation.
user: Explain Bpy.Types.Movietrackingcamera in complete detail according to the official Blender documentation.

assistant: ingCamera.k2 MovieTrackingCamera.k3 MovieTrackingCamera.nuke_k1 MovieTrackingCamera.nuke_k2 MovieTrackingCamera.pixel_aspect MovieTrackingCamera.principal_point MovieTrackingCamera.principal_point_pixels MovieTrackingCamera.sensor_width MovieTrackingCamera.units MovieTrackingCamera.bl_rna_get_subclass() MovieTrackingCamera.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Give a detailed overview of ShaderNodeHueSaturation(ShaderNode): syntax, arguments, return values, common patterns.

assistant: # ShaderNodeHueSaturation(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.ShaderNodeHueSaturation(*ShaderNode*)
:   Apply a color transformation in the HSV color model

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

assistant: Domain
:   The domain on which the selection field is evaluated.

    Point:
    :   The selection is on the points, control points, and vertices of the geometry.

    Edge:
    :   The selection is on the edges of the mesh component. The other components
        are not modified.

    Face:
    :   The selection is on the faces of the mesh component. The other components
        are not modified.

    Spline:
    :   The selection is on the splines in the curve component. For each spline, it
        will either be deleted entirely or not at all. The other components are not
        modified.

    Instance:
    :   The selection is on the top-level instances, and the entire instance is
        removed if it is selected. If the input also contains realized geometry,
        that will be unaffected.

Mode
:   The type of elements to be affected.
    This only applies to the mesh component.

    All:
    :   Vertices, edges, and faces in the selection will be deleted.

    Only Edges & Faces:
    :   Vertices won’t be deleted, even if they are in the selection.

    Only Faces:
    :   Only faces in the selection will be deleted.
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Corner Index
:   The geometry-wide index of the selected corner. You can pass this to the
    [Evaluate at Index Node](../../utilities/field/evaluate_at_index.html) or the
    [Sample Index Node](../../geometry/sample/sample_index.html) (with the domain set to Face Corner)
    to retrieve details about the corner.

    If the edge has no connected corners, *Corner Index* will be zero.

Total
:   The number of faces (not face corners!) connected to the edge.
user: How do I use NodeSocketFloatWavelength(NodeSocketStandard) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeSocketFloatWavelength(NodeSocketStandard)

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

*class* bpy.types.NodeSocketFloatWavelength(*NodeSocketStandard*)
:   Floating-point number socket of a node

    default_value
    :   Input value used for unconnected socket

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

    links
    :   List of node links from or to this socket.

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Toggling Quad View will split the 3D Viewport into four views:
three orthographic side views and one user perspective view.

[image reference removed]

Quad View.

### Options

Lock Rotation
:   Prevent changes to the orientation and perspective of the 3D Viewport.

Sync Zoom/Pan
:   Syncs the view position between side views. (Requires *Lock Rotation* to be enabled.)

Clip Contents
:   Clip objects based on what is visible in the other side views.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Edge Index
:   The index of the edge for which to find connected corners.

Weights
:   The weights of the corners in the geometry. Unlike the other inputs which follow
    the context domain, this one is always evaluated in the Face Corner domain.

    The corners are sorted by their associated weight in ascending order.
    Corners with the same weight are sorted by their index.

Sort Index
:   The 0-based index of the corner to select from the edge’s sorted corners.
    If this value is outside the range of valid indices, it wraps around.
user: Show practical ways to work with Modal Operators in a Blender add-on or script – include code.

assistant: Modal operators exist as a concept in between [Tools](tool_system.html)
and regular operators.
They require some sort of interactive input.

|  |  |
| --- | --- |
| `Esc`, `RMB` | Cancels a modal operator. |
| `Return`, `LMB` | Confirms the action of a modal operator. |

### Slider Operators

Slider operators are used to interactively adjust a percentage value
in the editor’s [Header](window_system/regions.html#ui-region-header).

You can adjust the percentage by dragging the slider left or right.
This can be made coarser (snapping in 10% increments) by holding `Ctrl`
and more precise by holding `Shift`.
For some sliders, you can toggle “overshoot” with `E`, which lets
you go beyond the 0-100% range.
user: Give a detailed overview of Deform Curves on Surface Node: syntax, arguments, return values, common patterns.

assistant: # Deform Curves on Surface Node

[image reference removed]

The *Deform Curves on Surface* node translates and rotates each curve based on the
difference in its root position. The root position is defined by UV coordinates stored
on each curve and the [UV Map](../../../../glossary/index.html#term-UV-Map) selected for the purpose in the
[Curves surface settings](../../../curves_new/properties.html#bpy-types-curves-surface).

The transformation is calculated based on the difference of the original mesh
(before shape keys and modifiers are evaluated), and the final mesh.

Unlike other geometry nodes, this node has quite a few implicit inputs:

- The original and evaluated mesh are retrieved from the modifier object’s [surface](../../../curves_new/properties.html#bpy-types-curves-surface)
  property. This means the node only works for curves objects.
- The original and evaluated UV map are also retrieved from the object’s surface property.
- A 3D vector attribute named `rest_position`, used for calculating tangents for rotating
  curves that are consistent with the tangents calculated on the original mesh (the rotation
  needs to be calculated from the normal and tangent of the original and evaluated meshes).
- A 2D vector attribute on the curve domain named `surface_uv_coordinate` to store the
  location of the root positions on the surface mesh’s UV map.

In future development, this node will be generalized so the setup is more flexible.

Parts of the internal operation are similar to the [Sample UV Surface Node](../../mesh/sample/sample_uv_surface.html).
user: Provide the full official documentation entry for ColorRamp(bpy_struct), preserving all code examples.

assistant: # ColorRamp(bpy_struct)

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

*class* bpy.types.ColorRamp(*bpy_struct*)
:   Color ramp mapping a scalar value to a color

    color_mode
    :   Set color mode to use for interpolation

        Type:
        :   enum in [`'RGB'`, `'HSV'`, `'HSL'`], default `'RGB'`

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

    hue_interpolation
    :   Set color interpolation

        Type:
        :   enum in [`'NEAR'`, `'FAR'`, `'CW'`, `'CCW'`], default `'NEAR'`

    interpolation
    :   Set interpolation between color stops

        Type:
        :   enum in [`'EASE'`, `'CARDINAL'`, `'LINEAR'`, `'B_SPLINE'`, `'CONSTANT'`], default `'LINEAR'`

    evaluate(*position*)
    :   Evaluate Color Ramp

        Parameters:
        :   **position** (*float in* *[**0**,* *1**]*) – Position, Evaluate Color Ramp at position

        Returns:
        :   Color, Color at given position

        Return type:
        :   float array of 4 items in [-inf, inf]

    *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