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

assistant: If you enter a mode such as Weight Paint for an object and then select another
object, Blender will typically switch back to Object Mode.
This means that, if you want to weight paint the other object too,
you have to enter the mode a second time.

There is a way of avoiding this, however. Once you enter a mode, the
[Outliner](../outliner/introduction.html) will show a dot next
to other objects that also support it. By clicking such a dot, you can
switch over to another object without leaving the mode.

Alternatively, you can hover over the other object in the 3D Viewport
and press `Alt`-`Q`.
user: Give a detailed overview of Tool Settings: syntax, arguments, return values, common patterns.

assistant: Depth
:   The initial depth (from the screen into the scene) used when placing the object.

    Surface:
    :   Start placing on the surface under the mouse cursor. If there is no surface, this does the
        same as *Cursor Plane*.

    Cursor Plane:
    :   Start placing on a plane that goes through the [3D Cursor](../3d_cursor.xhtml)
        and is aligned according to the *Orientation* and *Plane Axis*.

    Cursor View:
    :   Start placing on a plane that goes through the 3D Cursor and is aligned to the view.

Orientation
:   The new object’s orientation – a set of three axes, out of which *Plane Axis* chooses one.

    Surface:
    :   The object uses the normal orientation of the surface under the mouse cursor.
        If there is no surface, this does the same as *Default*.

    Default:
    :   The object uses the default [Transform Orientation](../controls/orientation.xhtml).

Snap To
:   The target to use while [Snapping](../controls/snapping.xhtml).

    Geometry:
    :   Snap to all types of geometry (vertices, edges, and faces).

    Default:
    :   Snap to the target defined in the global snapping options.

Plane Axis
:   Which of the three *Orientation* axes (X, Y or Z) is “up” for the object.
    The object’s base will be perpendicular to this axis.

Auto Axis
:   Rather than using the *Orientation* axis indicated by *Plane Axis*,
    use the one that’s closest to the viewport’s viewing direction
    (when not hovering over a surface).

Base

Origin
:   How the base is defined.

    Edge:
    :   The base is defined from one corner to the opposing corner.

    Center:
    :   The base is defined from the centerpoint to a corner.

Aspect
:   Whether the base has a free or fixed aspect ratio.

    Free:
    :   The width and depth of the base can be chosen independently.

    Fixed:
    :   The width and depth of the base are forced to be equal.

Height

Origin
:   How the height is defined.

    Edge:
    :   The base becomes the bottom, after which you define the top.

    Center:
    :   The base becomes the center, after which you define the top.

Aspect
:   Whether the side of the bounding box has a free or fixed aspect ratio.

    Free:
    :   The height can be chosen independently of the base.

    Fixed:
    :   The height is forced to be equal to the largest side of the base.

Vertices
:   The number of vertices in the caps.

