PGCRYPT/OpenBlender_Train huggingface dataset:
user: Provide the full official documentation entry for Texture, preserving all code examples.

assistant: [image reference removed]

Typical modifier Texture options.

Those options allow to use any kind of image (including parametric ones) to control the modifier’s effect.
Most of the time, only the value (grayscale) of the texture is used,
but in some cases (like with some modes of the [Displace modifier](deform/displace.xhtml#bpy-types-displacemodifier)),
the whole RGB color components might be exploited.

Texture
:   The [texture data-block](../../render/materials/legacy_textures/introduction.xhtml) to use.

Texture Coordinates
:   The texture’s coordinates to get each vertex’ value:

    UV
    :   Take texture coordinates from face UV coordinates.

        UV Map
        :   The [UV Map](../../glossary/index.xhtml#term-UV-Map) from which to take texture coordinates. If the object has no
            UV coordinates, it falls back to the *Local* coordinate system. If this field is blank,
            but there is a UV map available (e.g. just after adding the first UV map to the mesh),
            the currently active UV map will be used.

    Object
    :   Take the texture coordinates from another object’s coordinate system.

        Object
        :   The object from which to take texture coordinates.
            Moving the object will therefore alter the coordinates of the texture mapping.

            If this field is blank, it falls back to the *Local* coordinate system.

    Global
    :   Take the texture coordinates from the global coordinate system.

    Local
    :   Take the texture coordinates from the object’s local coordinate system.

Use Channel
:   Which channel to use as value source
    (only available with a few modifiers currently, others follow the *Intensity* behavior,
    unless otherwise specified).

    Intensity
    :   The average of the RGB channels (if RGB(1.0, 0.0, 0.0) value is 0.33).

    Red/Green/Blue/Alpha
    :   One of the color channels’ values.

    Hue
    :   The hue from the HSV color model
        (i.e; the color in the standard wheel, e.g. blue has a higher hue value than yellow).

    Saturation
    :   The saturation from the HSV color model (e.g. the value for pure red is 1.0, for gray is 0.0).

    Value
    :   The value from the HSV color model.
user: Show practical ways to work with Selecting Outliner Items in a Blender add-on or script – include code.

assistant: # Selecting Outliner Items

[image reference removed]

Selected data-blocks with the Cube active.

Selection is done with `LMB` (and/or the [context menu](editing.html#editors-outliner-editing-context-menu))
on the row of a data-block. Single selections will also activate the data-block.
The rows of selected data-blocks are highlighted blue, with the active data-block highlighted in a lighter blue.

Clicking in empty space below the list of data-blocks will deselect all.

Children of a data-block can also be selected by clicking the icon that is displayed to
the right of the parent data-block’s name.
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Domain
:   The [attribute domain](../attributes_reference.html#attribute-domains) used to evaluate the *Value* input.
    The *Auto* option chooses the domain automatically based on the connected nodes.

### Viewer Items

Socket Type
:   The data type used to evaluate the input.

Auto Remove
:   Remove the item automatically when it is unlinked.
user: How do I use J in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [jitter (bpy.types.Brush attribute)](bpy.types.Brush.html#bpy.types.Brush.jitter) - [jitter_absolute (bpy.types.Brush attribute)](bpy.types.Brush.html#bpy.types.Brush.jitter_absolute) - [jitter_factor (bpy.types.ParticleSettings attribute)](bpy.types.ParticleSettings.html#bpy.types.ParticleSettings.jitter_factor) - [jitter_unit (bpy.types.Brush attribute)](bpy.types.Brush.html#bpy.types.Brush.jitter_unit) - [join() (aud.aud.Sound method)](aud.html#aud.aud.Sound.join)   - [(in module bpy.ops.node)](bpy.ops.node.html#bpy.ops.node.join)   - [(in module bpy.ops.object)](bpy.ops.object.html#bpy.ops.object.join)   - [(in module bpy.ops.palette)](bpy.ops.palette.html#bpy.ops.palette.join) - [join_named() (in module bpy.ops.node)](bpy.ops.node.html#bpy.ops.node.join_named) - [join_nodes() (in module bpy.ops.node)](bpy.ops.node.html#bpy.ops.node.join_nodes) | - [join_selection() (in module bpy.ops.grease_pencil)](bpy.ops.grease_pencil.html#bpy.ops.grease_pencil.join_selection) - [join_shapes() (in module bpy.ops.object)](bpy.ops.object.html#bpy.ops.object.join_shapes) - [join_tracks() (in module bpy.ops.clip)](bpy.ops.clip.html#bpy.ops.clip.join_tracks) - [join_triangles() (in module bmesh.ops)](bmesh.ops.html#bmesh.ops.join_triangles) - [join_uvs() (in module bpy.ops.object)](bpy.ops.object.html#bpy.ops.object.join_uvs) - [joint_bindings (bpy.types.SplineIKConstraint attribute)](bpy.types.SplineIKConstraint.html#bpy.types.SplineIKConstraint.joint_bindings) - [jpeg2k_codec (bpy.types.ImageFormatSettings attribute)](bpy.types.ImageFormatSettings.html#bpy.types.ImageFormatSettings.jpeg2k_codec) - [jump() (in module bpy.ops.text)](bpy.ops.text.html#bpy.ops.text.jump) - [jump_height (bpy.types.WalkNavigation attribute)](bpy.types.WalkNavigation.html#bpy.types.WalkNavigation.jump_height) - [jump_to_file_at_point() (in module bpy.ops.text)](bpy.ops.text.html#bpy.ops.text.jump_to_file_at_point) - [jump_to_target_button() (in module bpy.ops.ui)](bpy.ops.ui.html#bpy.ops.ui.jump_to_target_button) |
user: What is Curve Tangent Node and how is it used in Blender Python scripting?

assistant: # Curve Tangent Node

[image reference removed]

The *Curve Tangent* node outputs the direction that a curve points in at each control point,
depending on the direction of the curve (which can be controlled with
the [Reverse Curve Node](../operations/reverse_curve.html)). The output values are normalized vectors.
user: Provide the full official documentation entry for Custom Properties, preserving all code examples.

assistant: Create and manage your own properties to store data in the Bone Collection’s data-block.
See the [Custom Properties](../../../files/custom_properties.xhtml#files-data-blocks-custom-properties) page for more information.
user: Show practical ways to work with GeometryNodeInputMeshVertexNeighbors(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeInputMeshVertexNeighbors(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.GeometryNodeInputMeshVertexNeighbors(*GeometryNode*)
:   Retrieve topology information relating to each vertex of a mesh

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

assistant: [image reference removed]

Floor constraint.

[Target](../interface/common.xhtml#rigging-constraints-interface-common-target)
:   The object or bone that defines the location, and optionally the rotation, of the floor.

Offset
:   Moves the virtual floor “up” or “down” by a certain distance. This makes it possible to,
    say, make foot bones stay a certain distance above the floor geometry to leave room for
    the actual feet.

Min/Max
:   The axis that’s perpendicular to the floor and points towards its “walkable” area.
    Setting this to Z creates a floor; X or Y creates a wall; and -Z creates a ceiling.

    By default, these axes correspond to the global axes.

Use Rotation
:   Use the *Target*’s local axes for *Min/Max* instead of the global axes.

[Target/Owner](../interface/common.xhtml#rigging-constraints-interface-common-space)
:   The spaces for evaluating and limiting the coordinates of the target and owner.

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: Provide the full official documentation entry for Annotation Tools, preserving all code examples.

assistant: The annotation tool can be activated in the Toolbar and has the following sub-tools:

Annotate
:   Draw free-hand strokes in the main area.

Annotate Line
:   Click and drag to create a line.
    Optionally, you can select the arrow style for the start and end of the line.

Annotate Polygon
:   Click multiple times to create multiple connected lines, then press `Return` or `Esc` to confirm.

Annotate Eraser
:   Click and drag to remove lines.
    The eraser has a *Radius* setting found in Tool Settings.
user: What is Options and how is it used in Blender Python scripting?

assistant: [image reference removed]

The Subdivision Surface modifier.

Catmull-Clark
:   Subdivides and smooths the surfaces to create a more pleasant looking mesh.
    According to its [Wikipedia page](https://en.wikipedia.org/wiki/Catmull%E2%80%93Clark_subdivision_surface),
    the “arbitrary-looking formula was chosen by Catmull and Clark based on the aesthetic appearance of
    the resulting surfaces rather than on a mathematical derivation.”

Simple
:   Only subdivides the surfaces, this often does not provide any smoothing
    unless the surface is [non-coplanar](../../../glossary/index.xhtml#term-Coplanar)
    (the same as the [Subdivide](../../meshes/editing/edge/subdivide.xhtml#bpy-ops-mesh-subdivide) operator, in Edit Mode).
    To work around this behavior for non-coplanar geometry,
    [triangulate](triangulate.xhtml) to ensure all geometry is coplanar.

    Simple mode can be used, for example, to increase the base mesh resolution when using displacement maps.

Levels Viewport, Render
:   The number of subdivision levels shown in the 3D Viewport or the final render.

Optimal Display
:   When rendering the wireframe of this object, the wires of the new subdivided edges will be skipped
    (only displays the edges of the original geometry).

### Advanced

Use Limit Surface
:   Places vertices at the surface that would be produced with infinite
    levels of subdivision (smoothest possible shape).

Quality
:   When *Use Limit Surface* is enabled this property controls
    how precisely vertices are positioned on the limit surface
    (relatively to their theoretical position of an infinitely subdivided mesh).
    It can be lowered to get a better performance.

    Using higher values does not necessarily mean real improvement in quality,
    ideal results might be reached well before the maximum *Quality* value.

UV Smooth
:   Controls how subdivision smoothing is applied to UVs.

    None:
    :   UVs remain unchanged.

    Keep Corners:
    :   UV islands are smoothed, but their boundary remain unchanged.

    Keep Corners, Junctions:
    :   UVs are smoothed, corners on discontinuous boundary and junctions of three or more regions are kept sharp.

    Keep Corners, Junctions, Concave:
    :   UVs are smoothed, corners on discontinuous boundary,
        junctions of three or more regions and darts and concave corners are kept sharp.

    Keep Boundaries:
    :   UVs are smoothed, boundaries are kept sharp.

    All:
    :   UVs and their boundaries are smoothed.

Boundary Smooth
:   Controls how open boundaries (and corners) are smoothed.

    All:
    :   Smooth boundaries, including corners.

    Keep Corners:
    :   Smooth boundaries, but corners are kept sharp.

Use Creases
:   Use the [Weighted Edge Creases](#modifiers-generate-subsurf-creases) values stored in edges to control how smooth they are made.

Use Custom Normals
:   Interpolates existing [Custom Split Normals](../../meshes/structure.xhtml#modeling-meshes-normals-custom) of the resulting mesh.
    Otherwise, new faces will have the overall normal orientation of that original face.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`Annotation.layers`](bpy.types.Annotation.html#bpy.types.Annotation.layers "bpy.types.Annotation.layers") - [`AnnotationLayers.new`](bpy.types.AnnotationLayers.html#bpy.types.AnnotationLayers.new "bpy.types.AnnotationLayers.new") | - [`AnnotationLayers.remove`](bpy.types.AnnotationLayers.html#bpy.types.AnnotationLayers.remove "bpy.types.AnnotationLayers.remove") |
user: Describe Transform from the Blender manual or Python API, including usage steps and snippets.

assistant: # Transform

When in *Edit Mode* you can use this panel to control position and roll of individual bones.
Whereas in *Pose Mode* you can only set location for the main bone, and you can now set rotation and scale.

In addition, in *Pose Mode* it is possible to restrict changes in position,
rotation and scale by axis on each bone in the armature.

Head X, Y, Z
:   Location of head end of the bone.

Tail X, Y, Z
:   Location of tail end of the bone.

Roll
:   Bone rotation around head-tail axis.

Length
:   The distance from the bone’s head to it’s tail. Changing the length moves the tail end.

Lock
:   Bone is not able to be transformed when in Edit Mode.
user: Describe SequenceTimelineChannel(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # SequenceTimelineChannel(bpy_struct)

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

*class* bpy.types.SequenceTimelineChannel(*bpy_struct*)
:   lock
    :   Type:
        :   boolean, default False

    mute
    :   Type:
        :   boolean, default False

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: The *Align Rotation* tool aligns entire islands to either the U or V axis.

The tool has three different methods of operation.
The different methods specify the source for the alignment,
and also whether to align with both the U and V axes,
or just the V axis alone.

When using the *Auto* method, islands are aligned so that UV edges are aligned
to either the U axis or the V axis. This method works best with quads
and meshes representing organic subjects.

When using the *Edge* method, only the selected edges are considered,
and the islands will be aligned such that the selected edges are aligned
with the V axis. This method works with the selection, so it works best
when a particular edge, or edge loop, needs to be aligned in UV coordinates.

When using the *Geometry* method, the geometry is taken into consideration.
Either the *X* axis, the *Y* axis, or the *Z* axis can be used. Suppose
the *X* axis is chosen. Using this method, edges which have a positive extent
in the *X* axis will be rotated in the UV map so that the edge
extends upwards in the *V* axis.
This method works best to align multiple islands which share some common
geometric property, either in the X, Y or Z axis.

Note that in the *Auto* method, edges can end up aligned either up or down or left or right
depending on the orientation of the island prior to activating the tool.
In the *Edge* method, the alignment of selected edges can be either up
or down in the V axis, whatever is closest to the current orientation of the UV island.
By comparison, in the *Geometry* method, the alignment will always be pointing up in the V axis,
ignoring any previous orientation.
user: Describe Troubleshooting Windows – Intel from the Blender manual or Python API, including usage steps and snippets.

assistant: # Troubleshooting Windows – Intel

Blender uses OpenGL for the 3D Viewport and user interface. The graphics processing unit (GPU) and driver have a big
impact on Blender’s behavior and performance.

This section lists possible solutions for graphics glitches, problems with EEVEE and Cycles, and crashes related to
your GPU.
user: Give a detailed overview of PrimitiveBoolean(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # PrimitiveBoolean(bpy_struct)

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

*class* bpy.types.PrimitiveBoolean(*bpy_struct*)
:   RNA wrapped boolean

    value
    :   Type:
        :   boolean, default False, (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: Provide the full official documentation entry for Group, preserving all code examples.

assistant: # Group

A [Group Node](../../interface/controls/nodes/groups.html) combines a set of nodes into a single one,
and selectively exposes inputs and outputs of those nodes.

Group nodes can simplify a node tree by hiding away complexity and reusing functionality.
user: Show practical ways to work with Surfaces in a Blender add-on or script – include code.

assistant: # Surfaces

The surface shader defines the light interaction at the surface of the mesh.
One or more BSDFs specify
if incoming light is reflected back, refracted into the mesh, or absorbed.

Emission defines how light is emitted from the surface,
allowing any surface to become a light source.
user: Provide the full official documentation entry for AttributeGroupGreasePencil(bpy_struct), preserving all code examples.

assistant: # AttributeGroupGreasePencil(bpy_struct)

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

*class* bpy.types.AttributeGroupGreasePencil(*bpy_struct*)
:   Group of geometry attributes

    active
    :   Active attribute

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

    active_index
    :   Active attribute index or -1 when none are active

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

    new(*name*, *type*, *domain*)
    :   Add attribute to geometry

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – Name, Name of geometry attribute
            - **type** (enum in [Attribute Type Items](bpy_types_enum_items/attribute_type_items.html#rna-enum-attribute-type-items)) – Type, Attribute type
            - **domain** (enum in [Attribute Domain Items](bpy_types_enum_items/attribute_domain_items.html#rna-enum-attribute-domain-items)) – Domain, Type of element that attribute is stored on

        Returns:
        :   New geometry attribute

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

    remove(*attribute*)
    :   Remove attribute from geometry

        Parameters:
        :   **attribute** ([`Attribute`](bpy.types.Attribute.html#bpy.types.Attribute "bpy.types.Attribute"), (never None)) – Geometry Attribute

    domain_size(*domain*)
    :   Get the size of a given domain

        Parameters:
        :   **domain** (enum in [Attribute Domain Items](bpy_types_enum_items/attribute_domain_items.html#rna-enum-attribute-domain-items)) – Domain, Type of element that attribute is stored on

        Returns:
        :   Size, Size of the domain

        Return type:
        :   int in [0, inf]

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

assistant: # Sampling

The quality of the renders can be adjusted by changing the [Anti-Aliasing](../../glossary/index.xhtml#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: What is Motion Tracking & Masking and how is it used in Blender Python scripting?

assistant: # Motion Tracking & Masking

You perform masking and tracking with the Movie Clip Editor.

[image reference removed]

The Movie Clip Editor.

See [Movie Clip Editor](../editors/clip/index.html) for more information on the Movie Clip Editor.
user: Describe CompositorNodeChromaMatte(CompositorNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CompositorNodeChromaMatte(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.CompositorNodeChromaMatte(*CompositorNode*)
:   Create matte based on chroma values

    *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 Stereo 3D Display: syntax, arguments, return values, common patterns.

assistant: If you have a real 3D display at some point, you can change the 3D display mode in the Window menu,
by calling the Stereo 3D operator.
Be aware that some modes require a fullscreen editor to work.

[image reference removed]

Window menu, stereo 3D operator.
user: Describe Frame Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Frame Node

The *Frame* node is used to organize and group other nodes within the editor.
It helps manage complex node trees by visually grouping related nodes together.

Frames are particularly useful when the setup is too large to view easily at once,
or when you want to separate logical sections of a node tree without creating a reusable Node Group.

[image reference removed]

Example of a Frame node used to organize nodes.
user: Show practical ways to work with Time Stretching in a Blender add-on or script – include code.

assistant: Use to remap the length of an animation; making it run slower or faster.
The *Old* and *New* settings may either be used as absolute values or as a ratio:
For example, setting *Old* to a value of 2 and *New* to 1 will run the animation twice as fast.

Old
:   The length in frames of the original animation.

New
:   The length in frames the new animation will last.
user: Explain Lattice Modifier in complete detail according to the official Blender documentation.

assistant: # Lattice Modifier

The *Lattice* modifier deforms the base object according to
the shape of a [Lattice](../../../animation/lattice.xhtml) object.
Objects to be deformed can be meshes, curves,
surfaces, text, lattices and even particles.
user: Show practical ways to work with Dependency graph: Object.to_mesh() in a Blender add-on or script – include code.

assistant: Function to get a mesh from any object with geometry. It is typically used by exporters, render
engines and tools that need to access the evaluated mesh as displayed in the viewport.

Object.to_mesh() is closely interacting with dependency graph: its behavior depends on whether it
is used on original or evaluated object.

When is used on original object, the result mesh is calculated from the object without taking
animation or modifiers into account:

- For meshes this is similar to duplicating the source mesh.
- For curves this disables own modifiers, and modifiers of objects used as bevel and taper.
- For meta-balls this produces an empty mesh since polygonization is done as a modifier evaluation.

When is used on evaluated object all modifiers are taken into account.

```
import bpy

class OBJECT_OT_object_to_mesh(bpy.types.Operator):
    """Convert selected object to mesh and show number of vertices"""
    bl_label = "DEG Object to Mesh"
    bl_idname = "object.object_to_mesh"

    def execute(self, context):
        # Access input original object.
        obj = context.object
        if obj is None:
            self.report({'INFO'}, "No active mesh object to convert to mesh")
            return {'CANCELLED'}
        # Avoid annoying None checks later on.
        if obj.type not in {'MESH', 'CURVE', 'SURFACE', 'FONT', 'META'}:
            self.report({'INFO'}, "Object cannot be converted to mesh")
            return {'CANCELLED'}
        depsgraph = context.evaluated_depsgraph_get()
        # Invoke to_mesh() for original object.
        mesh_from_orig = obj.to_mesh()
        self.report({'INFO'}, f"{len(mesh_from_orig.vertices)} in new mesh without modifiers.")
        # Remove temporary mesh.
        obj.to_mesh_clear()
        # Invoke to_mesh() for evaluated object.
        object_eval = obj.evaluated_get(depsgraph)
        mesh_from_eval = object_eval.to_mesh()
        self.report({'INFO'}, f"{len(mesh_from_eval.vertices)} in new mesh with modifiers.")
        # Remove temporary mesh.
        object_eval.to_mesh_clear()
        return {'FINISHED'}

def register():
    bpy.utils.register_class(OBJECT_OT_object_to_mesh)

def unregister():
    bpy.utils.unregister_class(OBJECT_OT_object_to_mesh)

if __name__ == "__main__":
    register()
```
user: Provide the full official documentation entry for Transform Brushes, preserving all code examples.

assistant: [image reference removed]

Recognizable by their yellow icon and cursor.
These brushes generally move, pinch and magnify the mesh.

Pinch/Magnify
:   Brush Type: [Pinch](pinch.html)

    Shortcut: `P`

    Pulls vertices towards the center of the brush. Useful for polishing angles and creases. Alternatively pushes them
    away from the center.

Grab
:   Brush Type: [Grab](grab.html)

    Shortcut: `G`

    Moves vertices along with the mouse. An essential brush for building shapes and adjusting proportions.

Grab 2D
:   Brush Type: [Grab](grab.html)

    Similar to Grab but with an infinitely projected falloff. Useful for grabbing broader shapes and giving a similar
    feel to using Liquify tools in image painting applications.

Grab Silhouette
:   Brush Type: [Grab](grab.html)

    Similar to Grab but only affects vertices with the normal facing sideways away from the view. Very useful for
    adjusting outer silhouettes of thin objects.

Elastic Grab
:   Brush Type: [Elastic Deform](elastic_deform.html)

    Used to simulate realistic deformations from grabbing of [Elastic](../../../glossary/index.html#term-Elastic) objects.

Elastic Snake Hook
:   Brush Type: [Snake Hook](snake_hook.html)

    Similar to Elastic Grab but rotates affected geometry based on the stroke direction.

Snake Hook
:   Brush Type: [Snake Hook](snake_hook.html)

    Shortcut: `K`

    Pulls vertices along with the stroke to create long, snake-like forms. Geometry is rotated and magnified to allow
    continuous pulling. Much more useful while having [Dyntopo](../introduction/adaptive.html#dyntopo-introduction) enabled.

Pull
:   Brush Type: [Snake Hook](snake_hook.html)

    Iteratively picks up and lets go of geometry like the Snake Hook, but much softer. Useful for subtle small scale
    deforming over longer strokes.

Thumb
:   Brush Type: [Thumb](thumb.html)

    Same as *Grab* but moves vertices along the surface direction. Useful for preserving specific surfaces.

Pose
:   Brush Type: [Pose](pose.html)

    Simulating an armature-like deformations. Useful for quick posing and transformations.

Nudge
:   Brush Type: [Nudge](nudge.html)

    Similar as *Thumb* but dynamically picks up vertices like the *Snake Hook*.
    Useful for nudging something along the mesh surface.

Twist
:   Brush Type: [Rotate](rotate.html)

    Rotates vertices within the brush in the direction the cursor is moved.

Relax Slide
:   Brush Type: [Relax Slide](slide_relax.html)

    Slides the topology of the mesh in the direction of the stroke
    while preserving the geometrical shape of the mesh. Alternatively smooths the mesh on ‘Shift’.
    Also useful for redistributing topology where it is needed.

Relax Pinch
:   Brush Type: [Relax Slide](slide_relax.html)

    Similar to the Relax Slide brush but pinches/relaxes geometry instead.

Boundary
:   Brush Type: [Boundary](boundary.html)

    Transform specifically mesh boundaries with various deformations.
user: Describe Visualization from the Blender manual or Python API, including usage steps and snippets.

assistant: There are some important visualization features in the 3D Viewport that can help animation.

When the current frame is a keyframe for the current active object, the name of this object
(shown in the upper left corner of the 3D Viewport) turns yellow.

[image reference removed]

Top: Current frame is a keyframe for Cube. Bottom: Current frame isn’t a keyframe.
user: Give a detailed overview of SoundEqualizerModifier(StripModifier): syntax, arguments, return values, common patterns.

assistant: # SoundEqualizerModifier(StripModifier)

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

*class* bpy.types.SoundEqualizerModifier(*StripModifier*)
:   Equalize audio

    graphics
    :   Graphical definition equalization

        Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`EQCurveMappingData`](bpy.types.EQCurveMappingData.html#bpy.types.EQCurveMappingData "bpy.types.EQCurveMappingData"), (readonly)

    new_graphic(*min_freq*, *max_freq*)
    :   Add a new EQ band

        Parameters:
        :   - **min_freq** (*float in* *[**0**,* *20000**]*) – Minimum Frequency, Minimum Frequency
            - **max_freq** (*float in* *[**0**,* *20000**]*) – Maximum Frequency, Maximum Frequency

        Returns:
        :   Newly created graphical Equalizer definition

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

    clear_soundeqs()
    :   Remove all graphical equalizers from the Equalizer modifier

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

assistant: # CompositorNodeIDMask(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.CompositorNodeIDMask(*CompositorNode*)
:   Create a matte from an object or material index pass

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

assistant: Switches Sculpt Mode from the [Active](../../../glossary/index.xhtml#term-Active) object to the object under the mouse.
See [Switching Objects](../../../editors/3dview/modes.xhtml#bpy-ops-object-transfer-mode) for more information.
user: Describe Viewport Render from the Blender manual or Python API, including usage steps and snippets.

assistant: # Viewport Render

Viewport rendering lets you create quick preview renders from the current viewpoint
(rather than from the active camera, as would be the case with a regular render).

You can use *Viewport Render* to render both images and animations.

Below is a comparison between the Viewport render and a final render using
the Cycles Renderer.

Model by © 2016 pokedstudio.com

|  |  |  |
| --- | --- | --- |
| ../../_images/editors_3dview_viewport-render_example-workbench-render.jpg   Viewport render using Solid Mode. | ../../_images/editors_3dview_viewport-render_example-eevee-render.jpg   Viewport render using Material Preview Mode. | ../../_images/editors_3dview_viewport-render_example-cycles-render.jpg   Full render. |
user: What is Snap and how is it used in Blender Python scripting?

assistant: [Mesh snapping](../../../editors/3dview/controls/snapping.xhtml) also works with curve components.
Both control points and their handles will be affected by snapping,
except for within itself (other components of the active curve).
Snapping works with 2D curves but points will be constrained to the local XY axes.
user: What is GeometryNodeImportText(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeImportText(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.GeometryNodeImportText(*GeometryNode*)
:   Import a string from a text file

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

assistant: # Vortex

[image reference removed]

Vortex force field visualization.

The *Vortex* force field gives a spiraling force that twists the direction of points around the force
object’s local Z axis. This can be useful for making a swirling sink, or tornado,
or kinks in particle hair.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Image
:   Standard color input image.

Highlights
:   The color tint applied to the bright areas of the image.

Factor Highlights
:   Controls how strongly the *Highlights* color affects the bright regions.
    A value of 0 disables the effect, while 1 applies it fully.

Shadows
:   The color tint applied to the darker areas of the image.

Factor Shadows
:   Controls the strength of the *Shadows* tint.

### Transition

Balance
:   Shifts the midpoint that defines what parts of the image are considered highlights or shadows.
    Increasing this value favors the highlight color; decreasing it favors the shadow color.

Smoothness
:   Adjusts how gradually the image transitions between tinted shadows and highlights.
    Higher values create a smooth, natural blend; lower values make the transition more abrupt.
user: Give a detailed overview of ColorManagedInputColorspaceSettings(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # ColorManagedInputColorspaceSettings(bpy_struct)

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

*class* bpy.types.ColorManagedInputColorspaceSettings(*bpy_struct*)
:   Input color space settings

    is_data
    :   Treat image as non-color data without color management, like normal or displacement maps

        Type:
        :   boolean, default False

    name
    :   Color space in the image file, to convert to and from when saving and loading the image

        Type:
        :   enum in [Color Space Convert Default Items](bpy_types_enum_items/color_space_convert_default_items.html#rna-enum-color-space-convert-default-items), default `'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: Describe Show/Hide from the Blender manual or Python API, including usage steps and snippets.

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

assistant: # NodeEvaluateClosureOutputItem(bpy_struct)

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

*class* bpy.types.NodeEvaluateClosureOutputItem(*bpy_struct*)
:   color
    :   Color of the corresponding socket type in the node editor

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

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

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

    structure_type
    :   What kind of higher order types are expected to flow through this socket

        Type:
        :   enum in [Node Socket Structure Type Items](bpy_types_enum_items/node_socket_structure_type_items.html#rna-enum-node-socket-structure-type-items), default `'AUTO'`

    *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 Usage in complete detail according to the official Blender documentation.

assistant: # Usage

Drivers can be added to properties via their context menu, a shortcut, copy-pasted,
or by typing an expression directly into the property’s value.

After adding drivers, they are usually modified in the [Drivers editor](../../editors/drivers_editor.html),
or via a simplified *Edit Driver* popover invoked from the property context menu.