PGCRYPT/OpenBlender_Train huggingface dataset:
user: Show practical ways to work with Simple Mode in a Blender add-on or script – include code.

assistant: Blender has two “modes” a simple and an advanced one. Simple mode only accepts simple numbers.

Decimals `Period`
:   Decimals can be entered by pressing `Period`.

Negate `Minus`
:   Negate the whole value by pressing `Minus`.

Inverse `Slash`
:   Hitting `Slash` during number entry switches the number being entered to
    its reciprocal, e.g. `2 /` results in 0.5 (1/2); `20 /` results in 0.05 (1/20).

Reset `Backspace`
:   Hitting `Backspace` after having deleted all leading chars
    will first reset the edited value to initial state, and on second press,
    the whole number editing will be canceled, going back to usual transform with mouse.

Next/Previous Component `Tab`, `Ctrl`-`Tab`
:   To enter numeric values for multiple axes, use `Tab` or `Ctrl`-`Tab`.
    E.g. To move an object, one unit on all three axes press: `G` `1`
    and `Tab` `1` and `Tab` `1`.

Non-number Inputs
:   You can also combine numeric input with
    [Axis Locking](axis_locking.html)
    to limit movement to a particular axis or tool specific shortcuts.
user: Give a detailed overview of Further Reading: syntax, arguments, return values, common patterns.

