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

assistant: Operation
:   The bitwise operation to apply:

    And:
    :   Returns a value where the bits of A and B are both set.

    Or:
    :   Returns a value where the bits of either A or B are set.

    Exclusive Or:
    :   Returns a value where only one of A or B has the bit set (XOR).

    Not:
    :   Inverts the bits of A. Equivalent to -A - 1 in decimal.

    Shift:
    :   Shifts the bits of A by the amount specified in *Shift*. Positive shifts are to the left; negative to the
        right.

    Rotate:
    :   Rotates the bits of A by the amount specified in *Shift*. Positive rotates left; negative rotates right.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Mesh
:   Standard geometry input.

Remove Custom Sharpness mode
:   If enabled, removes any existing custom normals or sharpness data.

Edge Sharpness Sharpness mode
:   Boolean field that defines whether an edge is marked sharp.
    True values result in sharp edges; false values result in smooth shading.

Face Sharpness Sharpness mode
:   Boolean field that defines whether a face is marked flat.
    True values result in flat-shaded faces; false values result in smooth shading.

Custom Normal Free mode, Tangent Space mode
:   The vector to store as the custom normal.
user: Give a detailed overview of Playback Controls: syntax, arguments, return values, common patterns.

assistant: The Playback Controls region contains controls and options
related to playback, keying, auto keyframing, and transport.

These settings allow you to:

- Control how animations are previewed and synchronized with audio.
- Insert and manage keyframes through keying sets and auto keying.
- Navigate the timeline using playback and transport controls.
- Adjust frame ranges and preview specific segments of the animation.
user: Provide the full official documentation entry for CompositorNodeTime(CompositorNode), preserving all code examples.

assistant: # CompositorNodeTime(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.CompositorNodeTime(*CompositorNode*)
:   Generate a factor value (from 0.0 to 1.0) between scene start and end time, using a curve mapping

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

assistant: # NodeSocketVectorAcceleration2D(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.NodeSocketVectorAcceleration2D(*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 2 items in [-inf, inf], default (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 GeometryNodeCurveArc(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeCurveArc(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.GeometryNodeCurveArc(*GeometryNode*)
:   Generate a poly spline arc

    mode
    :   Method used to determine radius and placement

        - `POINTS`
          Points – Define arc by 3 points on circle. Arc is calculated between start and end points.
        - `RADIUS`
          Radius – Define radius with a float.

        Type:
        :   enum in [`'POINTS'`, `'RADIUS'`], default `'RADIUS'`

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

assistant: Parents Particles
:   Render also parent particles if child particles are used.
    Children have a lot of different deformation options,
    so the straight parents would stand between their curly children.
    So by default *Parents* are not rendered if you activate *Children*.
    See [Children](children.html).

Unborn
:   Render particles before they are born.

Dead
:   Render particles after they have died.
    This is very useful if particles die in a collision *Die on hit*, so you can cover objects with particles.
user: What is Usage and how is it used in Blender Python scripting?

