PGCRYPT/OpenBlender_Train huggingface dataset:
user: How do I use Node Operators in Blender? Include parameters, examples, warnings and best practices.

assistant: rs

bpy.ops.node.toggle_viewer()
:   Toggle selected viewer node in compositor and geometry nodes

bpy.ops.node.translate_attach(*\**, *TRANSFORM_OT_translate=None*, *NODE_OT_attach=None*)
:   Move nodes and attach to frame

    Parameters:
    :   - **TRANSFORM_OT_translate** (`TRANSFORM_OT_translate`, (optional)) – Move, Move selected items
        - **NODE_OT_attach** (`NODE_OT_attach`, (optional)) – Attach Nodes, Attach active node to a frame

bpy.ops.node.translate_attach_remove_on_cancel(*\**, *TRANSFORM_OT_translate=None*, *NODE_OT_attach=None*)
:   Move nodes and attach to frame

    Parameters:
    :   - **TRANSFORM_OT_translate** (`TRANSFORM_OT_translate`, (optional)) – Move, Move selected items
        - **NODE_OT_attach** (`NODE_OT_attach`, (optional)) – Attach Nodes, Attach active node to a frame

bpy.ops.node.tree_path_parent(*\**, *parent_tree_index=0*)
:   Go to parent node tree

    Parameters:
    :   **parent_tree_index** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Parent Index, Parent index in context path

    File:
    :   [startup/bl_operators/node.py:892](https://projects.blender.org/blender/blender/src/branch/main/scripts/startup/bl_operators/node.py#L892)

bpy.ops.node.view_all()
:   Resize view so you can see all nodes

bpy.ops.node.view_selected()
:   Resize view so you can see selected nodes

bpy.ops.node.viewer_border(*\**, *xmin=0*, *xmax=0*, *ymin=0*, *ymax=0*, *wait_for_input=True*)
:   Set the boundaries for viewer operations

    Parameters:
    :   - **xmin** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – X Min
        - **xmax** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – X Max
        - **ymin** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Y Min
        - **ymax** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Y Max
        - **wait_for_input** (*boolean**,* *(**optional**)*) – Wait for Input

bpy.ops.node.viewer_shortcut_get(*\**, *viewer_index=0*)
:   Toggle a specific viewer node using 1,2,..,9 keys

    Parameters:
    :   **viewer_index** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Viewer Index, Index corresponding to the shortcut, e.g. number key 1 corresponds to index 1 etc..

    File:
    :   [startup/bl_operators/node.py:1280](https://projects.blender.org/blender/blender/src/branch/main/scripts/startup/bl_operators/node.py#L1280)

bpy.ops.node.viewer_shortcut_set(*\**, *viewer_index=0*)
:   Create a viewer shortcut for the selected node by pressing ctrl+1,2,..9

    Parameters:
    :   **viewer_index** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Viewer Index, Index corresponding to the shortcut, e.g. number key 1 corresponds to index 1 etc..

    File:
    :   [startup/bl_operators/node.py:1220](https://projects.blender.org/blender/blender/src/branch/main/scripts/startup/bl_operators/node.py#L1220)
user: How do I use GeometryNode(NodeInternal) in Blender? Include parameters, examples, warnings and best practices.

assistant: yNodeWarning`](bpy.types.GeometryNodeWarning.html#bpy.types.GeometryNodeWarning "bpy.types.GeometryNodeWarning")

*class* bpy.types.GeometryNode(*NodeInternal*)
:   *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 Polyline Gestures: syntax, arguments, return values, common patterns.

assistant: Clicking places a point in the viewport. Each time `LMB` is pressed, a new point of the polygon is created.
Pressing `LMB` on the starting point, pressing `LMB` twice,
or pressing `Return` closes the selection area.

### Controls

Move `Spacebar`
:   Hold to reposition the selection area.
user: Describe ShaderNodeCombineColor(ShaderNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ShaderNodeCombineColor(ShaderNode)

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

*class* bpy.types.ShaderNodeCombineColor(*ShaderNode*)
:   Create a color from individual components using multiple models

    mode
    :   Mode of color processing

        Type:
        :   enum in [Node Combsep Color Items](bpy_types_enum_items/node_combsep_color_items.html#rna-enum-node-combsep-color-items), default `'RGB'`

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

assistant: Grid
:   The resulting SDF grid after mean filtering.
    The surface becomes smoother and more uniform, making it useful for
    refining noisy or rough SDFs before further operations such as
    [Grid to Mesh](grid_to_mesh.html).
user: Provide the full official documentation entry for Structure, preserving all code examples.

assistant: Vertex Mass
:   Value for the mass of the hair.

Stiffness
:   Controls the bending stiffness of the hair strands.

    Random
    :   Random stiffness of hair.

Damping
:   Damping of bending motion.
user: Explain Face Bones in complete detail according to the official Blender documentation.

assistant: Start by identifying basic face landmarks to follow as guide for bones placement.

[image reference removed]

Basic Face Landmarks.

- Orange lines represent bones that should be placed in closed loops.
- Yellow lines represent bones whose position depends on surrounding bone loops.
- Red lines represent outer edge bones.
- Purple lines represent bridging bones used to cover deforming flesh.

[image reference removed]

Eyes-Nose Landmarks.

The eyes-nose loop area is split in different parts identified by bone names. Follow the image to place the bones.

[image reference removed]

Eyes-Nose Bone Positions.

[image reference removed]

Jaw-Ear Bone Positions.

Also the jaw-ear area is split in different parts identified by bone names. Follow the image to place the bones.

[image reference removed]

Lips Merge Point.

[image reference removed]

Face Stretcher Bones.

After the main face bones are placed use the cheek bone to connect the eye-nose area to the jaw mouth area.
Then do the same with the brow area. This process will automatically define face muscles compression areas.

Position the eye bones in the eye pivot point facing right **toward** the face on the Y axis.
The length of the eye bones should correspond to the radius of the eye.

[image reference removed]

Eyes Pivot Position.

Finally position the teeth bones on your teeth geometry and the tongue bone chain as described in the figure.

[image reference removed]

Mouth and Teeth Positions.

Before generating the rig ensure the face master bone is facing upward.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Edge Index
:   The index of the edge for which to find connected corners.

Weights
:   The weights of the corners in the geometry. Unlike the other inputs which follow
    the context domain, this one is always evaluated in the Face Corner domain.

    The corners are sorted by their associated weight in ascending order.
    Corners with the same weight are sorted by their index.

Sort Index
:   The 0-based index of the corner to select from the edge’s sorted corners.
    If this value is outside the range of valid indices, it wraps around.
user: Explain MeshLoop(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # MeshLoop(bpy_struct)

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

*class* bpy.types.MeshLoop(*bpy_struct*)
:   Loop in a Mesh data-block

    bitangent
    :   Bitangent vector of this vertex for this face (must be computed beforehand using calc_tangents, use it only if really needed, slower access than bitangent_sign)

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

    bitangent_sign
    :   Sign of the bitangent vector of this vertex for this face (must be computed beforehand using calc_tangents, bitangent = bitangent_sign \* cross(normal, tangent))

        Type:
        :   float in [-1, 1], default 0.0, (readonly)

    edge_index
    :   Edge index

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

    index
    :   Index of this loop

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

    normal
    :   The normal direction of the face corner, taking into account sharp faces, sharp edges, and custom normal data

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

    tangent
    :   Local space unit length tangent vector of this vertex for this face (must be computed beforehand using calc_tangents)

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

    vertex_index
    :   Vertex index

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for X/Y/Z Global, preserving all code examples.

assistant: These operations perform a non-interactive mirror along the global X, Y, or Z axis.

X Global
:   Mirrors the selection along the global X axis.

Y Global
:   Mirrors the selection along the global Y axis.

Z Global
:   Mirrors the selection along the global Z axis.
user: What is Draw Sharp and how is it used in Blender Python scripting?

assistant: # Draw Sharp

Similar to the [Draw](draw.xhtml) brush,
but it always deforms the mesh from the original coordinates
and uses the *Sharper* Falloff by default.

Draw Sharp is useful on high density meshes for creating cloth wrinkles, stylized hair or hard surface edges.
To further sharpen or polish sharp edges in the case that the mesh density is not enough,
it’s recommended to use the [Pinch](pinch.xhtml),
[Crease](crease.xhtml) or
[Multiplane Scrape](multiplane_scrape.xhtml) brushes.

A limitation is that the brush does not remesh the sculpted surfaces
with [Dyntopo](../tool_settings/dyntopo.xhtml#bpy-ops-sculpt-dynamic-topology-toggle) enabled.
Because of that, a better brush to use with Dyntopo can be [Crease](crease.xhtml).
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Base Color
:   Diffuse surface color. For conductor materials (metals) it should be black.

Specular
:   Amount of specular reflection. Specifies facing (along normal)
    reflectivity. Conductor materials (metals) can have colored specular reflection.

Roughness
:   Specifies microfacet roughness of the surface for diffuse and specular reflection.

Emissive Color
:   Color of the emitted light. This light is added to the BSDF result.

Transparency
:   Transparency factor. This is the inverse of the alpha channel (1 - alpha) you find in an image.
    Use an Invert node to convert alpha to transparency.
    This will only have an effect if the material uses a blend mode other than opaque.

Normal
:   Controls the normals of the base layers.

Clear Coat
:   Extra white specular layer on top of others.
    This is useful for materials like car paint and the like.

Clear Coat Roughness:
:   Roughness of clear coat specular.

Clear Coat Normal
:   Controls the normals of the *Clear Coat* layer.

Ambient Occlusion
:   Amount of occlusion to apply to indirect lighting. Usually a bake ambient occlusion map.
    The final occlusion factor is the minimum of this input and the runtime ambient occlusion effect.
user: Describe Resource Information from the Blender manual or Python API, including usage steps and snippets.

assistant: The right side of the Status Bar displays information about the Blender instance.
Which information is shown can be chosen by `RMB` on the Status Bar
or in the [Preferences](../../editors/preferences/interface.html#prefs-interface-status-bar).

[image reference removed]

Scene Statistics
:   Shows information about the data in the active scene.

    - **Collection**: The name of the active [Collection](../../scene_layout/collections/index.html).
    - **Active Object**: The name of the active selected object.
    - **Geometry**: Information about the current scene depending on the mode and object type.
      This can be the number of vertices, faces, triangles, or bones.
    - **Objects**: The number of selected objects and the total count of objects.

Scene Duration
:   Shows the total amount of time of the playback along with the current frame number and total frame count.
    The format of the duration text is determined by the
    [Timecode Style](../../editors/preferences/animation.html#bpy-types-preferencesview-timecode-style).

System Memory
:   Shows an estimate of Blender’s RAM consumption. On a single-instance single-machine scenario,
    this estimate provides a measurement against the hardware limit of the machine.

Extensions Updates
:   Shows the number of [extensions](../../advanced/extensions/index.html) with available updates.

Blender Version
:   Shows the version number of Blender that is currently running.
user: Explain GeometryNodeInputMaterial(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeInputMaterial(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.GeometryNodeInputMaterial(*GeometryNode*)
:   Output a single material

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

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

assistant: ### Brush Asset

Picks the brush asset used by the tool.

See [Brush Asset](../tool_settings/brushes.xhtml) for more information.

See [Draw Brushes](../brushes/draw.xhtml) for a detailed list of all draw brushes and their options.

### Brush Settings

Parameters to control to look of the stroke.

See [Draw Brushes](../brushes/draw.xhtml) for details.

### Eraser

Default Eraser Brush
:   Select a brush to use as eraser for quickly alternating with the main brush using
    `Ctrl`-`LMB`.

### Color

Settings to determine the color of strokes.

See [Color](../tool_settings/color.xhtml)
user: Describe Noise from the Blender manual or Python API, including usage steps and snippets.

assistant: # Noise

[image reference removed]

Noise Texture panel.

Although this looks great, it is not Perlin Noise! This is a true, randomly generated Noise.
This gives a different result every time, for every frame, for every pixel.
user: Provide the full official documentation entry for Separate Color Node, preserving all code examples.

assistant: # Separate Color Node

[image reference removed]

The *Separate Color Node* splits an image into its composite color channels.
The node can output multiple [Color Models](../../../glossary/index.html#term-Color-Model) depending on the Mode property.
user: Describe Bpy.Types.Fileselectparams from the Blender manual or Python API, including usage steps and snippets.

assistant: eys bpy_struct.path_from_id bpy_struct.path_from_module bpy_struct.path_resolve bpy_struct.pop bpy_struct.property_overridable_library_set bpy_struct.property_unset bpy_struct.rna_ancestors bpy_struct.type_recast bpy_struct.values References ¶ SpaceFileBrowser.params UILayout.template_file_select_path Next Float2Attribute(Attribute) Previous FileSelectIDFilter(bpy_struct) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page FileSelectParams(bpy_struct) FileSelectParams FileSelectParams.directory FileSelectParams.display_size FileSelectParams.display_size_discrete FileSelectParams.display_type FileSelectParams.filename FileSelectParams.filter_glob FileSelectParams.filter_id FileSelectParams.filter_search FileSelectParams.list_column_size FileSelectParams.list_display_size FileSelectParams.recursion_level FileSelectParams.show_details_datetime FileSelectParams.show_details_size FileSelectParams.show_hidden FileSelectParams.sort_method FileSelectParams.title FileSelectParams.use_filter FileSelectParams.use_filter_asset_only FileSelectParams.use_filter_backup FileSelectParams.use_filter_blender FileSelectParams.use_filter_blendid FileSelectParams.use_filter_folder FileSelectParams.use_filter_font FileSelectParams.use_filter_image FileSelectParams.use_filter_movie FileSelectParams.use_filter_script FileSelectParams.use_filter_sound FileSelectParams.use_filter_text FileSelectParams.use_filter_volume FileSelectParams.use_library_browsing FileSelectParams.use_sort_invert FileSelectParams.bl_rna_get_subclass() FileSelectParams.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.material_slot`](bpy.context.html#bpy.context.material_slot "bpy.context.material_slot") | - [`Object.material_slots`](bpy.types.Object.html#bpy.types.Object.material_slots "bpy.types.Object.material_slots") |
user: How do I use Introduction in Blender? Include parameters, examples, warnings and best practices.

assistant: # Introduction

*Sculpt Mode* is similar to *Edit Mode* in that it is used to alter the shape of a drawing,
but Sculpt Mode uses a very different workflow:
Instead of dealing with individual elements (points and edit lines),
an area of the model is altered using a brush.
In other words, instead of selecting a group of points,
Sculpt Mode manipulates the drawing in the brush region of influence.
user: Show practical ways to work with Status Messages in a Blender add-on or script – include code.

assistant: The middle of the Status Bar displays information about in-progress operations.

[image reference removed]

Running Task
:   Shows the progress of the currently running task (such as rendering or baking).
    Hovering the mouse pointer over the progress bar will display a time estimate.
    The task can be aborted by clicking the cancel button ().

Report Message
:   Informational messages or warnings, such as after saving a file.
    They disappear after a short time.
    Click them to show the full message in the [Info Editor](../../editors/info_editor.xhtml).
user: Give a detailed overview of Working With Actions: syntax, arguments, return values, common patterns.

assistant: When you first animate an object (or other data-block) in Blender, Blender tries
to automatically find an appropriate action for it, or if it can’t find an
appropriate action then it will create one. After an action has been assigned,
it also creates and assigns a new slot for the data-block.

Blender uses heuristics to try to find an appropriate action, based on the
idea that animation of closely related data-blocks should typically go in the
same action. For example, an object and its data are considered closely related,
so if a camera object is already animated and you insert keys for its
[focal length](../glossary/index.xhtml#term-Focal-Length) (which lives on the camera data, *not* the
camera object), the action that’s assigned to the object will be reused for the
camera data as well. These relationships go both ways, so the action will also
be reused when keying the camera object if the camera data is already animated.

Some examples of other data-blocks that are considered closely related for this
purpose are: materials and their embedded node trees, worlds and their embedded
node trees, and meshes and their shape key data.

### Manually Assigning Actions and Slots

In addition to letting Blender automatically choose an action and slot for a
data-block, you can also manually assign them. This can be used to assign
existing animation to a data-block by selecting both the action and slot. It can
also be used to specify an action for a data-block’s keys to go into, by
assigning the action but leaving the slot blank, in which case a new slot will
be created when the first key is set.

For each data-block in the properties editor there is an Animation panel with
action and slot selectors. You can use these to assign actions and slots to a
data-block.

[image reference removed]

The action and slot selector for Camera data in the
[Properties Editor](../editors/properties_editor.xhtml).

For the active object you can also assign its action and slot in the action
Editor’s header.

[image reference removed]

The action and slot selector for the active object (in this case a camera object) in the
[Action Editor](../editors/dope_sheet/modes/action.xhtml).

When you select an action to animate a data-block, for convenience Blender
attempts to automatically select an appropriate slot for you based on name and
associated type. If no appropriate slot is found then the slot selector will
remain empty, in which case you can manually select an existing slot, create a
new one, or just start keying and let Blender automatically create a new slot
for you. If Blender assigns a slot you didn’t want, you can select another slot
manually or simply clear the slot selection.

### NLA

Actions can also be assigned to NLA strips within a data-block’s NLA system.
Please see the documentation for the [NLA Editor](../editors/nla/introduction.xhtml)
for how to animate data-blocks via the NLA system.
user: How do I use Gizmos in Blender? Include parameters, examples, warnings and best practices.

assistant: The *Split* node provides an interactive gizmo in the Node Editor.
To enable it, make sure [Active Node Gizmo](../../../editors/compositor.xhtml#bpy-types-spacenodeeditor-show-gizmo-active-node)
is turned on, then select the *Split* node.

The gizmo displays a split line with draggable handles:

- Drag the line to adjust the split *position* horizontally or vertically.
- Use the circular handle at the center to adjust the *rotation* interactively.
user: Explain Displace Modifier in complete detail according to the official Blender documentation.

assistant: # Displace Modifier

The *Displace* modifier displaces vertices in a mesh based on the intensity of a texture.
Either procedural or image textures can be used.

The displacement can be along a particular local axis, along the vertex normal,
or the separate RGB components of the texture can be used to displace vertices in the local X,
Y and Z directions simultaneously (sometimes referred to as *Vector Displacement*).
user: How do I use Lightgroup(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # Lightgroup(bpy_struct)

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

*class* bpy.types.Lightgroup(*bpy_struct*)
:   name
    :   Name of the Lightgroup

        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 Using Gizmos in Blender? Include parameters, examples, warnings and best practices.

assistant: Node inputs that can be controlled with a gizmo have an additional icon.
The gizmos of that node are shown if it is selected.
Clicking on the icon pins the gizmo, so that it is shown even if the node is not selected.
Modifying the gizmo in the 3D viewport, modifies the value in the socket.

[image reference removed]

Example of a node group that has gizmos.

Gizmos are often automatically propagated when an input socket with a gizmo is linked.
The gizmo then controls the value that it is propagated to, instead of the input of the node group directly.
Not all nodes support propagating gizmos, but many math operations do.
A double link indicates that the propagation was successful.

[image reference removed]

The gizmo is propagated from the Size X input socket to the Value node.

Gizmos can also be propagated to Group Inputs, in which case they are also available on the parent group node.
If the current group is used by a modifier directly, the gizmo will also be available on the modifier.
Gizmos that are propagated to the modifier always show when the modifier is active, independent of whether any node
is visible or selected.
user: How do I use Transforms in Blender? Include parameters, examples, warnings and best practices.

assistant: Applying transforms resets an object’s *Location*, *Rotation*, or *Scale* values
while visually keeping the object in place.
In practice, this means:

- The object’s origin is moved to the global origin (for location).
- Rotation values are cleared to zero.
- Scale values are reset to 1.0.

The geometry itself is adjusted so that the object continues to appear unchanged in the 3D Viewport
and final render.

For simple cases you may not notice a difference,
but applying transforms can affect how modifiers, constraints, and parenting behave,
since they often depend on an object’s transform values.

### Options

Location
:   Apply (set) the location of the selection.
    This will make Blender consider the current location to be equivalent to 0 in each plane
    i.e. the selection will not move, the current location will be considered to be the “default location”.
    The object origin will be set to actual (0, 0, 0) (where the colored axis lines intersect in each view).

Rotation
:   Apply (set) the rotation of the selection.
    This will make Blender consider the current rotation to be equivalent to 0 degrees in each plane
    i.e. the selection will not rotated, the current rotation will be considered to be the “default rotation”.

Scale
:   Apply (set) the scale of the selection.
    This will make Blender consider the current scale to be equivalent to 0 in each plane
    i.e. the selection will not scaled, the current scale will be considered to be the “default scale”.

Rotation & Scale
:   Apply (set) the rotation and scale of the selection. Do the above two applications simultaneously.

Apply Properties
:   Modify properties such as curve vertex radius, font size and bone envelope
    according to the applied transformation. (Found in the [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel)
user: Explain GreasePencilTreeNode(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # GreasePencilTreeNode(bpy_struct)

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

subclasses —
[`GreasePencilLayer`](bpy.types.GreasePencilLayer.html#bpy.types.GreasePencilLayer "bpy.types.GreasePencilLayer"), [`GreasePencilLayerGroup`](bpy.types.GreasePencilLayerGroup.html#bpy.types.GreasePencilLayerGroup "bpy.types.GreasePencilLayerGroup")

*class* bpy.types.GreasePencilTreeNode(*bpy_struct*)
:   Grease Pencil node in the layer tree. Either a layer or a group

    channel_color
    :   Color of the channel in the dope sheet

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

    hide
    :   Set tree node visibility

        Type:
        :   boolean, default False

    lock
    :   Protect tree node from editing

        Type:
        :   boolean, default False

    name
    :   The name of the tree node

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

    next_node
    :   The layer tree node after (i.e. above) this one

        Type:
        :   [`GreasePencilTreeNode`](#bpy.types.GreasePencilTreeNode "bpy.types.GreasePencilTreeNode"), (readonly)

    parent_group
    :   The parent group of this layer tree node

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

    prev_node
    :   The layer tree node before (i.e. below) this one

        Type:
        :   [`GreasePencilTreeNode`](#bpy.types.GreasePencilTreeNode "bpy.types.GreasePencilTreeNode"), (readonly)

    select
    :   Tree node is selected

        Type:
        :   boolean, default False

    use_masks
    :   The visibility of drawings in this tree node is affected by the layers in the masks list

        Type:
        :   boolean, default False

    use_onion_skinning
    :   Display onion skins before and after the current frame

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

assistant: Splines are the fundamental components of curve objects, defining their shapes.
A curve object can consist of multiple splines,
similar to how a mesh object can contain multiple disconnected meshes.
Each spline’s shape is determined by its [Control Points](#curve-spline-types).
Splines come in several types: Poly, Bézier, and NURBS, each with its own algorithm for representing curves,
as described in the [Spline Types](#spline-types) section.

Splines have unique properties that can be adjusted in Edit Mode via the
[Active Spline](properties/active_spline.xhtml) panel.

### Control Points

Splines are made up of control points, which connect to form the spline.
Control points can be [selected](selecting.xhtml) and transformed to adjust the spline’s shape.
This is analogous to vertices in a mesh object.
user: Give a detailed overview of Annotation(ID): syntax, arguments, return values, common patterns.

assistant: # Annotation(ID)

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

*class* bpy.types.Annotation(*ID*)
:   Freehand annotation sketchbook

    animation_data
    :   Animation data for this data-block

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

    layers
    :   Type:
        :   [`AnnotationLayers`](bpy.types.AnnotationLayers.html#bpy.types.AnnotationLayers "bpy.types.AnnotationLayers") [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`AnnotationLayer`](bpy.types.AnnotationLayer.html#bpy.types.AnnotationLayer "bpy.types.AnnotationLayer"), (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: Show practical ways to work with Troubleshooting Linux – Intel in a Blender add-on or script – include code.

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

assistant: For real-time discussion, we have [chat.blender.org](https://chat.blender.org) which uses [Blender ID](https://id.blender.org) for authentication.

You can join these channels:

- [#general](https://chat.blender.org/#/room/#general:blender.org)
  For general chat with the community.
- [#blender-coders](https://chat.blender.org/#/room/#blender-coders:blender.org)
  For developers to discuss Blender development.
- [#python](https://chat.blender.org/#/room/#python:blender.org)
  For support for developers using the Python API.
- [#docs](https://chat.blender.org/#/room/#docs:blender.org)
  For discussion related to Blender’s documentation.
- [#translations](https://chat.blender.org/#/room/#translations:blender.org)
  For discussion related to translating Blender and its documentation.
user: Describe Prune Grid Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Prune Grid Node

[image reference removed]

The *Prune Grid* node optimizes the storage of a voxel grid by collapsing
uniform regions into coarser tiles or inner nodes, reducing memory usage and
improving performance.

This node performs the inverse operation of the
[Voxelize Grid](voxelize_grid.xhtml) node.
While voxelization expands sparse tiles into dense voxels, pruning
detects large uniform areas and replaces them with more compact representations.
This is especially useful after operations that create large
regions of constant values, such as filling, clipping, or thresholding.
user: Provide the full official documentation entry for Curve Display, preserving all code examples.

assistant: # Curve Display

When in Edit Mode, curves have special [overlays](../../editors/3dview/display/overlays.xhtml)
to control how curves are displayed in the 3D Viewport.

Handles
:   Controls the visibility of Bézier curve handles in edit mode.

    None:
    :   Hides all Bézier curve handles, providing an unobstructed view of the curve.

    Selected:
    :   Displays the handles only for selected control points.

    All:
    :   Displays the handles for all control points in the curve.

Normals
:   Toggles the display of the curve normals.

    Normal Size
    :   Length of the axis that points the direction of the normal.
user: What is Linked Duplicate and how is it used in Blender Python scripting?

assistant: Creates copies of the selected strips, reusing any actions they reference.
Editing the keyframes in a copied strip therefore also affects the original
(and vice versa). Blender warns you about this by highlighting the other strip in red.

[image reference removed]

Linked duplicated strip being edited.
user: How do I use Getting Started in Blender? Include parameters, examples, warnings and best practices.

assistant: Before contributing, you need an account at [projects.blender.org](https://projects.blender.org/).
Click the “Sign In” button and follow the prompts to create an account if you don’t already have one.

Once logged in, you can start editing directly from your browser.
user: Give a detailed overview of Combine Transform Node: syntax, arguments, return values, common patterns.

assistant: # Combine Transform Node

[image reference removed]

The *Combine Transform* node combines a translation vector,
a rotation vector, and a scale vector into a [Transformation Matrix](../../../../glossary/index.xhtml#term-Transformation-Matrix).
user: Explain Enabling Add-on in complete detail according to the official Blender documentation.

assistant: This add-on is enabled by default. In case it is not:

1. Open Blender and go to [Add-ons](../../editors/preferences/addons.html) section of the [Preferences](../../editors/preferences/index.html).
2. Search “UV Layout” and check the *Enable Add-on* checkbox.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Geometry
:   The input geometry containing the hair curves to trim.

Scale Uniform
:   When enabled, each curve is scaled uniformly to reach the target length.
    When disabled, trimming is applied progressively from root to tip.

Length Factor
:   Multiplies the original curve length by this factor.
    A value of 1.0 keeps the hair at its original length, while 0.5 halves it.

Replace Length
:   When enabled, the *Length* input fully replaces the original curve length
    instead of scaling it by the *Length Factor*.

Length
:   The target length for the operation.
    Used when *Replace Length* is enabled.

Mask
:   A per-curve mask that modulates the overall trimming effect.
    A value of 0.0 disables trimming for that curve, while 1.0 applies the full effect.

Random Offset
:   Adds random variation to the trimmed length of each curve,
    creating more natural-looking hair variation.

Pin at Parameter
:   Specifies a parameter along each curve to act as a pivot or anchor point during trimming.
    The trimming operation is performed relative to this point.

Seed
:   Sets the random seed used for the random offset.
    Changing this value produces different trimming variations while maintaining the same parameters.
user: Provide the full official documentation entry for NODE_FH_image_node(FileHandler), preserving all code examples.

assistant: # NODE_FH_image_node(FileHandler)

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Faces & Edges by Vertices, preserving all code examples.

assistant: *Faces & Edges by Vertices* is similar to *Faces by Edges* except that
it also splits the vertices of the adjacent connecting edges.
This has the same functionality as manually ripping all faces and edges away from a vertex.

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_mesh_split_faces-before.png>   Before. | <../../../../_images/modeling_meshes_editing_mesh_split_faces-after.png>   After (also moving edges away). |
user: Provide the full official documentation entry for Flip, preserving all code examples.

assistant: This will reverse the normals direction of all selected faces.
Note that this allows you to precisely control the direction
(**not** the orientation, which is always perpendicular to the face) of your normals,
as only the selected faces are flipped.
user: Give a detailed overview of FunctionNodeMatchString(FunctionNode): syntax, arguments, return values, common patterns.

assistant: # FunctionNodeMatchString(FunctionNode)

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

*class* bpy.types.FunctionNodeMatchString(*FunctionNode*)
:   Check if a given string exists within another string

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

assistant: # Python Scripting

The Python Scripting mode offers full programmable line stylizes.
In this control mode, all styling operations are written as Python scripts referred to as
style modules in the Freestyle terminology. The input to a style module is a view map
(i.e. a set of detected feature edges), and the output is a set of stylized strokes.

A style module is composed of successive calls of five basic operators: selection, chaining,
splitting, sorting and stroke creation. The selection operator identifies a subset of input
feature edges based on one or more user-defined selection conditions (predicates).
The selected edges are processed with the chaining,
splitting and sorting operators to build chains of feature edges. These operators are also
controlled by user-supplied predicates and functions in order to determine how to transform
the feature edges into chains. Finally, the chains are transformed into stylized strokes
by the stroke creation operator, which takes a list of user-defined stroke shaders.

Python style modules are stored within blend-files as text data-blocks.
External style module files first need to be loaded in the Text Editor.
Then the select menu within an entry of the style module stack
allows you to select a module from the list of loaded style modules.

[image reference removed]

A screen capture of a style module `cartoon.py` loaded in the Text Editor (left),
as well as Freestyle options in the Python Scripting mode in the View Layers buttons (right).

Freestyle for Blender comes with a number of Python style modules that can serve as a starting
point of your own style module writing. See also the section of the Freestyle Python API in
the Blender Python API reference manual for the full detail of style module constructs.

|  |  |
| --- | --- |
| ../../_images/render_freestyle_python_scripting-mode-example-1.jpg   By T.K. using the Python Scripting mode ([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Turning_Pages.zip), CC0). | ../../_images/render_freestyle_python_scripting-mode-example-2.png   By T.K. using the Python Scripting mode ([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Lily_Broken_Topology.zip), CC0). |