PGCRYPT/OpenBlender_Train huggingface dataset:
user: Provide the full official documentation entry for Snap Target, preserving all code examples.

assistant: Determines the target which the selection will be snapped to.

Increment:
:   Snaps to grid points. When in Orthographic view, the snapping increment changes depending on the zoom level.

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

Grid:
:   Snaps to the grid that’s displayed in the viewport.

Vertex:
:   Snaps to the vertex that’s closest to the mouse cursor.

Edge:
:   Snaps to the edge that’s closest to the mouse cursor.

Face:
:   Snaps to the surfaces of faces in mesh objects; This is useful for retopologizing.

Volume:
:   Snaps the selection to a depth that’s centered *inside* the object under the cursor.
    This is useful for positioning an [Armature](../../../animation/armatures/introduction.xhtml)
    bone so it’s centered inside a character’s arm, for example; the other snapping options
    would place it on the arm’s surface instead.

    While Blender also has [Volume objects](../../../modeling/volumes/introduction.xhtml), this option
    is not related to those.

Edge Center:
:   Snaps to the centerpoint of the edge that’s closest to the mouse cursor.

Edge Perpendicular:
:   Snaps to a specific point on the edge so that the line from the selection’s original location
    (indicated by a white cross) to its new location is perpendicular to that edge.
user: Show practical ways to work with Shrinkwrap Type Items in a Blender add-on or script – include code.

assistant: # Shrinkwrap Type Items

NEAREST_SURFACEPOINT:
:   Nearest Surface Point.

    Shrink the mesh to the nearest target surface.

PROJECT:
:   Project.

    Shrink the mesh to the nearest target surface along a given axis.

NEAREST_VERTEX:
:   Nearest Vertex.

    Shrink the mesh to the nearest target vertex.

TARGET_PROJECT:
:   Target Normal Project.

    Shrink the mesh to the nearest target surface along the interpolated vertex normals of the target.
user: Show practical ways to work with Built-In Attributes in a Blender add-on or script – include code.

assistant: Built-in attributes always exist, and cannot be removed. Their data type and domain cannot be changed.

| Name | Type | Domain | Notes |
| --- | --- | --- | --- |
| `position` | *Vector* | *Point* | Built-in attribute describing vertex or point locations, in the local space of a geometry. Any node that changes the location of points will adjust this attribute, like the [Transform Geometry Node](geometry/operations/transform_geometry.xhtml) and the [Set Position Node](geometry/write/set_position.xhtml). |
| `radius` | *Float* | *Point* | A built-in attribute on point clouds used to set the size for the points in the viewport. Also built-in on curves, where it controls the size of each curve control point when converted to a mesh, or for other operations. |
| `id` | *Integer* | *Point* | Created by the [Distribute Points on Faces](point/distribute_points_on_faces.xhtml) to provide stability when the shape of the input mesh changes, and used on instances to create motion blur. Values are expected to be large, with no order. This attribute is used by nodes that generate randomness, like the [Random Value Node](utilities/random_value.xhtml). Unlike other built-in attributes, this attribute is not required, and can be removed. |
| `material_index` | *Integer* | *Face* | Used to specify the material slot for every face in a mesh. |
| `sharp_edge` | *Boolean* | *Edge* | Attribute determining if an edge should have flat (rather than smooth) shading enabled in the viewport or a render. |
| `sharp_face` | *Boolean* | *Face* | Attribute determining if a face should have flat (rather than smooth) shading enabled in the viewport or a render. |
| `resolution` | *Integer* | *Spline* | Determines the number of evaluated points between two control points of a spline. Only NURBS and Bézier splines have this attribute, for poly splines, the value is always one. |
| `cyclic` | *Boolean* | *Spline* | Determines whether the spline has a segment that connects its first and last control points. |
| `handle_left` | *Vector* | *Point* | Describes the location of the left handle of a curve control point, on the side of the curve’s start. Only exists when the curve contains a Bézier spline. |
| `handle_right` | *Vector* | *Point* | Describes the location of the right handle of a curve control point, on the side of the curve’s end. Only exists when the curve contains a Bézier spline. |
user: What is Properties and how is it used in Blender Python scripting?

