PGCRYPT/OpenBlender_Train huggingface dataset:
user: Show practical ways to work with GeometryNodeMeshToCurve(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeMeshToCurve(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.GeometryNodeMeshToCurve(*GeometryNode*)
:   Generate a curve from a mesh

    mode
    :   - `EDGES`
          Edges – Convert mesh edges to curve segments. Attributes are propagated to curve points..
        - `FACES`
          Faces – Convert each mesh face to a cyclic curve. Face attributes are propagated to curves..

        Type:
        :   enum in [`'EDGES'`, `'FACES'`], default `'EDGES'`

    *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: How do I use Convert to Mesh Plane in Blender? Include parameters, examples, warnings and best practices.

assistant: Converts the selected [image empty](../../../modeling/empties.xhtml#bpy-types-object-empty-image) to a textured mesh plane.

For a description of the options see [Mesh Plane](../../../modeling/meshes/import_images_as_planes.xhtml).
user: Explain Attribute Data Types in complete detail according to the official Blender documentation.

assistant: The type of an attribute is the kind of data stored at each element.

Float:
:   Single floating-point value, commonly used for weights or intensity values.

Boolean:
:   True or false value for binary conditions.

Integer:
:   32-bit integer, used for indices or discrete values.

Vector:
:   3D vector with floating-point values, often representing directions or positions.

Color:
:   RGBA color with 32-bit floating-point values, stored in linear [Color Space](../../glossary/index.xhtml#term-Color-Space)
    Suitable for high dynamic range and wide-gamut colors.

Byte Color:
:   RGBA color with 8-bit positive integer values, useful for compact color storage.
    These are always stored in the sRGB [Color Space](../../glossary/index.xhtml#term-Color-Space).
    For wide gamut or linear workflows, use the *Color* type instead.

String:
:   Text string for storing names or labels.

2D Vector:
:   2D vector with floating-point values, often used for UV coordinates.

8-Bit Integer:
:   Small integer with a range from -128 to 127.

2D 16-Bit Integer Vector:
:   Signed 16-bit 2D vector for compact storage of integer pairs.

2D Integer Vector:
:   Signed 32-bit 2D vector.

Quaternion:
:   Floating-point [Quaternion](../../glossary/index.xhtml#term-Quaternion) rotation used in 3D transformations.

4x4 Matrix:
:   Floating-point matrix used for transformations or storing spatial relationships.

The above list is in the order of least to most “complex” (An integer can contain more data than a
boolean, so it is more complicated). When joining separate geometries together, the more complex data
type is preferred when there are matching names. This is particularly important when joining geometry
with named attributes with the [Join Geometry Node](geometry/join_geometry.xhtml).

To store 2D Vectors (UV maps) and Byte Colors the
[Store Named Attribute Node](attribute/store_named_attribute.xhtml) must be
used because there are no sockets for those types.

### Data Conversion

Through the use of Geometry Nodes, data can be converted between types.

Valid conversions:

- Between color and vector – mapping between color channels and vector components.
- Between color and float – the color data is converted to its grayscale equivalent.
- Between float and integer – integers simply become floats, floats are truncated.
- Between float and vector – when a float becomes a vector the value is used for each component.
  When a vector becomes a float the average of the components is taken.
- Between float and boolean – values greater than 0 are true, true maps to 1, and false maps to 0.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.lightprobe`](bpy.context.html#bpy.context.lightprobe "bpy.context.lightprobe") - [`BlendData.lightprobes`](bpy.types.BlendData.html#bpy.types.BlendData.lightprobes "bpy.types.BlendData.lightprobes") | - [`BlendDataProbes.new`](bpy.types.BlendDataProbes.html#bpy.types.BlendDataProbes.new "bpy.types.BlendDataProbes.new") - [`BlendDataProbes.remove`](bpy.types.BlendDataProbes.html#bpy.types.BlendDataProbes.remove "bpy.types.BlendDataProbes.remove") |
user: Give a detailed overview of Sound: syntax, arguments, return values, common patterns.

assistant: This panel contains the sound settings for live playback
within Blender and are only available with a device other than *None*.
To control these settings for exporting sound
see the [Encoding Panel](../../render/output/properties/output.html#render-output-video-encoding-panel)
and [Audio Panel](../../scene_layout/scene/properties.html#data-scenes-audio).

Audio Device
:   Sets the audio engine to use to process and output audio.

    None:
    :   No audio playback support (audio strips can still be loaded and rendered normally).

    CoreAudio:
    :   On macOS, CoreAudio is the native audio API.
        This is the default setting for macOS users and should be preferred.

    PulseAudio:
    :   PulseAudio is the most commonly used sound server on modern Linux distributions.
        If PulseAudio is available, this should be the preferred setting on Linux.

    WASAPI:
    :   On Windows, WASAPI is the native audio API introduced with Windows Vista.
        This is the default setting for Windows users and should be preferred.

    Jack:
    :   High quality professional audio engine that needs a properly configured server running on your system.
        Supports accurate synchronization with other professional audio applications using Jack.

    OpenAL:
    :   Available on all platforms in case the native engines do not work.
        The played back 3D audio might sound different than when rendered.

    SDL:
    :   Uses Simple Direct Media Layer API from [libsdl.org](https://www.libsdl.org)
        which supports all platforms. Might be of lower quality and thus should only be used as backup.

Channels
:   The number of audio source “locations” to output.

    Mono:
    :   Output a single audio channel.

    Stereo:
    :   Output two audio channels; typically a left and right channel.

    4 Channels:
    :   Output a four audio channels.

    5.1 Surround:
    :   Output a five audio channels with one LFE channel.

    7.1 Surround:
    :   Output a seven audio channels with one LFE channel.

Mixing Buffer
:   Sets the number of samples used by the audio mixing buffer.
    Higher buffer sizes can cause latency issues,
    but if you hear clicks or other problems, try to increase the size.

Sample Rate
:   Sets the audio [sampling rate](https://en.wikipedia.org/wiki/Sampling_(signal_processing)#Sampling_rate).

Sample Format
:   Sets the audio sample format.
user: How do I use Grease Pencil in Blender? Include parameters, examples, warnings and best practices.

assistant: Manhattan
:   The minimum number of pixels the mouse should have moved either
    horizontally or vertically before the movement is recorded.
    Decreasing this should work better for curvy lines.

Euclidean
:   The minimum distance that mouse has to travel before movement is recorded.
user: Give a detailed overview of Select by Face Strength: syntax, arguments, return values, common patterns.

assistant: Another way to affect normals is to set a *Face Strength* on the faces of the model.
The Face Strength can be either *Weak*, *Medium*, or *Strong*.
The idea is that the [Weighted Normal Modifier](../../../modifiers/normals/weighted_normal.xhtml) can
be set to pay attention to the Face Strength as follows:
When combining the normals that meet at a vertex, only the faces
with the strongest Face Strength will contribute to the final value.

For example, if three faces meet at a vertex and have the face weights weak, medium, and strong,
then only the normal associated with the strong face will be used to set the final result.

Use the submenu to pick one of *Weak*, *Medium*, or *Strong*.
Then this tool selects those faces that have the chosen face strength.
user: Describe Clip Display from the Blender manual or Python API, including usage steps and snippets.

assistant: # Clip Display

This pop-over contains various display settings for both Tracking mode and Mask mode.

R, G, B
:   Controls the color channels used for the frame preview. The tracking algorithm works with grayscale images,
    and with these options, you can check which combination of enabled and disabled channels will yield
    the best contrast and the least noise.

    Note that this only affects the preview. To select which channels to use for the actual tracking,
    use the [Track tab in the Toolbar](../../../movie_clip/tracking/clip/toolbar/track.xhtml) to set a default
    for newly created markers, or the [Track tab in the Sidebar](../../../movie_clip/tracking/clip/sidebar/track/track.xhtml)
    to configure existing markers.

Grayscale Preview (B/W)
:   Shows the whole frame as a grayscale image.

Mute Footage `M`
:   Hides the movie clip and displays a black image instead.
    This helps to find markers that are tracked inaccurately or not at all.

Render Undistorted
:   Applies the [Lens settings](../../../movie_clip/tracking/clip/sidebar/track/camera.xhtml#motion-tracking-camera-lens) to the
    video preview to undo lens distortion. Does not change the footage itself.

Show Stable
:   Applies the [2D stabilization](../../../movie_clip/tracking/clip/sidebar/stabilization/introduction.xhtml)
    settings to the video preview. Does not change the footage itself.

Grid
:   Displays a grid which is originally orthographic, but is distorted by the Lens settings.
    This can be used for manual calibration: the distorted grid lines should match lines
    in the footage that are meant to be straight.

Calibration
:   Applies the Lens settings to annotation strokes.
    Like the Grid, this option also helps to perform manual calibration.

Display Aspect Ratio
:   Changes the aspect ratio for displaying only. It does not affect the tracking or solving process.
user: Show practical ways to work with Scale in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| ../../../../_images/scene-layout_object_properties_instancing_faces_scale-enabled.png   Scale enabled. | ../../../../_images/scene-layout_object_properties_instancing_faces_scale-changed.png   Top face of cube scaled down. |

By enabling *Scale* for the parent object,
the scale of the child objects will be adapted to the size of each face in the parent object.

Thus, by rescaling the face of the parent object,
the size of the instanced object will change accordingly.
user: Explain FunctionNodeInvertMatrix(FunctionNode) in complete detail according to the official Blender documentation.

assistant: # FunctionNodeInvertMatrix(FunctionNode)

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

*class* bpy.types.FunctionNodeInvertMatrix(*FunctionNode*)
:   Compute the inverse of the given matrix, if one exists

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

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: What is CollectionProperty(Property) and how is it used in Blender Python scripting?

assistant: # CollectionProperty(Property)

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

*class* bpy.types.CollectionProperty(*Property*)
:   RNA collection property to define lists, arrays and mappings

    fixed_type
    :   Fixed pointer type, empty if variable type

        Type:
        :   [`Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct"), (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 Separate Cylindrical Node in complete detail according to the official Blender documentation.

assistant: # Separate Cylindrical Node

[image reference removed]

The *Separate Cylindrical* node converts a vector from Cartesian coordinates (X, Y, Z)
into cylindrical coordinates (R, Φ, Z) and outputs each component separately. It is the inverse of the
[Combine Cylindrical](combine_cylindrical.xhtml) node.

This node is useful for analyzing geometry or generating procedural effects that depend on
radial distance, angular position, or height – for example, creating spiral deformations,
cylindrical gradients, or radial masks.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Hue/Saturation Modifier.

Mode
:   The color transformation will be applied on the stroke and/or the fill color.

    Stroke & Fill, Stroke, Fill

Hue
:   Specifies the hue rotation of the image. 360° are mapped to (0 to 1).
    The hue shifts of 0 (-180°) and 1 (+180°) have the same result.

Saturation
:   A saturation of 0 removes hues from the image, resulting in a grayscale image.
    A shift greater than 1.0 increases saturation.

Value
:   Value is the overall brightness of the image.
    De/Increasing values shift an image darker/lighter.

### Influence

See [Influence Filters](../introduction.html#grease-pencil-modifier-influence-filters).
user: Show practical ways to work with Importing Alembic Files in a Blender add-on or script – include code.

assistant: When importing an Alembic file, [Mesh Sequence Cache modifiers](../../modeling/modifiers/modify/mesh_sequence_cache.xhtml)
are automatically added to time-varying meshes. For time-varying object transforms
(so animation of rotation, location, or scale)
the [Transform Cache Constraint](../../animation/constraints/transform/transform_cache.xhtml#bpy-types-transformcacheconstraint) is used.

### General

Scale
:   Value by which to enlarge or shrink the objects with respect to the world’s origin

### Options

Relative Path
:   Select the file relative to the blend-file.

Set Frame Range
:   If checked, update scene’s start and end frame to match those of the Alembic archive.

Is Sequence
:   Set to true if the cache is split into separate files.

Validate Meshes
:   Check the imported mesh for corrupt data and fix it if necessary.
    When disabled, erroneous data may cause crashes displaying or editing the meshes.
    This option will make the importing slower but is recommended, as data errors are not always obvious.

Always Add Cache Reader
:   Add cache modifiers and constraints to imported objects even if they are
    not animated so that they can be updated when reloading the Alembic archive.
user: Describe PivotConstraint(Constraint) from the Blender manual or Python API, including usage steps and snippets.

assistant: # PivotConstraint(Constraint)

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

*class* bpy.types.PivotConstraint(*Constraint*)
:   Rotate around a different point

    head_tail
    :   Target along length of bone: Head is 0, Tail is 1

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

    offset
    :   Offset of pivot from target (when set), or from owner’s location (when Fixed Position is off), or the absolute pivot point

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

    rotation_range
    :   Rotation range on which pivoting should occur

        - `ALWAYS_ACTIVE`
          Always – Use the pivot point in every rotation.
        - `NX`
          -X Rotation – Use the pivot point in the negative rotation range around the X-axis.
        - `NY`
          -Y Rotation – Use the pivot point in the negative rotation range around the Y-axis.
        - `NZ`
          -Z Rotation – Use the pivot point in the negative rotation range around the Z-axis.
        - `X`
          X Rotation – Use the pivot point in the positive rotation range around the X-axis.
        - `Y`
          Y Rotation – Use the pivot point in the positive rotation range around the Y-axis.
        - `Z`
          Z Rotation – Use the pivot point in the positive rotation range around the Z-axis.

        Type:
        :   enum in [`'ALWAYS_ACTIVE'`, `'NX'`, `'NY'`, `'NZ'`, `'X'`, `'Y'`, `'Z'`], default `'NX'`

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

    target
    :   Target Object, defining the position of the pivot when defined

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

    use_bbone_shape
    :   Follow shape of B-Bone segments when calculating Head/Tail position

        Type:
        :   boolean, default False

    use_relative_location
    :   Offset will be an absolute point in space instead of relative to the target

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain ShaderNodeTangent(ShaderNode) in complete detail according to the official Blender documentation.

assistant: # ShaderNodeTangent(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.ShaderNodeTangent(*ShaderNode*)
:   Generate a tangent direction for the Anisotropic BSDF

    axis
    :   Axis for radial tangents

        - `X`
          X – X axis.
        - `Y`
          Y – Y axis.
        - `Z`
          Z – Z axis.

        Type:
        :   enum in [`'X'`, `'Y'`, `'Z'`], default `'X'`

    direction_type
    :   Method to use for the tangent

        - `RADIAL`
          Radial – Radial tangent around the X, Y or Z axis.
        - `UV_MAP`
          UV Map – Tangent from UV map.

        Type:
        :   enum in [`'RADIAL'`, `'UV_MAP'`], default `'RADIAL'`

    uv_map
    :   UV Map for tangent generated from UV

        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")

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

assistant: The following shortcuts can be used while moving/rotating/scaling an object in the 3D Viewport,
dragging the slider of a value, and so on. Note that they should be pressed after starting
the drag, not before.

|  |  |
| --- | --- |
| `Ctrl` | Snap to coarse increments, making it easier to (say) rotate an object by exactly 90°. |
| `Shift` | Make the value change more slowly in response to mouse movement, giving you more precision. |
| `Shift`-`Ctrl` | Snap to fine increments. |
user: Give a detailed overview of Add Sound Strip: syntax, arguments, return values, common patterns.

assistant: Move Strips
:   Use mouse to position strip in timeline immediately after adding. If this option is enabled, Start Frame and
    Channel properties are not displayed.

Start Frame
:   The [Start Frame](../../../../editors/video_sequencer/sequencer/sidebar/strip.html#bpy-types-strip-frame-start) to place the left handle of the strip.

Channel
:   The [Channel](../../../../editors/video_sequencer/sequencer/channels.html) to place the strip.

Relative Path
:   Store the location of the image file relative to the blend-file.

Replace Selection
:   Replaces the currently selected strips with the new strip.

Cache
:   Cache the sound in memory, enables [Caching](../../../../editors/video_sequencer/sequencer/sidebar/strip.html#bpy-types-sound-use-memory-cache) in the Source properties.

Mono
:   Merge all sound channels into one channel,
    enables [Mono](../../../../editors/video_sequencer/sequencer/sidebar/strip.html#bpy-types-sound-use-mono) in the Sound properties.
user: Provide the full official documentation entry for CLIP_UL_tracking_objects(UIList), preserving all code examples.

assistant: # CLIP_UL_tracking_objects(UIList)

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

*class* bpy.types.CLIP_UL_tracking_objects(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *item*, *_icon*, *_active_data*, *_active_propname*, *_index*)

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

assistant: # Emission

The *Emitter* system works just like its name says: it emits/produces particles for a certain amount of time.
In such a system, particles are emitted from the selected object from the *Start*
frame to the *End* frame and have a certain lifespan.
These particles are rendered default as [Halos](render.xhtml#particle-halo),
but you may also render this kind of particles as objects
(depending on the particle system’s render settings,
see [Visualization](render.xhtml)).

[image reference removed]

Particle Emission settings.

The buttons in the *Emission* panel control the way particles are emitted over time:

Number
:   The maximum amount of parent particles used in the simulation.

Seed
:   Blender uses this as starting point to produce random numbers during the simulation.

Frame Start
:   The start frame of particle emission. You may set negative values,
    which enables you to start the simulation before the actual rendering.

End
:   The end frame of particle emission.

Lifetime
:   The lifespan (in frames) of the particles.

Lifetime Randomness
:   A random variation of the lifetime of a given particle.
    The shortest possible lifetime is *Lifetime* × (1 - *Random*).
    Values above 1.0 are not allowed.
    For example with the default *Lifetime* value of 50 a *Random* setting of 0.5
    will give you particles with a live span ranging from 50 frames to \(50 × (1.0 - 0.5) = 25\)
    frames, and with a *Random* setting of 0.75 you will get particles with live spans ranging
    from 50 frames to \(50 × (1.0 - 0.75) = 12.5\) frames.
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Geometry
:   The resulting geometry with braided deformation applied.

Flare Parameter
:   A value from 0 to 1 indicating the position along the braid flare region.
    This can be used for shading or for adding effects (such as tying, binding, or loosening
    near the braid tip).

Strand Index
:   An index identifying which strand of the braid each curve belongs to within its braid group.

### Guide Map

Guide Index
:   The guide index map actually used to generate the braid.
    If a new guide map was created by this node, it is provided here for reuse downstream.
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: [image reference removed]

Tint Modifier.

Mode
:   The color transformation will be applied on the stroke and/or the fill color.

    Stroke & Fill, Stroke, Fill

Strength
:   Controls the amount for the color mixing.

    A value of 0 respect the original stroke’s color,
    a value of 1.0 totally replace the original color with the tint color.

    A shift greater than 1.0 will make the points alpha less transparent than originally (2.0 is fully opaque).

Tint Type
:   Uniform:
    :   Color
        :   Defines the tint color for mixing with the original color.

    Gradient:
    :   Color Ramp
        :   Defines the tint gradient color for mixing with the original color.
            For controls see [Color Ramp Widget](../../../interface/controls/templates/color_ramp.xhtml#ui-color-ramp-widget).

        Object
        :   A [Data ID](../../../interface/controls/templates/data_block.xhtml#ui-data-id) to select an object (usually an empty),
            which position and rotation will be used to define the center of the effect.

        Radius
        :   Defines the maximum distance of the effect.

### Influence

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: What is Network and how is it used in Blender Python scripting?

assistant: Allow Online Access
:   Allow Blender to access the internet.

    Add-ons that follow this setting will only connect to the internet if enabled.
    However, Blender cannot prevent third-party add-ons from violating this rule.

Time Out
:   The time (in seconds) that online operations may wait before timing out.

    Use the systems default when zero.

Connection Limit
:   The maximum number of simultaneous connections an online operation may make.

    Do not limit the number of connections when zero.
user: Describe Geometry Randomization from the Blender manual or Python API, including usage steps and snippets.

assistant: Many nodes don’t guarantee the order of elements in which they output things. For example, the order of edges coming
out of the **Triangulate** node is deterministic but not well defined. The order may change between Blender versions.
Therefor, if node setups depend on a specific order, they may break when the Blender implementation changes. Changing
the order can often be necessary in order to fix bugs or improve performance.

“Geometry randomization” can be temporarily enabled to see if a blend-file depends on the indices in unstable ways.
When enabled, various internal algorithms shuffle the result geometry elements so that any dependence on it would not
work anymore. When building setups that are supposed to last a long time, it is recommended to check if they still
work with randomization enabled.

To enable it, first enable **Developer Extras** in the [preferences](../../editors/preferences/interface.xhtml).
Then [search](../../interface/operators.xhtml#bpy-ops-wm-search-operator) for **Set Geometry Randomization**.
The popup allows enabling and disabling the randomization.
user: What is GeometryNodeExtrudeMesh(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeExtrudeMesh(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.GeometryNodeExtrudeMesh(*GeometryNode*)
:   Generate new vertices, edges, or faces from selected elements and move them based on an offset while keeping them connected by their boundary

    mode
    :   Type:
        :   enum in [`'VERTICES'`, `'EDGES'`, `'FACES'`], default `'FACES'`

    *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: How do I use NodeGeometryViewerItem(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeGeometryViewerItem(bpy_struct)

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

*class* bpy.types.NodeGeometryViewerItem(*bpy_struct*)
:   auto_remove
    :   Remove the item automatically when it is unlinked

        Type:
        :   boolean, default False

    color
    :   Color of the corresponding socket type in the node editor

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

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

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

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

assistant: # Themes

The *Themes* section allows you to customize interface appearance and colors.

[image reference removed]

The colors for each editor can be set separately by simply selecting the editor you wish to
change in the multi-choice list at the left, and adjusting colors as required.
Notice that changes appear in real-time on your screen. In addition, details such as the dot size
in the *3D Viewport* or the *Graph Editor* can also be changed.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeForeachGeometryElementInput.pair_with_output`](bpy.types.GeometryNodeForeachGeometryElementInput.html#bpy.types.GeometryNodeForeachGeometryElementInput.pair_with_output "bpy.types.GeometryNodeForeachGeometryElementInput.pair_with_output") - [`GeometryNodeRepeatInput.pair_with_output`](bpy.types.GeometryNodeRepeatInput.html#bpy.types.GeometryNodeRepeatInput.pair_with_output "bpy.types.GeometryNodeRepeatInput.pair_with_output") | - [`GeometryNodeSimulationInput.pair_with_output`](bpy.types.GeometryNodeSimulationInput.html#bpy.types.GeometryNodeSimulationInput.pair_with_output "bpy.types.GeometryNodeSimulationInput.pair_with_output") - [`NodeClosureInput.pair_with_output`](bpy.types.NodeClosureInput.html#bpy.types.NodeClosureInput.pair_with_output "bpy.types.NodeClosureInput.pair_with_output") |
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`BlendData.cache_files`](bpy.types.BlendData.html#bpy.types.BlendData.cache_files "bpy.types.BlendData.cache_files") - [`MeshSequenceCacheModifier.cache_file`](bpy.types.MeshSequenceCacheModifier.html#bpy.types.MeshSequenceCacheModifier.cache_file "bpy.types.MeshSequenceCacheModifier.cache_file") | - [`TransformCacheConstraint.cache_file`](bpy.types.TransformCacheConstraint.html#bpy.types.TransformCacheConstraint.cache_file "bpy.types.TransformCacheConstraint.cache_file") |
user: Give a detailed overview of Selecting Bones: syntax, arguments, return values, common patterns.

assistant: # Selecting Bones

You can select and edit bones of armatures in *Edit Mode* and in *Pose Mode*.
Here, we will see how to select bones in *Edit Mode*.
Selecting bones in *Pose Mode* is similar to selecting in *Edit Mode*
with a few specific differences that will be detailed in
the [posing part](../posing/selecting.xhtml).

Similar to [vertex/edge selection](../../../modeling/meshes/selecting/introduction.xhtml) in meshes,
there are two ways to select whole bones in *Edit Mode*:

1. Directly, by selecting the bone’s body.
2. Selecting both of its joints (root and tip).

This is an important point to understand,
because selecting bones’ joints only might lead to non-obvious behavior,
with respect to which bone you actually select.

Note that unlike the mesh display type, the armature display type has no effect on selection behavior.
In other words, you can select a bone’s joint or body the same way regardless of
the bone visualization chosen.
user: Provide the full official documentation entry for Effector, preserving all code examples.

assistant: # Effector

Effector objects are used to deflect fluids and influence the fluid flow. To define any mesh object
as an effector object, add fluid physics by clicking *Fluid* in Properties ‣ Physics.
Then select *Effector* as the fluid *Type*.
user: How do I use Relations in Blender? Include parameters, examples, warnings and best practices.

assistant: Key Targets
:   The [list view](../../../../interface/controls/templates/list_view.xhtml#ui-list-view) of keys (target particle systems).

Object
:   The name of a target object for the selected key. If empty it uses the current particle system.

System
:   Index of particle system on the target object.

Time
:   The time (frame number) at which the particles will be at the position of the selected system.
    Note also that the *Start* frame of the Keyed system adds an offset to this time.

Duration
:   How long (in frames) the particles stay on this system before they start moving to the next one.
user: Give a detailed overview of Bmesh: syntax, arguments, return values, common patterns.

assistant:  in a valid state or else other tools may behave incorrectly. Any errors that arise from not following these conventions is considered a bug in the script, not a bug in Blender. Selection / Flushing ¶ As mentioned above, it is possible to create an invalid selection state (by selecting a state and then deselecting one of its vertices for example), mostly the best way to solve this is to flush the selection after performing a series of edits. This validates the selection state. Module Functions ¶ Submodules BMesh Operators (bmesh.ops) BMesh Types (bmesh.types) BMesh Utilities (bmesh.utils) BMesh Geometry Utilities (bmesh.geometry) bmesh. from_edit_mesh ( mesh ) ¶ Return a BMesh from this mesh, currently the mesh must already be in editmode. Parameters : mesh ( bpy.types.Mesh ) – The editmode mesh. Returns : the BMesh associated with this mesh. Return type : bmesh.types.BMesh bmesh. new ( * , use_operators = True ) ¶ Parameters : use_operators ( bool ) – Support calling operators in bmesh.ops (uses some extra memory per vert/edge/face). Returns : Return a new, empty BMesh. Return type : bmesh.types.BMesh bmesh. update_edit_mesh ( mesh , * , loop_triangles = True , destructive = True ) ¶ Update the mesh after changes to the BMesh in editmode, optionally recalculating n-gon tessellation. Parameters : mesh ( bpy.types.Mesh ) – The editmode mesh. loop_triangles ( bool ) – Option to recalculate n-gon tessellation. destructive ( bool ) – Use when geometry has been added or removed. Next BMesh Operators (bmesh.ops) Previous Font Drawing (blf) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page BMesh Module (bmesh) Introduction Example Script Standalone Module Mesh Access Edit-Mode Tessellation CustomData Access Keeping a Correct State Selection / Flushing Module Functions from_edit_mesh() new() update_edit_mesh()
user: Describe GeometryNodePointsOfCurve(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodePointsOfCurve(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.GeometryNodePointsOfCurve(*GeometryNode*)
:   Retrieve a point index within a curve

    *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: How do I use Camera & Lens Effects Nodes in Blender? Include parameters, examples, warnings and best practices.

assistant: # Camera & Lens Effects Nodes

The *Camera & Lens Effects* nodes simulate real-world imperfections and optical
characteristics of cameras and lenses. These effects can be used to add realism,
match rendered imagery with live-action footage, or achieve specific cinematic looks.

These nodes are typically applied near the end of a compositing chain to stylize or enhance
the final image. They include effects such as sensor noise, chromatic aberration,
and vignetting, all of which help replicate the subtleties of physical camera systems.
user: How do I use Bpy.Types.Greasepencilweightproximitymodifier in Blender? Include parameters, examples, warnings and best practices.

assistant: _group_filter GreasePencilWeightProximityModifier.use_layer_pass_filter GreasePencilWeightProximityModifier.use_material_pass_filter GreasePencilWeightProximityModifier.use_multiply GreasePencilWeightProximityModifier.vertex_group_name GreasePencilWeightProximityModifier.bl_rna_get_subclass() GreasePencilWeightProximityModifier.bl_rna_get_subclass_py() Inherited Properties Inherited Functions