PGCRYPT/OpenBlender_Train huggingface dataset:
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Portal Depth: Cycles Only
:   Number of times the ray has passed through a [Ray Portal BSDF](../shader/ray_portal.xhtml).
user: Show practical ways to work with Getting Started in a Blender add-on or script – include code.

assistant: The object to be painted on must first be [unwrapped](../../modeling/meshes/uv/unwrapping/introduction.html).
UVs can be added traditionally, with standard [Unwrapping Tools](../../modeling/meshes/editing/uv.html),
or by adding [Simple UVs](tool_settings/texture_slots.html#bpy-ops-paint-add-simple-uvs) in Texture Paint mode.

Once you have unwrapped your model to a UV map, you can begin the texturing process.
To use texture paint you may do any of the following:

- Activate the Texture Paint workspace. Here the 3D Viewport has the Texture Paint Mode enabled
  and the Image Editor is already switched to Paint mode.
- In the 3D Viewport, select Texture Paint Mode from the mode selector in the header,
  and you can paint directly onto the mesh.
- In the Image Editor, switch the mode to Paint (shown in the image to the right).

[image reference removed]

Enabling Paint mode.

Once you enable Texture Painting, your mouse becomes a brush.
As soon as you enable Texture Painting or switch to Texture Paint Mode,
different tools become available in the Toolbar.

In the Image Editor, you paint on a flat canvas that is wrapped around the mesh using UV coordinates.
Any changes made in the Image Editor show up immediately in the 3D Viewport, and vice versa.

To work with the UV layout (for example, to move coordinates) you must use the [UV Editor](../../editors/uv/index.html).

A full complement of brushes and colors can be selected from the Sidebar region in the Image Editor.
Brush changes made in either panel are immediately reflected in the other panel.
However, the modified texture will **not** be saved automatically;
you must explicitly do so with [Save Image](../../editors/image/editing.html#bpy-ops-image-save).
user: How do I use Group Input Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Group Input Node

[image reference removed]

The *Group Input* node provides access to input sockets of a node group.
It acts as the entry point for data passed into the group from the outside,
such as images, values, or other data types.

Additional input sockets can be added or removed from the *Group Input* node
through the *Group* panel in the Sidebar or by using the group interface editor
in the Node Editor header. When the node group is used in another compositor tree,
the sockets defined in *Group Input* appear as input sockets on the *Group* node itself.
user: Give a detailed overview of GeometryNodeGridPrune(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeGridPrune(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.GeometryNodeGridPrune(*GeometryNode*)
:   Make the storage of a volume grid more efficient by collapsing data into tiles or inner nodes

    data_type
    :   Node socket data type

        Type:
        :   enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items), default `'FLOAT'`

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

assistant: ```
blender -b file.blend -a
```

`-a`
:   Render the whole animation using all the settings saved in the blend-file.

```
blender -b file.blend -E CYCLES -s 10 -e 500 -t 2 -a
```

`-E CYCLES`
:   Use the “Cycles Render” engine.
    For a list of available render engines, run `blender -E help`.

`-s 10 -e 500`
:   Set the start frame to `10` and the end frame to `500`.

`-t 2`
:   Use only two threads.
user: Describe Vector Display from the Blender manual or Python API, including usage steps and snippets.

assistant: Visualization options for the vector fields.

Display As
:   Streamlines:
    :   Choose to display the vectors as “Streamlines”.

    Needle:
    :   Choose to display the vectors as “Needles”.

    MAC Grid:
    :   Choose to display the vector field as “Marker-And-Cell Grid”.

> Mac Grid X, Y, Z Mac Grid
> :   Show an individual X/Y/Z component of the MAC grid.

Magnitude Streamlines or Needle Only
:   Scale the display vectors by the magnitude of the vectors they represent.

Field
:   The vector field represented by the display vectors (e.g. fluid velocity, external forces).

Scale
:   Scale the vectors by this size in the viewport.
user: What is GeometryNodeSetGeometryName(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeSetGeometryName(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.GeometryNodeSetGeometryName(*GeometryNode*)
:   Set the name of a geometry for easier debugging

    *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 Insert Blank Keyframe (Active Layer) in Blender? Include parameters, examples, warnings and best practices.

assistant: Add a new blank keyframe to the active layer at the current frame.
If there is already a keyframe at the current frame,
a new blank keyframe will be added on the next frame.

All Layers
:   When enabled, Blank keyframe will be created on all layers, not only the active one.

Duration
:   The number of blank frames to insert.
user: Provide the full official documentation entry for Gizmos, preserving all code examples.

assistant: The *Split* node provides an interactive gizmo in the Node Editor.
To enable it, make sure [Active Node Gizmo](../../../editors/compositor.html#bpy-types-spacenodeeditor-show-gizmo-active-node)
is turned on, then select the *Split* node.

The gizmo displays a split line with draggable handles:

- Drag the line to adjust the split *position* horizontally or vertically.
- Use the circular handle at the center to adjust the *rotation* interactively.
user: Describe Dope Sheet View from the Blender manual or Python API, including usage steps and snippets.

assistant: # Dope Sheet View

[image reference removed]

Dope Sheet View.

The Dope Sheet View is used to visualize motion tracking data,
it is implemented as separate view of the Movie Clip editor just like the Graph View.

It displays channels for selected tracks and each channel visualizes tracked
segments of tracks as dark bars and keyframed positions of tracks as small diamonds.

The background is highlighted depending on the number of tracks in a frame.
This means that if for a frame (or sequence of frames) there are less than eight tracks,
the background will turn red;
if there are from eight to sixteen tracks, the background will be yellow.

This is only a visual feedback, which doesn’t mean that the camera motion will not
reconstruct with less than eight tracks. It only means that you should pay attention to those frames and
check if all possible good feature points are tracked there. Remember, if there are no good feature points in
the frame and there are less than 16 tracks in the frame, it doesn’t mean the solution won’t be accurate.
Rather, adding more tracks on bad feature points will reduce the accuracy of solution.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Follow Track constraint.

Active Clip
:   Whether the tracking marker is in the scene’s [Active Clip](../../../scene_layout/scene/properties.xhtml#bpy-types-scene-active-clip).
    If unchecked, a selector appears for choosing another clip.

3D Position
:   Whether to use the tracking marker’s reconstructed world position (instead of its position
    in the flat video).

Undistort
:   Whether to use the tracking marker’s video position after compensating for lens distortion
    (see [Lens settings](../../../movie_clip/tracking/clip/sidebar/track/camera.xhtml#motion-tracking-camera-lens)).
    Not available when *3D Position* is checked.

Frame Method
:   How to handle a difference in aspect ratio between the tracked video footage and the rendered image.

    Stretch:
    :   The object is positioned as though the video were stretched to exactly match the size of the
        rendered image.

    Fit:
    :   The object is positioned as though the video were made as large as possible while still keeping
        its original aspect ratio and fitting inside the rendered image along both axes.

    Crop:
    :   The object is positioned as though the video were made as large as possible while still keeping
        its original aspect ratio and fitting inside the rendered image along one axis.

Object
:   The physical object containing the tracking marker to follow. See the
    [Objects Panel](../../../movie_clip/tracking/clip/sidebar/track/objects.xhtml) in the Movie Clip Editor.
    If left empty, *Track* will list the markers used to reconstruct the physical camera.

Track
:   The tracking marker to follow.

Camera
:   The Blender camera in whose field of view the constrained object should appear.
    If left empty, the scene’s [active camera](../../../scene_layout/scene/properties.xhtml#bpy-types-scene-camera) is used.

Depth Object
:   If this object is set, the constrained object will be projected onto its surface.
    This can be used to create a facial makeup effect, for example.
    Not available when *3D Position* is checked.

Constraint to F-Curve
:   Replaces the constraint by a set of equivalent [keyframes](../../keyframes/introduction.xhtml).

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects its owner.
user: What is Project from View and how is it used in Blender Python scripting?

assistant: Projects the selected faces onto the view plane. The UV map essentially becomes a wireframe picture
of the mesh, taken in the 3D Viewport at the current viewing angle. Use this option if you are using a picture
of a real object as a texture. You will get stretching in areas where the model recedes away from you.

### Options

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

Orthographic
:   Use an [Orthographic](../../../editors/3dview/navigate/projections.html#bpy-ops-view3d-view-persportho) projection instead of Perspective.

Camera Bounds
:   Map the borders of the image that would be rendered through the current camera to the borders of the UV map.
    This option only has an effect when viewing the scene through the camera;
    see [Viewing the Active Camera](../../../editors/3dview/navigate/camera_view.html#bpy-ops-view3d-view-camera).

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

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

Clip to Bounds
:   Moves any out-of-bounds UVs to the nearest border.

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

assistant: # ConstraintTargetBone(bpy_struct)

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

*class* bpy.types.ConstraintTargetBone(*bpy_struct*)
:   Target bone for multi-target constraints

    subtarget
    :   Target armature bone

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

    target
    :   Target armature

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

    weight
    :   Blending weight of this bone

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

assistant: # Introduction

Each blend-file contains a database.
This database contains all scenes, objects, meshes, textures, etc. that are in the file.

A file can contain multiple [Scenes](../scene_layout/scene/introduction.xhtml)
and each scene can contain multiple [Objects](../scene_layout/object/introduction.xhtml).
Objects can contain multiple materials which can contain many textures.
It is also possible to create links between different objects, or share data between objects.
A file can link data from other Blender files.
user: Provide the full official documentation entry for Platform Specific Keys, preserving all code examples.

assistant: ### macOS

The `Cmd` key can be used instead of `Ctrl` on macOS
for all but a few exceptions which conflict with the operating system.

List of additional macOS specific keys:

|  |  |
| --- | --- |
| `Cmd`-`Comma` | Preferences. |
user: Show practical ways to work with MeshLoopColor(bpy_struct) in a Blender add-on or script – include code.

assistant: # MeshLoopColor(bpy_struct)

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

*class* bpy.types.MeshLoopColor(*bpy_struct*)
:   Vertex loop colors in a Mesh

    color
    :   Color in sRGB color space

        Type:
        :   float array of 4 items in [0, 1], default (0.0, 0.0, 0.0, 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: Show practical ways to work with General Tools in a Blender add-on or script – include code.

assistant: [image reference removed]

General transform and annotate tools like in other modes.

[Move](tools/transforms.xhtml)
:   Translation tool.

[Rotate](tools/transforms.xhtml)
:   Rotation tool.

[Scale](tools/transforms.xhtml)
:   Scale tool.

[Transform](tools/transforms.xhtml)
:   Adjust the objects translation, rotations and scale.

[Annotate](../../interface/annotate_tool.xhtml#tool-annotate-freehand)
:   Draw free-hand annotation.

    [Annotate Line](../../interface/annotate_tool.xhtml#tool-annotate-line)
    :   Draw straight line annotation.

    [Annotate Polygon](../../interface/annotate_tool.xhtml#tool-annotate-polygon)
    :   Draw a polygon annotation.

    [Annotate Eraser](../../interface/annotate_tool.xhtml#tool-annotate-eraser)
    :   Erase previous drawn annotations.
user: Give a detailed overview of Toolbar: syntax, arguments, return values, common patterns.

assistant: # Toolbar

Metaball Edit Mode tools:

[Tweak](../../../interface/selecting.xhtml#tool-select-tweak)
:   Select or move.

    [Select Box](../../../interface/selecting.xhtml#tool-select-box)
    :   Select objects by dragging a box.
        All objects that intersect the box will be selected.

    [Select Circle](../../../interface/selecting.xhtml#tool-select-circle)
    :   Select objects by dragging a circle. All objects that intersect the path of
        the circle will be selected.

    [Select Lasso](../../../interface/selecting.xhtml#tool-select-lasso)
    :   Select objects by drawing a lasso.

Cursor
:   Change the location of the 3D Cursor.

Move
:   Translation tool.

Rotate
:   Rotation tool.

Scale
:   Scale tool.

    [Scale Cage](../../../scene_layout/object/tools/scale_cage.xhtml#tool-scale-cage)
    :   Change the scale of an object by controlling its cage.

Transform
:   Tool to adjust the objects translation, rotations and scale.

[Annotate](../../../interface/annotate_tool.xhtml#tool-annotate-freehand)
:   Draw free-hand annotation.

    [Annotate Line](../../../interface/annotate_tool.xhtml#tool-annotate-line)
    :   Draw straight line annotation.

    [Annotate Polygon](../../../interface/annotate_tool.xhtml#tool-annotate-polygon)
    :   Draw a polygon annotation.

    [Annotate Eraser](../../../interface/annotate_tool.xhtml#tool-annotate-eraser)
    :   Erase previous drawn annotations.

[Measure](../../../editors/3dview/toolbar/measure.xhtml#tool-measure)
:   Measure distances in the scene.

Shear
:   Shear selected items along a defined axis.
user: Give a detailed overview of Examples: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Wireframes on a displaced plane.

In this example, the wireframes carry a second (dark) material while the displaced plane uses its original one.

[image reference removed]

Vertex group weighting.

The weights of the vertex group gradually change from 0 to 1.

[image reference removed]

Wireframe and Subdivision Surface modifier.

Cube with enabled *Crease Edges* option. The *Crease Weight* is set to 0, 0.5 and 1.
user: How do I use Common Options in Blender? Include parameters, examples, warnings and best practices.

assistant: Each modifier has several buttons at its top:

/ Enable
:   Enables/Disables the modifier. Useful to compare the image with or without modifications.

Remove Strip Modifier
:   Deletes the modifier from the stack.

Move Strip Modifier
:   Dragging this button changes the modifier’s position in the stack which affects its computation order.

### Masking

You can mask each modifier to limit the area of the image it affects. This can be done using
either a [Mask](../../../movie_clip/masking/introduction.html) or another strip.

Mask Input Type
:   Type of input data used for the mask.

    Strip:
    :   Use the grayscale representation of another strip’s image.

    Mask:
    :   Use a Mask data-block.

Mask
:   The Strip or Mask data-block to use.

Mask Time Mask Input Only
:   How the start frame of the mask is calculated.

    Relative:
    :   Mask animation is offset to the start of the strip.

    Absolute:
    :   Mask animation is in sync with the scene frame.
user: Give a detailed overview of Acceleration Structure: syntax, arguments, return values, common patterns.

assistant: Use Spatial Splits
:   Spatial splits improve the rendering performance in scenes with a mix of large and small polygons.
    The downsides are longer BVH build times and slightly increased memory usage.

Use Curves BVH
:   Use a special type of [BVH](../../../glossary/index.xhtml#term-BVH) for rendering curves.
    The bounding boxes are not axis aligned allowing a spatially closer fit to the curve geometry.
    Disabling this option will reduce memory, at the cost of increasing curve render time.

BVH Time Steps
:   Split BVH primitives by this number of time steps to speed up render time at the expense of memory.

Use Compact BVH
:   Use a more compact BVH structure, which can reduce RAM usage but render slower.
user: Give a detailed overview of Weight Table: syntax, arguments, return values, common patterns.

assistant: The Weight Table shows all the weights associated with the *active vertex*, which is the
vertex that was selected last (and is highlighted in white). If there is no active vertex,
or it isn’t part of any vertex group, the panel is not displayed.

### Set the Active Group

You can click the name of a vertex group to make it the active one.

[[image reference removed]](../../../../_images/modeling_meshes_properties_vertex-groups_vertex-weights_editor-name.png)

Changing the active vertex group.

### Display Weights in Edit Mode

[image reference removed]

Enable display of weights in Edit Mode.

When you are in Edit Mode, you can make the weights of the active group visible on the mesh:
open the *Mesh Edit Mode Overlays* popover and enable the *Vertex Group Weights* option.

[[image reference removed]](../../../../_images/modeling_meshes_properties_vertex-groups_vertex-weights_edit-mode.png)

Weights in Edit Mode.

### Change a Weight

You can change the weight for a vertex group by either clicking the number and typing a new
one or by dragging left and right with `LMB`. You can also click the arrows
(only shown when hovering) to change the weight in steps of 0.01.

[[image reference removed]](../../../../_images/modeling_meshes_properties_vertex-groups_vertex-weights_editor-weight.png)

Changing a weight value.

### Copy a Weight

The *Paste Weight to Selected* button copies the weight from the active vertex to the other selected
vertices. Note that, even though it uses the word “paste,” it doesn’t interact with the *Copy* button
and in fact doesn’t use the clipboard at all.

[[image reference removed]](../../../../_images/modeling_meshes_properties_vertex-groups_vertex-weights_editor-paste.png)

Copying a weight.

### Delete a Weight

The *Delete Weight* button removes the active vertex from the vertex group,
making the row disappear from the list.

[[image reference removed]](../../../../_images/modeling_meshes_properties_vertex-groups_vertex-weights_editor-delete.png)

Deleting a weight.
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: The first two sockets are the minimum output.

Image
:   Outputs the entire image in the specified color space.

Alpha
:   The alpha value taken from the movie or image.

Offset X
:   The X offset value from the footage camera or tracking.

Offset Y
:   The Y offset value from the footage camera or tracking.

Scale
:   The scale of the image taken from the footage camera or tracking.

Angle
:   The lens angle taken from the footage camera or tracking.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: String
:   String value to be sliced.

Position
:   Integer value used to determine the starting point of the new string within the input string.
    The first letter of the string is at index 0.

Length
:   Integer value used to determine how many characters are extracted from the input string.
user: How do I use Simulation in Blender? Include parameters, examples, warnings and best practices.

assistant: # Simulation

Speed
:   You can control the internal timing of the soft body system with this value.
    It sets the correlation between frame rate and tempo of the simulation.
    A free falling body should cover a distance of about five meters after
    one second and travel at a speed of ten meters per seconds.

    You can adjust the scale of your scene and simulation with this correlation.
    If you render with 25 frames per second, you will have to set *Speed* to 1.3.
user: Describe Camera View from the Blender manual or Python API, including usage steps and snippets.

assistant: # Camera View

[image reference removed]

Demonstration of camera view.

The Camera view shows the current scene from the active camera’s viewpoint.

The Camera view can be used to virtually compose shots and preview how the scene will look when rendered.
The rendered image will contain everything within the dashed frame.
user: What is Properties and how is it used in Blender Python scripting?

assistant: Color Attribute
:   The target Color Attribute.
    The listed Color Attributes are those of the mesh of the active object.
    If the active object has no mesh, a warning will be displayed.
    If the property is marked in red, it means the Color Attribute is not available in
    the mesh of the active object, but it may be available in other meshes of
    objects that share this material!
user: Provide the full official documentation entry for Normalized Weight Workflow, preserving all code examples.

assistant: In order to be used for things like deformation, weights usually have to be normalized,
so that all deforming weights assigned to a single vertex add up to 1.
The *Armature* modifier in Blender does this automatically, so it is technically not necessary to
ensure that weights are normalized at the painting stage.

However, while more complicated, working with normalized weights has certain advantages,
because it allows use of certain tools designed for them, and because when weights are normalized,
understanding the final influence of the current group does not require knowing weights in
other groups on the same vertex.

These tools are provided to aid working with normalized weights:

Normalize All
:   In order to start working with normalized weights it is first necessary to normalize the existing weights.
    The [Normalize All](editing.xhtml#bpy-ops-object-vertex-group-normalize-all) tool can be used for that.
    Make sure to select the right mode and disable *Lock Active*.

Auto Normalize
:   Once the weights are initially normalized,
    the [Auto Normalize](tool_settings/options.xhtml#bpy-types-toolsettings-use-auto-normalize) option
    can be enabled to automatically maintain normalization as you paint.
    This also tells certain tools that the weights are supposed to be already normalized.

Vertex group locking
:   Any vertex group can be locked to prevent changes to it. This can be done via
    the lock icon in the vertex group list, or using bone selection and
    the [locks pie menu](editing.xhtml#bpy-ops-object-vertex-group-lock).

    This setting prevents accidental edits to groups. However,
    since it is also respected by *Auto Normalize*, in the normalized weight workflow
    it has a more significant meaning of locking the current influence of chosen bones,
    so that when you paint other bones, the weight is redistributed only between the unlocked groups.

    In locations affected by multiple bones, this allows more precise tweaking and re-balancing of
    weights by temporarily focusing on a subset of bones. This can also be aided by
    the [Lock Relative](tool_settings/options.xhtml#bpy-types-toolsettings-use-auto-normalize) option, which displays unlocked groups as
    though re-normalized with the locked groups deleted, thus making it appear as if the locked groups did not even
    exist.

Multi-Paint
:   Finally, the [Multi-Paint](tool_settings/options.xhtml#bpy-types-toolsettings-use-auto-normalize) option allows treating
    multiple selected bones as if they were one bone, so that the painting operations change
    the combined weight, preserving the ratio within the group. Combined with locking,
    this allows balancing between one set of bones versus the rest, excluding a third set
    that has its influence not affected in any way due to locks.

    Technically, this option does not require the normalized workflow, but since non-normalized
    weights can add to more than 1, the weight display behaves best with *Auto Normalize* enabled.
user: How do I use Collision in Blender? Include parameters, examples, warnings and best practices.

assistant: # Collision

[Particles](particles/index.html), [Soft Bodies](soft_body/index.html)
and [Cloth objects](cloth/index.html) may collide with mesh objects.
[Boids](particles/emitter/physics/boids.html) try to avoid *Collision* objects.

- You may limit the effect on particles to a group of objects
  (in the [Field Weights panel](particles/emitter/force_field.html)).
- *Deflection* for soft body objects is difficult, they often penetrate the colliding objects.
- Hair particles ignore deflecting objects
  (but you can animate them as soft bodies which take deflection into account).

If you change the deflection settings for an object you have to recalculate the particle,
soft body or cloth system by *Delete Bake*, this is not done automatically.

[image reference removed]

A collider object can be temporarily disabled via an animatable toggle to
the right of the button that permanently activates or deactivates it.
user: Explain W in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [**Walk Cycle**](glossary/index.html#term-Walk-Cycle) - [**Weight Painting**](glossary/index.html#term-Weight-Painting) | - [**White Point**](glossary/index.html#term-White-Point) - [**World Space**](glossary/index.html#term-World-Space) |
user: Show practical ways to work with Split Non-Planar Faces in a Blender add-on or script – include code.

assistant: Splits any selected faces that are bent beyond a given limit.

Max Angle
:   Faces that are bent by more than this angle will be split.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_mesh_cleanup_split-non-planar-before.png   Original mesh. | ../../../../_images/modeling_meshes_editing_mesh_cleanup_split-non-planar-after.png   Result of Split Non-Planar Faces. |
user: Give a detailed overview of Managing Preferences: syntax, arguments, return values, common patterns.

assistant: Default preferences are managed from the ☰ menu in the preferences window.

The following items are available in this menu:

Auto-Save Preferences
:   By default changes to preferences are saved on exit,
    this allows changes to the keymap and Quick Favorites menu to be stored and used between
    [Blender Sessions](../../glossary/index.html#term-Blender-Session).

    When disabled, a *Save Preferences* button is shown to manually perform the operation.

Revert to Saved Preferences
:   Undoes any unsaved modifications, loading the previously saved state.

Load Factory Preferences
:   Completely undo all the modifications made to the preferences,
    resetting to the state used before making customizations.
user: Give a detailed overview of Join Geometry Node: syntax, arguments, return values, common patterns.

assistant: # Join Geometry Node

The *Join Geometry* node merges separately generated geometries into a single one.
If the geometry inputs contain different types of data, the output will also contain different data types.

[image reference removed]
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Curves
:   The guide curves with interpolated curves.

Closest Index
:   Index of the closest guide curve for each generated curve.

Closest Weight
:   Weight of the closest guide curve for each generated curve.
user: Describe DynamicPaintSurfaces(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # DynamicPaintSurfaces(bpy_struct)

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

*class* bpy.types.DynamicPaintSurfaces(*bpy_struct*)
:   Collection of Dynamic Paint Canvas surfaces

    active
    :   Active Dynamic Paint surface being displayed

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

    active_index
    :   Type:
        :   int in [0, inf], default 0

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of PrimitiveInt(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # PrimitiveInt(bpy_struct)

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

*class* bpy.types.PrimitiveInt(*bpy_struct*)
:   RNA wrapped int

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

assistant: Since instances can store a geometry, and a geometry can contain instances, nested instancing is possible.
In other words, it is possible to instance an instance, or even a collection of instances.
For example, by default, the [Instance on Points Node](instances/instance_on_points.xhtml) will create
nested instances by instancing instances on the points of real geometry.

[image reference removed]

A node group that creates nested instancing by chaining
[Instance on Points](instances/instance_on_points.xhtml) nodes.

Here, nested instancing is used to distribute geometry that contains both a mesh
and instances. The output geometry contains a “real” mesh and a group of instances.
Each instance contains a sphere mesh and many instances of a cone geometry.

[image reference removed]

The tree of instanced geometry for the example above.

What makes this method helpful is the output geometry only contains three unique meshes:
the plane, the sphere, and the cone. This would make the performance much better if the meshes
were more complicated.
user: What is Int2Attribute(Attribute) and how is it used in Blender Python scripting?

assistant: # Int2Attribute(Attribute)

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

*class* bpy.types.Int2Attribute(*Attribute*)
:   Geometry attribute that stores 2D integer vectors

    data
    :   Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`Int2AttributeValue`](bpy.types.Int2AttributeValue.html#bpy.types.Int2AttributeValue "bpy.types.Int2AttributeValue"), (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: Describe Navigating from the Blender manual or Python API, including usage steps and snippets.

assistant: # Navigating

As with most editors, you can:

- Pan the view vertically (channels) and horizontally (time) by dragging `MMB`.
- Zoom in and out by rolling `Wheel` or dragging `Ctrl`-`MMB`.

You can also use the scrollbars for this.
user: How do I use Connect Vertex Path in Blender? Include parameters, examples, warnings and best practices.

assistant: # Connect Vertex Path

This tool connects vertices in the order they are selected, splitting the faces between them.
When there are only two vertices selected, a cut will be made across unselected faces,
a bit like the Knife tool; but this is limited to straight cuts across connected faces.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_vertex_connect-vertex-path_pair-before.png   Two disconnected vertices. | ../../../../_images/modeling_meshes_editing_vertex_connect-vertex-path_pair-after.png   Result of connecting. |

Running a second time will connect the first/last endpoints.
When many vertices are selected, faces will be split by their selected vertices.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_vertex_connect-vertex-path_multi-before.png   Before. | ../../../../_images/modeling_meshes_editing_vertex_connect-vertex-path_multi-after.png   After. |

Vertices not connected to any faces will create edges,
so this can be used as a way to quickly connect isolated vertices too.
user: What is Introduction and how is it used in Blender Python scripting?

assistant: # Introduction

Motion Tracking is used to track the motion of objects and/or a camera and, through the constraints,
to apply this tracking data to 3D objects (or just one), which have either been created in Blender or
imported into the application. Blender’s motion tracker supports a couple of very powerful tools for 2D tracking and
3D motion reconstruction, including camera tracking and object tracking, as well as some special features like
the plane track for compositing. Tracks can also be used to move and deform masks for rotoscoping in the Mask Editor,
which is available as a special mode in the Movie Clip Editor.
user: Describe Getting Started from the Blender manual or Python API, including usage steps and snippets.

assistant: # Getting Started

Welcome! This section guides you through contributing to the Blender manual.

Blender’s manual is written in [reStructuredText (RST)](https://www.sphinx-doc.org/en/master/usage/restructuredtext/basics.html),
a straightforward markup language ideal for technical documentation.
You can edit the manual either directly online or by using your local text editor.

All contributions are managed through a collaborative workflow on Blender’s development platform,
[projects.blender.org](https://projects.blender.org/).

You have two options for editing the manual:
user: Describe Group Input Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Group Input Node

[image reference removed]

The *Group Input* node provides access to input sockets of a node group.
It acts as the entry point for data passed into the group from the outside,
such as images, values, or other data types.

Additional input sockets can be added or removed from the *Group Input* node
through the *Group* panel in the Sidebar or by using the group interface editor
in the Node Editor header. When the node group is used in another compositor tree,
the sockets defined in *Group Input* appear as input sockets on the *Group* node itself.
user: Give a detailed overview of Crash Log: syntax, arguments, return values, common patterns.

assistant: When Blender crashes, it writes out a text file which contains information that may help identify the cause of the
crash. Usually, this file is written in the [Temporary Directory](../advanced/blender_directory_layout.html#temp-dir) directory.

This file contains a log of tools used up until the crash as well as some other debug information. When reporting bugs
about crashes it can be helpful to attach this file to your reports, especially when others are unable to reproduce
the crash.

### Windows

On a crash, a file is written based on the name of the currently loaded blend-file, so `test.blend` will create a
file called `test.crash.txt`.

Batch scripts are provided in Blender installation directory which may be run to obtain the Blender debug log and
system info text files:

- `blender_debug_log.cmd` is used in most cases.
- `blender_debug_gpu.cmd` and `blender_debug_gpu_workaround.cmd` log GPU-related errors.
- `blender_factory_startup.cmd` starts Blender with default settings which is recommended for debugging.

If the crash happens in Blender module, stack trace is also written to a file named `blender.crash.txt`.
The path to that file can be found at the end of `blender_debug_out.txt` file.

### macOS

After a crash, the macOS Crash Reporter shows a window with backtrace after some time, or when Blender is opened
again. Copy the text in the crash report and save it in a text file. That file should be attached to the bug report
while following other bug reporting guidelines.

Some `.crash` files can also be found in `~/Library/Logs/DiagnosticReports/` with the name of format:
`Blender_YYYY-MM-DD-HHMMSS_MACNAME.crash`. If a report is present corresponding to the time of crash, that file can
also provide hints about cause of the crash. Alternatively, Console.app can be used to navigate all “User Reports”
(see sidebar in the app).

### Linux

After a crash, a file named `blender.crash.txt` is written to the `/tmp` directory.
user: Give a detailed overview of USD Primvar data types: syntax, arguments, return values, common patterns.

assistant: Blender supports a subset of the
[USD basic data types](https://openusd.org/release/api/_usd__page__datatypes.html#Usd_Basic_Datatypes) for import
and export.

Only the types natively supported by Blender’s
[attribute system](../../modeling/geometry_nodes/attributes_reference.xhtml) will be processed.

| Blender type | USD type | Notes |
| --- | --- | --- |
| Boolean | bool |  |
| 8-Bit Integer | uchar | The USD unsigned 8-bit value will be cast to a signed value for import. The signed value will be cast to unsigned for export. |
| Integer | int | A 32-bit signed integer value. |
| Float | float | A 32-bit, single-precision, floating point value. |
| Vector | float3 | 3D vector with 32-bit floating-point values. |
| 2D Vector | float2/texCoord2f | 2D vector with 32-bit floating-point values. |
| Color | color4f | RGBA color with 32-bit floating-point values. As a special case, when encountering a Primvar or attribute for USD’s `displayColor`, it will be read or written as `color3f` data with an Alpha component of 1.0. |
| Byte Color | color4f | USD does not provide a byte color equivalent. The byte values will be converted to float and exported as a color4f. |
| Quaternion | quatf | Floating point [Quaternion](../../glossary/index.xhtml#term-Quaternion) rotation. |
user: Describe Bpy.Types.Keymapitem from the Blender manual or Python API, including usage steps and snippets.

assistant: tem.direction KeyMapItem.hyper KeyMapItem.hyper_ui KeyMapItem.id KeyMapItem.idname KeyMapItem.is_user_defined KeyMapItem.is_user_modified KeyMapItem.key_modifier KeyMapItem.map_type KeyMapItem.name KeyMapItem.oskey KeyMapItem.oskey_ui KeyMapItem.properties KeyMapItem.propvalue KeyMapItem.repeat KeyMapItem.shift KeyMapItem.shift_ui KeyMapItem.show_expanded KeyMapItem.type KeyMapItem.value KeyMapItem.compare() KeyMapItem.to_string() KeyMapItem.bl_rna_get_subclass() KeyMapItem.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References