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

assistant: # Add Strip

The Add effect strip adds the colors of two strips together.
Use this effect with a base image strip, and a modifier strip.
The modifier strip is either a solid color or a black-and-white mask,
or another image entirely.

You can use this effect to increase the brightness of an image, or if you use a BW mask,
selectively increase the brightness of certain areas of the image. The Mix node, in Add mode,
does exactly the same thing as the Add SFX strip here,
and is controlled the same way by feeding the Factor input.

The [example](#fig-sequencer-strips-effects-add) shows what happens when you add gray to an image.
The image gets bright because we are adding gray
RGB(0.5, 0.5, 0.5) to say, a blue color RGB(0.1, 0.1, 0.5) resulting in RGB(0.6, 0.6, 1.0)
which retains the original hue (relationship between the colors) but is much brighter
(has a higher value). When applied to the whole image like this, it seems to flash.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`MovieTracking.objects`](bpy.types.MovieTracking.html#bpy.types.MovieTracking.objects "bpy.types.MovieTracking.objects") - [`MovieTrackingObjects.active`](bpy.types.MovieTrackingObjects.html#bpy.types.MovieTrackingObjects.active "bpy.types.MovieTrackingObjects.active") | - [`MovieTrackingObjects.new`](bpy.types.MovieTrackingObjects.html#bpy.types.MovieTrackingObjects.new "bpy.types.MovieTrackingObjects.new") - [`MovieTrackingObjects.remove`](bpy.types.MovieTrackingObjects.html#bpy.types.MovieTrackingObjects.remove "bpy.types.MovieTrackingObjects.remove") |
user: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

The UV Editor is used for editing UV maps, which describe how a 2D image should be mapped
onto a 3D object.

[image reference removed]

UV Editor with a UV map and a test grid texture.

Image textures are typically needed when the desired look is hard to achieve with procedural textures,
or if the texture is not uniform. For example, a car would only have scratches in a few places where they make sense,
not in random places all over its body.

Blender offers a number of projections (Box, Sphere…) that automatically apply a 2D image to a 3D object,
but these tend to only work for simple meshes. For more complex ones, you need to create a UV map instead.
This is a flat area where each face of the 3D object is laid out on the 2D image, specifying which part of the
image it should be textured with. This gives you complete control over the mapping process.

The name “UV” refers to the axes of the map: U for horizontal, V for vertical. These letters were chosen to
avoid confusion with “X” and “Y”, which refer to axes in 3D space instead.
user: Give a detailed overview of Should I Translate... ?: syntax, arguments, return values, common patterns.

assistant: ### Maybe

Hyperlinks
:   May be translated, but only as an addition, not as a replacement.
    Keep the original link text and add the translation alongside.
    See also [Adding Text](#adding-text).

Technical Terms
:   Translate only if the localized expression is commonly used and well understood.
    Otherwise, keep the English term.
    See also [Technical Terms](#technical-terms).

Unclear Text
:   If you are not sure you understood the meaning, mark the text as *fuzzy* and/or add a translator comment.
    Another translator may be able to clarify it.

UI Elements
:   UI elements should use the same translation as in Blender’s user interface.
    If the UI element has not yet been translated, keep the English term
    and add the translation in parentheses.

### Never

Images
:   You probably will not find the original scene if it is a screenshot of a file and it is too much load on the server
    (and too much work for you).
user: Provide the full official documentation entry for Multiresolution Modifier, preserving all code examples.

assistant: # Multiresolution Modifier

The *Multiresolution* modifier (often shortened to “Multires”)
gives you the ability to subdivide a mesh similarly
to the [Subdivision Surface](subdivision_surface.html) modifier,
but also allows you to edit the new subdivision levels in
[Sculpt Mode](../../../sculpt_paint/sculpting/introduction/adaptive.html).

Deform modifiers will be applied onto the Multires subdivision levels instead of the base mesh,
if they come after the Multires.
user: Show practical ways to work with ObjectModifiers(bpy_struct) in a Blender add-on or script – include code.

assistant: # ObjectModifiers(bpy_struct)

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

*class* bpy.types.ObjectModifiers(*bpy_struct*)
:   Collection of object modifiers

    active
    :   The active modifier in the list

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

    new(*name*, *type*)
    :   Add a new modifier

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – New name for the modifier
            - **type** (enum in [Object Modifier Type Items](bpy_types_enum_items/object_modifier_type_items.html#rna-enum-object-modifier-type-items)) – Modifier type to add

        Returns:
        :   Newly created modifier

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

    remove(*modifier*)
    :   Remove an existing modifier from the object

        Parameters:
        :   **modifier** ([`Modifier`](bpy.types.Modifier.html#bpy.types.Modifier "bpy.types.Modifier"), (never None)) – Modifier to remove

    clear()
    :   Remove all modifiers from the object

    move(*from_index*, *to_index*)
    :   Move a modifier to a different position

        Parameters:
        :   - **from_index** (*int in* *[**-inf**,* *inf**]*) – From Index, Index to move
            - **to_index** (*int in* *[**-inf**,* *inf**]*) – To Index, Target index

    *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 Advanced: syntax, arguments, return values, common patterns.

assistant: ### Blender as a Module

From a Python perspective it’s nicer to have everything as an extension
which lets the Python script combine many components.

Advantages include:

- You can use external editors or IDEs with Blender’s Python API and execute scripts within the IDE
  (step over code, inspect variables as the script runs).
- Editors or IDEs can auto-complete Blender modules and variables.
- Existing scripts can import Blender APIs without having to be run inside of Blender.

This is marked advanced because to run Blender as a Python module requires a special build option.
For instructions on building see
[Building Blender as a Python module](https://developer.blender.org/docs/handbook/building_blender/python_module/).

### Python Safety (Build Option)

Since it’s possible to access data which has been removed (see [Gotchas](info_gotcha.html)),
it can be hard to track down the cause of crashes.
To raise Python exceptions on accessing freed data (rather than crashing),
enable the CMake build option `WITH_PYTHON_SAFETY`.
This enables data tracking which makes data access about two times slower
which is why the option isn’t enabled in release builds.
user: Provide the full official documentation entry for N, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [**N-gon**](glossary/index.xhtml#term-N-gon) - [**NDOF**](glossary/index.xhtml#term-NDOF) - [Nodes](interface/controls/nodes/index.xhtml#index-0)   - [Closure](interface/controls/nodes/types/utilities/closure/closure.xhtml#index-0)   - [Combine Bundle Node](interface/controls/nodes/types/utilities/bundles/combine_bundle.xhtml#index-0)   - [Compositing Nodes](compositing/introduction.xhtml#index-0)   - [Evaluate Closure](interface/controls/nodes/types/utilities/closure/evaluate_closure.xhtml#index-0)   - [Geometry Nodes](modeling/geometry_nodes/index.xhtml#index-0)   - [Join Bundle Node](interface/controls/nodes/types/utilities/bundles/join_bundle.xhtml#index-0)   - [Separate Bundle](interface/controls/nodes/types/utilities/bundles/separate_bundle.xhtml#index-0)   - [Shader Nodes](render/shader_nodes/introduction.xhtml#index-0)   - [Texture Nodes](editors/texture_node/introduction.xhtml#index-1) | - [**Non-manifold**](glossary/index.xhtml#term-Non-manifold) - [**Non-uniform Rational Basis Spline**](glossary/index.xhtml#term-Non-uniform-Rational-Basis-Spline) - [**Nonlinear Animation**](glossary/index.xhtml#term-Nonlinear-Animation) - [**Normal**](glossary/index.xhtml#term-Normal) - [**Normal Mapping**](glossary/index.xhtml#term-Normal-Mapping) - [**NURBS**](glossary/index.xhtml#term-NURBS) |
user: What is Points and how is it used in Blender Python scripting?

assistant: The main element used in editing Grease Pencil objects are points.
Points represent a single point in 3D space.

Each point stores all the properties that define the final appearance of the strokes
as its location, thickness, alpha, weight and UV rotation for textures.
user: Show practical ways to work with Example in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| ../../../../_images/modeling_modifiers_generate_triangulate_before.png   Mesh before triangulation. | ../../../../_images/modeling_modifiers_generate_triangulate_after.png   Mesh after triangulation. |
user: What is Set Position Node and how is it used in Blender Python scripting?

assistant: # Set Position Node

[image reference removed]

The *Set Position* node controls the location of each point, the same way as controlling
the `position` attribute.
If the input geometry contains instances, this node will affect the location of the origin of each instance.

The input node for this data is the [Position Node](../read/position.xhtml).
user: Show practical ways to work with Track Preview Widget in a Blender add-on or script – include code.

assistant: The widget in this panel is called “Track Preview” and it displays the content of the pattern area.
This helps to check how accurately the feature is being tracked
(controlling that there is no sliding off original position)
and also helps to move the track back to the correct position.
The track can be moved directly using this widget by mouse dragging.

If an anchor is used
(the position in the image which is tracking is different from the position which is used for parenting),
a preview widget will display the area around the anchor position.
This configuration helps in masking some things when there is no good feature at position where
the mask corner should be placed. Details of this technique will be written later.

There is small area below the preview widget which can be used to enlarge the vertical size of
preview widget (the area is highlighted with two horizontal lines).
user: What is Inherited Properties and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`FileHandler.bl_idname`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_idname "bpy.types.FileHandler.bl_idname") - [`FileHandler.bl_import_operator`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_import_operator "bpy.types.FileHandler.bl_import_operator") | - [`FileHandler.bl_export_operator`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_export_operator "bpy.types.FileHandler.bl_export_operator") - [`FileHandler.bl_label`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_label "bpy.types.FileHandler.bl_label") - [`FileHandler.bl_file_extensions`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_file_extensions "bpy.types.FileHandler.bl_file_extensions") |
user: What is Smart UV Project and how is it used in Blender Python scripting?

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

[image reference removed]

Smart UV project on a truncated pyramid.

### Options

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

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

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

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

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

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

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

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

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

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

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

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

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

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

assistant: [image reference removed]

The Explode modifier, with a Particle System above it.

Particle UV
:   If set, the U value of the coordinates in that [UV Map](../../../glossary/index.xhtml#term-UV-Map) will be overwritten
    with the age of the particle attached to the matching mesh face
    (in proportion, from 0 for not yet born particles, to 1 for dead ones).

    The V value is set to a constant 0.5 value.

    You can for example vary the color of a fragment (face) during the explosion phase,
    by using a texture with a color gradient along its *U* axis.

Show
:   Unborn
    :   Show faces when their attached particles are unborn.

    Alive
    :   Show faces when their attached particles are alive.

    Dead
    :   Show faces when their attached particles are dead.

Cut Edges
:   Split the mesh in pieces based on location of emitted particles, instead of using existing faces.
    This will typically results in a splitting that appears more random.

Size
:   Scale each face using the size of its attached particle, once that particle is alive.

Vertex Group
:   Vertices in this group may not be affected by the *Explode* modifier.
    Vertices with full weight are not affected at all,
    while vertices with less weight have a higher chance of being affected.

    Vertices with null weight will be treated like those which do not belong to the group at all,
    and explode normally.

    Invert
    :   Inverts the influence of the selected vertex group, meaning that the group
        now represents vertices that will not be deformed by the modifier.

        The setting reverses the weight values of the group.

Protect
:   Clean vertex group edges. Depending on the weights assigned to that vertex group,
    either completely protect those faces from being affected by the *Explode* modifier
    (which would happen if the faces had a weight value of 1),
    or completely remove protection from those faces
    (which would happen if the faces had a weight value of 0).

Refresh
:   Refresh data in the *Explode* modifier.
user: Explain GeometryNodeCurveSpiral(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeCurveSpiral(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.GeometryNodeCurveSpiral(*GeometryNode*)
:   Generate a poly spline in a spiral shape

    *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: What is Maintain Volume Constraint and how is it used in Blender Python scripting?

assistant: # Maintain Volume Constraint

The *Maintain Volume* constraint ensures that an object or bone keeps its
original volume by automatically scaling down two axes when another axis
is scaled up (and vice versa). This can be useful for stretching and squashing
stylized characters, for example.
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

Soft body simulation is used for simulating soft deformable objects.
It was designed primarily for adding secondary motion to animation,
like jiggle for body parts of a moving character.

It also works for simulating more general soft objects that bend, deform and
react to forces like gravity and wind, or collide with other objects.

While it can simulate cloth and other stiff types of deformable objects to
an extent, the [Cloth Simulation](../cloth/index.xhtml) can do it better
with a solver specifically designed for this purpose.

The simulation works by combining existing animation on the object with forces
acting on it. There are exterior forces like gravity or force fields and
interior forces that hold the vertices together.
This way you can simulate the shapes that an object would take on in reality if it had volume,
was filled with something, and was acted on by real forces.

Soft bodies can interact with other objects through *Collision*.
They can interact with themselves through *Self-Collision*.

The result of the soft body simulation can be converted to a static object.
You can also *bake edit* the simulation, i.e.
edit intermediate results and run the simulation from there.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Volume
:   Standard volume geometry input.

Mode
:   Random:
    :   Distribute points randomly inside of the volume. The local point count is implicitly
        defined as a product of the global from the *Density* input and the local voxel value.
        This method creates a distribution that is not stable as the input volume deforms.

    Grid:
    :   Distribute the points in a grid pattern inside of the volume. At each grid point, the voxel
        value is used to determine whether to add a point.

Density Random
:   Number of points to sample per unit volume.

Seed Random
:   Seed used by the random number generator to generate random points

Spacing Grid
:   Spacing between grid points.

Threshold Grid
:   Minimum value of a volume cell to contain a grid point.
user: Describe VOLUME_UL_grids(UIList) from the Blender manual or Python API, including usage steps and snippets.

assistant: # VOLUME_UL_grids(UIList)

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

*class* bpy.types.VOLUME_UL_grids(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *grid*, *_icon*, *_active_data*, *_active_propname*, *_index*)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Brush Assets in complete detail according to the official Blender documentation.

assistant: Brushes are used as assets, and stored in [asset libraries](../../files/asset_libraries/introduction.xhtml). This makes the
brushes shared across project files. All available brush assets can be displayed in the
[Asset Browser](../../editors/asset_browser.xhtml), which also provides ways to organize them.

Blender comes bundled with a number of brushes in the Essentials asset library. These can be customized into all
kinds of custom brushes by duplicating them (see [Brush Editing](brush_management.xhtml)).

While it’s possible to have brush data-blocks that are local to the file and not marked as assets, such brushes cannot
be activated for actual painting or sculpting. Use the Mark as Asset operator to make them brush assets that can be
activated.
user: Explain Updating on macOS in complete detail according to the official Blender documentation.

assistant: On macOS there is one main way to update Blender. This section covers that approach.

### Updating from a DMG

When an update for Blender is released, it can be downloaded directly
from the [Blender website](https://www.blender.org/download/). Install the new version by overwriting the current
`Blender.app` in the Applications folder. You can rename `Blender.app` or place it in a different folder to have
more than one version at a time.
user: Describe Distance Key Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Distance Key Node

[image reference removed]

The Distance Key node determines a pixel’s alpha value based on the three-dimensional
distance between the image pixel color and the key color in a 3D color space.

This key works well when trying to single out a specific color in a background
(not necessarily green).
user: Give a detailed overview of Armature Mode Switching: syntax, arguments, return values, common patterns.

assistant: While writing scripts that deal with armatures you may find you have to switch between modes,
when doing so take care when switching out of Edit-Mode not to keep references
to the edit bones or their head/tail vectors.
Further access to these will crash Blender so it’s important that the script
clearly separates sections of the code which operate in different modes.

This is mainly an issue with Edit-Mode since pose data can be manipulated without having to be in Pose-Mode,
yet for operator access you may still need to enter Pose-Mode.
user: What is GeometryNodeMeshLine(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeMeshLine(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.GeometryNodeMeshLine(*GeometryNode*)
:   Generate vertices in a line and connect them with edges

    count_mode
    :   - `TOTAL`
          Count – Specify the total number of vertices.
        - `RESOLUTION`
          Resolution – Specify the distance between vertices.

        Type:
        :   enum in [`'TOTAL'`, `'RESOLUTION'`], default `'TOTAL'`

    mode
    :   - `OFFSET`
          Offset – Specify the offset from one vertex to the next.
        - `END_POINTS`
          End Points – Specify the line’s start and end points.

        Type:
        :   enum in [`'OFFSET'`, `'END_POINTS'`], default `'OFFSET'`

    *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 Fly & Walk: syntax, arguments, return values, common patterns.

assistant: View Navigation
:   The default mode for interactive first person navigation.

    See [Fly/Walk Navigation](../3dview/navigate/walk_fly.xhtml#dview-fly-walk).

### Walk

Reverse Mouse
:   Inverts the mouse’s Y movement.

Mouse Sensitivity
:   Speed factor for when looking around, high values mean faster mouse movement.

Teleport Duration
:   Interval of time warp when teleporting in navigation mode.

Walk Speed
:   Base speed for walking and flying.

Speed Factor
:   The multiplication factor for the speed boost.

### Gravity

Simulates the effect of gravity when walking.

View Height
:   The distance from the ground floor to the camera when walking.

Jump Height
:   The maximum height of a jump.
user: How do I use Denoising in Blender? Include parameters, examples, warnings and best practices.

assistant: Denoising can be enabled to reduce the amount of noise from the raw ray-traced output.
This can help image stability but will also over-blur the final ray-traced output.

Spatial Reuse
:   Reuse the rays from neighbor pixels.
    Can introduce some light leaks across surfaces.

Temporal Accumulation
:   Accumulate samples by re-projecting the last ray tracing results.
    This removes [Fireflies](../../../glossary/index.xhtml#term-Fireflies) but also introduces color bias.
    Useful for viewport temporal stability or making renders converge faster.

Bilateral Filter
:   Blur the resolved ray-traced output using a bilateral filter.
user: Explain Select More/Less in complete detail according to the official Blender documentation.

assistant: # Select More/Less

With at least one vertex, edge, or face selected, *Select More/Less* expands or shrinks the selection.
However, if there is only one selection in any selection mode, *Less* will deselect it.

Face Step
:   With *Face Step* on, each use of the tool
    will affect the size of the selection on a face by face basis.
    When deactivated, it will be based on either vertices or edges depending on which
    [Selection Mode](introduction.html) is active.

[image reference removed]

(From left to right) initial selection, without Face Step,
with Face Step, and in edge selection mode.
user: Give a detailed overview of Select Edge Ring: syntax, arguments, return values, common patterns.

assistant: Holding `Ctrl`-`Alt` while clicking an edge selects that edge and then expands the selection
as far as possible in the two directions perpendicular to it. (While this of course works for selecting
edge “rings” that go all the way around a mesh, it also works if there’s no ring.)

You can additionally hold `Shift` to extend the current selection rather than replacing it.
user: Give a detailed overview of Platform Specific: syntax, arguments, return values, common patterns.

assistant: ### Windows

#### Mixed Python Libraries (DLLs)

If Python is raising errors or you have an add-on that just fails when enabled with an error – e.g: `... is not a
valid Win32 application.` – this may be caused by some inconsistency in the Python libraries. While Blender comes
with its own bundled Python interpreter, duplicate, incompatible libraries can cause problems.

[image reference removed]

A Python traceback.

To find out which Python Library caused the Problem check the error message.

This is normally reported somewhere around the bottom line of the traceback. With the error above you see the problem
is caused while trying to import `_socket`. This corresponds to either a file named `_socket.py` or
`_socket.pyd`.

To help troubleshoot this problem, the following script can be pasted into the Text editor and run to check for
duplicate libraries in your search path.
(The output will show in [Command Line Window](../advanced/command_line/index.xhtml).)

```
import os
import sys

# Change this based on the library you wish to test
test_lib = "_socket.pyd"

def GetSystemDirectory():
    from ctypes import windll, create_string_buffer, sizeof
    GetSystemDirectory = windll.kernel32.GetSystemDirectoryA
    buffer = create_string_buffer(260)
    GetSystemDirectory(buffer, sizeof(buffer))
    return os.fsdecode(buffer.value)

def library_search_paths():
    return (
        # Windows search paths
        os.path.dirname(sys.argv[0]),
        os.getcwd(),
        GetSystemDirectory(),
        os.environ["WINDIR"],  # GetWindowsDirectory
        *os.environ["PATH"].split(";"),

        # regular Python search paths
        *sys.path,
        )

def check_library_duplicate(libname):
    paths = [p for p in library_search_paths()
             if os.path.exists(os.path.join(p, libname))]

    print("Library %r found in %d locations:" % (libname, len(paths)))
    for p in paths:
        print("- %r" % p)

check_library_duplicate(test_lib)
```
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: Steps
:   Specifies how many copies will be extruded along the “sweep”.

Angle
:   Specifies the angle “swept” by this tool, in degrees (e.g. set it to 180 for half a turn).

Auto Merge
:   Automatically merges the first a last duplicates,
    if they make a full revolution which results in overlapping geometry.

Flip Normals
:   Reverses the [Normal’s](../../../glossary/index.xhtml#term-Normal) direction for any resulting geometry.

Center X, Y, Z
:   Specifies the center of the spin. By default it uses the cursor position.

Axis X, Y, Z
:   Specify the spin axis as a vector. By default it uses the view axis (viewport).
user: Describe Add Driver from the Blender manual or Python API, including usage steps and snippets.

assistant: The usual way to add a driver to a property is to `RMB` click a property,
then choose *Add Driver* in the context menu.
Drivers can also be added by pressing `Ctrl`-`D` with the mouse over the property.

This operation adds a driver with a single variable (which needs to be filled in),
and displays the *Edit Driver* popover.
user: Give a detailed overview of Window Stereo 3D Display: syntax, arguments, return values, common patterns.

assistant: An essential component of the Stereoscopy pipeline is the ability to display the stereo image in a proper display.
Blender supports from high-end 3D displays to simple red-cyan glasses.
On top of that, you can set a different display mode for each window.

The display mode can be changed via the Window menu
or if you create your own shortcuts for the `wm.set_stereo_3d` operator.

[image reference removed]

Window menu, stereo 3D operator.

### Display Mode

Anaglyph
:   Render two differently filtered colored images for each eye.
    Anaglyph glasses are required. We support red-cyan, green-magenta and yellow-blue glasses.

Interlace
:   Render two images for each eye into one interlaced image.
    A 3D-ready monitor is required. We support Row, Column and Checkerboard Interleaved.
    An option to Swap Left/Right helps to adjust the image for the screen. This method works better in fullscreen.

Time Sequential
:   Render alternate eyes.
    This method is also known as Page Flip.
    This requires the graphic card to support Quad Buffer and it only works in fullscreen.

Side-by-Side
:   Render images for left and right eye side-by-side.
    There is an option to support Cross-Eye glasses.
    It works only in fullscreen, and it should be used with the Full Editor operator.

Top-Bottom
:   Render images for left and right eye one above another.
    It works only in fullscreen, and it should be used with the Full Editor operator.
user: Provide the full official documentation entry for EdgeSplitModifier(Modifier), preserving all code examples.

assistant: # EdgeSplitModifier(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.EdgeSplitModifier(*Modifier*)
:   Edge splitting modifier to create sharp edges

    split_angle
    :   Angle above which to split edges

        Type:
        :   float in [0, 3.14159], default 0.523599

    use_edge_angle
    :   Split edges with high angle between faces

        Type:
        :   boolean, default True

    use_edge_sharp
    :   Split edges that are marked as sharp

        Type:
        :   boolean, default True

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for ParticleKey(bpy_struct), preserving all code examples.

assistant: # ParticleKey(bpy_struct)

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

*class* bpy.types.ParticleKey(*bpy_struct*)
:   Key location for a particle over time

    angular_velocity
    :   Key angular velocity

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

    location
    :   Key location

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

    rotation
    :   Key rotation quaternion

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

    time
    :   Time of key over the simulation

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

    velocity
    :   Key velocity

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], default (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 CompositorNodeHueCorrect(CompositorNode) in a Blender add-on or script – include code.

assistant: # CompositorNodeHueCorrect(CompositorNode)

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

*class* bpy.types.CompositorNodeHueCorrect(*CompositorNode*)
:   Adjust hue, saturation, and value with a curve

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

    *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 Object Gizmos and how is it used in Blender Python scripting?

assistant: Object Gizmos allow mouse-controlled translation, rotation and scaling in the 3D Viewport.
While they’re called “object” gizmos in the popover, they also apply to other transformable
elements such as mesh vertices.

There is a separate gizmo for each operation.
Each gizmo can be used separately or in combination with the others.

A gizmo always has three color-coded axes: X (red), Y (green), and Z (blue).
You can drag an axis with `LMB` to transform along it. The Move and Scale gizmos
additionally have small colored squares for transforming along two axes in one go.

Various modifier keys can be used:

- Holding `Ctrl` at any time will toggle [snapping](../controls/snapping.html)
  and also make rotation and scaling work in coarse increments.
- Holding `Shift` *after* pressing `LMB` will do the opposite of the above, “slowing down”
  the transformation relative to mouse movement to allow finer adjustments.
- Holding `Shift` *before* pressing `LMB` will perform the transformation in the plane
  that’s perpendicular to the clicked axis. See [Plane Locking](../../../scene_layout/object/editing/transform/control/axis_locking.html#view3d-transform-plane-lock).

The Gizmos popover has the following settings for object gizmos:

Orientation
:   The orientation to use for the gizmo. *Default* means to use the viewport’s
    [Transform Orientation](../controls/orientation.html).
    The other options override it.

Move
:   Show the gizmo to control the location.
    Dragging the small white circle allows free movement in the viewing plane.

Rotate
:   Show the gizmo to control the rotation.
    Dragging the large white circle allows rotation around the viewing direction.
    Dragging the translucent white disc within that circle (only visible when
    hovering over the gizmo) allows [trackball rotation](../../../scene_layout/object/editing/transform/rotate.html#view3d-transform-trackball).

Scale
:   Show the gizmo to control the scale.
    Dragging the area between the small and large white circles scales along all three axes.

The latter three options are also available in a pie menu
if you have the *Grave Accent / Tilde Action* in the
[Keymap Preferences](../../preferences/keymap.html) set to *Gizmos*.

|  |  |  |  |
| --- | --- | --- | --- |
| <../../../_images/editors_3dview_display_gizmo_options-translate.png>   Move. | <../../../_images/editors_3dview_display_gizmo_options-rotate.png>   Rotate. | <../../../_images/editors_3dview_display_gizmo_options-scale.png>   Scale. | <../../../_images/editors_3dview_display_gizmo_options-all.png>   Combination. |
user: Give a detailed overview of Fields: syntax, arguments, return values, common patterns.

assistant: # Fields

Fundamentally, a field is a function: a set of instructions that can transform an arbitrary number
of inputs into a single output. A field’s result can then be calculated many times with different input data.
They are used all over geometry nodes to allow calculations that have different results
for every element (mesh vertices, faces, etc.).

[image reference removed]

A field input to a node.

For example, in the figure above, the field connected to the “Set Position” node
depends on two inputs, [Position](geometry/read/position.xhtml) and
[Index](geometry/read/input_index.xhtml), and transforms them into
a vector using a single instruction.
user: What is Inherited Properties and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`Attribute.name`](bpy.types.Attribute.html#bpy.types.Attribute.name "bpy.types.Attribute.name") - [`Attribute.data_type`](bpy.types.Attribute.html#bpy.types.Attribute.data_type "bpy.types.Attribute.data_type") - [`Attribute.storage_type`](bpy.types.Attribute.html#bpy.types.Attribute.storage_type "bpy.types.Attribute.storage_type") | - [`Attribute.domain`](bpy.types.Attribute.html#bpy.types.Attribute.domain "bpy.types.Attribute.domain") - [`Attribute.is_internal`](bpy.types.Attribute.html#bpy.types.Attribute.is_internal "bpy.types.Attribute.is_internal") - [`Attribute.is_required`](bpy.types.Attribute.html#bpy.types.Attribute.is_required "bpy.types.Attribute.is_required") |
user: What is MeshLoopTriangle(bpy_struct) and how is it used in Blender Python scripting?

assistant: # MeshLoopTriangle(bpy_struct)

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

*class* bpy.types.MeshLoopTriangle(*bpy_struct*)
:   Tessellated triangle in a Mesh data-block

    area
    :   Area of this triangle

        Type:
        :   float in [0, inf], default 0.0, (readonly)

    index
    :   Index of this loop triangle

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

    loops
    :   Indices of mesh loops that make up the triangle

        Type:
        :   int array of 3 items in [0, inf], default (0, 0, 0), (readonly)

    material_index
    :   Material slot index of this triangle

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

    normal
    :   Local space unit length normal vector for this triangle

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

    polygon_index
    :   Index of mesh face that the triangle is a part of

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

    split_normals
    :   Local space unit length custom normal vectors of the face corners of this triangle

        Type:
        :   float multi-dimensional array of 3 \* 3 items in [-1, 1], default ((0.0, 0.0, 0.0), (0.0, 0.0, 0.0), (0.0, 0.0, 0.0)), (readonly)

    use_smooth
    :   Type:
        :   boolean, default False, (readonly)

    vertices
    :   Indices of triangle vertices

        Type:
        :   int array of 3 items in [0, inf], default (0, 0, 0), (readonly)

    center
    :   The midpoint of the face.

        (readonly)

    edge_keys
    :   (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Light Falloff Node

Cycles Only

[image reference removed]

The *Light Falloff* node allows you to manipulate how light intensity decreases over distance.
In reality light will always fall off quadratically; however,
it can be useful to manipulate as a non-physically-based lighting trick.
Note that using Linear or Constant falloff may cause more light to be introduced with every global
illumination bounce, making the resulting image extremely bright if many bounces are used.