assistant: - [Sphinx RST Primer](https://www.sphinx-doc.org/en/master/usage/restructuredtext/basics.html):
  Introduction to RST syntax.
- [Docutils reStructuredText Reference](https://docutils.sourceforge.io/rst.html):
  Comprehensive documentation on RST markup.
user: How do I use Main Region in Blender? Include parameters, examples, warnings and best practices.

assistant: The curve view allows you to view and edit [F-Curves](fcurves/introduction.xhtml).
An F-Curve has several key parts:

Curve
:   The curve describes how the value of a property (Y axis) evolves over time (X axis).

[Keyframes](../../animation/keyframes/index.xhtml)
:   Keyframes are user-defined values on certain frames and are represented
    by little black discs that become orange when selected.
    The values on the other frames are calculated automatically by interpolating
    between these keyframes.

[Handles](fcurves/properties.xhtml#editors-graph-fcurves-settings-handles)
:   Each keyframe has two handles – points that can be dragged around to influence
    the shape of the curve around it.

[image reference removed]

A simple curve. The discs are keyframes, and the circles are their handles.

### Navigation

As with most editors, you can:

Pan
:   Pan the view by dragging with `MMB`.

Zoom
:   Zoom in and out with the mouse `Wheel`.

Scale View
:   Scale the view horizontally or vertically by dragging with `Ctrl`-`MMB`.

You can also use the scrollbars.

### Playhead & 2D Cursor

[image reference removed]

Graph Editor 2D Cursor.

The current frame is represented by a vertical blue line called the *Playhead*.
Like other [Animation Editors](../../animation/animation_editors.xhtml),
you can move it by clicking or dragging with `LMB` in the scrubbing area at the top.

Combined with the horizontal blue line, the Playhead forms the *2D Cursor*
which can be used as a [pivot point](../3dview/controls/pivot_point/index.xhtml)
for rotating and scaling. You can disable the horizontal line using
View ‣ Show Cursor or Sidebar ‣ View ‣ Show Cursor.

The 2D Cursor can be moved by clicking or dragging with `Shift`-`RMB`
or by adjusting its coordinates in the [View tab](#graph-editor-view-properties) of the Sidebar.
user: Provide the full official documentation entry for TextureNodeTexBlend(TextureNode), preserving all code examples.

assistant: # TextureNodeTexBlend(TextureNode)

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

*class* bpy.types.TextureNodeTexBlend(*TextureNode*)
:   *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 Cameras and how is it used in Blender Python scripting?

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

assistant: Extruding is the main way of adding new control points to a surface. It’s not possible
to do this directly as would be the case with Curves.

Start by selecting a complete border of the surface grid. Then press `E` to duplicate
the control points, and move the mouse to bring them to the desired position.
Finally, click `LMB` to confirm. (Alternatively, click `RMB` or press `Esc`
to cancel the move and keep the new control points at their original position.)

### Example

First, we select a border control point and expand the selection to the complete row
using [Select Control Point Row](../selecting.xhtml#bpy-ops-curve-select-row).

|  |  |
| --- | --- |
| ../../../_images/modeling_surfaces_editing_control-points_selecting-point.png   Selecting control point | ../../../_images/modeling_surfaces_editing_control-points_selecting-row.png   Selecting remaining control points in the row |

Then, we extrude a few times:

[image reference removed]

Control points extruded twice
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Value/Vector
:   The input value or vector to be remapped.

From Min
:   The lower bound of the range to remap from.

From Max
:   The higher bound of the range to remap from.

To Min
:   The lower bound of the target range.

To Max
:   The higher bound of the target range.

Steps
:   The number of values allowed between *To Min* and *To Max* when using *Stepped Linear* interpolation.
    A higher value will give a smoother interpolation while lower values will progressively quantize the input.
user: Show practical ways to work with Bpy.Types.Greasepencil in a Blender add-on or script – include code.

assistant: ate_preview ID.override_create ID.override_hierarchy_create ID.user_clear ID.user_remap ID.make_local ID.user_of_id ID.animation_data_create ID.animation_data_clear ID.update_tag ID.preview_ensure ID.bl_rna_get_subclass ID.bl_rna_get_subclass_py References ¶ bpy.context.annotation_data bpy.context.gpencil bpy.context.grease_pencil BlendData.grease_pencils BlendDataGreasePencilsV3.new BlendDataGreasePencilsV3.remove Next GreasePencilArmatureModifier(Modifier) Previous GpWeightPaint(Paint) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page GreasePencil(ID) GreasePencil GreasePencil.after_color GreasePencil.animation_data GreasePencil.attributes GreasePencil.before_color GreasePencil.color_attributes GreasePencil.ghost_after_range GreasePencil.ghost_before_range GreasePencil.layer_groups GreasePencil.layers GreasePencil.materials GreasePencil.onion_factor GreasePencil.onion_keyframe_type GreasePencil.onion_mode GreasePencil.stroke_depth_order GreasePencil.use_autolock_layers GreasePencil.use_ghost_custom_colors GreasePencil.use_onion_fade GreasePencil.use_onion_loop GreasePencil.bl_rna_get_subclass() GreasePencil.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: What is NodeTreePath(bpy_struct) and how is it used in Blender Python scripting?

assistant: # NodeTreePath(bpy_struct)

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

*class* bpy.types.NodeTreePath(*bpy_struct*)
:   Element of the node space tree path

    node_tree
    :   Base node tree from context

        Type:
        :   [`NodeTree`](bpy.types.NodeTree.html#bpy.types.NodeTree "bpy.types.NodeTree"), (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 Posterize in Blender? Include parameters, examples, warnings and best practices.

assistant: # Posterize

[image reference removed]

The *Posterize Node* reduces the number of colors in image, converting
smooth gradients into sharp transitions.
This node is useful for generating masks in particular for rotoscoping.
user: Show practical ways to work with Distance Key Node in a Blender add-on or script – include code.

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: How do I use Version/Revision Milestones in Blender? Include parameters, examples, warnings and best practices.

assistant: ad/releases/4-1/) – March 2024
:   Geometry Nodes baking support, Menu Switch node, OpenImageDenoise GPU acceleration, more realtime viewport
    compositor functions, simpler animation keyframe insertion, hierarchical bone collections, graph editor
    click-and-slide, video sequencer performance and color scope improvements, alignment to the [VFX Reference Platform
    2024](https://vfxplatform.com/), armature and shape key export to USD.

[4.2 LTS](https://www.blender.org/download/releases/4-2/) – July 2024
:   Next generation of EEVEE with major upgrades to lighting, sun lights, displacement, subsurface, volumetrics, and
    motion blur, Cycles gains Ray Portal BSDF and Thin-Film Interference, better soft volume rendering with reduced
    noise, blue noise-based sampling, Blender Extensions platform launched, Khronos PBR Neutral Tone Mapper, sculpting
    selection improvements, Node inputs support matrices, Node Tools can use mouse position and viewport, video
    sequencer graphical overhaul, additional USD export options, native portable installation support.
    **First LTS of the 4.0 series.**

[4.3](https://www.blender.org/download/releases/4-3/) – November 2024
:   Light linking and shadow linking in EEVEE, Metallic BSDF, Gabor noise texture, EEVEE render passes in the
    compositor, minimum stretch (SLIM) UV unwrapping, numerous Geometry Nodes updates including for…each zone,
    physics nodes, Grease Pencil engine rewritten for speed and features, over 100 default brushes now included for
    painting and sculpting, UI area docking.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Vector
:   Texture coordinate to sample texture at;
    defaults to Generated texture coordinates if the socket is left unconnected.

Scale
:   Scale of the texture.

Distortion
:   Amount of distortion.
user: How do I use Tools in Blender? Include parameters, examples, warnings and best practices.

assistant: # Tools

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

    [Select Box](../../interface/selecting.xhtml#tool-select-box)
    :   Select geometry by dragging a box.

    [Select Circle](../../interface/selecting.xhtml#tool-select-circle)
    :   Select geometry by dragging a circle.

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

Cursor
:   Change the location of the 3D Cursor.

Move
:   Translation tool.

Rotate
:   Rotation tool.

Scale
:   Scale tool.

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

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

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

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

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

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

[Measure](../../editors/3dview/toolbar/measure.xhtml#tool-measure)
:   Measure distances in the scene.
user: Explain Show/Hide in complete detail according to the official Blender documentation.

assistant: ### Mute

Muting a node removes its contribution to the node tree,
and makes all links pass through it without change.
Links will appear red as an indicator of passing through the muted node.

### Node Preview

Shows/Hides a preview region on the node that displays the frame
after that node’s operation has been applied. This can also be toggled
by clicking the material ball icon in the node header.

### Node Options

Shows/Hides all node properties.

### Unconnected Sockets

Collapses/Expands any input or output sockets that have no other nodes connected to them.

### Collapse

Collapses the node so only the node header is visible.
This can also be toggled by clicking the triangle on the left of the node header.

### Collapse and Hide Unused Sockets

Applies both the [Unconnected Sockets](#bpy-ops-node-hide-socket-toggle) and [Collapse](#bpy-ops-node-hide-toggle) operations.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: Mode
:   The Mask Modifier can hide parts of a mesh based on two different modes, selectable from this select menu.

    Vertex Group
    :   Hides all vertices not included in the chosen vertex group.

        The Mask modifier in Vertex Group mode.

        |  |  |
        | --- | --- |
        | ../../../_images/modeling_modifiers_generate_mask_vertex-group.png | ../../../_images/modeling_modifiers_generate_mask_panel-vertex-group.png |

    Armature
    :   When in Pose Mode,
        vertices belonging to the vertex group associated with the active bone (same names) will be visible.
        Vertices not in that group will be hidden.

        The Mask modifier in Armature mode.

        |  |  |
        | --- | --- |
        | ../../../_images/modeling_modifiers_generate_mask_armature.png | ../../../_images/modeling_modifiers_generate_mask_panel-armature.png |

Smooth
:   When using Vertex Group *Mode*, use weights to cut faces at the weight contour.
    This option will result in a mask that has smoother removing the sharp edges along the mask edges.

    [image reference removed]

Invert
:   Normally, vertices belonging to the selected vertex group (or group associated with the active pose bone)
    will be shown. The *Invert* toggle allows you to reverse this behavior, instead only showing vertices
    which do not belong to the vertex group.

Threshold
:   Hides vertices with weights less than or equal to this value.
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Normal Direction
:   To manually set a fixed normal direction vector.
    `LMB` click and drag on the sphere to set the direction of the normal.
    Holding `Ctrl` while dragging snaps to 45 degree rotation increments.
user: Provide the full official documentation entry for Blender 2.8, preserving all code examples.

assistant: - [Blender 2.83 LTS](https://docs.blender.org/manual/en/2.83/)
- [Blender 2.82](https://docs.blender.org/manual/en/2.82/)
- [Blender 2.81](https://docs.blender.org/manual/en/2.81/)
- [Blender 2.80](https://docs.blender.org/manual/en/2.80/)
user: What is Notes and how is it used in Blender Python scripting?

assistant: - Supports both unnamed (`{}`) and named (`{name}`) placeholders.
  However, all unnamed placeholders must appear before any named ones.
- Only float, integer, and string inputs are supported.
- Python-style conversions such as `!r` are not supported.
- Sub-attribute access (e.g. `{vector.x}`) is not supported.
- Percent-based formatting (e.g. `%d`, `%s`) is not supported.
- Alternate form specifiers using `#` (e.g. `{:#x}`) are not supported.
- Locale-based formatting using `L` (as in the fmt library) is not supported.
- Grouping options like thousands separators (e.g. `{:,}` or `{:_}`) are not supported.

### Input Naming Behavior

Each input must have a unique, valid identifier name used in placeholders (e.g. `{value}`).
This node uses special logic to automatically assign names to new inputs:

- If connected, the first character of the linked socket’s name is used.
- Otherwise, names default to letters `a` through `z`.
- If needed, the original socket name is converted to a valid identifier.
- If all else fails, a unique suffix is appended (e.g. `_001`, `_002`).
user: Explain Brush Settings in complete detail according to the official Blender documentation.

assistant: Density Mode
:   Determines whether the brush adds or removes curves.

    Auto:
    :   Either add or remove curves depending on the distance between existing curve roots under the cursor.

    Add:
    :   Add new curves between existing curves, taking the minimum distance into account.

    Remove:
    :   Remove curves whose root points are too close.

Distance Min
:   Goal distance between the curve roots.

    Edit Minimum Distance `R`
    :   Interactively sets the *Distance Min* value by displaying
        a graphic inside the brush cursor, giving a representation of the density.

        The density can be adjusted by moving the mouse cursor closer or farther from the paint cursor.
        The *Distance Min* will be changed once the operator is confirmed.

Count Max
:   The maximum amount of points that the brush tries to sample in the surface.
user: Provide the full official documentation entry for Node Bundles, preserving all code examples.

assistant: # Node Bundles

A *bundle* is a container that groups multiple values into one socket.
This makes it possible to pass many values through
a single link, similar to a *struct* in programming.

Bundles reduce the number of exposed inputs and outputs in a node group,
and can contain mixed data types such as geometry, fields, values, objects,
or even nested bundles.

[image reference removed]

A cube and cylinder combined into a bundle, then separated again.
user: Describe Masks from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

A mask is used to control which vertices of the mesh are influenced by sculpting and painting.
The mask can for example be created/edited via the [Mask Gesture Tools](../tools/mask_tools.html)
and [Mask by Color](../tools/mask_by_color.html) tool.

Internally, masks are stored using the `sculpt_mask` [Attributes](../../../modeling/geometry_nodes/attributes_reference.html).

### Clear & Invert

Creating masks follows a slightly different mental model than selecting in other modes.
For example `Shift`-`LMB` is used for smoothing instead of adding to a mask.

Masking is also conceptually inverted to selection
(i.e. You **cannot** edit masked vertices. But you **can** edit selected vertices).

Instead a mask is typically always added to the current mask with `LMB` and subtracted with `Ctrl`-`LMB`.
So if you wish to edit the masked surfaces, you’ll need to use the [Invert](../editing/mask.html#mask-invert) operator,
In the case of masking everything that is visible,
the best workflow is to first [Clear](../editing/mask.html#mask-clear) and then [Invert](../editing/mask.html#mask-invert) the mask.

Both these operators can be quickly accessed in the `A` pie menu.

[image reference removed]
user: Show practical ways to work with Custom Function - Square Value in a Blender add-on or script – include code.

assistant: Create a custom function to get the square of a value (i.e. *value*2).
Adding the function to the *Driver Namespace* allows it to be used from driver expressions.
The *Driver Namespace* has a list of built-in functions for use in driver expressions,
as well as constants such as π and e.
These can be inspected via the Python Console:

```
>>> bpy.app.driver_namespace[' <tab>
                              acos']
                              acosh']
                              asin']
                              asinh']
                              atan']
                              ...
```

To add a new function to the *Driver Namespace*, the function itself needs to be implemented
and then added to the `bpy.app.driver_namespace`.

1. Add the following to the Text Editor inside Blender and press *Run Script*.

   ```
   import bpy

   def square(val):
      """Returns the square of the given value"""
      return val * val

   # Add function to driver_namespace.
   bpy.app.driver_namespace['square'] = square
   ```
2. Add a driver with a *Scripted Expression* such as `square(frame)`.
3. Observe the effect when scrubbing the timeline.

There are more custom function examples available in Blender’s Text Editor
Templates ‣ Python ‣ Driver Functions.
Since [Simple Expressions](drivers_panel.xhtml#drivers-simple-expressions) cannot access
custom functions, using them only makes sense for complex computations.
user: Provide the full official documentation entry for Lightmap Pack, preserving all code examples.

assistant: Places each selected face separately on the UV map. Lightmaps are commonly used for baking lighting information
into a texture for use in realtime rendering – as such, they prioritize using as much of the texture as possible,
typically resulting in a disconnected and distorted UV map that would be unsuitable for manual texturing work.

### Options

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

Selection
:   Selected Faces
    :   Only unwraps the selected faces.

    All Faces
    :   Unwraps the whole mesh.

Share Texture Space
:   You can use [Multi-Object Editing](../../../editors/3dview/modes.html#dview-multi-object-mode) to generate UV maps for multiple meshes at the same time.
    When *Share Texture Space* is enabled, the UV maps won’t overlap each other,
    so that you can later use the same lightmap texture for all the meshes.

New UV Map
:   Creates a new UV map instead of overwriting the currently selected one. See [UV Maps](../uv/uv_texture_spaces.html#uv-maps-panel).

Pack Quality
:   Higher values result in a UV map that wastes less space (but also takes longer to calculate).

Margin
:   How much empty space to leave between the faces in the UV map.
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Output
:   Outputs the value from the input corresponding to the selected menu item, unchanged.

For each menu entry, an additional Boolean output is created.
The output corresponding to the selected item is *true*, and all others are *false*.
These Boolean outputs can be used to trigger different node branches, control visibility,
or drive conditional operations elsewhere in the node tree.
user: Show practical ways to work with ThemeOutliner(bpy_struct) in a Blender add-on or script – include code.

assistant: # ThemeOutliner(bpy_struct)

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

*class* bpy.types.ThemeOutliner(*bpy_struct*)
:   Theme settings for the Outliner

    active
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    active_object
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    edited_object
    :   Type:
        :   float array of 4 items in [0, 1], default (0.0, 0.0, 0.0, 0.0)

    match
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    row_alternate
    :   Overlay color on every other row

        Type:
        :   float array of 4 items in [0, 1], default (0.0, 0.0, 0.0, 0.0)

    selected_highlight
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    selected_object
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    space
    :   Settings for space

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Context Menu in complete detail according to the official Blender documentation.

assistant: Context menus are pop-ups that can be opened with `RMB`.
In most editors, it’s also possible to use the `Menu` key.
The contents of the menu depend on the location of the mouse pointer.

When invoked in an editor, the menu contains a list of operators sensitive to the editor’s mode.
When invoked over buttons and properties, common options include:

Single
:   Apply the change to a single value of a set (e.g. only the X coordinate of an object’s Location).

All
:   Apply the change to all values in a set (e.g. all coordinates of an object’s Location).

Reset to Default Value(s) `Backspace`
:   Replaces the current value by the default.

Copy Data Path `Shift`-`Ctrl`-`C`
:   Copies the Python property data path, relative to the data-block.
    Useful for Python scripting.

Copy Full Data Path `Shift`-`Ctrl`-`Alt`-`C`
:   Copies the full Python property data path including any needed context information.

Copy As New Driver
:   Creates a new driver using this property as input, and copies it to the clipboard.
    Use *Paste Driver* to add the driver to a different property, or *Paste Driver Variables*
    to extend an existing driver with a new input variable.

Copy To Selected
:   Copies the property value to the selected object’s corresponding property.
    A use case is if the Properties context is pinned.

Assign Shortcut
:   Lets you define a keyboard or mouse shortcut for an operation.
    To define the shortcut you must first move the mouse cursor over the button that pops up.
    When “Press a key” appears you must press and/or click the desired shortcut.
    Press `Esc` to cancel.

Change Shortcut
:   Lets you redefine the shortcut.

Remove Shortcut
:   Unlinks the existing shortcut.

Open File Location, Open Location Externally
:   Opens the containing folder using the operating system’s file manager.

Online Manual `F1`
:   Opens an online page of the Blender Manual in a web browser.

Online Python Reference
:   Context-sensitive access to
    the [Python API Reference](https://docs.blender.org/api/current/).

Edit Source
:   For UI development – Creates a text data-block with the source code associated with the control,
    in case the control is based on a Python script.
    In the Text Editor it points at the code line where the element is defined.

Edit Translation
:   For UI development – Points at the translation code line.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`GreasePencil.layer_groups`](bpy.types.GreasePencil.html#bpy.types.GreasePencil.layer_groups "bpy.types.GreasePencil.layer_groups") - [`GreasePencilTreeNode.parent_group`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.parent_group "bpy.types.GreasePencilTreeNode.parent_group") - [`GreasePencilv3LayerGroup.active`](bpy.types.GreasePencilv3LayerGroup.html#bpy.types.GreasePencilv3LayerGroup.active "bpy.types.GreasePencilv3LayerGroup.active") - [`GreasePencilv3LayerGroup.move`](bpy.types.GreasePencilv3LayerGroup.html#bpy.types.GreasePencilv3LayerGroup.move "bpy.types.GreasePencilv3LayerGroup.move") - [`GreasePencilv3LayerGroup.move_bottom`](bpy.types.GreasePencilv3LayerGroup.html#bpy.types.GreasePencilv3LayerGroup.move_bottom "bpy.types.GreasePencilv3LayerGroup.move_bottom") - [`GreasePencilv3LayerGroup.move_to_layer_group`](bpy.types.GreasePencilv3LayerGroup.html#bpy.types.GreasePencilv3LayerGroup.move_to_layer_group "bpy.types.GreasePencilv3LayerGroup.move_to_layer_group") - [`GreasePencilv3LayerGroup.move_to_layer_group`](bpy.types.GreasePencilv3LayerGroup.html#bpy.types.GreasePencilv3LayerGroup.move_to_layer_group "bpy.types.GreasePencilv3LayerGroup.move_to_layer_group") | - [`GreasePencilv3LayerGroup.move_top`](bpy.types.GreasePencilv3LayerGroup.html#bpy.types.GreasePencilv3LayerGroup.move_top "bpy.types.GreasePencilv3LayerGroup.move_top") - [`GreasePencilv3LayerGroup.new`](bpy.types.GreasePencilv3LayerGroup.html#bpy.types.GreasePencilv3LayerGroup.new "bpy.types.GreasePencilv3LayerGroup.new") - [`GreasePencilv3LayerGroup.new`](bpy.types.GreasePencilv3LayerGroup.html#bpy.types.GreasePencilv3LayerGroup.new "bpy.types.GreasePencilv3LayerGroup.new") - [`GreasePencilv3LayerGroup.remove`](bpy.types.GreasePencilv3LayerGroup.html#bpy.types.GreasePencilv3LayerGroup.remove "bpy.types.GreasePencilv3LayerGroup.remove") - [`GreasePencilv3Layers.move_to_layer_group`](bpy.types.GreasePencilv3Layers.html#bpy.types.GreasePencilv3Layers.move_to_layer_group "bpy.types.GreasePencilv3Layers.move_to_layer_group") - [`GreasePencilv3Layers.new`](bpy.types.GreasePencilv3Layers.html#bpy.types.GreasePencilv3Layers.new "bpy.types.GreasePencilv3Layers.new") |
user: Explain OperatorOptions(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # OperatorOptions(bpy_struct)

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

*class* bpy.types.OperatorOptions(*bpy_struct*)
:   Runtime options

    is_grab_cursor
    :   True when the cursor is grabbed

        Type:
        :   boolean, default False, (readonly)

    is_invoke
    :   True when invoked (even if only the execute callbacks available)

        Type:
        :   boolean, default False, (readonly)

    is_repeat
    :   True when run from the ‘Adjust Last Operation’ panel

        Type:
        :   boolean, default False, (readonly)

    is_repeat_last
    :   True when run from the operator ‘Repeat Last’

        Type:
        :   boolean, default False, (readonly)

    use_cursor_region
    :   Enable to use the region under the cursor for modal execution

        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: How do I use Installing Git and Downloading the Repository in Blender? Include parameters, examples, warnings and best practices.

assistant: In this guide, we will use the official Git client, though any Git client will do.

1. Download and install [Git](https://git-scm.com/download/win) for Windows.
2. Simply check out the Blender Manual’s repository using:

   ```
   cd ~
   git lfs install
   git clone https://projects.blender.org/blender/blender-manual.git
   ```
3. The repository will now be downloaded which may take a few minutes depending on your internet connection.
user: What is Chroma Key Node and how is it used in Blender Python scripting?

assistant: # Chroma Key Node

[image reference removed]

The *Chroma Key* node determines if a pixel is a foreground or background
(and thereby should be transparent) based on its chroma values.

Use this, for example, to composite images that have been shot in front of a green or blue screen.
user: How do I use Introduction in Blender? Include parameters, examples, warnings and best practices.

assistant: # Introduction

EEVEE is Blender’s realtime render engine focused on speed and interactivity while achieving the
goal of rendering PBR materials.
EEVEE can be used interactively in the 3D Viewport but also produce high quality final renders.

[image reference removed]

EEVEE in the 3D Viewport – “Tiger” by Daniel Bystedt.

EEVEE materials are created using the same shader nodes as Cycles, making it easy to render existing
scenes. For Cycles users, this makes EEVEE work great for previewing materials in realtime.

EEVEE is based on rasterization and is not a path tracer.
Instead of computing each ray of light, rasterization determines what surface is visible from the camera.
It then estimates the way light interacts with these surfaces and materials using numerous algorithms.
While EEVEE is designed to use PBR principles,
it is not perfect and Cycles will always provide more physically accurate renders.
For these reasons, EEVEE has a set of [limitations](limitations/index.xhtml).

[image reference removed]

EEVEE final render – “Temple” by Dominik Graf.
user: What is Saving Catalogs and how is it used in Blender Python scripting?

assistant: Saving catalogs makes any edits to any catalogs permanent by writing the current set up to the asset library.
Catalogs can be saved in the [Asset Browser](../../editors/asset_browser.xhtml)
through Header ‣ Catalog ‣ Save Asset Catalog.
Once the catalog is created you can double `LMB` on it’s name
Catalogs can also be saved in the *Source List* region of the editor
by clicking the save icon found at the top of the tree view.
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

Transform is the modality of operations that perform transformations in 2D and 3D elements.
Transformations can include things like moving, rotating, scaling,
and applying other operations to objects in the scene.

They work by changing the geometry which you can edit directly.
user: Describe skin.glue from the Blender manual or Python API, including usage steps and snippets.

assistant: This rig is in concept similar to [skin.anchor](#skin-anchor), but instead of overriding controls,
it is used to read or adjust the state of controls generated by other rigs.
The head of the bone must overlap a control of another skin rig.

The rig sets up its ORG bone to read the state of the control,
while moving all constraints that were originally on the bone to the control.

Glue Mode
:   Specifies how the ORG bone is connected to the skin control.

    Child Of Control
    :   Makes the ORG bone a child of the control bone.

    Mirror Of Control
    :   Makes the ORG bone a sibling of the control with a Copy Transforms constraint from the control.
        The resulting local space transformation is the same as control’s local space.

    Mirror With Parents
    :   Parents the ORG bone to the parent automation a control owned by
        the glue rig would have had, while making it follow the actual control.
        This includes both direct and parent-induced motion of the control into
        the local space transformation of the bone.

    Deformation Bridge
    :   Other than adding glue constraints to the control, the rig acts as a one segment basic deform chain.
        This is convenient when a pair of controls need to be bridged both with glue and a deform bone.

Relink Constraints
:   Operates the same as in [basic.raw_copy](basic.xhtml#rigify-rigs-basic-raw-copy),
    except all constraints are moved from ORG to the control bone.

Use Tail Target
:   Relinks `TARGET` or any constraints with an empty target bone and no relink specification
    to reference the control located at the tail of the glue bone.

Target Local With Parents
:   Switches the tail target to operate similarly to *Mirror With Parents*.

Add Constraint
:   Allows to add a typical glue constraints with specific *Influence*, as if it were at
    the start of the ORG bone constraint stack.
user: Give a detailed overview of Images: syntax, arguments, return values, common patterns.

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: How do I use For Each Geometry Element Zone in Blender? Include parameters, examples, warnings and best practices.

assistant: # For Each Geometry Element Zone

This zone type allows executing nodes for each element of a geometry. For example, the nodes can process
every face of a mesh, or every instance.

[image reference removed]

The *For Each Element* zone.

The zone is ideal for tasks that generate large or complex geometry for every element of an input geometry.
For example, generating a unique tree for every input curve, or a unique building on every input face.

The zone makes less sense for processing small amounts of geometry. In that case (for example each of a character’s
hairs separately) it will likely **always be slower** than working on fewer larger geometries. The additional
flexibility from processing each element separately comes at the cost that Blender can’t optimize the operation
as well. For node groups that need to handle lots of geometry elements, it’s recommended to design the node setup
so that iteration over tiny sub-geometries is not required.
user: What is PreferencesApps(bpy_struct) and how is it used in Blender Python scripting?

assistant: # PreferencesApps(bpy_struct)

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

*class* bpy.types.PreferencesApps(*bpy_struct*)
:   Preferences that work only for apps

    show_corner_split
    :   Split and join editors by dragging from corners

        Type:
        :   boolean, default True

    show_edge_resize
    :   Resize editors by dragging from the edges

        Type:
        :   boolean, default True

    show_regions_visibility_toggle
    :   Header and side bars visibility toggles

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

assistant: # GeometryNodeCurveToMesh(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.GeometryNodeCurveToMesh(*GeometryNode*)
:   Convert curves into a mesh, optionally with a custom profile shape defined by curves

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe LayerObjects(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # LayerObjects(bpy_struct)

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

*class* bpy.types.LayerObjects(*bpy_struct*)
:   Collections of objects

    active
    :   Active object for this layer

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

    selected
    :   All the selected objects of this layer

        Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`Object`](bpy.types.Object.html#bpy.types.Object "bpy.types.Object"), (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 Inherited Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`LineStyleGeometryModifier.name`](bpy.types.LineStyleGeometryModifier.html#bpy.types.LineStyleGeometryModifier.name "bpy.types.LineStyleGeometryModifier.name") |
user: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

Once an armature is [skinned](../skinning/index.html) by the needed object(s),
you need a way to configure the armature into positions known as poses.
Basically, by transforming the bones, you deform or transform the skinned object(s).
However, you will notice that you cannot do this in *Edit Mode* –
remember that *Edit Mode* is used to edit the default, base, or “rest” position of an armature.
You may also notice that you cannot use *Object Mode* either, as here you can only transform whole objects.

So, armatures have a third mode dedicated to the process of posing known as *Pose Mode*.
In rest position (as edited in *Edit Mode*), each bone has its own position/rotation/scale to neutral values
(i.e. 0.0 for position and rotation, and 1.0 for scale). Hence, when you edit a bone in *Pose Mode*,
you create an offset in the transform properties, from its rest position.
This may seem quite similar if you have worked with [relative shape keys](../../shape_keys/index.html)
or [Delta Transformations](../../../scene_layout/object/properties/transforms.html#bpy-types-object-delta).

Even though it might be used for completely static purposes,
posing is heavily connected with animation features and techniques.
So if you are not familiar at all with animation in Blender,
it might be a good idea to read the [animation chapter](../../index.html) first,
and then come back here.