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

assistant: # GeometryNodeDistributePointsOnFaces(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.GeometryNodeDistributePointsOnFaces(*GeometryNode*)
:   Generate points spread out on the surface of a mesh

    distribute_method
    :   Method to use for scattering points

        - `RANDOM`
          Random – Distribute points randomly on the surface.
        - `POISSON`
          Poisson Disk – Distribute the points randomly on the surface while taking a minimum distance between points into account.

        Type:
        :   enum in [`'RANDOM'`, `'POISSON'`], default `'RANDOM'`

    use_legacy_normal
    :   Output the normal and rotation values that have been output before the node started taking smooth normals into account

        Type:
        :   boolean, default False

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

assistant: # NodeSocketVectorDirection(NodeSocketStandard)

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

*class* bpy.types.NodeSocketVectorDirection(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

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

    links
    :   List of node links from or to this socket.

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Storyboarding, preserving all code examples.

assistant: # Storyboarding

Storyboarding in Blender provides a flexible way to plan, visualize, and iterate on shots before production begins.
It combines 2D drawing, 3D layout, and video editing tools into a single, non-destructive workflow.

Using Blender, artists can create storyboards directly inside the same environment used for layout, animation, and
rendering. This allows early creative decisions about composition, timing, and camera movement to remain consistent
throughout production.

A typical storyboarding setup in Blender involves:

- **Multiple Scenes:** Each scene represents an individual shot or camera setup, keeping assets and timelines organized.
- **Grease Pencil Drawings:** Used to sketch story panels directly in 3D space or over cameras for quick visual blocking.
- **Video Sequence Editor:** Combines scene strips, sound, and timing adjustments into a complete sequence.
- **Linked Assets:** Enables reuse of characters, props, and sets across multiple scenes, ensuring visual consistency.
- **Asset Libraries and Overrides:** Provide a structured way to manage shared resources across a production.

This workflow bridges the gap between 2D storyboarding and 3D previsualization, supporting both traditional drawn
storyboards and 3D layout boards (often called “3D animatics”). It scales from solo projects to collaborative pipelines,
where multiple artists contribute to shots, layout, and editorial in parallel.

Blender’s integrated design means that storyboards, timing edits, and scene data remain connected. Changes to a camera,
pose, or Grease Pencil drawing automatically update in the edit—streamlining revisions and enabling rapid iteration
from concept to final animation.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Swirl Visual Effect.

Object
:   Sets the object to use as the center of the swirl.

Radius
:   External radius size of the swirl.

Angle
:   Rotation angle of the swirl. A value of 0 shows no swirl.
user: Explain Bpy Extras.Io Utils in complete detail according to the official Blender documentation.

assistant: is_conversion() axis_conversion_ensure() create_derived_objects() poll_file_object_drop() unpack_list() unpack_face_list() path_reference() path_reference_copy() unique_name() bpy_extras.io_utils.ExportHelper bpy_extras.io_utils.ExportHelper.check() bpy_extras.io_utils.ExportHelper.invoke() bpy_extras.io_utils.ImportHelper bpy_extras.io_utils.ImportHelper.check() bpy_extras.io_utils.ImportHelper.invoke() bpy_extras.io_utils.ImportHelper.invoke_popup()
user: Show practical ways to work with Splash Screen in a Blender add-on or script – include code.

assistant: When Blender is configured for a particular studio or a project, it can be
helpful to customize the splash screen so artists know which version they
are running.

The `BLENDER_CUSTOM_SPLASH` [environment variable](command_line/arguments.html#command-line-args-environment-variables)
replaces the entire splash image, while `BLENDER_CUSTOM_SPLASH_BANNER`
only overlays a banner.
user: Describe Collections from the Blender manual or Python API, including usage steps and snippets.

assistant: While the *scene collection* contains all the Scene’s objects,
the user can also make their own collections to better organize these objects.

It works like a Venn diagram, where all the objects are part of the *scene collection*,
but can also be part of multiple collections.

[image reference removed]

Venn diagram.

The result is a clear and flexible way to arrange objects together on the Scene level.

[image reference removed]

Scene organization.
user: Explain Select Random in complete detail according to the official Blender documentation.

assistant: # Select Random

Adds random items to the selection. The [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last)
panel offers the following options:

Ratio
:   The ratio of items that should end up selected, e.g. 0.5 to select half of all items
    (that are not [hidden](../../../scene_layout/object/editing/show_hide.xhtml)).

    Note that the existing selection is ignored: if half of the items are already selected,
    setting *Ratio* to 0.1 won’t deselect anything, nor will it select 10% of the unselected
    items. Instead, it always picks 10% of *all* visible items and adds them to the selection.

Random Seed
:   A number that influences which specific items get picked.

Action
:   Select:
    :   Add random items to the selection.

    Deselect:
    :   Remove random items from the selection.
user: Describe Snap Target from the Blender manual or Python API, including usage steps and snippets.

assistant: Determines the target which the selection will be snapped to.

Increment:
:   Snaps to grid points. When in Orthographic view, the snapping increment changes depending on the zoom level.

    This option snaps to an imaginary grid that starts at the selection’s original location and has the same
    resolution as the viewport grid. In other words, it lets you move the selection in “increments” of the
    grid cell size.

Grid:
:   Snaps to the grid that’s displayed in the viewport.

Vertex:
:   Snaps to the vertex that’s closest to the mouse cursor.

Edge:
:   Snaps to the edge that’s closest to the mouse cursor.

Face:
:   Snaps to the surfaces of faces in mesh objects; This is useful for retopologizing.

Volume:
:   Snaps the selection to a depth that’s centered *inside* the object under the cursor.
    This is useful for positioning an [Armature](../../../animation/armatures/introduction.html)
    bone so it’s centered inside a character’s arm, for example; the other snapping options
    would place it on the arm’s surface instead.

    While Blender also has [Volume objects](../../../modeling/volumes/introduction.html), this option
    is not related to those.

Edge Center:
:   Snaps to the centerpoint of the edge that’s closest to the mouse cursor.

Edge Perpendicular:
:   Snaps to a specific point on the edge so that the line from the selection’s original location
    (indicated by a white cross) to its new location is perpendicular to that edge.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`GreasePencilFrames.copy`](bpy.types.GreasePencilFrames.html#bpy.types.GreasePencilFrames.copy "bpy.types.GreasePencilFrames.copy") - [`GreasePencilFrames.move`](bpy.types.GreasePencilFrames.html#bpy.types.GreasePencilFrames.move "bpy.types.GreasePencilFrames.move") - [`GreasePencilFrames.new`](bpy.types.GreasePencilFrames.html#bpy.types.GreasePencilFrames.new "bpy.types.GreasePencilFrames.new") | - [`GreasePencilLayer.current_frame`](bpy.types.GreasePencilLayer.html#bpy.types.GreasePencilLayer.current_frame "bpy.types.GreasePencilLayer.current_frame") - [`GreasePencilLayer.frames`](bpy.types.GreasePencilLayer.html#bpy.types.GreasePencilLayer.frames "bpy.types.GreasePencilLayer.frames") - [`GreasePencilLayer.get_frame_at`](bpy.types.GreasePencilLayer.html#bpy.types.GreasePencilLayer.get_frame_at "bpy.types.GreasePencilLayer.get_frame_at") |
user: Give a detailed overview of Transparency: syntax, arguments, return values, common patterns.

assistant: The [Transparent BSDF](../../shader_nodes/shader/transparent.xhtml) shader is given
special treatment. Rays pass straight through it, changing neither direction nor type
as if there were no geometry at all.

Alpha pass output is also different for the transparent
BSDF.
Other transmission BSDFs are considered opaque,
because they change the light direction. As such they cannot be used for
alpha-over compositing, while this is possible with the transparent BSDF.

Note that, while semantically the ray passes through as if no geometry was hit,
rendering performance is affected as each transparency step requires executing the shader and tracing a ray.
user: Describe Grease Pencil from the Blender manual or Python API, including usage steps and snippets.

assistant: Converts the selected curve, mesh, or text object to a Grease Pencil object, generating strokes
that follow the original shape. Basic materials are also created.
When multiple objects are selected, they are combined into a single Grease Pencil object.

Keep Original
:   Keeps the original object by creating a duplicate before conversion.

Thickness
:   Defines the stroke thickness.

Stroke Offset
:   Adjusts the offset to separate strokes from filled areas.

Export Faces
:   Converts mesh faces into filled strokes.
user: Explain Blend from Shape in complete detail according to the official Blender documentation.

assistant: # Blend from Shape

The *Blend from Shape* operator blends the current mesh towards the vertex positions
stored in a [Shape Key](../../../../animation/shape_keys/index.xhtml).
This allows you to reuse existing shape keys to partially or fully reshape geometry in *Edit Mode*.

This is useful for:

- Correcting or refining geometry by borrowing deformations from a shape key.
- Copying specific shape features into a mesh while editing.
- Mixing shapes interactively without leaving Edit Mode.
user: Show practical ways to work with Bpy.Types.Modifier in a Blender add-on or script – include code.

assistant: ridable_library_set bpy_struct.property_unset bpy_struct.rna_ancestors bpy_struct.type_recast bpy_struct.values References ¶ Object.modifiers ObjectModifiers.active ObjectModifiers.new ObjectModifiers.remove Next ModifierViewerPathElem(ViewerPathElem) Previous MirrorModifier(Modifier) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page Modifier(bpy_struct) Modifier Modifier.execution_time Modifier.is_active Modifier.is_override_data Modifier.name Modifier.persistent_uid Modifier.show_expanded Modifier.show_in_editmode Modifier.show_on_cage Modifier.show_render Modifier.show_viewport Modifier.type Modifier.use_apply_on_spline Modifier.use_pin_to_last Modifier.bl_rna_get_subclass() Modifier.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Explain ThemeRegionsAssetShelf(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # ThemeRegionsAssetShelf(bpy_struct)

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

*class* bpy.types.ThemeRegionsAssetShelf(*bpy_struct*)
:   Theme settings for asset shelves

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: For objects of type curve, surface, mesh and lattice,
there is the possibility to use one of its vertices or points as the parent of other objects.
You can parent an object to a single vertex or a group of three vertices as well;
that way the child/children will move when the parent mesh is deformed.

### Vertex Parent from Edit Mode

In *Object Mode*, select the child/children and then the parent object.
`Tab` into *Edit Mode* and on the parent object select either one vertex
that defines a single point, or select three vertices that define an area
(the three vertices do not have to form a complete face;
they can be any three vertices of the parent object),
and then press `Ctrl`-`P` and confirm.

At this point, if a single vertex was selected,
a relationship/parenting line will be drawn from the vertex to the child/children. If three
vertices were selected then a relationship/parenting line is drawn from the averaged center of
the three points (of the parent object) to the child/children. Now,
as the parent mesh deforms and the chosen parent vertex/vertices move,
the child/children will move as well.

### Vertex Parent from Object Mode

Vertex parenting can be performed from Object Mode,
this is done like regular object parenting,
press `Ctrl`-`P` in Object Mode and select *Vertex* or *Vertex (Triangle)*.

The nearest vertices will be used from each object which is typically what you would want.

Vertex Parent example.

|  |  |  |
| --- | --- | --- |
| <../../../_images/scene-layout_object_editing_parent_object-mode-example-1.png>   The small cubes can each be automatically parented to a triad of nearby vertices on the icosphere using the “Vertex (Triangle)” in the set parent context menu. | <../../../_images/scene-layout_object_editing_parent_object-mode-example-2.png>   Reshaping the object in Edit Mode then means each of the cubes follows their vertex parent separately. | <../../../_images/scene-layout_object_editing_parent_object-mode-example-3.png>   Scaling the parent icosphere in Object Mode means the child cubes are also scaled as expected. |

The parent context menu item means users can rapidly set up a large number of vertex parent
relationships,
and avoid the tedious effort of establishing each parent-child vertex relationship separately.
user: What is BuildModifier(Modifier) and how is it used in Blender Python scripting?

assistant: # BuildModifier(Modifier)

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

*class* bpy.types.BuildModifier(*Modifier*)
:   Build effect modifier

    frame_duration
    :   Total time the build effect requires

        Type:
        :   float in [1, 1.04857e+06], default 100.0

    frame_start
    :   Start frame of the effect

        Type:
        :   float in [-1.04857e+06, 1.04857e+06], default 1.0

    seed
    :   Seed for random if used

        Type:
        :   int in [1, 1048574], default 0

    use_random_order
    :   Randomize the faces or edges during build

        Type:
        :   boolean, default False

    use_reverse
    :   Deconstruct the mesh instead of building it

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

assistant: # StripProxy(bpy_struct)

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

*class* bpy.types.StripProxy(*bpy_struct*)
:   Proxy parameters for a sequence strip

    build_100
    :   Build 100% proxy resolution

        Type:
        :   boolean, default False

    build_25
    :   Build 25% proxy resolution

        Type:
        :   boolean, default False

    build_50
    :   Build 50% proxy resolution

        Type:
        :   boolean, default False

    build_75
    :   Build 75% proxy resolution

        Type:
        :   boolean, default False

    build_record_run
    :   Build record run time code index

        Type:
        :   boolean, default False

    directory
    :   Location to store the proxy files

        Type:
        :   string, default “”, (never None, blend relative `//` prefix supported)

    filepath
    :   Location of custom proxy file

        Type:
        :   string, default “”, (never None, blend relative `//` prefix supported)

    quality
    :   Quality of proxies to build

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

    timecode
    :   Method for reading the inputs timecode

        - `NONE`
          None – Ignore generated timecodes, seek in movie stream based on calculated timestamp.
        - `RECORD_RUN`
          Record Run – Seek based on timestamps read from movie stream, giving the best match between scene and movie times.
        - `RECORD_RUN_NO_GAPS`
          Record Run No Gaps – Effectively convert movie to an image sequence, ignoring incomplete or dropped frames, and changes in frame rate.

        Type:
        :   enum in [`'NONE'`, `'RECORD_RUN'`, `'RECORD_RUN_NO_GAPS'`], default `'NONE'`

    use_overwrite
    :   Overwrite existing proxy files when building

        Type:
        :   boolean, default False

    use_proxy_custom_directory
    :   Use a custom directory to store data

        Type:
        :   boolean, default False

    use_proxy_custom_file
    :   Use a custom file to read proxy data from

        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 Gravity, preserving all code examples.

assistant: Factor
:   Setting the factor allows you to add gravity to your brush strokes,
    giving it a draping effect.

Orientation
:   Using another object, the gravity can be oriented to the set object’s local Z axis,
    changing the direction of the gravity.
user: Describe BlendDataActions(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # BlendDataActions(bpy_struct)

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

*class* bpy.types.BlendDataActions(*bpy_struct*)
:   Collection of actions

    new(*name*)
    :   Add a new action to the main database

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – New name for the data-block

        Returns:
        :   New action data-block

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

    remove(*action*, *\**, *do_unlink=True*, *do_id_user=True*, *do_ui_user=True*)
    :   Remove an action from the current blendfile

        Parameters:
        :   - **action** ([`Action`](bpy.types.Action.html#bpy.types.Action "bpy.types.Action"), (never None)) – Action to remove
            - **do_unlink** (*boolean**,* *(**optional**)*) – Unlink all usages of this action before deleting it
            - **do_id_user** (*boolean**,* *(**optional**)*) – Decrement user counter of all data-blocks used by this action
            - **do_ui_user** (*boolean**,* *(**optional**)*) – Make sure interface does not reference this action

    tag(*value*)
    :   tag

        Parameters:
        :   **value** (*boolean*) – Value

    *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 Playhead, preserving all code examples.

assistant: [image reference removed]

Playhead.

The *Playhead* is the blue vertical line showing the current frame number.

It can be moved to a new position by clicking or
dragging `LMB` in the scrubbing area at the top or by
click and drag `Shift`-`RMB` anywhere in the timeline.

While dragging it can snap to elements of the editor in which it is dragged.
- Seconds
- Frames
- Markers
- Strips
- Keys

It is only possible to snap to elements that are visible in the editor in which the playhead is dragged.
For example having “Strips” enabled but dragging in the Graph Editor will do nothing.
Snapping can be toggled during scrubbing by holding down `Ctrl`.

Snapping to seconds or frames can have a custom increment for example snapping to every third frame.
This is always relative to the first frame of the scene and ignores the preview range.
In contrast to the other snapping options, seconds and frames will always snap to the closest position,
regardless of the snap distance set. When mixing options, the system will first try to snap to
elements that are snapped by distance. Only if no element is close enough will it snap to seconds or frames.

You can also move it in single-frame increments by pressing `Left` or `Right` or `Alt`-`Wheel`.
To jump to the beginning or end frame (of the ends of the preview range if that is active)
press `Shift`-`Left` or `Shift`-`Right`.

### Snapping

Playhead snapping helps you position the playhead precisely when scrubbing the timeline
by snapping it to specific elements like frames, markers, or keyframes.

Use Snapping
:   Enables or disables snapping behavior when moving the playhead.

Snap Distance
:   The maximum distance (in pixels) the playhead can be from a target before snapping to it.

Snap Target
:   Specifies which elements the playhead can snap to:

    Frames:
    :   Snap to frame intervals.

    Seconds:
    :   Snap to second intervals.

    Markers:
    :   Snap to timeline markers.

    Keyframes:
    :   Snap to animation keyframes.

    Strips:
    :   Snap to the start and end points of strips (e.g. in the Video Sequencer).

Frame Step Frames
:   The interval in frames between each snap point when using the *Frames* target.

Second Step Seconds
:   The interval in seconds between each snap point when using the *Seconds* target.
user: What is Examples and how is it used in Blender Python scripting?

assistant: ### bpy.context

This module gives you access to the current scene,
the currently selected objects, the current object mode, and so on.

[image reference removed]

Get the current 3D Viewport mode (Object, Edit, Sculpt, etc.):

```
bpy.context.mode
```

Get the active object:

```
bpy.context.object
bpy.context.active_object
```

Change the active object’s X coordinate to 1:

```
bpy.context.object.location.x = 1
```

Move the active object by 0.5 along the X axis:

```
bpy.context.object.location.x += 0.5
```

Change all three location coordinates in one go:

```
bpy.context.object.location = (1, 2, 3)
```

Change only the X and Y coordinates:

```
bpy.context.object.location.xy = (1, 2)
```

Get the selected objects:

```
bpy.context.selected_objects
```

Get the selected objects excluding the active one:

```
[obj for obj in bpy.context.selected_objects if obj != bpy.context.object]
```

### bpy.data

Gives you access to all the data in the blend-file,
regardless of whether it’s currently active or selected.

[image reference removed]

### bpy.ops

“Operators” are actions that are normally triggered from a button or menu item
but can also be called programmatically. See the
[bpy.ops](https://docs.blender.org/api/current/bpy.ops.html)
API documentation for a list of all operators.
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Phase
:   Volume scattering phase function.

    Henyey-Greenstein:
    :   Simple and widely used phase function, useful for approximating scattering in biological tissues.

    Fournier-Forand:
    :   Cycles Only
        Suitable for modeling the scattering of light in underwater environments.

    Draine:
    :   Cycles Only
        Suitable for modeling the scattering of interstellar dust.

    Rayleigh:
    :   Cycles Only
        Describes the scattering by particles with a size smaller than the wavelength of light,
        such as the scattering of sunlight in earth’s atmosphere.

    Mie:
    :   Cycles Only
        Describes the scattering by particles with a size larger than the wavelength of light, such as cloud and fog.

[image reference removed]

Volume scattering phase as a function of angles between the incoming and the outgoing direction,
in logarithmic scale. Light comes from the left side.
user: How do I use Introduction in Blender? Include parameters, examples, warnings and best practices.

assistant: # Introduction

View Layers allow you to separate a render into multiple layers, which can then be composited together.
This is useful for rendering scene elements independently—such as characters, lighting variations, or background
elements—without duplicating the entire scene or re-rendering everything after each change.

For example, you can:

- Apply different compositing effects to foreground and background elements.
- Render characters separately from the environment for post-processing.
- Generate multiple lighting passes without modifying the original scene setup.

View Layers also improve performance and flexibility during iteration by letting you re-render only the layers
that have changed.

[image reference removed]

View Layers and collections.

Each View Layer references a combination of [Collections](../../scene_layout/collections/introduction.xhtml),
which define the visibility, selectability, and contribution of scene objects in the final render.
Multiple View Layers can use the same or different collections, allowing for tailored layer setups.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeViewer.active_item`](bpy.types.GeometryNodeViewer.html#bpy.types.GeometryNodeViewer.active_item "bpy.types.GeometryNodeViewer.active_item") - [`GeometryNodeViewer.viewer_items`](bpy.types.GeometryNodeViewer.html#bpy.types.GeometryNodeViewer.viewer_items "bpy.types.GeometryNodeViewer.viewer_items") | - [`NodeGeometryViewerItems.new`](bpy.types.NodeGeometryViewerItems.html#bpy.types.NodeGeometryViewerItems.new "bpy.types.NodeGeometryViewerItems.new") - [`NodeGeometryViewerItems.remove`](bpy.types.NodeGeometryViewerItems.html#bpy.types.NodeGeometryViewerItems.remove "bpy.types.NodeGeometryViewerItems.remove") |
user: Provide the full official documentation entry for GeometryNodeSDFGridFillet(GeometryNode), preserving all code examples.

assistant: # GeometryNodeSDFGridFillet(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.GeometryNodeSDFGridFillet(*GeometryNode*)
:   Round off concave internal corners in a signed distance field. Only affects areas with negative principal curvature, creating smoother transitions between surfaces

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

assistant: # Harmonic

In a *Harmonic* force field,
the source of the force field is the zero point of a harmonic oscillator (spring, pendulum).
If you set the *Damping* parameter to 1,
the movement is stopped in the moment the object is reached.
This force field is really special if you assign it to particles.
user: Describe Transform from the Blender manual or Python API, including usage steps and snippets.

assistant: - Move `G`
- Rotate `R`
- Scale `S`
- Shear `Shift`-`Ctrl`-`Alt`-`S`

Axis Locking

Transformations can be locked to an axis by pressing `X` or `Y` after one of the transform tools.
Also, holding the `MMB` will constrain movement to the X or Y axis.

### Vertex Slide

Vertex Slide will transform a vertex along one of its adjacent edges.
Use `Shift`-`V` to activate tool.
The nearest selected vertex to the mouse cursor will be the control one.
Move the mouse along the direction of the desired edge to specify the vertex position.
Then press `LMB` to confirm the transformation.

Factor
:   Determines the amount of slide performed.
    Negative values correspond to slides toward one vertex, while positive ones, refer to the other one.

Even `E`
:   By default, the offset value of the vertices is a percentage of the edges length along which they move.
    When Even mode is active, the vertices are shifted by an absolute value.

Flipped `F`
:   When Flipped is active, vertices move the same distance from adjacent vertices,
    instead of moving from their original position.

Clamp `Alt` or `C`
:   Toggle clamping the slide within the edge extents.

### Edge Slide

Slides one or more edges across adjacent faces with a few restrictions involving the selection
of edges (i.e. the selection *must* define a valid loop, see below).

Factor
:   Determines the amount of slide performed.
    Negative values correspond to slides toward one face, while positive ones, refer to the other one.

Even `E`
:   Forces the edge loop to match the shape of the adjacent edge loop.
    You can flip to the opposite vertex using `F`.

Flipped `F`
:   When Even mode is active, this flips between the two adjacent edge loops the active edge loop will match.

Clamp `Alt` or `C`
:   Toggle clamping the slide within the edge extents.

Mirror Editing
:   Lets you propagate the operation to the symmetrical elements of the mesh (if present, in local X direction).
user: What is Light Path Node and how is it used in Blender Python scripting?

assistant: # Light Path Node

[image reference removed]

The *Light Path* node is used to find out for which kind of incoming ray the shader is being executed;
particularly useful for non-physically-based tricks. More information about the meaning of each type
is in the [Light Paths](../../cycles/render_settings/light_paths.xhtml) documentation.
user: Explain Remesh in complete detail according to the official Blender documentation.

assistant: # Remesh

For a general explanation to remeshing, visit the [Introduction](../introduction/adaptive.html).

Voxel Size `R`
:   The resolution or the amount of detail the remeshed mesh will have.
    The value is used to define the size, in object space, of the [Voxel](../../../glossary/index.html#term-Voxel).
    These voxels are assembled around the mesh and are used to determine the new geometry.
    For example a value of 0.5m will create topological patches that are about 0.5m
    (assuming *Preserve Volume* is enabled).
    Lower values preserve finer details but will result in a mesh with a much more dense topology.

    The voxel size also be adjusted from the 3D Viewport using `R`.
    Using the shortcut displays an interactive grid overlay showing the resulting voxel size.
    Moving the mouse closer to center of the grid decreases the voxel size
    while moving away from the center increase the voxel size.
    Holding `Shift` increases the precision; adjusting the voxel size in small increments.

    Sample Voxel Size
    :   Used to adjust the *Voxel Size* by picking an area of the mesh
        to match the denseness of polygons after the remesh operation.

Adaptivity
:   Reduces the final face count by simplifying geometry where detail is not needed.
    This introduce triangulation to faces that do not need as much detail.
    Note, an *Adaptivity* value greater than zero disables *Fix Poles*.

Fix Poles
:   Tries to produce less [poles](../../../glossary/index.html#term-Pole) at the cost of some performance to produce a better topological flow.

Preserve
:   Volume
    :   Tells the algorithm to try to preserve the original volume of the mesh.
        Enabling this could make the operator slower depending on the complexity of the mesh.

    Paint Mask
    :   Reprojects the [paint mask](../editing/mask.html#sculpt-mask-menu) onto the new mesh.

    Face Sets
    :   Reprojects [Face Sets](../editing/face_sets.html#sculpting-editing-facesets) onto the new mesh.

    Color Attributes
    :   Reprojects the [Color Attributes](../../../modeling/meshes/properties/object_data.html#modeling-meshes-properties-object-data-color-attributes) onto the
        new mesh.

Voxel Remesh
:   Performs the remeshing operation to create a new manifold mesh based on the volume of the current mesh.
    Performing this will lose all mesh object data layers associated with the original mesh.
user: Provide the full official documentation entry for Hints, preserving all code examples.

assistant: ### Offset Calculation

The transformation applied from one copy to the next is calculated as the sum of the three
different components (*Relative*, *Constant* and *Object*),
each of which can be enabled/disabled independently of the others. This allows, for example,
a relative offset of (1.0, 0.0, 0.0) and a constant offset of (0.1, 0.0, 0.0),
giving an array of objects neatly spaced along the X axis with a constant 0.1
unit between them, whatever the original object’s size.
user: Show practical ways to work with Weight Paint Tools in a Blender add-on or script – include code.

assistant: # Weight Paint Tools

For Grease Pencil Weight Paint modes each brush type is exposed as a tool,
the brush can be changed in the Tool Settings.
See [Brush](tool_settings/brush.html) for more information.

[image reference removed]

Brush
:   Tool to use for any of the weight paint [brushes](brushes.html).

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

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

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

    [Annotate Eraser](../../../interface/annotate_tool.html#tool-annotate-eraser)
    :   Erase previous drawn annotations.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Distribution
:   Sheen shading model.

    Ashikhmin:
    :   Classic Ashikhmin velvet, used in Blender versions prior to 4.0

    Microfiber:
    :   Microflake-based model of multiple scattering between normal-oriented fibers.
user: How do I use ShaderNodeVolumeInfo(ShaderNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ShaderNodeVolumeInfo(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.ShaderNodeVolumeInfo(*ShaderNode*)
:   Read volume data attributes from volume grids

    *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 Import OBJ Node in a Blender add-on or script – include code.

assistant: # Import OBJ Node

[image reference removed]

The *Import OBJ* node loads geometry data from a .obj file and outputs it as instances.

Each object defined in the OBJ file is imported as a separate instance,
which helps to preserve scene structure and optimize performance.
This approach allows for efficient manipulation and reuse of the geometry within Geometry Nodes workflows.

This node is useful for importing static 3D assets created in other modeling software.
user: Give a detailed overview of Getting Started: syntax, arguments, return values, common patterns.

assistant: Manual links

The following links take you from the basics to the more advanced
concepts of Python scripting for Blender.

- [Text Editor](../../editors/text_editor.html)
- [Python Console](../../editors/python_console.html)
- [Info Editor](../../editors/info_editor.html)

External links

Here are external links containing a lot of good information
to start learning how to write scripts for Blender:

- [Python API: Quickstart](https://docs.blender.org/api/current/info_quickstart.html)
- [CG Cookie: Blender 2.8 Python Scripting Superpowers for Non-Programmers](https://cgcookie.com/posts/blender-2-8-python-scripting-superpowers-for-non-programmers)
- [Olav3D Tutorials: 3D Programming for Beginners Using Python](https://www.youtube.com/watch?v=rHzf3Dku_cE)
- [Blender Artists: Python Support Forum](https://blenderartists.org/c/coding/python-support)
user: Explain RaytraceEEVEE(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # RaytraceEEVEE(bpy_struct)

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

*class* bpy.types.RaytraceEEVEE(*bpy_struct*)
:   Quality options for the raytracing pipeline

    denoise_bilateral
    :   Blur the resolved radiance using a bilateral filter

        Type:
        :   boolean, default True

    denoise_spatial
    :   Reuse neighbor pixels’ rays

        Type:
        :   boolean, default True

    denoise_temporal
    :   Accumulate samples by reprojecting last tracing results

        Type:
        :   boolean, default True

    resolution_scale
    :   Determines the number of rays per pixel. Higher resolution uses more memory.

        - `1`
          1:1 – Full resolution.
        - `2`
          1:2 – Render this effect at 50% render resolution.
        - `4`
          1:4 – Render this effect at 25% render resolution.
        - `8`
          1:8 – Render this effect at 12.5% render resolution.
        - `16`
          1:16 – Render this effect at 6.25% render resolution.

        Type:
        :   enum in [`'1'`, `'2'`, `'4'`, `'8'`, `'16'`], default `'2'`

    screen_trace_quality
    :   Precision of the screen space ray-tracing

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

    screen_trace_thickness
    :   Surface thickness used to detect intersection when using screen-tracing

        Type:
        :   float in [1e-06, inf], default 0.2

    trace_max_roughness
    :   Maximum roughness to use the tracing pipeline for. Higher roughness surfaces will use fast GI approximation. A value of 1 will disable fast GI approximation.

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

    use_denoise
    :   Enable noise reduction techniques for raytraced effects

        Type:
        :   boolean, default True

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type