assistant: Extrude Point
:   `LMB` click to add a new point connected to the currently selected point.
    The new point will have [handle type](../../../../modeling/curves/structure.xhtml#curve-bezier-handle-type) of *Vector*.
    `Shift`-`LMB` click will add point as type *Auto*.
    However, the handle type switches to *Align* when handles are moved (See *Move Point*).

Delete Point
:   `Ctrl`-`LMB` click on an existing point to delete it.

Insert Point
:   `Ctrl`-`LMB` click on a [Curve Segment](../../../../glossary/index.xhtml#term-Curve-Segment) to insert a new control point between the two
    adjacent control points. `Ctrl`-`LMB` click and drag to control the handles of the inserted points.

Move Segment
:   `LMB` drag on a segment in between two control points to adjust the handles, changing the shape of the
    curve without affecting the location of any control points.

Select Point
:   `LMB` click to select a single point or handle at a time.

Move Point
:   `LMB` drag to move existing points or handles. With an endpoint of a stroke selected,
    click and drag on empty space to *Extrude Point* and move the handle at the same time.

Close Stroke
:   Make the stroke [Cyclic](../../../../glossary/index.xhtml#term-Cyclic) by clicking the endpoints.

Cycle Handle Type
:   Double `LMB` click on the control point to cycle through all handle types.
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: To add translations to your Python script, you must define a dictionary formatted like that:
`{locale: {msg_key: msg_translation, ...}, ...}` where:

- locale is either a lang ISO code (e.g. `fr`), a lang+country code (e.g. `pt_BR`),
  a lang+variant code (e.g. `sr@latin`), or a full code (e.g. `uz_UZ@cyrilic`).
- msg_key is a tuple (context, org message) - use, as much as possible, the predefined [`contexts`](#bpy.app.translations.contexts "bpy.app.translations.contexts").
- msg_translation is the translated message in given language!

Then, call `bpy.app.translations.register(__name__, your_dict)` in your `register()` function, and
`bpy.app.translations.unregister(__name__)` in your `unregister()` one.

The `Manage UI translations` add-on has several functions to help you collect strings to translate, and
generate the needed Python code (the translation dictionary), as well as optional intermediary po files
if you want some… See
[How to Translate Blender](https://developer.blender.org/docs/handbook/translating/translator_guide/) and
[Using i18n in Blender Code](https://developer.blender.org/docs/handbook/translating/developer_guide/)
for more info.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Mesh
:   Standard geometry input.

Selection
:   The selection of which face corners should be considered for point distribution.

Distance Min
:   The minimal distance points can have to each other.
    This option is only available for the *Poisson Disk* distribution method.
    At its default value of zero, the node’s behavior is the same as it is in *Random* mode,
    because none of the internally generated points are removed.

Density Max
:   The point density for the point distribution. The unit is in number of points per square meter.
    This value is multiplied by the values from the *Density* input. Only available in *Poisson Disk* mode.

Density
:   The number of points to distribute per square meter on each mesh face.
    This value is multiplied by the values from the *Density Attribute*.

    In *Poisson Disk* mode, this value is multiplied by the *Density Max* input for the final density.

Seed
:   The random [Seed](../../../glossary/index.xhtml#term-Seed) to use when generating points.
user: Show practical ways to work with Images in a Blender add-on or script – include code.

assistant: ### Display

By default, only renders are displayed and saved with the render *View* applied.
These images are the “Render Result” and “Viewer” image data-blocks,
and the files saved directly to disk with the Render Animation operator.
However, when loading a render saved to an intermediate OpenEXR file,
Blender cannot detect automatically that this is a render
(it could be e.g. an image texture or displacement map).
We need to specify that this is a render and that we want the transformations
applied, with the following settings.

View as Render
:   Display the image data-block (not only renders) with view, exposure, gamma, RGB curves applied.
    Useful for viewing rendered frames in linear OpenEXR files the same as when rendering them directly.

### Output

For file saving an equivalent option exists.

Save as Render
:   Option in the image save operator to apply the view, exposure, gamma, RGB curves.
    This is useful for saving linear OpenEXR to e.g. PNG or JPEG files in display space.

Wide gamut images can be written in the following file formats: PNG, JPEG, WebP, TIFF and JPEG 2000.

HDR images can only be written as PNG files. They are written with 203 nits diffuse
white to match the convention in most browsers and image viewers.
user: Show practical ways to work with Rigging in a Blender add-on or script – include code.

assistant: Rigging is a general term used for adding controls to objects,
typically for the purpose of animation.

Rigging often involves using one or more of the following features:

[Armatures](armatures/index.html#armatures-index)
:   This allows mesh objects to have flexible joints and is often used for skeletal animation.

[Constraints](constraints/index.html#constraints-index)
:   To control the kinds of motions that make sense and add functionality to the rig.

[Object Modifiers](../modeling/modifiers/index.html)
:   Mesh deformation can be quite involved, there are multiple modifiers that help control this.

[Shape Keys](shape_keys/index.html#animation-shape-keys-index)
:   To support different target shapes *(such as facial expressions)* to be controlled.

[Drivers](drivers/index.html#animation-drivers-index)
:   So your rig can control many different values at once,
    as well as making some properties automatically update based on changes elsewhere.

Rigging can be as advanced as your project requires.
Rigs effective define a user interface for the animator to use,
without being concerned with the underlying mechanisms

### Examples

- An armature is often used with a modifier to deform a mesh for character animation.
- A camera rig can be used instead of animating the camera object directly to simulate real-world camera rigs
  (with a boom arm, mounted on a rotating pedestal for example, effects such as camera jitter can be added too).
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Mode
:   And:
    :   True when both inputs are true.
        ([AND](https://en.wikipedia.org/wiki/AND_gate))

    Or:
    :   True when at least one input is true.
        ([OR](https://en.wikipedia.org/wiki/OR_gate))

    Not:
    :   Opposite of the input.
        ([NOT](https://en.wikipedia.org/wiki/NOT_gate))

    Not And:
    :   (True when at least one input is false.
        [NAND](https://en.wikipedia.org/wiki/NAND_gate))

    Nor:
    :   True when both inputs are false.
        ([NOR](https://en.wikipedia.org/wiki/NOR_gate))

    Equal:
    :   True when both inputs are equal. Also known as “exclusive nor”.
        ([XNOR](https://en.wikipedia.org/wiki/XNOR_gate))

    Not Equal:
    :   ([XOR](https://en.wikipedia.org/wiki/XOR_gate))
        True when both inputs are different. Also known as “exclusive or”.

    Imply:
    :   True unless the first input is true and the second is false.
        ([IMPLY](https://en.wikipedia.org/wiki/IMPLY_gate))

    Subtract:
    :   True when the first input is true and the second is false. Also known as “”not imply”.
        ([NIMPLY](https://en.wikipedia.org/wiki/NIMPLY_gate))
user: Give a detailed overview of Metaball: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Family meta properties.

Resolution Viewport
:   Controls the resolution of the resultant mesh as generated by the *Meta* objects.
    The 3D Viewport resolution of the generated mesh; finest to coarsest.

Render
:   The rendered resolution of the generated mesh; finest to coarsest.

Influence Threshold
:   Defines how much a meta’s surface “influences” other metas.
    It controls the *field level* at which the surface is computed.
    The setting is global to a group of *Meta* objects.
    As the threshold increases, so does the influence that each meta has on each other.

    There are two types of [influence](#meta-ball-editing-negative-influence): *positive* or *negative*.

Update on Edit
:   While transforming metas (move, scale, etc.), you have four “modes” of visualization.

    This should help you if you experience difficulties (metas are quite computationally intensive…),
    but with modern computers, this should not happen, unless you use many metas,
    or very high resolutions…

    Always:
    :   Fully display the meta during transformations.

    Half:
    :   During transformations, display the meta at half its *Viewport* resolution.

    Fast:
    :   Do not display meta during transformations.

    Never:
    :   Never show meta mesh (not a very recommended option, as the meta is only visible at render time!).
user: Describe CollisionSettings(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CollisionSettings(bpy_struct)

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

*class* bpy.types.CollisionSettings(*bpy_struct*)
:   Collision settings for object in physics simulation

    absorption
    :   How much of effector force gets lost during collision with this object (in percent)

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

    cloth_friction
    :   Friction for cloth collisions

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

    damping
    :   Amount of damping during collision

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

    damping_factor
    :   Amount of damping during particle collision

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

    damping_random
    :   Random variation of damping

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

    friction_factor
    :   Amount of friction during particle collision

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

    friction_random
    :   Random variation of friction

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

    permeability
    :   Chance that the particle will pass through the mesh

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

    stickiness
    :   Amount of stickiness to surface collision

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

    thickness_inner
    :   Inner face thickness (only used by softbodies)

        Type:
        :   float in [0.001, 1], default 0.0

    thickness_outer
    :   Outer face thickness

        Type:
        :   float in [0.001, 1], default 0.0

    use
    :   Enable this object as a collider for physics systems

        Type:
        :   boolean, default False

    use_culling
    :   Cloth collision acts with respect to the collider normals (improves penetration recovery)

        Type:
        :   boolean, default False

    use_normal
    :   Cloth collision impulses act in the direction of the collider normals (more reliable in some cases)

        Type:
        :   boolean, default False

    use_particle_kill
    :   Kill collided particles

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

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

assistant: # Gizmos

[image reference removed]

Grid with gizmo in the 3D viewport.

Gizmos allow changing inputs of Geometry Nodes directly in the 3D viewport.
This is often more intuitive than controlling the inputs in the modifier or node editor.
user: How do I use GeometryNodeSetCurveHandlePositions(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeSetCurveHandlePositions(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.GeometryNodeSetCurveHandlePositions(*GeometryNode*)
:   Set the positions for the handles of Bézier curves

    mode
    :   Whether to update left and right handles

        Type:
        :   enum in [Node Geometry Curve Handle Side Items](bpy_types_enum_items/node_geometry_curve_handle_side_items.html#rna-enum-node-geometry-curve-handle-side-items), default `'LEFT'`

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

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeCaptureAttribute.capture_items`](bpy.types.GeometryNodeCaptureAttribute.html#bpy.types.GeometryNodeCaptureAttribute.capture_items "bpy.types.GeometryNodeCaptureAttribute.capture_items") |  |
user: What is Usage and how is it used in Blender Python scripting?

assistant: The Ellipse Mask node supports an interactive gizmo in the node editor.
To enable it, make sure [Active Node](../../../editors/compositor.xhtml#bpy-types-spacenodeeditor-show-gizmo-active-node) gizmo is enabled,
and select the Ellipse Mask node in the Compositor.

The gizmo allows direct manipulation of the mask shape:

- Drag edges to adjust the width or height individually.
- Drag corners to adjust width and height simultaneously.
- Drag the center cross (X) to move the mask’s position.
- Drag the center dot to rotate the mask.
- Hold `Shift` while dragging edges or corners to preserve the current aspect ratio.
user: Provide the full official documentation entry for Common Editor Keys, preserving all code examples.

assistant: These keys are shared across editors such as the 3D Viewport, UV and Graph editor.

|  |  |
| --- | --- |
| `A` | Select all. |
| `Alt`-`A` /  Double-tap `A` | Select none. |
| `Ctrl`-`I` | Invert selection. |
| `H` | Hide selected items. |
| `Shift`-`H` | Hide unselected items. |
| `Alt`-`H` | Reveal hidden items. |
| `T` | Toggle Toolbar. |
| `N` | Toggle Sidebar. |
user: Provide the full official documentation entry for Sampling, preserving all code examples.

assistant: # Sampling

The quality of the renders can be adjusted by changing the [Anti-Aliasing](../../glossary/index.html#term-Anti-Aliasing) method.
A different one can be selected for the 3D Viewport, viewport rendering and
for final rendering.

The setting for the 3D Viewport is a user preference to specify the anti-aliasing method
that runs best on the used system. The setting for viewport rendering
and final rendering is saved per scene.

No Anti-Aliasing
:   With this option selected no anti-aliasing will be applied.

Single Pass Anti-Aliasing
:   Scene will be rendered with a post-process anti-aliasing pass.

Multisample
:   The scene will be rendered multiple times with a slight offset.
    The anti-aliasing will be gathered from the multiple renders.
    The number of samples are predefined so it uses the best distribution of the samples.

    5, 8, 11, 16, 32

    *Progressive Viewport Rendering*

    For the 3D Viewport, one sample is rendered at a time. When there are no changes
    to the scene or viewport the next sample will be rendered.
user: Show practical ways to work with Select Next/Previous Active in a Blender add-on or script – include code.

assistant: Next Active
:   This uses selection history to select the next vertex, edge, or face based on the surrounding topology.
    Which means that, it will derive the next selection from the previous two selections.

|  |  |  |
| --- | --- | --- |
| ../../../_images/modeling_meshes_selecting_more-less_select-active-1.png   Initial selection. | ../../../_images/modeling_meshes_selecting_more-less_select-active-2.png   Using Next Active once. | ../../../_images/modeling_meshes_selecting_more-less_select-active-3.png   Using Next Active twice. |

Previous Active
:   Only the last selected element will be removed.
user: How do I use NodeTreeInterfaceSocketString(NodeTreeInterfaceSocket) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeTreeInterfaceSocketString(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.NodeTreeInterfaceSocketString(*NodeTreeInterfaceSocket*)
:   String socket of a node

    default_value
    :   Input value used for unconnected socket

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

    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 UVLoopLayers(bpy_struct) and how is it used in Blender Python scripting?

assistant: # UVLoopLayers(bpy_struct)

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

*class* bpy.types.UVLoopLayers(*bpy_struct*)
:   Collection of UV map layers

    active
    :   Active UV Map layer

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

    active_index
    :   Active UV map index

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

    new(*\**, *name='UVMap'*, *do_init=True*)
    :   Add a UV map layer to Mesh

        Parameters:
        :   - **name** (*string**,* *(**optional**,* *never None**)*) – UV map name
            - **do_init** (*boolean**,* *(**optional**)*) – Whether new layer’s data should be initialized by copying current active one, or if none is active, with a default UVmap

        Returns:
        :   The newly created layer

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

    remove(*layer*)
    :   Remove a UV map layer

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

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

assistant: Blender saves by default a small preview of current scene in the blend-file.
This will show in the *Thumbnail* view of the [File Browser](../../editors/file_browser.xhtml).

During its installation, Blender also adds a small tool to your OS,
that will allow your system file browser to show those previews as file thumbnails as well.

### macOS

The Blender Thumbnail extension can be disabled in the System Settings under “Login Items & Extensions”,
within the Quick Look category.
user: Describe Cameras from the Blender manual or Python API, including usage steps and snippets.

assistant: # Cameras

A camera is an object that provides a means of rendering images from Blender.
It defines which portion of a scene is visible in the rendered image.

Cameras are invisible in renders, so they do not have any material or texture settings.
However, they do have *Object* and *Editing* setting panels available which are displayed
when a camera is the active object.
user: How do I use Installation on Linux in Blender? Include parameters, examples, warnings and best practices.

assistant: # Installation on Linux

This guide covers the following topics:

1. [Installing Dependencies](#installing-dependencies)
2. [Downloading the Repository](#downloading-the-repository)
3. [Setting up the Build Environment](#setting-up-the-build-environment)
user: Give a detailed overview of GeometryNodeSwitch(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeSwitch(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.GeometryNodeSwitch(*GeometryNode*)
:   Switch between two inputs

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

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

assistant: - Remeshing only works on the original mesh data and
  ignores generated geometry from modifiers, shape keys, rigging, etc.
- Remeshing will not work with the [Multiresolution Modifier](../../../modeling/modifiers/generate/multiresolution.html).
user: How do I use Line Gestures in Blender? Include parameters, examples, warnings and best practices.

assistant: Dragging creates a line. The resulting action acts upon everything on the highlighted side of the line. The area acted
upon is extended in both directions of the viewport.

### Controls

Flip `F`
:   Toggles the side of the line that the tool affects.

Snap `Ctrl`
:   Hold to constrain the rotation of the line to user-specified intervals. Defaults to 5 degree increments,
    customizable via the Snapping menu indicated by the magnet icon in the header.

Move `Spacebar`
:   Hold to reposition the line.

### Tool Settings

Limit to Segment
:   The affected area will not extend the length of the drawn line.
    This helps defining a smaller area instead of extending the line infinitely long.
user: Explain Set Geometry Name Node in complete detail according to the official Blender documentation.

assistant: # Set Geometry Name Node

[image reference removed]

The *Set Geometry Name* node stores a custom name on the geometry, overriding the name which
might come from the [Object Info Node](../../input/scene/object_info.xhtml) or a
[Grease Pencil to Curves Node](../../grease_pencil/operations/grease_pencil_to_curves.xhtml).
The name is displayed in the spreadsheet and can helpful for debugging purposes.
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: [image reference removed]

Clamp To constraint.

[Target](../interface/common.xhtml#rigging-constraints-interface-common-target)
:   The Curve object to snap to.

Main Axis
:   The axis for determining the constraint owner’s coordinate and the Curve’s minimum/maximum
    coordinates.

Cyclic
:   When disabled, the constraint owner will stop at the start/end of the Curve when it leaves
    the range of the Curve’s bounding box. When enabled, it will jump to the opposite side
    and begin another run along the Curve.

    This option is mainly useful for Curves that are also [cyclic](../../../modeling/curves/editing/curve.xhtml#bpy-ops-curve-cyclic-toggle)
    (closed).

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects the object.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Grid
:   The input voxel grid to sample values from. The grid may store scalar,
    vector, color, or boolean data depending on its data type.

X, Y, Z
:   The integer voxel coordinates in grid index space to sample from.
    Each coordinate specifies which voxel to retrieve the value from along its respective axis.
user: How do I use Drag & Dropping to 3D Viewport in Blender? Include parameters, examples, warnings and best practices.

assistant: Dragging an object from the Outliner to the [3D Viewport](../3dview/index.html)
creates a [duplicate](../../scene_layout/object/editing/duplicate.html) – a new object with its own copy
of the underlying object data.

Dragging object data from the Outliner to the 3D Viewport creates a
[linked duplicate](../../scene_layout/object/editing/duplicate_linked.html) – a new object that references
the same underlying object data.
user: Show practical ways to work with FunctionNodeSeparateTransform(FunctionNode) in a Blender add-on or script – include code.

assistant: # FunctionNodeSeparateTransform(FunctionNode)

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

*class* bpy.types.FunctionNodeSeparateTransform(*FunctionNode*)
:   Split a transformation matrix into a translation vector, a rotation, and a scale vector

    *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 MirrorModifier(Modifier) and how is it used in Blender Python scripting?

assistant: # MirrorModifier(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.MirrorModifier(*Modifier*)
:   Mirroring modifier

    bisect_threshold
    :   Distance from the bisect plane within which vertices are removed

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

    merge_threshold
    :   Distance within which mirrored vertices are merged

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

    mirror_object
    :   Object to use as mirror

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

    mirror_offset_u
    :   Amount to offset mirrored UVs flipping point from the 0.5 on the U axis

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

    mirror_offset_v
    :   Amount to offset mirrored UVs flipping point from the 0.5 point on the V axis

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

    offset_u
    :   Mirrored UV offset on the U axis

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

    offset_v
    :   Mirrored UV offset on the V axis

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

    use_axis
    :   Enable axis mirror

        Type:
        :   boolean array of 3 items, default (False, False, False)

    use_bisect_axis
    :   Cuts the mesh across the mirror plane

        Type:
        :   boolean array of 3 items, default (False, False, False)

    use_bisect_flip_axis
    :   Flips the direction of the slice

        Type:
        :   boolean array of 3 items, default (False, False, False)

    use_clip
    :   Prevent vertices from going through the mirror during transform

        Type:
        :   boolean, default False

    use_mirror_merge
    :   Merge vertices within the merge threshold

        Type:
        :   boolean, default True

    use_mirror_u
    :   Mirror the U texture coordinate around the flip offset point

        Type:
        :   boolean, default False

    use_mirror_udim
    :   Mirror the texture coordinate around each tile center

        Type:
        :   boolean, default False

    use_mirror_v
    :   Mirror the V texture coordinate around the flip offset point

        Type:
        :   boolean, default False

    use_mirror_vertex_groups
    :   Mirror vertex groups (e.g. .R->.L)

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

assistant: Keyboard shortcuts

Blender makes heavy use of keyboard shortcuts to speed up work.
These can be customized in the [Keymap Editor](../../editors/preferences/keymap.html#prefs-input-keymap-editor).

Theme colors

Blender allows for most of its interface colors to be changed to suit the needs of the user.
If you find that the colors you see on screen do not match those
in the Manual, it could be that your default theme has been altered.
Creating a new theme or selecting/altering a preexisting one can be done by opening
the [Preferences](../../editors/preferences/index.html) and clicking on the *Themes* tab.

Accessibility

Blender has several options for visibility customization,
including resolution scale, and the ability to load custom fonts.
These settings can be configured in the [Interface Preferences](../../editors/preferences/interface.html).
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: # Introduction

Shape keys are used to deform objects into new shapes for animation.
In other terminology, shape keys may be called *morph targets* or *blend shapes*.

The most common use cases for shape keys are in character facial animation
(e.g. mouth positions, expressions, phonemes) and in refining a skeletal rig.
They are particularly useful for modeling organic, soft body parts and muscles,
where additional control over the resulting shape is needed beyond what can be achieved
with transformations such as rotation or scale.

Shape keys can be applied to object types with vertices, such as meshes, curves, surfaces, and lattices.

[image reference removed]

Example of a mesh with different shape keys applied.