PGCRYPT/OpenBlender_Train huggingface dataset:
user: Give a detailed overview of Avoid Problematic Footage: syntax, arguments, return values, common patterns.

assistant: The 2D stabilizer can not work miracles; some flaws simply can not be fixed satisfactory.
Notorious issues are motion blur, rolling shutter, pumping autofocus and moving compression artifacts.
Especially if you do succeed with basic stabilization, such image flaws become yet the more noticeable and annoying.
When on set or on location, it might be tempting to “fix matters in post production”.
Resist that deception, it rarely works out well.

- Prefer a short exposure time to avoid motion blur.
  While motion blur is good to render filmed movements more smooth and natural,
  it seriously impedes the ability to track features precisely.
  As a guideline, try to get at least to 1/250 s.
- Prefer higher frame rates. The more *temporal resolution* the stabilizer has to work on, the better the results.
  If you have the option to choose between progressive and interlaced modes, by all means use interlaced
  and deinterlace the footage to the *doubled frame rate*. This can be done with
  the [yadif](https://ffmpeg.org/ffmpeg-filters.html#yadif-1) filter of FFmpeg: use the mode 1 (`send_field`).
- Beware of the [Rolling Shutter](../../../../../glossary/index.xhtml#term-Rolling-Shutter) effect. Avoid fast lateral movements.
  If you can, prefer a camera which produces less rolling shutter.
  Also, using a higher frame rate reduces the amount of rolling shutter; another reason to prefer
  interlaced over progressive for the purpose at hand.
- Switch off autofocus.
  Better plan your movement beforehand, set a fixed focus and rely on depth of field through using a small aperture.
  Pumping movements might not be so noticeable to the human observer, but the feature tracking tends to slide away
  on defocused image elements; fixing this manually after the fact can cause a huge waste of time.
- Increase the lighting level, at least use a higher sensitivity.
  This helps to set a fast shutter speed plus a small aperture.
  Better lighting and good exposure also help to reduce the impact of compression artifacts.
  If you can, also select a codec with less data reduction, better color space, etc.
  Inevitably, we’re loosing some quality through the interpolation necessary for stabilization.
  Plus we’re loosing some quality due to color space conversion.
user: What is Rendering From The Command Line and how is it used in Blender Python scripting?

assistant: # Rendering From The Command Line

In some situations we want to increase the render speed,
access Blender remotely to render something or build scripts that use the command line.

One advantage of using the command line is that we do not need a graphical display
(no need for X server on Linux for example)
and consequently we can render via a remote shell (typically SSH).

- See [Command Line Arguments](arguments.xhtml)
  for a full list of arguments
  (for example to specify which scene to render, the end frame number, etc.), or simply run:

```
blender --help
```

- See [Command Line Launching](launch/index.xhtml#command-line-launch-index)
  for specific instructions on launching Blender from the command line.
user: Describe Resize from the Blender manual or Python API, including usage steps and snippets.

assistant: Adjusts the image dimensions by scaling its pixel resolution. This is useful for various tasks, such as:

- Reducing texture resolution to optimize performance and memory usage.
- Increasing image resolution for more detailed painting or editing.

Size X, Y
:   Defines the new width and height of the image in pixels.

All UDIM Tiles
:   Applies the resizing operation to all UDIM tiles in the image.
user: What is Outline and how is it used in Blender Python scripting?

assistant: The *Outline* operator converts selected Grease Pencil strokes into closed perimeter shapes.
It creates new strokes around the outer boundary of the original stroke,
effectively generating a filled outline with adjustable thickness.

View
:   Defines the projection method used to generate the outline:

    View:
    :   Use the current viewport perspective as the projection plane.

    Front:
    :   Use the X-Z axes as the projection plane (front view).

    Side:
    :   Use the Y-Z axes as the projection plane (side view).

    Top:
    :   Use the X-Y axes as the projection plane (top view).

    Camera:
    :   Use the active camera’s perspective as the projection plane.

Radius
:   Sets the thickness of the outline on both sides of the original stroke.
    Higher values result in a wider perimeter.

Offset Factor
:   Scales the stroke outline inward or outward.
    - Positive values push the perimeter outward.
    - Negative values pull it inward.
    - A value of 0 centers the perimeter on the original stroke.

Corner Subdivisions
:   Number of subdivisions used to smooth corners at stroke endpoints and joints.
    Higher values result in smoother corners but increase stroke complexity.

|  |  |
| --- | --- |
| ../../../_images/grease-pencil_modes_edit_stroke-menu_outline-1.png   Original stroke. | ../../../_images/grease-pencil_modes_edit_stroke-menu_outline-2.png   Stroke after applying the *Outline* operator. |
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Segment Coordinates
:   Segment coordinates for texture mapping within each radial segment.

Segment ID
:   Unique ID for every radial segment startiing at 0 and increasing counterclockwise by 1 for every for each segment.

Segment Width
:   Relative width of each radial segment. May be used to scale textures to fit into each segment.

Segment Rotation
:   Counterclockwise rotation of each segment coordinate system. May be used to align the rotation of the textures of each segment.
user: Give a detailed overview of Screen Space Effects: syntax, arguments, return values, common patterns.

assistant: Ray-triangle intersection is not currently supported.
Instead of this, EEVEE uses the depth buffer as an approximated scene representation.
This reduces the complexity of scene scale effects and enables a higher performance.
However, only what is in inside the view can be considered when computing these effects.
Also, since it only uses one layer of depth, only the front-most pixel distance is known.

These limitations creates a few problems:

- The screen space effects disappear when reaching the screen border.
  This can be partially fixed by using the *overscan* feature.
- Screen space effects lack deep information (or the thickness of objects).
  This is why most effects have a thickness parameter to control how to consider potential intersected pixels.
- Objects behind other objects (occluded) are not considered by these effects.
- Blended surfaces are not considered by these effects.
  They are not part of the depth prepass and do not appear in the depth buffer.
- Objects that a part of [Holdout Collections](../../../editors/outliner/editing.xhtml#bpy-ops-outliner-collection-holdout-set)
  will not be rendered with screen space effects.

### Raytracing

- Blended materials and materials using raytrace refractions will not appear in dithered materials reflections.
- Blended materials are not compatible with raytracing.
- Only one refraction event is correctly modeled.
  An approximation of the second refraction event can be achieved using the
  [Thickness workflow](../material_settings.xhtml#eevee-materials-thickness).
- Only dithered materials *not* using Raytrace Refractions can be refracted.
user: Provide the full official documentation entry for Group Output, preserving all code examples.

assistant: # Group Output

[image reference removed]

The *Group Output* node defines the final output of a node group.
It determines which values are passed out of the node group to the parent node tree
(or to the renderer, in the case of the Compositor).

In the Compositor, this node defines the image result that is sent to the renderer or to
image output after rendering.

This node is updated automatically after each evaluation or render,
and updates interactively when connected inputs are changed—provided that all inputs are fully evaluated.
user: How do I use CompositorNodePlaneTrackDeform(CompositorNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CompositorNodePlaneTrackDeform(CompositorNode)

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

*class* bpy.types.CompositorNodePlaneTrackDeform(*CompositorNode*)
:   Replace flat planes in footage by another image, detected by plane tracks from motion tracking

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

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

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Merge by Distance: syntax, arguments, return values, common patterns.

assistant: Merges the selected vertices that are closer to each other than a certain distance.

Merge Distance
:   Vertices closer than this distance will be merged.

Unselected
:   Allow merging selected vertices with unselected ones.

Sharp Edges
:   Mark edges as [sharp](../edge/edge_data.html#bpy-ops-mesh-mark-sharp) if they have split
    [custom normals](../../structure.html#modeling-meshes-normals-custom).
user: Provide the full official documentation entry for Bpy.Types.Preferencesexperimental, preserving all code examples.

assistant: erencesExperimental.use_sculpt_texture_paint PreferencesExperimental.use_shader_node_previews PreferencesExperimental.use_undo_legacy PreferencesExperimental.use_viewport_debug PreferencesExperimental.write_legacy_blend_file_format PreferencesExperimental.bl_rna_get_subclass() PreferencesExperimental.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: What is Displacement and how is it used in Blender Python scripting?

assistant: # Displacement

Detail can be added to the shape of a surface with displacement shaders.

To create displacement, connect a [Displacement](../../shader_nodes/displacement/displacement.xhtml)
or [Vector Displacement](../../shader_nodes/displacement/vector_displacement.xhtml) node
to the displacement input of the Material Output node. Procedural, painted or baked textures can
then be connected to these nodes.

[image reference removed]

Typical displacement node setup.

Three displacement methods exist, with varying accuracy, performance and memory usage.
The displacement method can be set per material in the
[Material Settings](../../eevee/material_settings.xhtml#bpy-types-material-displacement-method).

[image reference removed]

Bump only, displacement only, and displacement and bump combined.
user: How do I use Bézier Curve in Blender? Include parameters, examples, warnings and best practices.

assistant: # Bézier Curve

The *Bézier Curve* modifier replaces the stroke by a Bézier approximation of it.

Error
:   The maximum distance allowed between the new Bézier curve and the original stroke.

[image reference removed]

Bézier Curve modifier demo by T.K.
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Toycar_bezier.zip)).
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeForeachGeometryElementOutput.generation_items`](bpy.types.GeometryNodeForeachGeometryElementOutput.html#bpy.types.GeometryNodeForeachGeometryElementOutput.generation_items "bpy.types.GeometryNodeForeachGeometryElementOutput.generation_items") |  |
user: Describe Make Group from the Blender manual or Python API, including usage steps and snippets.

assistant: Creates a new node group that contains all selected nodes.

*Group Input* and *Group Output* nodes will be created to represent connections to unselected nodes outside the group.
Inputs will be routed to the *Group Input* and outputs routed to the *Group Output*.

When grouping a **single node**, the resulting node group will:

- Preserve the interface of the original node, including panels and default values.
- Inherit the name of the original node

When grouping **multiple nodes**, the group is created with inputs and outputs sockets generated from the connections.
In this case, a generic name such as “NodeGroup”, “NodeGroup.001”, etc. is used.
user: Show practical ways to work with Grease Pencil Object Modes in a Blender add-on or script – include code.

assistant: # Grease Pencil Object Modes

Object Modes allow editing different aspects of Grease Pencil objects.
These modes are specifically tailored to the Grease Pencil object,
unlike the more general modes, which work for other object types
(with the exception of object mode which is the same for all objects).

Draw Mode is where new strokes are created.
Strokes are directly sketched on a canvas, using different tools and brushes.

Sculpt Mode can be used to deform and shape existing strokes more organically.
Strokes can be smoothed, deformed, or reshaped, adding fluidity and dynamism to drawings.

Edit Mode allows modifying individual strokes and points of Grease Pencil objects.
This mode is ideal for fine-tuning linework, adjusting shapes, and refining details.

Vertex Paint Mode allows adding color the vertices of strokes directly.
This mode is useful for adding shading, gradients, or detailed color effects
providing finer control over the drawing’s appearance.

Weight Paint Mode allows assigning vertex weights to strokes.
This is crucial for rigging and animating characters, ensuring smooth,
and precise deformations based on the painted weights.

This mode allows working with the entire Grease Pencil object as a whole.
It’s used for overall transformations and managing the placement of the object within the scene.
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Dimensions
:   The dimensions of the space to evaluate the noise in.

    1D:
    :   Evaluate the noise in 1D space at the input *W*.

    2D:
    :   Evaluate the noise in 2D space at the input *Vector*. The Z component is ignored.

    3D:
    :   Evaluate the noise in 3D space at the input *Vector*.

    4D:
    :   Evaluate the noise in 4D space at the input *Vector* and the input *W* as the fourth dimension.

Normalize
:   If enabled, ensures that the output values stay in the range 0.0 to 1.0.
    When disabled, output values are in the range -1.0 to 1.0.

Type
:   Type of Noise texture, with different ways to combine octaves.

    FBM:
    :   Fractal Brownian motion, produces a homogeneous and isotropic result.
        Values from octaves are added together.

    Multifractal:
    :   More uneven, varying by location similar to real terrain.
        Values from octaves are multiplied together.

    Hybrid Multifractal:
    :   Creates peaks and valleys with different roughness values, like real mountains rise out of flat plains.
        Combines octaves using both addition and multiplication.

    Ridged Multifractal:
    :   Creates sharp peaks. Calculates the absolute value of the noise,
        creating “canyons”, and then flips the surface upside down.

    Hetero Terrain:
    :   Similar to *Hybrid Multifractal* creates a heterogeneous terrain, but with the likeness of river channels.
user: Explain Select More/Less in complete detail according to the official Blender documentation.

assistant: Their purpose, based on the currently selected control points, is to reduce or enlarge this selection.

More
:   For each selected control point, select *all* its linked points (i.e. one or two…).

Less
:   For each selected control point, if *all* points linked to this point are selected, keep this one selected.
    Otherwise, deselect it.

This implies two points:

1. When *all* control points of a curve are selected, nothing will happen
   (as for *Less*, all linked points are always selected, and of course, *More* cannot add any).
   Conversely, the same goes when no control points are selected.
2. Second, these tools will never “go outside” of a curve
   (they will never “jump” to another curve in the same object).
user: How do I use Delete Keyframes in Blender? Include parameters, examples, warnings and best practices.

assistant: There are several methods of removing keyframes:

- In the 3D Viewport or Video Sequencer Preview press `Alt`-`I` to remove keys from selected objects, bones or strips
  on the current frame.
- When the mouse is over a value, press `Alt`-`I`.
- `RMB` a value and choose *Delete Keyframe* from the menu.
user: Describe LineStyleGeometryModifier_Polygonalization(LineStyleGeometryModifier) from the Blender manual or Python API, including usage steps and snippets.

assistant: # LineStyleGeometryModifier_Polygonalization(LineStyleGeometryModifier)

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

*class* bpy.types.LineStyleGeometryModifier_Polygonalization(*LineStyleGeometryModifier*)
:   Modify the stroke geometry so that it looks more ‘polygonal’

    error
    :   Maximum distance between the original stroke and its polygonal approximation

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Geometry Modifier Type Items](bpy_types_enum_items/linestyle_geometry_modifier_type_items.html#rna-enum-linestyle-geometry-modifier-type-items), default `'2D_OFFSET'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        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](#bpy.types.LineStyleGeometryModifier_Polygonalization.type "bpy.types.LineStyleGeometryModifier_Polygonalization.type")
user: What is Inputs and how is it used in Blender Python scripting?

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

Surface Input Type
:   Determines how the surface data is provided for interpolation.

    Object:
    :   Use an object reference to provide the surface.

    Geometry:
    :   Use a geometry input directly connected to the surface mesh.

Surface
:   The surface object used as the attachment base for the interpolated curves.
    Its transforms must match those of the modifier object.

Surface UV Map
:   The UV map used to find attachment locations for the interpolated curves on the surface.

Surface Rest Position
:   When enabled, sets the surface mesh to its rest position before attaching curves.
    This ensures consistent root positions when deformation is applied afterward.

Follow Surface Normal
:   When enabled, aligns the interpolated curves with the surface normal at their root attachment point.

Part by Mesh Islands
:   When enabled, treats separate mesh islands on the surface as independent regions for interpolation,
    preventing cross-blending of guides between disconnected areas.

Interpolation Guides
:   The number of nearest guide curves used to interpolate the shape of each new curve.
    Higher values result in smoother transitions but may slightly reduce performance.

Distance to Guides
:   The maximum distance from a guide curve within which interpolation occurs.
    Curves outside this range will not influence the result.

### Distribution

Distribution Method
:   Determines how root points for interpolated curves are distributed across the surface.

    Random:
    :   Distributes roots randomly across the surface.

    Poisson Disk:
    :   Uses Poisson disk sampling to maintain a minimum distance between root points,
        producing an even and natural distribution.

Density
:   The number of interpolated hair curves generated per unit of surface area.
    Higher values increase the total hair density.

Density Mask
:   A scalar factor used to locally scale the curve density across the surface.

Mask Texture
:   Uses an image texture to control which areas of the surface generate hair.
    The image is sampled using the *Surface UV Map* input.

Viewport Amount
:   A factor used to reduce curve density in the viewport for performance optimization.
    This does not affect the final render density.

Seed
:   Sets the random seed for the interpolation and distribution processes.
    Changing this value generates a different random distribution while maintaining the same parameters.
user: What is Grids and how is it used in Blender Python scripting?

assistant: The [List View](../../interface/controls/templates/list_view.xhtml#ui-list-view) shows the grids in the OpenVDB-file, listing their name and data type.
A “grid” is a set of volumetric data, which typically stores the density of each voxel
but can also contain temperatures, velocities and so on.

Click a grid to make the volume object display it.
user: Show practical ways to work with Curve to Mesh Node in a Blender add-on or script – include code.

assistant: # Curve to Mesh Node

[image reference removed]

The Curve to Mesh node converts all splines of a curve to a mesh.
Optionally, a profile curve can be provided to give the curve a custom shape.

The node transfers attributes to the result. Attributes that are built-in on meshes but not curves,
like `sharp_face`, will be transferred to the correct domain as well.
user: Give a detailed overview of R: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [**Radiosity**](glossary/index.html#term-Radiosity) - [**Random Seed**](glossary/index.html#term-Random-Seed) - [**Ray Tracing**](glossary/index.html#term-Ray-Tracing) - [**Real User**](glossary/index.html#term-Real-User) - [**Refraction**](glossary/index.html#term-Refraction) - [**Render**](glossary/index.html#term-Render) - [**Resource**](glossary/index.html#term-Resource) - [**Rest Pose**](glossary/index.html#term-Rest-Pose) - [**RGB**](glossary/index.html#term-RGB) - [**Rig**](glossary/index.html#term-Rig) - [Rigid Body Constraints](physics/rigid_body/constraints/introduction.html#index-1)   - [Fixed Constraint](physics/rigid_body/constraints/types/fixed.html#index-0)   - [Generic Constraint](physics/rigid_body/constraints/types/generic.html#index-0)   - [Generic Spring Constraint](physics/rigid_body/constraints/types/generic_spring.html#index-0)   - [Hinge Constraint](physics/rigid_body/constraints/types/hinge.html#index-0)   - [Motor Constraint](physics/rigid_body/constraints/types/motor.html#index-0)   - [Piston Constraint](physics/rigid_body/constraints/types/piston.html#index-0)   - [Point Constraint](physics/rigid_body/constraints/types/point.html#index-0)   - [Slider Constraint](physics/rigid_body/constraints/types/slider.html#index-0) | - [**Roll**](glossary/index.html#term-Roll) - [**Roll Angle**](glossary/index.html#term-Roll-Angle) - [**Rolling Shutter**](glossary/index.html#term-Rolling-Shutter) - [**Roughness Map**](glossary/index.html#term-Roughness-Map) |
user: How do I use Rip in Blender? Include parameters, examples, warnings and best practices.

assistant: # Rip

The *Rip* tool interactively separates selected UV elements (vertices, edges, or faces) from connected components,
creating a “rip” in the UV map. After the separation, the selection can be moved in the direction of the mouse
pointer, allowing the detached elements to be repositioned interactively.

This is useful for isolating UV islands or unwrapping overlapping elements
without affecting surrounding geometry.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_uv_tools_rip_before.png   Before. | ../../../../_images/modeling_meshes_uv_tools_rip_after.png   After. |
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Equidistant objects being pushed together.

[image reference removed]

Random objects being pushed together.

[image reference removed]

Push (middle) vertices around the 3D cursor compared to Scale (right).
user: Explain User Directories in complete detail according to the official Blender documentation.

assistant: User directories store preferences, startup file, installed extensions,
presets and more. By default these use the standard configuration folders
for each operating system.

### Linux

```
$HOME/.config/blender/5.0/
```

If the `$XDG_CONFIG_HOME` environment variable is set:

```
$XDG_CONFIG_HOME/blender/5.0/
```

### macOS

```
/Users/$USER/Library/Application Support/Blender/5.0/
```

### Windows

```
%USERPROFILE%\AppData\Roaming\Blender Foundation\Blender\5.0\
```

### Portable Installation

When running Blender from a portable drive, it’s possible to keep the configuration
files on the same drive to take with you.

To enable this, create a folder named `portable` at the following locations:

- Windows: Next to the Blender executable, in the unzipped folder
- Linux: Next to the Blender executable, in the unzipped folder
- macOS: Inside the application bundle at `Blender.app/Contents/Resources`

This folder will then store preferences, startup file, installed extensions
and presets.

### Environment Variables

The `BLENDER_USER_RESOURCES` [environment variable](command_line/arguments.html#command-line-args-environment-variables)
can be set to a custom directory to replace the default user directory.
user: Provide the full official documentation entry for face.skin_eye, preserving all code examples.

assistant: Implements a skin system [parent controller](skin.xhtml#rigify-rigs-skin-skin-parents) that manages
two skin chains for the top and bottom eyelids in addition to generating the eye rotation mechanism.

The rig must have two child skin chains with names tagged with `.T` and `.B` symmetry
to mark the top and bottom eyelid, which are connected at their ends forming eye corners.
The chains are rigged to follow the surface of the eye and twist to its normal.

In addition, it creates target controls for aiming the eye, including a master control shared by
all eyes under the same parent rig. The eyelids are rigged to follow the movement of the eyeball
with adjustable influence.

Eyeball and Iris Deforms
:   Generates deform bones for the eyeball and the iris, the latter copying XZ scale from
    the eye target control. The iris is located at the tail of the ORG bone.

Eyelid Detach Option
:   Generates a slider to disable the mechanism that keeps eyelid controls stuck to the surface of the eye.

Split Eyelid Follow Slider
:   Generates two separate sliders for controlling the influence of the eye rotation on X and Z eyelid motion.

Eyelids Follow Default
:   Depending on *Split Eyelid Follow Slider*, specifies the default values for the split follow sliders,
    or fixed factors to be multiplied with the single common follow influence slider value.
user: Show practical ways to work with Checker Deselect in a Blender add-on or script – include code.

assistant: Deselects control points according to a repeating pattern, starting at the active point.
For example, if *Deselected* is set to 2 and *Selected* to 3, the operator will
deselect the first two consecutive points, leave the next three unchanged, deselect
the two that come after those, and so on. This is done in both the “horizontal” and
“vertical” direction of the grid.

Deselected
:   The number of control points to deselect in each pattern repetition.

Selected
:   The number of control points to leave unchanged in each pattern repetition.

Offset
:   Offset from the starting point.
user: Explain ShaderNodeBsdfTranslucent(ShaderNode) in complete detail according to the official Blender documentation.

assistant: # ShaderNodeBsdfTranslucent(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.ShaderNodeBsdfTranslucent(*ShaderNode*)
:   Lambertian diffuse transmission

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

assistant: |  |  |
| --- | --- |
| - [**Saturation**](glossary/index.xhtml#term-Saturation) - [**Scanline**](glossary/index.xhtml#term-Scanline) - [**Scene Referenced**](glossary/index.xhtml#term-Scene-Referenced) - [**Seed**](glossary/index.xhtml#term-Seed) - [**Session**](glossary/index.xhtml#term-Session) - Shader Nodes   - [Color Ramp](render/shader_nodes/color/color_ramp.xhtml#index-0)   - [Combine XYZ](render/shader_nodes/utilities/vector/combine_xyz.xhtml#index-0)   - [Math](render/shader_nodes/utilities/math/math.xhtml#index-0)   - [Menu Switch](render/shader_nodes/utilities/menu_switch.xhtml#index-0)   - [Mix Vector](render/shader_nodes/utilities/vector/mix_vector.xhtml#index-0)   - [Separate XYZ](render/shader_nodes/utilities/vector/separate_xyz.xhtml#index-0) | - [**Shading**](glossary/index.xhtml#term-Shading) - [**Smoothing**](glossary/index.xhtml#term-Smoothing) - [**Specular Light**](glossary/index.xhtml#term-Specular-Light) - [**SSS**](glossary/index.xhtml#term-SSS) - [**Straight Alpha**](glossary/index.xhtml#term-Straight-Alpha) - [**Subdiv**](glossary/index.xhtml#term-Subdiv) - [**Subdividing**](glossary/index.xhtml#term-Subdividing) - [**Subdivision Surface**](glossary/index.xhtml#term-Subdivision-Surface) - [**Subsurface Scattering**](glossary/index.xhtml#term-Subsurface-Scattering) - [**Swing**](glossary/index.xhtml#term-Swing) - [**Swing and Twist**](glossary/index.xhtml#term-Swing-and-Twist) |
user: Describe Bake Object Transform to Grease Pencil from the Blender manual or Python API, including usage steps and snippets.

assistant: Applies all transform animation at Object level within a selected frame range to Grease Pencil object keyframes.

Start Frame, End Frame
:   Start/End frame for the baking process.

Step
:   Frame steps for the baking process.

Only Selected Keyframes
:   Convert only the selected keyframes.

Target Frame
:   Target destination frame for the baked animation.

Projection Type
:   Sets the projection type to use for the converted strokes.
user: What is GeometryNodeImportOBJ(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeImportOBJ(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.GeometryNodeImportOBJ(*GeometryNode*)
:   Import geometry from an OBJ file

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is FloatAttribute(Attribute) and how is it used in Blender Python scripting?

assistant: # FloatAttribute(Attribute)

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

*class* bpy.types.FloatAttribute(*Attribute*)
:   Geometry attribute that stores floating-point values

    data
    :   Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`FloatAttributeValue`](bpy.types.FloatAttributeValue.html#bpy.types.FloatAttributeValue "bpy.types.FloatAttributeValue"), (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: Explain LayerCollection(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # LayerCollection(bpy_struct)

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

*class* bpy.types.LayerCollection(*bpy_struct*)
:   Layer collection

    children
    :   Layer collection children

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

    collection
    :   Collection this layer collection is wrapping

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

    exclude
    :   Exclude from view layer

        Type:
        :   boolean, default False

    hide_viewport
    :   Temporarily hide in viewport

        Type:
        :   boolean, default False

    holdout
    :   Mask out objects in collection from view layer

        Type:
        :   boolean, default False

    indirect_only
    :   Objects in collection only contribute indirectly (through shadows and reflections) in the view layer

        Type:
        :   boolean, default False

    is_visible
    :   Whether this collection is visible for the view layer, take into account the collection parent

        Type:
        :   boolean, default False, (readonly)

    name
    :   Name of this layer collection (same as its collection one)

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

    visible_get()
    :   Whether this collection is visible, take into account the collection parent and the viewport

        Return type:
        :   boolean

    has_objects()
    :   Return type:
        :   boolean

    has_selected_objects(*view_layer*)
    :   Parameters:
        :   **view_layer** ([`ViewLayer`](bpy.types.ViewLayer.html#bpy.types.ViewLayer "bpy.types.ViewLayer")) – View layer the layer collection belongs to

        Return type:
        :   boolean

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

assistant: |  |  |
| --- | --- |
| - [`Object.motion_path`](bpy.types.Object.html#bpy.types.Object.motion_path "bpy.types.Object.motion_path") | - [`PoseBone.motion_path`](bpy.types.PoseBone.html#bpy.types.PoseBone.motion_path "bpy.types.PoseBone.motion_path") |
user: Explain Built-in Keymaps in complete detail according to the official Blender documentation.

assistant: Blender provides two default keymaps:

[Blender](blender_default.xhtml)
:   The default keymap, used throughout this manual.

[Industry Compatible](industry_compatible.xhtml)
:   A keymap that more closely matches the shortcuts of other 3D editing applications.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

The Skin modifier.

Branch Smoothing
:   A branch point is a vertex with three or more connected edges.
    These areas tend to produce more complicated topology, some of which may overlap.
    This setting relaxes the surface around these points,
    with the side effect of shrinking it.

Symmetry
:   These checkboxes are used to keep the output topology symmetrical in their respective axes.
    In other words, using it avoids merging triangles across an axis unless the triangles form a symmetric quad.

Smooth Shading
:   Output faces with smooth shading rather than flat shading.
    The smooth/flat shading of the input geometry is not preserved.

Create Armature
:   Create an armature on top of the object. Each edge becomes a bone.

    This tool does the following:

    1. A new armature object is added with bones matching the input mesh.
       The active selection is switched to the new armature.
    2. Weight groups are added to the input mesh. The Skin modifier propagates these weights to the output as well.
    3. An [Armature](../deform/armature.xhtml) modifier is added directly below the Skin one.
       Note that the Armature modifier is being applied after
       the Skin one because it should only deform the output,
       whereas if it were above, it might change the resulting topology.

Add Skin Data
:   This modifier uses a [custom set of data](#modeling-modifiers-generate-skin-data) in the mesh,
    that is generated automatically when you add the modifier the first time.

    However, you may remove that data, or loose it some way or the other. That operator will generate it again.

Mark/Clear Loose
:   By default, a branch vertex (vertex with three or more connected edges)
    will generate extra edge loops along adjacent edges in order to keep the output tight.
    Branches can be made loose by clicking *Mark Loose*, which will allow the output to stretch between
    all adjacent vertices. This can be disabled again by clicking *Clear Loose*.

Mark Root
:   Marking a vertex as root causes that vertex to be used for calculating rotations for connected limbs.
    Root vertices also affect the armature output, they will be used as the origin for the root bones.

    Each set of connected vertices should have one root node
    (one is selected by default if you do not assign any manually).
    *Mark Root* enforces the one-root per set rule, so it is not necessary to manually unmark roots.

Equalize Radii
:   Makes the skin radii of selected vertices equal on each axis.
user: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

[image reference removed]

The Outliner editor.

The *Outliner* shows the content of the blend-file in a tree. You can use it to:

- Get an overview of the data in the scene.
- Select and deselect objects.
- Make objects unselectable or invisible in the 3D Viewport.
- Exclude objects from rendering.
- Duplicate objects.
- Delete objects.
- Manage parent/child relationships and [collections](../../scene_layout/collections/introduction.xhtml).

Items with an arrow on the left can be expanded. Click it with `LMB` to expand a single item,
drag `LMB` to expand multiple items, or click `Shift`-`LMB` to expand an item recursively.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`Context.gizmo_group`](bpy.types.Context.html#bpy.types.Context.gizmo_group "bpy.types.Context.gizmo_group") | - [`Gizmo.group`](bpy.types.Gizmo.html#bpy.types.Gizmo.group "bpy.types.Gizmo.group") |
user: How do I use WalkNavigation(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # WalkNavigation(bpy_struct)

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

*class* bpy.types.WalkNavigation(*bpy_struct*)
:   Walk navigation settings

    jump_height
    :   Maximum height of a jump

        Type:
        :   float in [0.1, 100], default 0.4

    mouse_speed
    :   Speed factor for when looking around, high values mean faster mouse movement

        Type:
        :   float in [0.01, 10], default 1.0

    teleport_time
    :   Interval of time warp when teleporting in navigation mode

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

    use_gravity
    :   Walk with gravity, or free navigate

        Type:
        :   boolean, default False

    use_mouse_reverse
    :   Reverse the vertical movement of the mouse

        Type:
        :   boolean, default False

    view_height
    :   View distance from the floor when walking

        Type:
        :   float in [0, 1000], default 1.6

    walk_speed
    :   Base speed for walking and flying

        Type:
        :   float in [0.01, 100], default 2.5

    walk_speed_factor
    :   Multiplication factor when using the fast or slow modifiers

        Type:
        :   float in [0.01, 10], default 5.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 Material Settings, preserving all code examples.

assistant: Pass Index
:   Index number for the *Material Index* [render pass](../layers/passes.xhtml).
    This can be used to give a mask to a material which then can be read with
    the [ID Mask Node](../../compositing/types/mask/id_mask.xhtml) in the Compositor.
user: How do I use File Output Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # File Output Node

[image reference removed]

The *File Output* node writes one or more images to disk during rendering or compositing.
Each connected input is saved to the specified directory and filename,
with the frame number appended to create a sequence.
For example: `{Directory}/{File Name}{Socket Name}{frame number}.{extension}`.

This node can be used to:

- Automatically save the final image after a render.
- Save intermediate results from anywhere in the node tree.
- Export multiple render passes or processed outputs directly to files.