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

assistant: # Mesh to Density Grid Node

[image reference removed]

The *Mesh to Density Grid* node converts a mesh into a **density grid**, where
each voxel stores a scalar value representing how far it lies inside or near
the surface of the mesh. This can be used to generate fog volumes, soft-body
representations, or as input to volumetric and field-based effects.

The resulting grid contains smooth gradients that transition from high values
inside the mesh to low values outside, allowing for continuous blending and
sampling operations.
user: Give a detailed overview of Example: syntax, arguments, return values, common patterns.

assistant: |  |  |  |
| --- | --- | --- |
| ../../../_images/physics_cloth_introduction_example1.jpg   Cloth example. | ../../../_images/physics_cloth_introduction_oncarved-wood.jpg   Cloth on carved wooden men (made by motorsep). | ../../../_images/physics_cloth_introduction_example2.jpg   Cloth example. |
user: Show practical ways to work with Adding Shape Keys in a Blender add-on or script – include code.

assistant: When adding a new shape key with the  button next to the list,
the new shape will be a copy of the *Basis* shape,
regardless of the current visible result in the 3D Viewport.

When adding a new shape key via Specials ‣ New Shape from Mix,
the new shape is created from the currently visible vertex configuration
(including the influence of other shape keys).

For facial animation with relative shape keys, a common technique is to first create
a shape key with a complex extreme pose (e.g. *anger* or *surprise*).
You can then break it down into smaller components by applying a temporary vertex group
to the complex shape and creating a copy with *New Shape from Mix*.
This helps reduce conflicts between shape keys that would otherwise produce double effects.

### Relative Shape Keys

1. In *Object Mode*, add a new shape key in the *Shape Key* panel ().
2. *Basis* is the rest shape. “Key 1”, “Key 2”, etc. will be the new shapes.
3. Switch to *Edit Mode*, select “Key 1” in the panel.
4. Modify the mesh as desired (do not add or remove vertices).
5. Select “Key 2”. The mesh resets to the *Basis* shape.
6. Modify “Key 2” as desired, then repeat for additional shape keys.
7. Switch back to *Object Mode*.
8. Adjust the *Value* sliders for “Key 1”, “Key 2”, etc. to blend between shapes.

The example below shows, from left to right: *Basis*, “Key 1”, “Key 2”,
and a mix of “Key 1” (`1.0`) and “Key 2” (`0.8`) in *Object Mode*.

[image reference removed]

Relative shape keys example.