Cap Fill Type
:   Set how the caps will be filled.

    Triangle Fan:
    :   Fill with triangular faces which share a vertex in the middle.

    N-gon:
    :   Fill each ring with an [N-gon](../../../glossary/index.xhtml#term-N-gon).

    Nothing:
    :   Do not fill. Creates only the outer rings of vertices.
user: How do I use Contacts in Blender? Include parameters, examples, warnings and best practices.

assistant: [Project Page](https://projects.blender.org/blender/documentation)
:   An overview of the documentation project.

[Documentation Forum](https://devtalk.blender.org/c/documentation/12)
:   A forum based discussions on writing and translating documentation. This includes the user manual, Wiki, release
    notes, and code docs.

[Chat](../../getting_started/about/community.xhtml#blender-chat)
:   `#docs` channel for informal discussions in real-time.

[Project Workboard](https://projects.blender.org/blender/documentation/projects)
:   Manage tasks such as bugs, todo lists, and future plans.
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: For each input, the same output is added to act as a pass through.

Geometry
:   Standard geometry output, which is used as the default bake item.
    More bake items can be added by dragging sockets into the blank socket or in the *Bake Items* panel.
    Items can be renamed by `Ctrl`-`LMB` on the socket name or in the nodes *Properties* panel.
user: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: Use the tool by:

1. Orient the 3D Viewport to define the direction in depth.
2. `LMB` and hold while moving the cursor to define direction of the line projection.
3. Adjust the operation with extra *Controls* shortcuts.
4. Release `LMB` to confirm.
user: Explain bpy_extras submodule (bpy_extras.mesh_utils) in complete detail according to the official Blender documentation.

assistant: # bpy_extras submodule (bpy_extras.mesh_utils)

bpy_extras.mesh_utils.mesh_linked_uv_islands(*mesh*)
:   Returns lists of polygon indices connected by UV islands.

    Parameters:
    :   **mesh** ([`bpy.types.Mesh`](bpy.types.Mesh.html#bpy.types.Mesh "bpy.types.Mesh")) – the mesh used to group with.

    Returns:
    :   list of lists containing polygon indices

    Return type:
    :   list[list[int]]

bpy_extras.mesh_utils.mesh_linked_triangles(*mesh*)
:   Splits the mesh into connected triangles, use this for separating cubes from
    other mesh elements within 1 mesh data-block.

    Parameters:
    :   **mesh** ([`bpy.types.Mesh`](bpy.types.Mesh.html#bpy.types.Mesh "bpy.types.Mesh")) – the mesh used to group with.

    Returns:
    :   Lists of lists containing triangles.

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

bpy_extras.mesh_utils.edge_face_count_dict(*mesh*)
:   Returns:
    :   Dictionary of edge keys with their value set to the number of faces using each edge.

    Return type:
    :   dict[tuple[int, int], int]

bpy_extras.mesh_utils.edge_face_count(*mesh*)
:   Returns:
    :   list face users for each item in mesh.edges.

    Return type:
    :   list[int]

bpy_extras.mesh_utils.edge_loops_from_edges(*mesh*, *edges=None*)
:   Edge loops defined by edges

    Takes me.edges or a list of edges and returns the edge loops

    return a list of vertex indices.
    [ [1, 6, 7, 2], …]

    closed loops have matching start and end values.

bpy_extras.mesh_utils.ngon_tessellate(*from_data*, *indices*, *fix_loops=True*, *debug_print=True*)
:   Takes a poly-line of indices (ngon) and returns a list of face
    index lists. Designed to be used for importers that need indices for an
    ngon to create from existing verts.

    Parameters:
    :   - **from_data** ([`bpy.types.Mesh`](bpy.types.Mesh.html#bpy.types.Mesh "bpy.types.Mesh") | list[Sequence[float]] | tuple[Sequence[float]]) – Either a mesh, or a list/tuple of 3D vectors.
        - **indices** (*list**[**int**]*) – a list of indices to use this list
          is the ordered closed poly-line
          to fill, and can be a subset of the data given.
        - **fix_loops** (*bool*) – If this is enabled poly-lines
          that use loops to make multiple
          poly-lines are dealt with correctly.

bpy_extras.mesh_utils.triangle_random_points(*num_points*, *loop_triangles*)
:   Generates a list of random points over mesh loop triangles.

    Parameters:
    :   - **num_points** (*int*) – The number of random points to generate on each triangle.
        - **loop_triangles** (Sequence[[`bpy.types.MeshLoopTriangle`](bpy.types.MeshLoopTriangle.html#bpy.types.MeshLoopTriangle "bpy.types.MeshLoopTriangle")]) – Sequence of the triangles to generate points on.

    Returns:
    :   List of random points over all triangles.

    Return type:
    :   list[[`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector")]
user: Explain Object Mode Items in complete detail according to the official Blender documentation.

assistant: # Object Mode Items

OBJECT:
:   Object Mode.

EDIT:
:   Edit Mode.

POSE:
:   Pose Mode.

SCULPT:
:   Sculpt Mode.

VERTEX_PAINT:
:   Vertex Paint.

WEIGHT_PAINT:
:   Weight Paint.

TEXTURE_PAINT:
:   Texture Paint.

PARTICLE_EDIT:
:   Particle Edit.

EDIT_GPENCIL:
:   Edit Mode.

    Edit Grease Pencil Strokes.

SCULPT_GREASE_PENCIL:
:   Sculpt Mode.

    Sculpt Grease Pencil Strokes.

PAINT_GREASE_PENCIL:
:   Draw Mode.

    Paint Grease Pencil Strokes.

WEIGHT_GREASE_PENCIL:
:   Weight Paint.

    Grease Pencil Weight Paint Strokes.

VERTEX_GREASE_PENCIL:
:   Vertex Paint.

    Grease Pencil Vertex Paint Strokes.

SCULPT_CURVES:
:   Sculpt Mode.
user: How do I use Brush Settings in Blender? Include parameters, examples, warnings and best practices.

assistant: ### General

Strength
:   This settings has a different effect on this brush.
    Instead of defining the strength of each individual step in the stroke,
    it determines the overall Opacity of the applied color.

    Use the *Flow* setting instead for faster increasing of strength.

### Unique

Flow
:   Amount of paint that is applied per stroke sample.
    Used to create fast/slow accumulation effect.

Wet Mix
:   Amount of paint that is picked from the surface into the brush color.
    Can achieve the effect of a wet canvas.

Wet Persistence
:   Amount of wet paint that stays in the brush after applying paint to the surface.

Wet Paint Radius
:   Ratio between the brush radius and the radius that is going to be used to sample the color to blend in wet paint.

Density
:   Amount of random elements that are going to be affected by this brush.
    Use this for a more detailed airbrush effect.
    This works best on a high resolution.

Tip Scale X
:   Scale of the brush tip in the X axis.
    This is useful for a achieving a painting stroke like a marker or paint roller.
user: What is SceneRenderView(bpy_struct) and how is it used in Blender Python scripting?

assistant: # SceneRenderView(bpy_struct)

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

*class* bpy.types.SceneRenderView(*bpy_struct*)
:   Render viewpoint for 3D stereo and multiview rendering

    camera_suffix
    :   Suffix to identify the cameras to use, and added to the render images for this view

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

    file_suffix
    :   Suffix added to the render images for this view

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

    name
    :   Render view name

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

    use
    :   Disable or enable the render view

        Type:
        :   boolean, default False

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

assistant: |  |  |
| --- | --- |
| - [`NodeEvaluateClosure.output_items`](bpy.types.NodeEvaluateClosure.html#bpy.types.NodeEvaluateClosure.output_items "bpy.types.NodeEvaluateClosure.output_items") - [`NodeEvaluateClosureOutputItems.new`](bpy.types.NodeEvaluateClosureOutputItems.html#bpy.types.NodeEvaluateClosureOutputItems.new "bpy.types.NodeEvaluateClosureOutputItems.new") | - [`NodeEvaluateClosureOutputItems.remove`](bpy.types.NodeEvaluateClosureOutputItems.html#bpy.types.NodeEvaluateClosureOutputItems.remove "bpy.types.NodeEvaluateClosureOutputItems.remove") |
user: Provide the full official documentation entry for Add-ons, preserving all code examples.

assistant: - 3D View
- Add Curve
- Add Mesh
- Animation
- Bake
- Camera
- Compositing
- Development
- Game Engine
- Geometry Nodes
- Grease Pencil
- Import-Export
- Lighting
- Material
- Modeling
- Mesh
- Node
- Object
- Paint
- Pipeline
- Physics
- Render
- Rigging
- Scene
- Sculpt
- Sequencer
- System
- Text Editor
- Tracking
- User Interface
- UV
user: How do I use Typical Scenarios for using Soft Bodies in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

The wind cone is a soft body, as the suspension.

[Animation](https://vimeo.com/1865817)

Soft bodies are well suited for:

- Jiggle on moving characters.
- Elastic and deformable objects made of materials like rubber or gelatin.
- Tree branches moving in the wind, swinging ropes, and the like.
- Flags, wide sleeves, cushions or other simple fabric reacting to forces.
user: Show practical ways to work with Language in a Blender add-on or script – include code.

assistant: Language
:   The language used for translating the user interface (UI).
    The list is broken up into categories determining how complete the translations are.

Translate
:   Tooltips
    :   Translates the descriptions when hovering over UI elements.

    Interface
    :   Translates all labels in menus, buttons, and panels.

    New Data
    :   Translates the names of new data-blocks.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`SpaceSpreadsheet.viewer_path`](bpy.types.SpaceSpreadsheet.html#bpy.types.SpaceSpreadsheet.viewer_path "bpy.types.SpaceSpreadsheet.viewer_path") | - [`SpreadsheetTableIDGeometry.viewer_path`](bpy.types.SpreadsheetTableIDGeometry.html#bpy.types.SpreadsheetTableIDGeometry.viewer_path "bpy.types.SpreadsheetTableIDGeometry.viewer_path") |
user: What is Example and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| ../../../../_images/modeling_modifiers_generate_triangulate_before.png   Mesh before triangulation. | ../../../../_images/modeling_modifiers_generate_triangulate_after.png   Mesh after triangulation. |
user: Explain Node Combsep Color Items in complete detail according to the official Blender documentation.

assistant: # Node Combsep Color Items

RGB:
:   RGB.

    Use RGB (Red, Green, Blue) color processing.

HSV:
:   HSV.

    Use HSV (Hue, Saturation, Value) color processing.

HSL:
:   HSL.

    Use HSL (Hue, Saturation, Lightness) color processing.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Image
:   HDR image.

Type
:   Algorithm used for tone mapping:

    Rh Simple:
    :   A simplified Reinhard tone mapping operator that uses the image’s average luminance.
        Suitable for quick and general-purpose tone mapping.

    R/D Photoreceptor:
    :   A more complex algorithm modeling human photoreceptor response,
        allowing finer adjustments in adaptation, contrast, and color correction.

Intensity R/D Photoreceptor
:   If less than zero, darkens image; otherwise, makes it brighter.

Contrast R/D Photoreceptor
:   Set to 0 to use estimate from input image.

Light Adaptation R/D Photoreceptor
:   If 0, global; if 1, based on pixel intensity.

Chromatic Adaptation R/D Photoreceptor
:   If 0, same for all channels; if 1, each independent.

Key Rh Simple
:   The value the average luminance is mapped to.

Balance Rh Simple
:   Normally always 1, but can be used as an extra control to alter the brightness curve.

Gamma Rh Simple
:   If not used, set to 1.
user: Provide the full official documentation entry for ThemeTopBar(bpy_struct), preserving all code examples.

assistant: # ThemeTopBar(bpy_struct)

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

*class* bpy.types.ThemeTopBar(*bpy_struct*)
:   Theme settings for the Top Bar

    space
    :   Settings for space

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

    *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 Drivers, preserving all code examples.

assistant: Upgrading to the latest graphics drivers often solves problems. Newer drivers have bug fixes that help Blender
function correctly.

On Windows, drivers are provided by the graphics card manufacturer (AMD). Windows Update automatically installs
graphics drivers, or your computer manufacturer may provide its own version of the graphics drivers.

However, these are not always the latest version or may have been corrupted in some way. We recommend always using
the official drivers.

[Download Latest AMD Drivers](https://www.amd.com/en/support)
user: Give a detailed overview of Color Picker: syntax, arguments, return values, common patterns.

assistant: # Color Picker

[image reference removed]

Circle HSV color picker.

The *Color Picker* is a pop-up control that allows you to define and adjust color values.
It appears when editing any color property in Blender, such as materials, lights, brushes, or interface themes.

The color picker provides multiple color models and interaction modes to suit different workflows,
and can display or edit colors in both *linear* and *perceptual* (display-referred) color spaces.
user: Explain Socket Syncing in complete detail according to the official Blender documentation.

assistant: Bundles use socket names to match their inputs and outputs.
If two bundle nodes are connected but have mismatched signatures,
Blender can offer to sync them automatically.

- Sync happens automatically when a node is connected for the first time.
- Existing sockets are never updated automatically to avoid overwriting data.
- A  button (*Sync Sockets*) button appears in the node header when a mismatch is detected, allowing manual synchronization.
user: Provide the full official documentation entry for Mesh to Curve Node, preserving all code examples.

assistant: # Mesh to Curve Node

[image reference removed]

The *Mesh to Curve* node converts a mesh into one or more curve splines.

Two different conversion modes are supported, depending on the desired output:

- **Edges**: Turns each string of connected mesh edges into a poly spline.
  Whenever two or more edge strings intersect, they will be split into separate splines.
- **Faces**: Creates a cyclic spline from each mesh face. This mode is generally much faster than *Edges*,
  as it parallelizes easily and can share face and corner attributes without needing to copy them.

Loose vertices are ignored – they will not be turned into single-point splines.

Attributes, both named and unnamed ones, are transferred to the resulting splines.
If there is a `radius` attribute, it will be applied as such,
although you may find it more convenient to use the
[Set Curve Radius Node](../../curve/write/set_curve_radius.xhtml) for this.
user: How do I use Inline Shader Nodes in Blender? Include parameters, examples, warnings and best practices.

assistant: ```
import bpy

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

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

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

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

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

    node_tree
    :   The inlined node tree.

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

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

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

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

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

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

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

assistant: The base layer is a mix between metal, diffuse, subsurface, and transmission components.
Most materials will use one of these components, though it is possible to smoothly mix
between them.

[image reference removed]

The metal component is opaque and only reflect lights. Diffuse is fully opaque, while
subsurface also involves light scattering just below the surface. Both diffuse and
subsurface sit below a specular layer. The transmission component includes both
specular reflection and refraction.

On top of all base layers there is an optional glossy coat. And finally the sheen layer
sits on top of all other layers, to add fuzz or dust.

Light emission can also be added. Light emits from below the coat and sheen layers,
to model for example emissive displays with a coat or dust.
user: Provide the full official documentation entry for Translate the User Manual, preserving all code examples.

assistant: # Translate the User Manual

Help bring Blender to the world! 🌍 Join the translation effort to make the Blender Manual accessible in more
languages. Whether you’re fluent in another language or just starting, every contribution makes a difference. Let’s
build a global community!
user: Describe SpreadsheetColumnID(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # SpreadsheetColumnID(bpy_struct)

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

*class* bpy.types.SpreadsheetColumnID(*bpy_struct*)
:   Data used to identify a spreadsheet column

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

    *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 Outputs, preserving all code examples.

assistant: Image
:   Processed image with the *Matte* applied to the images’ [Alpha Channel](../../../glossary/index.xhtml#term-Alpha-Channel).

Matte
:   Output matte to use for checking the quality of the key, or to manually apply
    using a [Set Alpha Node](../color/set_alpha.xhtml) or
    [Mix Node](../color/mix_color.xhtml).

Edges
:   Shows what edges were detected on the matte.
    Useful for adjusting the *Edge* *Size* and *Tolerance*.
user: Give a detailed overview of GeometryNodeUVTangent(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeUVTangent(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.GeometryNodeUVTangent(*GeometryNode*)
:   Generate tangent directions based on a UV map

    *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: Provide the full official documentation entry for Film, preserving all code examples.

assistant: # Film

Exposure
:   This can be used to change the brightness of an image.
    Different than the *Exposure* option found in the [Color management](../../color_management/displays_views.xhtml#render-post-color-management) panel,
    this exposure option works *on the data* while the Color management exposure is on the *view transform*.
user: What is GeometryNodeSplineLength(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeSplineLength(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.GeometryNodeSplineLength(*GeometryNode*)
:   Retrieve the total length of each spline, as a distance or as a number of points

    *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 WeightedNormalModifier(Modifier): syntax, arguments, return values, common patterns.

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

assistant: # XrUserPath(bpy_struct)

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

*class* bpy.types.XrUserPath(*bpy_struct*)
:   path
    :   OpenXR user path

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is NodeTreeInterfaceSocketVectorVelocity(NodeTreeInterfaceSocket) and how is it used in Blender Python scripting?

assistant: # NodeTreeInterfaceSocketVectorVelocity(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketVectorVelocity(*NodeTreeInterfaceSocket*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], default (0.0, 0.0, 0.0)

    dimensions
    :   Dimensions of the vector socket

        Type:
        :   int in [2, 4], default 0

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

    *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 NodeTreeInterfaceSocketVectorTranslation2D(NodeTreeInterfaceSocket), preserving all code examples.

assistant: # NodeTreeInterfaceSocketVectorTranslation2D(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketVectorTranslation2D(*NodeTreeInterfaceSocket*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-inf, inf], default (0.0, 0.0)

    dimensions
    :   Dimensions of the vector socket

        Type:
        :   int in [2, 4], default 0

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is LineStyleGeometryModifier_PerlinNoise1D(LineStyleGeometryModifier) and how is it used in Blender Python scripting?

assistant: # LineStyleGeometryModifier_PerlinNoise1D(LineStyleGeometryModifier)

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

*class* bpy.types.LineStyleGeometryModifier_PerlinNoise1D(*LineStyleGeometryModifier*)
:   Add one-dimensional Perlin noise to stroke backbone geometry

    amplitude
    :   Amplitude of the Perlin noise

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

    angle
    :   Displacement direction

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    frequency
    :   Frequency of the Perlin noise

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

    octaves
    :   Number of octaves (i.e., the amount of detail of the Perlin noise)

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

    seed
    :   Seed for random number generation (if negative, time is used as a seed instead)

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

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Geometry Modifier Type Items](bpy_types_enum_items/linestyle_geometry_modifier_type_items.html#rna-enum-linestyle-geometry-modifier-type-items), default `'2D_OFFSET'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

    *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](#bpy.types.LineStyleGeometryModifier_PerlinNoise1D.type "bpy.types.LineStyleGeometryModifier_PerlinNoise1D.type")
user: Explain Select Grouped in complete detail according to the official Blender documentation.

assistant: Selects nodes that share similar properties with the active node.

- **Type**: Select all nodes of the same type (e.g. all *Math* nodes).
- **Color**: Select nodes with the same custom [color](node_editors.xhtml#bpy-types-node-color).
  (This refers to user-assigned editor colors, not the color data processed by nodes.)
- **Prefix/Suffix**: Select nodes whose names match the same starting or ending text.
user: How do I use NodeSocketVectorVelocity4D(NodeSocketStandard) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeSocketVectorVelocity4D(NodeSocketStandard)

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

*class* bpy.types.NodeSocketVectorVelocity4D(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 4 items in [-inf, inf], default (0.0, 0.0, 0.0, 0.0)

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe Preview from the Blender manual or Python API, including usage steps and snippets.

assistant: # Preview

The Preview panel gives a quick visualization of the active material applied in a simple scene.

Shape
:   Preview the material on a Plane, Sphere, Cube, Hair, Shader Ball, Cloth or Fluid object.
    This shape is also used for previews when linking and appending materials.

Preview World Cycles Only
:   Use the world from the current scene for lighting in the material preview.

[image reference removed]

Preview shapes.
user: Explain SEQUENCER_FH_sound_strip(FileHandler) in complete detail according to the official Blender documentation.

assistant: # SEQUENCER_FH_sound_strip(FileHandler)

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

*class* bpy.types.SEQUENCER_FH_sound_strip(*FileHandler*)
:   *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 Hinge Constraint in a Blender add-on or script – include code.

assistant: # Hinge Constraint

The hinge permits one degree of freedom between two objects. Translation is completely constrained.
Rotation is permitted about the Z axis of the object hosting the Physics constraint
(usually an [Empty](../../../../glossary/index.xhtml#term-Empty), distinct from the two objects that are being linked).
Adjusting the position and rotation of the object hosting the constraint allows you to
control the anchor and axis of the hinge.

The Hinge is the only single-axis rotational constraint that uses the Z axis instead of the X axis.
If something is wrong with your hinge, check your other constraints to see if this might be the problem.

[image reference removed]

*Hinge* constraint options.
user: Provide the full official documentation entry for Shader Nodes, preserving all code examples.

assistant: - All BSDF’s are using approximations to achieve realtime performance
  so there will always be small differences between Cycles and EEVEE.
- Some utility nodes are not yet compatible with EEVEE.
- Certain combinations of BSDF’s will result in more noise than others.
  This is the case when mixing Diffuse BSDF and Refraction BSDF.
- Displacement of flat shaded surfaces will split the mesh into triangles.
  See [Displacement](../material_settings.xhtml#bpy-types-material-displacement-method) for a workaround.
user: Give a detailed overview of Light Groups: syntax, arguments, return values, common patterns.

assistant: Cycles only

A Light Group provides a limited *Combined* render pass where the scene is only illuminated by
certain lights. Multiple such passes can then be combined in compositing to construct a full render
with all the lights. The most straightforward way is to simply *Add* them together using
the [Mix Color Node](../../compositing/types/color/mix_color.html), but by making more complex combinations,
it’s possible to change the color and intensity of individual lights without having to re-render.

To assign a Light object to a new or existing Light Group, use the panel
Object ‣ Shading ‣ Light Group ([details](../cycles/object_settings/object_data.html#bpy-types-object-lightgroup)).

To assign the World background to a Light Group, use the panel
World ‣ Settings ‣ Light Group ([details](../cycles/world_settings.html#bpy-types-world-lightgroup)).

Name
:   The name of the light group.

### Light Group Sync

These operators are available from the  button to the right of the
Light Group list.

Add Used Lightgroups
:   Create Light Groups for any lights that reference a non-existing one.

Remove Unused Lightgroups
:   Delete any Light Groups that are not referenced by any lights.