assistant: Mode
:   Storage mode for custom normal data:

    Sharpness:
    :   Store the sharpness of each face or edge. Similar to the “Shade Smooth” and “Shade Flat” operators.

    Free:
    :   Store custom normals as simple vectors in the local space of the mesh.
        This is efficient and fast to evaluate but does not support deformation.

    Tangent Space:
    :   Store normals in a deformation dependent custom transformation space.
        This method is slower, but can be better when subsequent operations
        change the mesh without handling normals specifically.

Domain Free mode
:   [Attribute domain](../../attributes_reference.html#attribute-domains) to store free custom normals.

    Point:
    :   Store normals per vertex.

    Face:
    :   Store normals per face.

    Face Corner:
    :   Store normals per face corner, this domain is necessary to bake
        existing mixed sharp and smooth edges into the custom normal vectors.
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

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.xhtml) or the
    [Sample Index Node](../../geometry/sample/sample_index.xhtml) (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: What is Texture Space and how is it used in Blender Python scripting?

assistant: This panel lets you configure the object’s [Texture Space](../../../glossary/index.xhtml#term-Texture-Space), which is a 3D box
used for generating texture coordinates without the use of a UV map.
You can visualize the texture space using the option in the
[Viewport Display](../../../scene_layout/object/properties/display.xhtml) panel.

Texture Mesh Mesh objects
:   Use another mesh for texture indices. The vertices of the two objects must be perfectly aligned
    or the UV map will be distorted.

Auto Texture Space
:   Calculates the texture space automatically.

Location X, Y, Z, Size X, Y, Z
:   Lets you define the texture space manually, relative to the object.
    Note that you can also edit it in the 3D Viewport – see [Editing](#editing) below.

Match Texture Space Curve objects
:   Modifies the *Location* and *Size* to match the object’s bounding box.
    This disables Auto Texture Space.

### Editing

Click one of these menu items, then move the mouse to adjust the texture space
and press `LMB` to confirm. While transforming, you can use keyboard shortcuts to lock
certain axes; see the status bar.

### Accessing

When setting up a material shader, you can use the *Generated* output of the
[Texture Coordinate Node](../../../render/shader_nodes/input/texture_coordinate.xhtml) to read the 3D coordinate
inside the object’s texture space. You can then pass this coordinate to a texture
node.
user: What is GaussianBlurStrip(EffectStrip) and how is it used in Blender Python scripting?

assistant: # GaussianBlurStrip(EffectStrip)

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

*class* bpy.types.GaussianBlurStrip(*EffectStrip*)
:   Sequence strip creating a gaussian blur

    input_1
    :   First input for the effect strip

        Type:
        :   [`Strip`](bpy.types.Strip.html#bpy.types.Strip "bpy.types.Strip"), (never None)

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

    size_x
    :   Size of the blur along X axis

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

    size_y
    :   Size of the blur along Y axis

        Type:
        :   float in [0, 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 Paragraph in Blender? Include parameters, examples, warnings and best practices.

assistant: The *Paragraph* Panel has settings for the alignment and spacing of text.

[image reference removed]

The Paragraph panel.

### Alignment

Horizontal
:   Left:
    :   Aligns text to the left of the frames when using them,
        else uses the origin of the text object as the starting point of the text (which grows to the right).

    Center:
    :   Centers text in the frames when using them,
        else uses the origin of the text object as the mid-point of the text
        (which grows equally to the left and right).

    Right:
    :   Aligns text to the right of the frames when using them,
        else uses the origin of the text object as the ending point of the text (which grows to the left).

    Justify:
    :   Only flushes a line when it is terminated by a word wrap (**not** by a newline),
        and uses *whitespace* instead of *character spacing* (kerning) to fill lines.

    Flush:
    :   Always flushes the line, even when it is still being typed-in.
        It uses character spacing (kerning) to fill lines.

Vertical
:   Top:
    :   - With text boxes, aligns the top of the text to the top of the frames.
        - With no text box, aligns the top of the text to the origin of the object, and grows to the bottom.

    Top Baseline:
    :   - With text boxes, aligns the ‘top’ baseline of the text to the top of the frames.
        - With no text box, aligns the actual baseline of the text to the origin of the object,
          and grows to the bottom.

    Middle:
    :   - With text boxes, centers the text in the frames.
        - With no text box, centers the text on the origin of the object,
          and grows in both top and bottom directions equally.

    Bottom Baseline:
    :   - With text boxes, aligns the baseline of the text to the bottom of the frames.
        - With no text box, aligns the baseline of the text to the origin of the object, and grows to the top.

    Bottom:
    :   - With text boxes, align the bottom of the text to the bottom of the frames.
        - With no text box, align the bottom of the text to the origin of the object, and grows to the top.

### Spacing

Character Spacing
:   A factor by which space between each character (kerning) is scaled in width.

    In Edit Mode in the 3D Viewport, you can also control individual kerning
    at text cursor position by pressing `Alt`-`Left` / `Alt`-`Right` to decrease/increase it.

Word Spacing
:   A factor by which whitespace between words is scaled in width.

Line Spacing
:   A factor by which the vertical space between lines is scaled.

Offset X, Y
:   These settings control the X and Y offset of the text position within the object.
    This applies relatively to the object’s origin, either to the whole text or, when using text boxes, to each frame.
user: Describe ShaderNodeVolumeCoefficients(ShaderNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ShaderNodeVolumeCoefficients(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.ShaderNodeVolumeCoefficients(*ShaderNode*)
:   Model all three physical processes in a volume, represented by their coefficients

    phase
    :   Phase function for the scattered light

        - `HENYEY_GREENSTEIN`
          Henyey-Greenstein – Henyey-Greenstein, default phase function for the scattering of light.
        - `FOURNIER_FORAND`
          Fournier-Forand – Fournier-Forand phase function, used for the scattering of light in underwater environments.
        - `DRAINE`
          Draine – Draine phase functions, mostly used for the scattering of light in interstellar dust.
        - `RAYLEIGH`
          Rayleigh – Rayleigh phase function, mostly used for particles smaller than the wavelength of light, such as scattering of sunlight in earth’s atmosphere.
        - `MIE`
          Mie – Approximation of Mie scattering in water droplets, used for scattering in clouds and fog.

        Type:
        :   enum in [`'HENYEY_GREENSTEIN'`, `'FOURNIER_FORAND'`, `'DRAINE'`, `'RAYLEIGH'`, `'MIE'`], default `'HENYEY_GREENSTEIN'`

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

assistant: Depending on your desktop environment setup, a Blender icon may appear on your desktop or
an entry for Blender is added to your menu after you install Blender.

Many desktop environments support the ability to “Run in terminal”.

[image reference removed]

Configuring the KDE menu icon to start Blender from a terminal.

This screenshot shows Blender started from a Linux Terminal and
the resulting text output written to it:

[image reference removed]

Starting Blender from a Linux terminal window.
user: Explain Known Limitations in complete detail according to the official Blender documentation.

assistant: ### Non-Uniform Scale

A parent with non-uniform scale and rotation in relation to its child may cause a *shear* effect.

While this is supported by parenting, the shear will be lost when the parent is cleared since it
can’t be represented by location, scale and rotation.

If *Clear and Keep Transformation* moves the object, non-uniform scale is the most likely cause.
user: Describe SceneObjects(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # SceneObjects(bpy_struct)

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

*class* bpy.types.SceneObjects(*bpy_struct*)
:   All of the scene objects

    *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 TextureNodeImage(TextureNode) in a Blender add-on or script – include code.

assistant: # TextureNodeImage(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.TextureNodeImage(*TextureNode*)
:   image
    :   Type:
        :   [`Image`](bpy.types.Image.html#bpy.types.Image "bpy.types.Image")

    image_user
    :   Parameters defining the image duration, offset and related settings

        Type:
        :   [`ImageUser`](bpy.types.ImageUser.html#bpy.types.ImageUser "bpy.types.ImageUser"), (readonly)

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with Move in a Blender add-on or script – include code.

assistant: To Top `Shift`-`PageUp`
:   Moves the selected tracks to the top.

Up `PageUp`
:   Moves the selected tracks up by one.

Down `PageDown`
:   Moves the selected tracks down by one.

To Bottom `Shift`-`PageDown`
:   Moves the selected tracks to the bottom.

When using the keyboard shortcuts, make sure the mouse cursor is hovering over the track region,
as otherwise, Blender will move the selected strips to different tracks (rather than moving the tracks).
user: Describe Interactive Mirror from the Blender manual or Python API, including usage steps and snippets.

assistant: The *Mirror* operator flips the selected elements across a chosen axis.
Mirroring is equivalent to scaling the selection by -1 along the selected axis,
but it offers a faster and more direct workflow.

The mirror is relative to the [Transformation Orientation](../../../../editors/3dview/controls/orientation.xhtml)
and [Pivot Point](../../../../editors/3dview/controls/pivot_point/index.xhtml)
This gives full control over how and where the mirroring occurs, for example:

- Position the pivot point wherever you want the center of symmetry.
- Choose a transformation orientation (e.g. *Global*, *Local*, *Normal*).
- Select an axis (X, Y, or Z) along which to mirror.

### Usage

To mirror along a specific axis:

- Press `Ctrl`-`M`, then `X`, `Y`, or `Z` to select an axis.
- Pressing the same key again toggles the orientation between the active
  [Transform Orientation](../../../../editors/3dview/controls/orientation.xhtml) and the global orientation.
- Hold `MMB` and drag to mirror interactively in the desired direction.

### Properties

Orientation
:   The [Transform Orientation](../../../../editors/3dview/controls/orientation.xhtml) used to align the X, Y, and Z axes.

Constraint Axis
:   The axis (or axes) to mirror across.
    For example, mirroring across the X axis flips the selection horizontally.
user: Explain Path Tracing in complete detail according to the official Blender documentation.

assistant: Cycles uses path tracing with next event estimation,
which is not good at rendering all types of light effects, like caustics,
but has the advantage of being able to render more detailed and
larger scenes compared to some other rendering algorithms.
This is because we do not need to store,
for example, a photon map in memory,
and because we can keep rays relatively coherent to use an on-demand image cache,
compared to e.g. bidirectional path tracing.

[image reference removed]

We do the inverse of what reality does,
tracing light rays from the camera into the scene and onto lights,
rather than from the light sources into the scene and then into the camera.
This has the advantage that we do not waste light rays that will not end up in the camera,
but also means that it is difficult to find some light paths that may contribute a lot.
Light rays will be sent either according to the surface BSDF,
or in the direction of known light sources.
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: # Introduction

Vertex Groups can potentially have a very large number of associated vertices
and thus a large number of weights (one weight per assigned vertex).
*Weight Painting* is a method to maintain large amounts of weight information
in a very intuitive way.

It is primarily used for rigging meshes, where the vertex groups are used to
define the relative bone influences on the mesh. But we use it also for
controlling particle emission, hair density, many modifiers, shape keys, etc.

[image reference removed]

Vertex group in Weight Paint Mode.

You can enter Weight Paint Mode from the Mode selector `Ctrl`-`Tab`.
The selected mesh object is displayed slightly shaded with a rainbow color spectrum.
The color visualizes the weights associated to each vertex in the active vertex group.
By default *blue* means unweighted and *red* means fully weighted.

You can assign weights to the vertices of the object by painting on it with weight brushes.
Starting to paint on a mesh automatically adds weights to the active vertex group
(a new vertex group is created if needed).

Vertex Groups can be managed in the pallette pop-over in the middle of the header.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Geometry
:   The input geometry containing the original hair curves to duplicate.

Amount
:   The number of duplicates generated for each original curve.
    Higher values increase hair density.

Viewport Amount
:   Defines the percentage of *Amount* used for viewport display.
    Reducing this value improves performance in the viewport while keeping render results unaffected.

Radius
:   The maximum distance around each guide curve within which duplicates are placed.
    Larger values spread the duplicates further apart.

Distribution Shape
:   Controls how duplicates are distributed within the radius, from the center to the outer edge.
    Different shapes can produce uniform, clustered, or edge-biased distributions.

Tip Roundness
:   Adjusts the rounding of duplicate curves near their tips.
    Higher values make the distribution more circular and natural toward the ends.

Even Thickness
:   When enabled, keeps an even density across the radius of duplicates.
    When disabled, density may vary depending on the distribution pattern.

Seed
:   Sets the random seed for duplicate placement.
    Changing this value alters the random arrangement of duplicates while maintaining the same parameters.
user: Show practical ways to work with Usage in a Blender add-on or script – include code.

assistant: ### Selecting a Brush and Material

In the Tool Settings select the brush, material and color type to use with the tool.
The Line tool uses *Draw Brush* types.
See [Brush Settings](../brushes/draw.html#grease-pencil-draw-common-options) for more information.

### Creating Lines

1. Click (`LMB` or the `Pen` tip) and drag the start point.
2. Release on the desired end point.
3. After releasing you can move the start and end point by clicking and dragging on the yellow manipulators.
4. Then confirm (`Return`/`MMB`) or cancel (`Esc`/`RMB`).

While dragging you can use `Shift` to snapping the line to horizontal, vertical or 45° angle
or use `Alt` to create the line from a center point.

`NumpadPlus` and `NumpadMinus` or using the mouse `Wheel`
will increase or decrease the amount of points in the final line.

`F` will adjust the line thickness and `Shift`-`F` will adjust the opacity of the strokes.

|  |  |  |
| --- | --- | --- |
| <../../../../_images/grease-pencil_modes_draw_tools_line_example-01.png>   click and dragging the start point. | <../../../../_images/grease-pencil_modes_draw_tools_line_example-02.png>   Moving start and end points with manipulators. | <../../../../_images/grease-pencil_modes_draw_tools_line_example-03.png>   The line after confirming. |

### Extruding

Before confirming you can use `E` to extrude the end point of the line
to generate multiple connected lines.

|  |  |  |
| --- | --- | --- |
| <../../../../_images/grease-pencil_modes_draw_tools_line_extrude-01.png>   End point extruding. | <../../../../_images/grease-pencil_modes_draw_tools_line_extrude-02.png>   Moving the end point of the last line with the manipulator. | <../../../../_images/grease-pencil_modes_draw_tools_line_extrude-03.png>   The connected lines after confirming. |
user: Provide the full official documentation entry for Outputs, preserving all code examples.

assistant: Grid
:   The resulting SDF grid after the boolean operation is applied.
    The output maintains valid signed distance values and can be converted
    to a mesh using the [Grid to Mesh](grid_to_mesh.xhtml)
    node or used in further volumetric operations.
user: Give a detailed overview of Boids: syntax, arguments, return values, common patterns.

assistant: # Boids

[image reference removed]

Boid Physics settings.

Boids particle systems are controlled by a limited artificial intelligence,
which can be programmed to follow basic rules and behaviors.
They are ideal for simulating flocks, swarms, herds and schools of various kind of animals,
insects and fishes or predators vs. preys simulations.
They can react on the presence of other objects and on the members of their own system.
Boids can handle only a certain amount of information,
therefore the sequence of the *Boid Brain* rules is very important.
In certain situations only the first three parameter are evaluated.
user: Describe Workflow from the Blender manual or Python API, including usage steps and snippets.

assistant: # Workflow

Shape keys are created and managed in the [Shape Keys panel](shape_keys_panel.xhtml),
found in the *Object Data* tab of the Properties editor
(for example, the *Mesh* tab for mesh objects).

A shape key is edited by selecting it in the panel and then moving the object’s vertices
to new positions in the 3D Viewport.

The panel also contains controls to adjust the *Value* (influence or weight) of each shape key.
This allows you to view a shape in isolation, or see how it combines with other active shape keys.
user: Describe Mask Extract from the Blender manual or Python API, including usage steps and snippets.

assistant: Creates a duplicate mesh object based on masked geometry.
The extracted geometry is also further processed by default for a cleaner result.

Threshold
:   Minimum mask value to consider the vertex valid to extract a face from the original mesh.

Add Boundary Loop
:   Creates and extra boundary loop on the edges of the geometry,
    making it easier smooth the boundaries and apply additional modifiers.

Smooth Iterations
:   Smooth iterations applied to the extracted mesh.

Project to Sculpt
:   Project the extracted mesh on to the original sculpt object.

Extract as Solid
:   Adds a [Solidify Modifier](../../../modeling/modifiers/generate/solidify.html) to the newly created mesh object.
user: How do I use Examples in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_shader_glossy_example.jpg   Sharp Glossy example. | <../../../_images/render_shader-nodes_shader_glossy_behavior-sharp.svg>   Sharp Glossy behavior. |
| ../../../_images/render_shader-nodes_shader_glossy_rough.jpg   Rough Glossy example. | <../../../_images/render_shader-nodes_shader_glossy_behavior.svg>   Rough Glossy behavior. |

[image reference removed]

Anisotropic shading with 0° rotation, 90° rotation and textured rotation of the tangent direction.
[Example blend-file](https://archive.blender.org/wiki/2015/uploads/b/b7/Blender2.65_cycles_anisotropic.blend).
user: Describe In Edit Mode from the Blender manual or Python API, including usage steps and snippets.

assistant: Each selected element is transformed around its own centerpoint.

[image reference removed]

Starting situation, rotation around Individual Origins, rotation around Median Point.

[image reference removed]

Starting situation, scaling using Individual Origins, scaling using Median Point.

When you transform adjacent faces or edges, they are treated as a single element
(meaning they don’t become disconnected).
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Directory
:   The base output directory.

File Name
:   The base name of the file.
    The final filename may also include frame numbers or layer names depending on the settings.

Media Type
:   Determines how multiple inputs are stored:

    Image:
    :   Saves each input as a separate image file.
        Each input can use its own image format settings.

    Multi-Layer EXR:
    :   Saves all inputs together in a single multi-layer OpenEXR file.

### Node Format

This panel controls file format and encoding options, depending on the *Media Type*:

- **Image**: Controls the default format and encoding for all outputs.
  To override settings for an individual output, enable *Override Node Format* in the *Images/Layers* panel.
  See [Saving Images](../../../files/media/image_formats.xhtml#bpy-types-imageformatsettings) for details on supported formats and options.
- **Multi-Layer EXR**: See [OpenEXR](../../../files/media/image_formats.xhtml#files-images-openexr) for EXR-specific settings.

### Images/Layers

Lists all input sockets of the node.
The name of each input socket is used to construct the final file name.

When saving individual images, each output can be renamed and will be written to disk
using either the global *Node Format* settings or its own overridden settings.
When using *Multi-Layer EXR*, each input is stored as a separate layer within the file.

Override Node Format
:   Allows the selected output to use a custom format instead of the global *Node Format*.

#### Item Format

When *Override Node Format* is enabled, this panel controls the format and encoding options
for the selected output image.
See [Saving Images](../../../files/media/image_formats.xhtml#bpy-types-imageformatsettings) for details.

### Output Paths

Displays the final file path and extension for each input/layer, based on current settings.
This helps verify that outputs are named and organized correctly.
user: Describe Group from the Blender manual or Python API, including usage steps and snippets.

assistant: # Group

A [Group Node](../../../interface/controls/nodes/groups.xhtml) combines a set of nodes into a single one,
and selectively exposes inputs and outputs of those nodes.

Group nodes can simplify a node tree by hiding away complexity and reusing functionality.
user: What is Mark Seam and how is it used in Blender Python scripting?

assistant: [image reference removed]

Seamed Suzanne.

To add an edge to a seam, simply select the edge and press `Ctrl`-`E` to *Mark Seam*,
or to remove it, use `Ctrl`-`E` to *Clear Seam*.

In the example to the right, the back-most edge of the cylinder was selected as the seam
(to hide the seam), and the default unwrap calculation was used.
In the UV Editor, you can see that all the faces are nicely unwrapped,
just as if you cut the seam with a scissors and spread out the fabric.

When marking seams, you can use [Select Linked](../../selecting/linked.xhtml#bpy-ops-mesh-select-linked)
in Face Select Mode to check your work.
This menu option selects all faces connected to the selected one, up to a seam.
If faces outside your intended seam are selected, you know that your seam is not continuous.
You do not need continuous seams, however, as long as they resolve regions that may stretch.

Just as there are many ways to skin a cat, there are many ways to go about deciding where seams should go.
In general though, you should think as if you were holding the object in one hand, and a pair of
sharp scissors in the other, and you want to cut it apart and spread it on the table with as little
tearing as possible. Note that we seamed the outside edges of her ears, to separate the front from the back.
Her eyes are disconnected sub-meshes, so they are automatically unwrapped by themselves.
A seam runs along the back of her head vertically, so that each side of her head is flattened out.

Another use for seams is to limit the faces unwrapped. For example, when texturing a head, you
do not really need to texture the scalp on the top and back of the head since it will be
covered in hair. So define a seam at the hairline. Then, when you select a frontal face,
and then select linked faces before unwrapping,
the select will only go up to the hairline seam, and the scalp will not be unwrapped.

When unwrapping anything that is bilateral, like a head or a body, seam it along the mirror axis.
For example, cleave a head or a whole body right down the middle in front view. When you unwrap,
you will be able to overlay both halves onto the same [Texture Space](../../../../glossary/index.xhtml#term-Texture-Space),
so that the image pixels for the right hand will be shared with the left;
the right side of the face will match the left, etc.

### Seams from Islands

Adds seams at the boundaries of existing UV islands.
This is useful when modifying the UVs of already unwrapped meshes.
user: How do I use Select Menu in Blender? Include parameters, examples, warnings and best practices.

assistant: The Select menu lets you select strips in different ways.

All `A`
:   Selects all the strips in the timeline.

None `Alt`-`A`
:   Deselects all the strips in the timeline.

Invert `Ctrl`-`I`
:   Inverts the current selection.

Box Select `B`
:   See [Box Select](../../../interface/selecting.xhtml#bpy-ops-select-box).

Box Select (Include Handles) `Ctrl`-`B`
:   Works like *Box Select*, but also selects any strip handles inside the box. If a strip has only
    one handle selected, dragging it will change the strip’s length. (If both handles are selected,
    the complete strip moves instead.)

Select Grouped `Shift`-`G`
:   Select strips that are similar to the active strip. By default, unsimilar strips are
    deselected, but this can be changed in the [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last)
    region.

    Type
    :   Select strips that have the same specific type as the active strip. For example,
        if the active strip is a Movie strip, this selects all Movie strips.

    Global Type
    :   Select strips that have the same general type (graphics or audio) as the active strip.

    Effect Type
    :   If the active strip is an effect strip, selects all effect strips. Otherwise,
        selects all non-effect strips. (Despite the name, this operator does not check
        the effect type.)

    Data
    :   Select strips that use the same source (file, scene, movie clip or mask) as the active strip.

    Effect
    :   Find the effect types that are applied to the active strip, and select all strips that have
        any of the same effect types applied to them. For example, if the active strip has a
        Gaussian Blur effect on it, this will select all other strips that are also blurred.

    Effect/Linked
    :   Select strips that are on a lower channel than a selected strip and overlap it in time;
        then, effect strips linked to the selected content strips; and finally, content strips
        linked to the selected effect strips.

    Overlap
    :   Select strips that partially or completely overlap the active strip in time.

Select Linked
:   All `Ctrl`-`L` / Less `Ctrl`-`NumpadMinus` / More `Ctrl`-`NumpadPlus`
    :   Add/remove neighboring strips to/from the selection.

Side of Frame
:   Left/Right `[`/`]`
    :   Select the strips that lie completely to the left or right of the current frame.

    Current
    :   Select the strips that intersect the current frame.

Handle
:   Both, Left, Right
    :   Select the left, right, or both handles of the selected strips.

    Both/Left/Right Neighbor
    :   Select the handle of the neighboring strip to the left, right, or on both sides of the selected strips.

Channel
:   Select all the strips that are in the same channels as the currently selected strips.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Movie Clip
:   The selectable clip data-block used as input for the gradient colors.

Tracking Object
:   Tracking Object to generate the gradient.
    You will probably want to create new a tracking object
    in the [Object](../../../movie_clip/tracking/clip/sidebar/track/objects.xhtml#movie-clip-tracking-properties-object) panel,
    because tracks used for gradients can not actually be used for camera/object tracking.
    After this tracks might be placed in places where gradient colors should be sampled.
    These tracks could be tracked or moved manually,
    so gradients would be updating automatically along the movie.
    Tracks might have an offset for easier tracking of feature-less screens.
user: How do I use GeometryNodeDeleteGeometry(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeDeleteGeometry(GeometryNode)

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

*class* bpy.types.GeometryNodeDeleteGeometry(*GeometryNode*)
:   Remove selected elements of a geometry

    domain
    :   Which domain to delete in

        Type:
        :   enum in [Attribute Domain Without Corner Items](bpy_types_enum_items/attribute_domain_without_corner_items.html#rna-enum-attribute-domain-without-corner-items), default `'POINT'`

    mode
    :   Which parts of the mesh component to delete

        Type:
        :   enum in [`'ALL'`, `'EDGE_FACE'`, `'ONLY_FACE'`], default `'ALL'`

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

assistant: # Using UV Maps

Sooner or later, you may want to use an image texture on your model.
The UV Editor allows you to map textures directly to the mesh faces.
The 3D Viewport shows you the object being textured.
If you set the 3D Viewport into Textured viewport shading,
you will immediately see any changes made in the UV Editor, and vice versa.
This is because no real rendering is taking place; it is all just viewport shading.
If you were to apply an image to UVs then render, the texture would not show up by default.
So to render an image, you must:

- Create a Material for the object.
- Tell Blender to use the UV textures on faces when rendering.

To create a Material, you have to click *Add New* Material in the Shading context.

There are two ways to tell Blender to use the UV texture when rendering;
the quick way and the proper way.

The quick way is to use generated UV coordinates. Generated coordinates is used by
default by all [Texture nodes](../../../render/shader_nodes/textures/index.html),
with the exception of Image textures that use UV coordinates by default.
To use generated coordinates for images as well use the *Generated* output of
the [Texture Coordinate node](../../../render/shader_nodes/input/texture_coordinate.html).

The proper way is to use [UV Unwrapping](unwrapping/index.html)
to manually generate UV coordinates. To use UV mapping,
use the [Texture Coordinate node](../../../render/shader_nodes/input/texture_coordinate.html)
(UV output) or the [UV Map node](../../../render/shader_nodes/input/uv_map.html)
and select the UV map to use, “UVMap” by default.

Full details of using Image textures are on
the [Image Textures](../../../render/materials/legacy_textures/types/image_movie.html) page.
user: What is WeightedNormalModifier(Modifier) and how is it used in Blender Python scripting?

assistant: # WeightedNormalModifier(Modifier)

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

*class* bpy.types.WeightedNormalModifier(*Modifier*)
:   invert_vertex_group
    :   Invert vertex group influence

        Type:
        :   boolean, default False

    keep_sharp
    :   Keep sharp edges as computed for default custom normals, instead of setting a single weighted normal for each vertex

        Type:
        :   boolean, default False

    mode
    :   Weighted vertex normal mode to use

        - `FACE_AREA`
          Face Area – Generate face area weighted normals.
        - `CORNER_ANGLE`
          Corner Angle – Generate corner angle weighted normals.
        - `FACE_AREA_WITH_ANGLE`
          Face Area & Angle – Generated normals weighted by both face area and angle.

        Type:
        :   enum in [`'FACE_AREA'`, `'CORNER_ANGLE'`, `'FACE_AREA_WITH_ANGLE'`], default `'FACE_AREA'`

    thresh
    :   Threshold value for different weights to be considered equal

        Type:
        :   float in [0, 10], default 0.01

    use_face_influence
    :   Use influence of face for weighting

        Type:
        :   boolean, default False

    vertex_group
    :   Vertex group name for modifying the selected areas

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

    weight
    :   Corrective factor applied to faces’ weights, 50 is neutral, lower values increase weight of weak faces, higher values increase weight of strong faces

        Type:
        :   int in [1, 100], default 50

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Object Data

These panels can be found in the *Data* tab of the [Properties Editor](../../../editors/properties_editor.xhtml)
editor after selecting a mesh object.

Mesh data-block
:   The [Data-Block Menu](../../../interface/controls/templates/data_block.xhtml#ui-data-block) at the top can be used to make the object point
    to different mesh [object data](../../../scene_layout/object/introduction.xhtml).
user: Explain Duplicate Elements Node in complete detail according to the official Blender documentation.

assistant: # Duplicate Elements Node

[image reference removed]

The *Duplicate Elements* node creates a new geometry with the specified elements
from the input duplicated an arbitrary number of times. The positions of elements
are not changed, so all of the duplicates will be at the exact same location.
user: Show practical ways to work with Custom Properties in a Blender add-on or script – include code.

assistant: # Custom Properties

[image reference removed]

Custom Properties panel.

Custom properties are a way to store your own data in Blender’s data-blocks. It can be used for rigging
(where bones and objects can have custom properties driving other properties), and Python scripts,
where it’s common to define new settings not available in Blender. It is also possible to access
custom properties from materials via the [Attribute Node](../render/shader_nodes/input/attribute.xhtml).

Only certain data supports custom properties:

- All [data-blocks types](data_blocks.xhtml#data-system-datablock-types).
- Bones and pose bones.
- Sequence strips.

To add a custom property, search for the *Custom Properties* panel,
found at the bottom of most [Properties](../editors/properties_editor.xhtml) or Sidebar region, and click *New*.
Properties can be removed from the same location with the delete icon.
Once properties are added they can be configured via the edit icon to work for a particular use case;
see [Editing Properties](#editing-properties) for more information.