For practical examples, see
[Combining Shape Keys and Drivers](../drivers/workflow_examples.xhtml#shapekey-driver-example).

### Absolute Shape Keys

[image reference removed]

Absolute shape keys workflow.

1. Add a sequence of shape keys as described above.
2. Disable the *Relative* checkbox.
3. Click the *Reset Timing* button.
4. Switch to *Object Mode*.
5. Drag *Evaluation Time* to scrub through the sequence of shapes.
user: Provide the full official documentation entry for Gamma Node, preserving all code examples.

assistant: # Gamma Node

[image reference removed]

Use this node to apply a gamma correction. The node is typically used to convert from gamma encoded to linear
color space, or in the reverse direction with 1/gamma.
user: Describe Action Strips from the Blender manual or Python API, including usage steps and snippets.

assistant: An action strip plays the keyframes inside an [action](../../animation/actions.xhtml).
You can create one using Add ‣ Action. Another way is to click
[Push Down Action](tracks.xhtml#bpy-ops-nla-action-pushdown) in the NLA’s Action Track –
this will create a strip based on the object’s active action.

Multiple strips can reference the same action, so that you can potentially change
multiple parts of the animation by editing a single set of keyframes.

A strip can be shorter than its underlying action, be it through cropping,
speeding up, or both. It can also be longer than its underlying action,
be it through extending, slowing down, or both. See the
[Sidebar](sidebar.xhtml#nla-sidebar-action-clip) for details.
user: Describe Nodes(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # Nodes(bpy_struct)

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

*class* bpy.types.Nodes(*bpy_struct*)
:   Collection of Nodes

    active
    :   Active node in this tree

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

    new(*type*)
    :   Add a node to this node tree

        Parameters:
        :   **type** (*string**,* *(**never None**)*) – Type, Type of node to add (Warning: should be same as node.bl_idname, not node.type!)

        Returns:
        :   New node

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

    remove(*node*)
    :   Remove a node from this node tree

        Parameters:
        :   **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – The node to remove

    clear()
    :   Remove all nodes from this node tree

    *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 ModifierViewerPathElem(ViewerPathElem): syntax, arguments, return values, common patterns.

assistant: # ModifierViewerPathElem(ViewerPathElem)

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

*class* bpy.types.ModifierViewerPathElem(*ViewerPathElem*)
:   modifier_uid
    :   The persistent UID of the modifier

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Advanced Gridlines Only: syntax, arguments, return values, common patterns.

assistant: Advanced coloring options for gridlines.

Color Gridlines
:   Flags:
    :   Color gridlines with flags.

    Highlight Range:
    :   Grid Display Only
        Highlight the cells with values of the displayed grid within the range.
        Values between the *Lower Bound* and *Upper Bound* (inclusive) are considered to be within the range.

        Lower Bound
        :   Lower bound of the highlighting range.

        Upper Bound
        :   Upper bound of the highlighting range.

        Color
        :   Color used to highlight the cells.

        Cell Type
        :   Choose to highlight only a particular type of cells.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Curves
:   The input geometry containing the curves whose control points will be redistributed.

Factor
:   Controls the strength of the redistribution effect.
    A value of 0.0 leaves the curves unchanged, while 1.0 fully applies even spacing.

Feature Awareness
:   Enables a simple feature-preserving algorithm that attempts to maintain
    local curve features and direction changes while redistributing points.
    This helps keep detailed areas or sharp bends more accurate.
user: Explain Bpy.Types.Imageformatsettings in complete detail according to the official Blender documentation.

assistant: tSettings.cineon_black ImageFormatSettings.cineon_gamma ImageFormatSettings.cineon_white ImageFormatSettings.color_depth ImageFormatSettings.color_management ImageFormatSettings.color_mode ImageFormatSettings.compression ImageFormatSettings.display_settings ImageFormatSettings.exr_codec ImageFormatSettings.file_format ImageFormatSettings.has_linear_colorspace ImageFormatSettings.jpeg2k_codec ImageFormatSettings.linear_colorspace_settings ImageFormatSettings.media_type ImageFormatSettings.quality ImageFormatSettings.stereo_3d_format ImageFormatSettings.tiff_codec ImageFormatSettings.use_cineon_log ImageFormatSettings.use_exr_interleave ImageFormatSettings.use_jpeg2k_cinema_48 ImageFormatSettings.use_jpeg2k_cinema_preset ImageFormatSettings.use_jpeg2k_ycc ImageFormatSettings.use_preview ImageFormatSettings.view_settings ImageFormatSettings.views_format ImageFormatSettings.bl_rna_get_subclass() ImageFormatSettings.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Give a detailed overview of PaletteColor(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # PaletteColor(bpy_struct)

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

*class* bpy.types.PaletteColor(*bpy_struct*)
:   color
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    strength
    :   Type:
        :   float in [0, 1], default 0.0

    weight
    :   Type:
        :   float in [0, 1], default 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: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.selected_movieclip_tracks`](bpy.context.html#bpy.context.selected_movieclip_tracks "bpy.context.selected_movieclip_tracks") - [`MovieTracking.tracks`](bpy.types.MovieTracking.html#bpy.types.MovieTracking.tracks "bpy.types.MovieTracking.tracks") - [`MovieTrackingObject.tracks`](bpy.types.MovieTrackingObject.html#bpy.types.MovieTrackingObject.tracks "bpy.types.MovieTrackingObject.tracks") - [`MovieTrackingObjectPlaneTracks.active`](bpy.types.MovieTrackingObjectPlaneTracks.html#bpy.types.MovieTrackingObjectPlaneTracks.active "bpy.types.MovieTrackingObjectPlaneTracks.active") - [`MovieTrackingObjectTracks.active`](bpy.types.MovieTrackingObjectTracks.html#bpy.types.MovieTrackingObjectTracks.active "bpy.types.MovieTrackingObjectTracks.active") - [`MovieTrackingObjectTracks.new`](bpy.types.MovieTrackingObjectTracks.html#bpy.types.MovieTrackingObjectTracks.new "bpy.types.MovieTrackingObjectTracks.new") | - [`MovieTrackingStabilization.rotation_tracks`](bpy.types.MovieTrackingStabilization.html#bpy.types.MovieTrackingStabilization.rotation_tracks "bpy.types.MovieTrackingStabilization.rotation_tracks") - [`MovieTrackingStabilization.tracks`](bpy.types.MovieTrackingStabilization.html#bpy.types.MovieTrackingStabilization.tracks "bpy.types.MovieTrackingStabilization.tracks") - [`MovieTrackingTracks.active`](bpy.types.MovieTrackingTracks.html#bpy.types.MovieTrackingTracks.active "bpy.types.MovieTrackingTracks.active") - [`MovieTrackingTracks.new`](bpy.types.MovieTrackingTracks.html#bpy.types.MovieTrackingTracks.new "bpy.types.MovieTrackingTracks.new") - [`UILayout.template_marker`](bpy.types.UILayout.html#bpy.types.UILayout.template_marker "bpy.types.UILayout.template_marker") |
user: Show practical ways to work with Viewport in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| `Alt`-`LMB` | Orbit View |
| `Alt`-`MMB` | Pan View |
| `Alt`-`RMB` | Zoom View |
| `F1` - `F4` | Front/Side/Top/Camera Viewpoints |
| `F` | Frame Selected |
| `Shift` `F` | Center View to Mouse |
| `A` | Frame All |
user: Provide the full official documentation entry for Getting Started, preserving all code examples.

assistant: # Getting Started

Welcome! This section guides you through contributing to the Blender manual.

Blender’s manual is written in [reStructuredText (RST)](https://www.sphinx-doc.org/en/master/usage/restructuredtext/basics.html),
a straightforward markup language ideal for technical documentation.
You can edit the manual either directly online or by using your local text editor.

All contributions are managed through a collaborative workflow on Blender’s development platform,
[projects.blender.org](https://projects.blender.org/).

You have two options for editing the manual:
user: What is Display Graphics and how is it used in Blender Python scripting?

assistant: Settings that control how Blender draws its user interface and other display graphics.
These options can influence performance and compatibility.

Backend
:   Selects the graphics API used for drawing the interface and rendering display content.

    Changing the backend requires restarting Blender for the change to take effect.

    OpenGL:
    :   Uses the OpenGL backend.
        This is the traditional backend, compatible with a wide range of systems.

    Vulkan:
    :   Uses the Vulkan backend. Vulkan may offer improved performance and better support for modern GPU features,
        but compatibility may vary depending on the system and drivers.

Device Vulkan
:   Specifies which GPU device to use for display drawing operations.

    This setting is useful for systems with multiple GPUs (e.g., integrated + discrete)
    where you want to force Blender to use a specific GPU for UI rendering.

    Changing the backend requires restarting Blender for the change to take effect.

    Auto:
    :   Automatically selects the most appropriate GPU based on system configuration and driver support.
user: Show practical ways to work with Example in a Blender add-on or script – include code.

assistant: [image reference removed]

Top: Suzanne without modifiers. Middle: Suzanne with each type of Cast Modifier (Sphere, Cylinder and Cuboid).
Bottom: Same as above, but now only X axis is enabled.
[Sample blend-file](https://archive.blender.org/wiki/2015/index.php/File:263-Cast-Modifier.blend).
user: Give a detailed overview of Sample Color: syntax, arguments, return values, common patterns.

assistant: Copies the color from any part of the user interfaces and sets it as the active
[Brush Color](../brush/brush_settings.xhtml#bpy-types-brush-color).

- Press `Shift`-`X` to sample a color from the image and set it as the primary brush color.
- In **Texture Paint**, `Shift`-`Ctrl`-`X` samples the **merged viewport color**, while `Shift`-`X`
  :   samples only the currently active texture.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Height
:   Distance to displace the surface along the normal.
    This is where a texture node can be connected.

Midlevel
:   Neutral displacement value that causes no displacement.
    With the default 0.5, any lower values will cause the surfaces to be pushed inwards,
    and any higher values will push them outwards.

Scale
:   Increase or decrease the amount of displacement.

Normal
:   Standard normal input.
user: Give a detailed overview of Star Node: syntax, arguments, return values, common patterns.

assistant: # Star Node

[image reference removed]

The *Star* node generates a poly spline in a star pattern by connecting alternating points of two circles.
The points on the inner circle are offset by a rotation so that they lie in between the points on the outer circle.
This offset can be changed with the twist input.
user: Provide the full official documentation entry for World Operators, preserving all code examples.

assistant: # World Operators

bpy.ops.world.convert_volume_to_mesh()
:   Convert the volume of a world to a mesh. The world’s volume used to be rendered by EEVEE Legacy. Conversion is needed for it to render properly

    File:
    :   [startup/bl_operators/world.py:26](https://projects.blender.org/blender/blender/src/branch/main/scripts/startup/bl_operators/world.py#L26)

bpy.ops.world.new()
:   Create a new world Data-Block
user: Give a detailed overview of Tool Settings: syntax, arguments, return values, common patterns.

assistant: ### Brush Asset

The asset selector can be used to open a pop-up asset browser to select the active brush asset for the tool.

See [Asset Operators](../../../../sculpt_paint/brush/brush_management.xhtml#brush-management-utility-operators) for more information.

### Brush Settings

Radius
:   The radius of the brush in pixels.

    `F` allows you to change the brush size interactively by dragging the pointer or
    by typing a number then confirm.

    (Size Pressure)
    :   Adjusts the radius based on the stylus pressure when using a [Graphics Tablet](../../../../getting_started/configuration/hardware.xhtml#hardware-tablet).

Strength
:   Control how much will affect the eraser has on the stroke transparency (alpha).

    You can change the brush strength interactively by pressing `Shift`-`F`
    in the 3D Viewport and then moving the pointer and then `LMB`.
    You can also enter the size numerically.

    (Strength Pressure)
    :   Adjusts the strength based on the stylus pressure when using a [Graphics Tablet](../../../../getting_started/configuration/hardware.xhtml#hardware-tablet).

Mode
:   Determines how the erase tool behaves.

    Dissolve:
    :   To simulate a raster type eraser, this eraser type
        affects the strength and thickness of the strokes before actually delete a point.

    Point:
    :   Delete one point at a time.

    Stroke:
    :   Delete an entire stroke.

#### Cursor

The cursor can be disabled by toggling the checkbox in the *Cursor* pop-over menu.
user: Give a detailed overview of Field Variance Node: syntax, arguments, return values, common patterns.

assistant: # Field Variance Node

[image reference removed]

The *Field Variance* node computes the variance and standard deviation of a field over a given domain.
This is useful for measuring how much a value varies across geometry or within specific groups.

For example, it can be used to analyze the spread of values like weights, positions, or custom attributes
within each group defined by the *Group ID*.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: Scale
:   Distance factor multiplied by the curve’s radius attribute to define the resulting tube radius.

### Profile

Profile Mode
:   Method used to define the profile shape of the tube.

    Round:
    :   Uses a circular profile to define the tube cross-section.

    Custom:
    :   Uses a custom object or geometry as the profile shape.

Resolution Round
:   The number of points around the circular profile.
    Also defines the resolution of the *Round* cap type.

Profile Input Custom
:   Defines how the custom profile is provided.

    Object:
    :   Uses a single object as the custom profile.

    Geometry:
    :   Uses input geometry directly as the profile.

Object / Geometry Custom
:   The specific object or geometry to use as the profile when *Custom* mode is active.

Shade Smooth
:   Enables smooth shading for the generated mesh.

### Resample

Resamples the input curve before generating the mesh.
This helps achieve evenly distributed geometry and consistent resolution along the tube.

Resample Mode
:   Determines how the curve is resampled.

    Evaluated:
    :   Uses the existing evaluated curve points.

    Auto:
    :   Automatically determines an appropriate sample length based on curve details.

    Count:
    :   Uses a fixed number of sample points.

    Length:
    :   Uses a fixed distance between sample points.

Scale Auto
:   Scale factor applied to the automatically derived resample length when using *Auto* mode.

Count Count
:   Number of sample points along the curve when using *Count* mode.

Length Length
:   Distance between sample points when using *Length* mode.

### Caps

Fills the open ends of the tube with cap geometry.

Caps Type
:   Method used to fill the tube ends.

    Flat:
    :   Uses a single n-gon to cap each end.

    Round:
    :   Uses a half-circle shape for rounded caps.

    Custom:
    :   Uses user-provided geometry or an object as the cap.

Smooth Flat Round
:   Smooths the transition between the tube body and the caps instead of creating a sharp edge.

Caps Input Custom
:   Defines how custom caps are provided.

    Object:
    :   Uses a single object as the custom cap.

    Geometry:
    :   Uses input geometry as the custom cap.

Start / End Custom
:   Specifies the objects or geometry to use for the start and end caps when *Custom* mode is active.

### UV Map

Name
:   The name of the UV map to create or modify on the output mesh.

Parameter U/V
:   Defines how the UVs are generated along the tube.

    Factor:
    :   Uses a normalized 0-1 factor along the curve and profile.

    Length:
    :   Maps UVs based on the real length of the curve and circumference.

    Index:
    :   Uses the point indices along the curve and profile.

Consider Curve Radius
:   When enabled, the UV generation takes into account variations in the curve’s radius.
user: Show practical ways to work with Tips and Tricks in a Blender add-on or script – include code.

assistant: # Tips and Tricks

Here are various suggestions that you might find useful when writing scripts.
Some of these are just Python features that you may not have thought to use with Blender,
others are Blender-specific.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Rotation
:   The [Euler](../../../../glossary/index.xhtml#term-Euler) rotation to align.

Factor
:   Determines how much the points are rotated towards the vector.
    Zero effectively disables the node and one means that the points are aligned with the vector perfectly.

Vector
:   The direction vector that points should be rotated to.
    The vector is in the local space of the object that is being modified.
    When it is all zeros for a point, it is not rotated at all.
user: What is Properties and how is it used in Blender Python scripting?

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

assistant: Device
:   The device used for compositing.

    CPU:
    :   Use the CPU for compositing.

    GPU:
    :   Use the GPU for compositing.

Precision GPU
:   The precision of compositor intermediate result.

    Auto:
    :   Use full precision for final renders, half precision otherwise.

    Full:
    :   Use full precision for final renders and viewport.

### Denoise Nodes

Denoising Device
:   The device to use to process [Denoise nodes](../../../compositing/types/filter/denoise.html) in the compositor.

    Auto:
    :   Use the same device used by the compositor to process the denoise node.

    CPU:
    :   Use the CPU to process the denoise node.

    GPU:
    :   Use the GPU to process the denoise node if available, otherwise fallback to CPU.

Preview Quality
:   The quality used by [Denoise nodes](../../../compositing/types/filter/denoise.html) during viewport
    and interactive compositing of a render if their quality is set to *Follow Scene*.

    High:
    :   Produces the highest quality output at the cost of long processing times.

    Balanced:
    :   Balanced between performance and quality, typically processing in half the time as *High*,
        while retaining most of the quality.

    Fast:
    :   Produces an output quickly at a noticeable cost of quality.

Final Quality
:   The quality used by [Denoise nodes](../../../compositing/types/filter/denoise.html) during the final
    render if their quality is set to *Follow Scene*.

    High:
    :   Produces the highest quality output at the cost of long processing times.

    Balanced:
    :   Balanced between performance and quality, typically processing in half the time as *High*,
        while retaining most of the quality.

    Fast:
    :   Produces an output quickly at a noticeable cost of quality.
user: Provide the full official documentation entry for ParticleSystems(bpy_struct), preserving all code examples.

assistant: # ParticleSystems(bpy_struct)

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

*class* bpy.types.ParticleSystems(*bpy_struct*)
:   Collection of particle systems

    active
    :   Active particle system being displayed

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

    active_index
    :   Index of active particle system slot

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # GeometryNodeInputEdgeSmooth(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.GeometryNodeInputEdgeSmooth(*GeometryNode*)
:   Retrieve whether each edge is marked for smooth or split normals

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

assistant: Mode
:   Inputs to use to control the line.

    Offset:
    :   Specify the offset from one vertex to the next.

    End Points:
    :   Specify the start and end point of the line.

Count Mode
:   Determines how the number of vertices is chosen.
    This is only available when the mode is set to *End Points*.

    Count:
    :   Specify the total number of vertices.

    Resolution:
    :   Specify the distance between vertices.
user: Describe Performance from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Slow Rendering

There are a couple of reasons why you may be experiencing a slow viewport.

Old Hardware
:   Sometimes your hardware, mainly your graphics card, may be too slow to keep up with your model.

Upgrade Graphics Driver
:   In some cases, slow selection is resolved by using updated drivers.

### Slow Selection

Blender uses OpenGL for selection, some graphics card drivers are slow at performing this operation.

This becomes especially problematic on dense geometry.

Possible Solutions:

GPU Depth Picking (Preferences)
:   See Preferences ‣ Viewport ‣ Selection.

    This option is enabled by default, disabling it may give a better performance at the cost of selection accuracy.

Upgrade Graphics Driver
:   In some cases, slow selection is resolved by using updated drivers. *It is generally good to use recent drivers
    when using 3D software.*

Select Centers (Workaround)
:   In *Object Mode*, holding `Ctrl` while selecting uses the object center point. While this can be useful on its
    own, it has the side effect of not relying on OpenGL selection.

Change Display Mode (Workaround)
:   Using *Wireframe* display mode can be used to more quickly select different objects.

### Viewport Playback Frame Rate Limited

Having the viewport playback clamped to a maximum of 60 FPS is typically caused by the VSync (vertical sync) setting
on your GPU, for higher frame rates you may have to disable VSync functionality although this may be of limited us
since frames rendered may be more than your GPU and monitor are able to display.

VSync is configured as part of your GPU driver options which vary depending on your system & GPU combination.
user: Explain Objects Panel in complete detail according to the official Blender documentation.

assistant: # Objects Panel

[image reference removed]

Objects panel.

This panel contains a [list view](../../../../../interface/controls/templates/list_view.xhtml#ui-list-view) with all objects which can be used for tracking,
camera or object solving.
By default there is only one object in this list which is used for camera solving.
It cannot be deleted and other objects cannot be used for camera solving;
all added objects are used for object tracking and solving only.
These objects can be referenced from Follow Track and Object Solver constraints.
Follow Track uses the camera object by default.

If some tracks were added and tracked to the wrong object, they can be copied to another
object using Track ‣ Copy Tracks and Track ‣ Paste Tracks.

The usage for all kind of objects (used for camera and object tracking) is the same:
track features, set camera data, solve motion. Camera data is sharing between all objects and
refining of camera intrinsics happens when solving camera motion only.
user: Provide the full official documentation entry for ThemeGraphEditor(bpy_struct), preserving all code examples.

assistant: # ThemeGraphEditor(bpy_struct)

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

*class* bpy.types.ThemeGraphEditor(*bpy_struct*)
:   Theme settings for the graph editor

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

    space
    :   Settings for space

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

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

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

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

    vertex_size
    :   Type:
        :   int in [1, 32], default 0

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with LineStyleAlphaModifier_DistanceFromCamera(LineStyleAlphaModifier) in a Blender add-on or script – include code.

assistant: # LineStyleAlphaModifier_DistanceFromCamera(LineStyleAlphaModifier)

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

*class* bpy.types.LineStyleAlphaModifier_DistanceFromCamera(*LineStyleAlphaModifier*)
:   Change alpha transparency based on the distance from the camera

    blend
    :   Specify how the modifier value is blended into the base value

        Type:
        :   enum in [`'MIX'`, `'ADD'`, `'SUBTRACT'`, `'MULTIPLY'`, `'DIVIDE'`, `'DIFFERENCE'`, `'MINIMUM'`, `'MAXIMUM'`], default `'MIX'`

    curve
    :   Curve used for the curve mapping

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    influence
    :   Influence factor by which the modifier changes the property

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

    invert
    :   Invert the fade-out direction of the linear mapping

        Type:
        :   boolean, default False

    mapping
    :   Select the mapping type

        - `LINEAR`
          Linear – Use linear mapping.
        - `CURVE`
          Curve – Use curve mapping.

        Type:
        :   enum in [`'LINEAR'`, `'CURVE'`], default `'LINEAR'`

    range_max
    :   Upper bound of the input range the mapping is applied

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

    range_min
    :   Lower bound of the input range the mapping is applied

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

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Alpha Modifier Type Items](bpy_types_enum_items/linestyle_alpha_modifier_type_items.html#rna-enum-linestyle-alpha-modifier-type-items), default `'ALONG_STROKE'`, (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.LineStyleAlphaModifier_DistanceFromCamera.type "bpy.types.LineStyleAlphaModifier_DistanceFromCamera.type")
user: What is Editor and how is it used in Blender Python scripting?

assistant: The Keymap editor lets you change the default hotkeys for each of Blender’s editors.

[image reference removed]

Keymap editor.

Usage

1. Find the operation whose shortcut you want to change. Filtering can help with this.
2. Select whether the operation should be triggered by a keyboard key, a mouse button, or something else.
3. Click the button on the right and press the shortcut you want to assign.

Active
:   Uncheck the checkbox to disable this keymap item.

Map Type
:   Keyboard:
    :   Single hotkey or key combination.

    Mouse:
    :   Actions from mouse buttons, tablet or touchpad input.

    NDOF:
    :   Movement or button from a 3D mouse ([NDOF](../../glossary/index.html#term-NDOF)) device.

    Tweak:
    :   Mouse click and drag *(optionally map drag direction to different actions)*.

    Text Input:
    :   Use this function by entering a text.

    Timer:
    :   For Blender internal use.

Operator ID Name
:   The identifier for the operator to call.

Event
:   Type
    :   The key or button that activates this keymap item (depending on the map type).

    Value
    :   The action (such as press, release, click, drag, etc.), (depending on the map type).

    Modifier
    :   Additional keys to hold (such as `Ctrl`, `Shift`, `Alt`).

Operator Properties
:   Initial values for the operator-specific properties.

### Restoring

If you want to restore the default settings for a keymap,
just click on the *Restore* button at the top right of this keymap.
user: Show practical ways to work with Source in a Blender add-on or script – include code.

assistant: Select the type of image to use. For images that come from files,
see [Supported Graphics Formats](../../files/media/image_formats.xhtml).

### Single Image

A single, static image.

### Image Sequence

An animation where each frame is stored in a separate file.
See [Opening an Image Sequence](../../files/media/image_formats.xhtml#image-formats-open-sequence).
For options, see [Movie](#movie) below.

### Movie

A video file. Note that if you want to do motion tracking and video compositing
rather than simply using the video as a texture, you should load it into the
[Movie Clip Editor](../clip/introduction.xhtml) instead.

Frames
:   How many frames of the video to play. Past this point, the video will be paused
    (unless *Cyclic* is enabled).

    Match Movie Length
    :   Sets the *Frames* to the number of frames in the video file.

Start
:   Scene frame at which the video should start playing.

Offset
:   Number of frames to offset the video to an earlier point in time.
    (Put differently: how many frames at the start of the video to skip.)

Cyclic
:   Start over after the last frame to create a continuous loop.

Auto Refresh
:   Play the video in the Image Editor when the scene animation is playing.
    (The mouse cursor should be in the Image Editor or the Timeline when starting playback
    for this to work.)

Deinterlace
:   Apply deinterlacing to interlaced (analog) video.

### Generated

Image generated by Blender.

X, Y
:   The width and height of the image in pixels.

Float Buffer
:   Creates a 32-bit image. This has a larger file size,
    but holds much more color information than the standard 8-bit image.
    For close-ups and large gradients, it may be better to use a 32-bit image.

Type
:   Blank:
    :   Creates a blank image of a single specified color.

    UV Grid:
    :   Creates a checkerboard pattern with a colored cross (+) in each square.

    Color Grid:
    :   Creates a more complex colored grid with letters and numbers denoting locations.
        It could be used to check for stretching or distortion in the UV mapping.

Color
:   The fill color when creating a *Blank* image.
user: Show practical ways to work with Scopes in a Blender add-on or script – include code.

assistant: [image reference removed]

Scopes in the Image Editor.

Displays different kinds of statistical information about the colors in the image.

Note that the Scopes tab is not shown if the active object is in Edit Mode
or Texture Paint Mode.

### Histogram

Displays a graph of the color distribution in the image. For each color value
(such as Luminance) on the X axis, it shows the number of pixels with that value
on the Y axis.
A predominantly dark image would have the highest values toward the left side of the graph.

Use this mode to balance out the tonal range in an image.
A well-balanced image should have a nice smooth distribution of color values.

You can drag `LMB` in the histogram to adjust its vertical zoom.

Luma
:   Shows a luminosity histogram.

RGB
:   Shows the RGB channels stacked on top of each other.

R/G/B/A
:   Shows a single color channel.

Show Line
:   Displays lines rather than filled shapes.

### Waveform

Plots the color distribution for each vertical line of pixels in the image.
The X axis of the Waveform corresponds to the X axis of the image, while the Y axis
represents the range of a color component such as Luminance. The brighter
a specific point is, the more pixels in that vertical line have that color value.

Waveform Opacity
:   Opacity of the points.

Waveform Mode
:   Luma
    :   Show a single Waveform plotting the luminosity distribution.

    YCbCr
    :   Show the Y, Cb and Cr Waveforms side by side.

    Parade
    :   Show the R, G and B Waveforms side by side.

    Red Green Blue
    :   Show the R, G and B Waveforms overlaid on top of each other.

### Vectorscope

Shows the color distribution in a radial fashion. The angle represents the hue,
while the distance from the center represents the saturation.

Vectorscope Opacity
:   Opacity of the points.

### Sample Line

The *Sample Line* scope is the same as the [Histogram](#histogram)
but allows you to get the sample data from a line.

Sample Line
:   Used to draw a line to read the sample data from.

### Samples

Full Sample
:   Sample every pixel.

Accuracy
:   Proportion of image pixels to sample if *Full Sample* is disabled.
user: How do I use Material in Blender? Include parameters, examples, warnings and best practices.

assistant: # Material

The *Material* modifier alters the base property with a new one taken from a given range mapped on
the current material under the stroke.

You can use various properties of the materials, among which many are mono-component
(i.e. give black-and-white results). In this case for the color modifier, an optional color ramp can be used to
map these gray-scale values to colored ones.
In the reverse case properties of the materials, which are multi-components
(i.e. give RGB results) the mean value will be used for Alpha and Thickness modifiers.

If used with the *Split by Material* option in the *Stroke* tab,
the result will not be blurred between materials along the strokes.

[image reference removed]

Material modifiers demo by T.K.
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Lilies_Color_Material.zip)).
user: Provide the full official documentation entry for Examples, preserving all code examples.

assistant: |  |  |  |  |
| --- | --- | --- | --- |
| ../../../_images/modeling_modifiers_deform_laplacian-smooth_repeat0.jpg   Femme front view [blend-file](https://archive.blender.org/wiki/2015/uploads/8/8f/Apinzonf_GSOC_2012_Media_femme_front.blend). | ../../../_images/modeling_modifiers_deform_laplacian-smooth_border0-0.jpg   Femme side view [blend-file](https://archive.blender.org/wiki/2015/uploads/4/47/Apinzonf_GSOC_2012_Media_femme_side.blend). | ../../../_images/modeling_modifiers_deform_laplacian-smooth_t-wgroup.png   Cube smooth [blend-file](https://archive.blender.org/wiki/2015/uploads/5/54/Apinzonf_GSOC_2012_Media_cube_smooth.blend). | ../../../_images/modeling_modifiers_deform_laplacian-smooth_camel-repeat0.jpg   Shape enhanced [blend-file](https://archive.blender.org/wiki/2015/uploads/4/44/Apinzonf_Shape_Enhanced_camel.blend). |
user: Give a detailed overview of Sample Curve Node: syntax, arguments, return values, common patterns.

assistant: # Sample Curve Node

[image reference removed]

The *Sample Curve* calculates a point on a curve at a certain distance from the start of the curve,
specified by the length or factor inputs. It also outputs data retrieved from that position on the curve.
The sampled values are linearly interpolated from the values at the evaluated curve points
at each side of the sampled point.
user: Describe Tablet from the Blender manual or Python API, including usage steps and snippets.

assistant: Tablet API (Windows only)
:   Select the native Windows Ink or older Wintab system for pressure sensitivity.
    Blender automatically selects the API for your operating system and tablet,
    however in case of problems this can be set manually.
    You may need to restart Blender for changes to take affect.

Max Threshold
:   Amount of pressure required to achieve full intensity.

Softness
:   Controls how the softness of the low pressure response onset using a gamma curve.