PGCRYPT/OpenBlender_Train huggingface dataset:
user: Give a detailed overview of LightProbeSphere(LightProbe): syntax, arguments, return values, common patterns.

assistant: # LightProbeSphere(LightProbe)

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

*class* bpy.types.LightProbeSphere(*LightProbe*)
:   Light probe that captures precise lighting from all directions at a single point in space

    clip_end
    :   Probe clip end, beyond which objects will not appear in reflections

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

    falloff
    :   Control how fast the probe influence decreases

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

    influence_type
    :   Type of influence volume

        Type:
        :   enum in [`'ELIPSOID'`, `'BOX'`], default `'ELIPSOID'`

    parallax_distance
    :   Lowest corner of the parallax bounding box

        Type:
        :   float in [0, inf], default 2.5

    parallax_type
    :   Type of parallax volume

        Type:
        :   enum in [`'ELIPSOID'`, `'BOX'`], default `'ELIPSOID'`

    show_parallax
    :   Show the parallax correction volume in the 3D view

        Type:
        :   boolean, default False

    use_custom_parallax
    :   Enable custom settings for the parallax correction volume

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

assistant: Font
:   Font glyph used to generate the curve.

Overflow
:   Controls how the text fits inside the text box.

    Overflow:
    :   Wraps the text at the *Text Box Width*.

    Scale To Fit:
    :   Scales the text size to fit the *Text Box Width* and *Text Box Height*.

    Truncate:
    :   Only outputs text characters that fit within the width and height, based on the *Size* input.
        Any part of the string that did not fit is moved to the *Remainder* output.

Alignment
:   Controls horizontal alignment of text on each line.

    Left:
    :   Aligns the text to the left.

    Center:
    :   Aligns the text to the center.

    Right:
    :   Aligns the text to the right.

    Justify:
    :   Aligns the text to the left and right.

    Flush:
    :   Aligns the text to the left and right with equal character spacing.

Align Y
:   Controls vertical alignment of the block of text.

    Top:
    :   Aligns the text to the top.

    Top Baseline:
    :   Aligns the text to the top baseline.

    Middle:
    :   Aligns the text to the middle.

    Bottom Baseline:
    :   Aligns the text to the bottom baseline.

    Bottom:
    :   Aligns the text to the bottom.

Pivot Point
:   Controls where on each character the output *Pivot Point* is placed.

    Midpoint:
    :   Place the pivot points at the center of each character’s bounds.

    Top Left:
    :   Place the pivot points at the top left of each character’s bounds.

    Top Center:
    :   Place the pivot points at the middle of the top of each character’s bounds.

    Top Right:
    :   Place the pivot points at the top right of each character’s bounds.

    Bottom Left:
    :   Place the pivot points at the bottom left of each character’s bounds.

    Bottom Center:
    :   Place the pivot points at the middle of bottom of each character’s bounds.

    Bottom Right:
    :   Place the pivot points at the bottom right of each character’s bounds.
user: Explain General in complete detail according to the official Blender documentation.

assistant: # General

*Sculpt Mode* is similar to *Edit Mode* in that it is used to alter the shape of a model,
but Sculpt Mode uses a very different workflow:
instead of dealing with individual elements (vertices, edges, and faces),
an area of the model is primarily changed using brushes.

[image reference removed]

Sculpting Mode Example.

Sculpt Mode is accessed from the mode menu of the [3D Viewport header](../../../editors/3dview/modes.xhtml)
or with the pie menu via `Ctrl`-`Tab`.
Once inside Sculpt Mode, the Toolbar and Tool Settings of the 3D Viewport will change to
Sculpt Mode specific panels. The cursor will change to a circle, to indicate the size of the brush.

The following pages will briefly explain the fundamental features and concepts of *Sculpt Mode*,
including various links to other pages for more details.
user: Show practical ways to work with CompositorNodeMovieDistortion(CompositorNode) in a Blender add-on or script – include code.

assistant: # CompositorNodeMovieDistortion(CompositorNode)

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

*class* bpy.types.CompositorNodeMovieDistortion(*CompositorNode*)
:   Remove lens distortion from footage, using motion tracking camera lens settings

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use ObjectConstraints(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ObjectConstraints(bpy_struct)

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

*class* bpy.types.ObjectConstraints(*bpy_struct*)
:   Collection of object constraints

    active
    :   Active Object constraint

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

    new(*type*)
    :   Add a new constraint to this object

        Parameters:
        :   **type** (enum in [Constraint Type Items](bpy_types_enum_items/constraint_type_items.html#rna-enum-constraint-type-items)) – Constraint type to add

        Returns:
        :   New constraint

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

    remove(*constraint*)
    :   Remove a constraint from this object

        Parameters:
        :   **constraint** ([`Constraint`](bpy.types.Constraint.html#bpy.types.Constraint "bpy.types.Constraint"), (never None)) – Removed constraint

    clear()
    :   Remove all constraint from this object

    move(*from_index*, *to_index*)
    :   Move a constraint to a different position

        Parameters:
        :   - **from_index** (*int in* *[**-inf**,* *inf**]*) – From Index, Index to move
            - **to_index** (*int in* *[**-inf**,* *inf**]*) – To Index, Target index

    copy(*constraint*)
    :   Add a new constraint that is a copy of the given one

        Parameters:
        :   **constraint** ([`Constraint`](bpy.types.Constraint.html#bpy.types.Constraint "bpy.types.Constraint"), (never None)) – Constraint to copy - may belong to a different object

        Returns:
        :   New constraint

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

    *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 MaterialSlot(bpy_struct) and how is it used in Blender Python scripting?

assistant: # MaterialSlot(bpy_struct)

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

*class* bpy.types.MaterialSlot(*bpy_struct*)
:   Material slot in an object

    link
    :   Link material to object or the object’s data

        Type:
        :   enum in [`'OBJECT'`, `'DATA'`], default `'DATA'`

    material
    :   Material data-block used by this material slot

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

    name
    :   Material slot name

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with Select Control Point Row in a Blender add-on or script – include code.

assistant: Selects the control points that are on the same grid line as the active one (similar to
[edge loop selection](../meshes/selecting/loops.xhtml#bpy-ops-mesh-loop-multi-select) for meshes).
Invoke the operator again to use the grid line in the other direction.
user: Explain Freestyle Module (freestyle) in complete detail according to the official Blender documentation.

assistant: # Freestyle Module (freestyle)

This module provides data types of view map components (0D and 1D
elements), base classes for defining line stylization rules
(predicates, functions, chaining iterators, and stroke shaders),
as well as helper functions for style module writing.
user: Explain Clamp To Constraint in complete detail according to the official Blender documentation.

assistant: # Clamp To Constraint

The *Clamp To* constraint snaps an object or bone to a [Curve](../../../modeling/curves/introduction.html).
Specifically, it works as follows:

- If no explicit *Main Axis* is chosen, the constraint picks one automatically based on the longest
  side of the Curve’s bounding box.
- Using this axis, it compares the original coordinate of the object or bone to the minimum and maximum
  coordinates of the Curve, and remaps it to the range 0-1 accordingly.
- This remapped coordinate is then used as a “curve time” to determine the position along the Curve,
  where a value of 0 corresponds to the first control point and 1 to the last.

Unless the Curve is a perfectly straight line, the object’s/bone’s coordinate along the *Main Axis*
will likely change.

If the object or bone moves along the Curve in the opposite direction than the expected one,
use [Switch Direction](../../../modeling/curves/editing/segments.html#bpy-ops-curve-switch-direction) to flip the order of the Curve’s control points.
user: Explain TexMapping(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # TexMapping(bpy_struct)

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

*class* bpy.types.TexMapping(*bpy_struct*)
:   Texture coordinate mapping settings

    mapping
    :   - `FLAT`
          Flat – Map X and Y coordinates directly.
        - `CUBE`
          Cube – Map using the normal vector.
        - `TUBE`
          Tube – Map with Z as central axis.
        - `SPHERE`
          Sphere – Map with Z as central axis.

        Type:
        :   enum in [`'FLAT'`, `'CUBE'`, `'TUBE'`, `'SPHERE'`], default `'FLAT'`

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

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

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

    max
    :   Maximum value for clipping

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

    min
    :   Minimum value for clipping

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

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

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

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

    use_max
    :   Whether to use maximum clipping value

        Type:
        :   boolean, default False

    use_min
    :   Whether to use minimum clipping value

        Type:
        :   boolean, default False

    vector_type
    :   Type of vector that the mapping transforms

        Type:
        :   enum in [Mapping Type Items](bpy_types_enum_items/mapping_type_items.html#rna-enum-mapping-type-items), default `'POINT'`

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

assistant: See [Editing Strips](../../../video_editing/edit/montage/editing.xhtml) for more information.

Mirror
:   Interactive Mirror `Ctrl`-`M`
    :   Starts mirror operation based on mouse cursor position

    X Global
    :   Mirrors the image in global X coordinates

    Y Global
    :   Mirrors the image in global Y coordinates

    X Local
    :   Mirrors the image in local X coordinates

    Y Local
    :   Mirrors the image in local Y coordinates

Duplicate `Shift`-`D`
:   The *Duplicate* operator creates a copy of the selected strip(s)
    and places them in the nearest available channel above the original.

    The duplicated content remain selected, allowing immediate repositioning.

Copy `Ctrl`-`C`
:   Adds selected strips to copy-paste buffer.

Paste `Ctrl`-`V`
:   Paste strips from copy-paste buffer.

Animation
:   Insert Keyframe `I`
    :   See [Insert Keyframe](../../../animation/keyframes/editing.xhtml#bpy-ops-anim-keyframe-insert).

    Insert Keyframe with Keying Set `K`
    :   See [Insert Keyframe with Keying Set](../../../animation/keyframes/editing.xhtml#bpy-ops-anim-keyframe-insert-menu).

    Change Keying Set `Shift`-`K`
    :   See [Set Active Keying Set](../../../animation/keyframes/keying_sets.xhtml#bpy-ops-anim-keying-set-active-set).

    Delete Keyframes `Alt`-`I`
    :   See [Delete Keyframes](../../../animation/keyframes/editing.xhtml#bpy-ops-anim-keyframe-delete).

    Clear Keyframes `Shift`-`Alt`-`I`
    :   See [Clear Keyframes](../../../animation/keyframes/editing.xhtml#bpy-ops-anim-keyframe-clear).

Show/Hide
:   Show Hidden Strips `Alt`-`H`
    :   Reveals all hidden/muted strips.

    Hide Selected `H`
    :   Mutes the selected strips.

    Hide Unselected `Shift`-`H`
    :   Mutes all strips except for the currently selected strips.

Delete
:   Delete selected strips
user: Give a detailed overview of Inherited Properties: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`LineStyleAlphaModifier.name`](bpy.types.LineStyleAlphaModifier.html#bpy.types.LineStyleAlphaModifier.name "bpy.types.LineStyleAlphaModifier.name") |
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Color 1/2
:   Color of the bricks.

Mortar
:   The color of the area between bricks.

Scale
:   Overall texture scale.

Mortar Size
:   The size of the filling between the bricks known as “mortar”; 0 means no mortar.

Mortar Smooth
:   Blurs/softens the edge between the mortar and the bricks.
    This can be useful with a texture and displacement textures.

Bias
:   The color variation between *Color 1/2*.
    Values of -1 and 1 only use one of the two colors; values in between mix the colors.

Brick Width
:   The width of the bricks.

Row Height
:   The height of the brick rows.
user: Give a detailed overview of Snake Hook: syntax, arguments, return values, common patterns.

assistant: # Snake Hook

Pulls vertices along with the movement of the brush to create long, snake-like forms.
During the stroke, geometry will be dynamically picked up & let go.

When the *Rake* setting is used,
the brush can also be used to rotate geometry via dragging.
user: Show practical ways to work with GeometryNodeOffsetPointInCurve(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeOffsetPointInCurve(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.GeometryNodeOffsetPointInCurve(*GeometryNode*)
:   Offset a control point index within its 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 ReadOnlyInteger(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ReadOnlyInteger(bpy_struct)

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

*class* bpy.types.ReadOnlyInteger(*bpy_struct*)
:   value
    :   Type:
        :   int in [-inf, inf], default 0, (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 Point Light in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Point light.

The point light is an omnidirectional point of light,
that is, a point radiating the same amount of light in all directions.
It’s visualized by a plain, circled dot.
Being a point light source, the direction of the light hitting an object’s surface
is determined by the line joining the light and the point on the surface of the object itself.
It can be used as simple model of e.g. a light bulb.

Light intensity/energy decays based on (among other variables)
distance from the point light to the object. In other words,
surfaces that are further away will be rendered darker.

Power
:   Power of the light. Higher values increase the intensity of the light.
    Negative values can be set, but should be avoided for predictable and physically based result.

Radius
:   When larger than zero, light will be emitted from a spherical surfaces with the specified radius.
    Lights with larger size have softer shadows and specular highlights, and they will also appear dimmer
    because their power is distributed over a larger area.

Soft Falloff
:   Apply falloff to avoid sharp edges when the light geometry intersects with other objects.
user: Show practical ways to work with Detect Features in a Blender add-on or script – include code.

assistant: Detects all possible features on the current frame and places markers at these features.
This operator does not take other frames into account,
so it might place markers on features which belong to moving objects.
If the camera is turning away from this shot,
no markers could be present within the frames after the camera moved away.

There are several properties for this operator:

Placement
:   Controls where to place markers.

    Whole Frame
    :   Places markers throughout the whole frame.

    Inside Annotated Area
    :   Places markers inside the area outlined with the [Annotation Tools](../../../../interface/annotate_tool.xhtml#tool-annotate).
        This can be used to outline some areas with interesting features
        and place markers only inside the outlined area.

    Outside Annotated Area
    :   Places markers outside the area outlined with the [Annotation Tools](../../../../interface/annotate_tool.xhtml#tool-annotate).
        This can be used to outline areas of no interest (like trees, humans, etc.)
        and place markers outside of these areas.

Margin
:   Controls the distance from the image boundary for created markers.
    If markers are placed too close to the image boundary,
    they will fail to track really quickly and they should be deleted manually.
    To reduce the amount of manual clean-up, this parameter can be used.

Threshold
:   Limits minimal threshold for placing markers.
    This value comes from the feature detection algorithm and it means:
    low values means most probably this feature would fail to track very soon,
    high value means it is not much such track.
    Amount of markers to be added can be controlled with this value.

Distance
:   Defines the minimal distance between placed markers.
    It is needed to prevent markers from being placed too close to each other
    (such placement can confuse the camera solver).
user: Explain Nodes(bpy_struct) in complete detail according to the official Blender documentation.

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 Named Attributes Overlay: syntax, arguments, return values, common patterns.

assistant: The “Named Attributes” overlay allows displaying when a custom named attribute is used
by a node or a node group. Named attributes can be used by the
[Capture Attribute Node](attribute/capture_attribute.xhtml), the
[Named Attribute Node](geometry/read/named_attribute.xhtml), and the
[Remove Named Attribute Node](attribute/remove_named_attribute.xhtml),
and can be written to, read, or removed.

Using named attributes (as opposed to [Anonymous Attributes](attributes_reference.xhtml#anonymous-attributes)) can be problematic
when the original geometry already has attributes with the specified names. In that case
a geometry node group might mistakenly overwrite some essential data. The overlay helps
to make detecting that situation easy.

The same data is also available in the [Named Attributes](../modifiers/geometry_nodes.xhtml#modifiers-geometry-nodes-named-attributes) panel
in the modifier’s UI.
user: What is Point(bpy_struct) and how is it used in Blender Python scripting?

assistant: # Point(bpy_struct)

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

*class* bpy.types.Point(*bpy_struct*)
:   Point in a point cloud

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

    index
    :   Index of this point

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

    radius
    :   Type:
        :   float in [-inf, inf], 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 GeometryNodeCurvePrimitiveBezierSegment(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeCurvePrimitiveBezierSegment(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.GeometryNodeCurvePrimitiveBezierSegment(*GeometryNode*)
:   Generate a 2D Bézier spline from the given control points and handles

    mode
    :   Method used to determine control handles

        - `POSITION`
          Position – The start and end handles are fixed positions.
        - `OFFSET`
          Offset – The start and end handles are offsets from the spline’s control points.

        Type:
        :   enum in [`'POSITION'`, `'OFFSET'`], default `'POSITION'`

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

assistant: The most common trick is to
[Keyframe](../../glossary/index.xhtml#term-Keyframe) animate the location or rotation of an *Active* physics object as well as
the *Animated* checkbox.
When the curve on the *Animated* property switches to disabled, the physics engine takes over
using the object’s last known location, rotation and velocities.

Animating the strengths of various other parameters
(a [Motor’s](constraints/types/motor.xhtml) Target Velocity,
a [Hinge’s](constraints/types/hinge.xhtml) limits, etc.)
can be used to accomplish a wide variety of interesting results.

Enabling a constraint during the physics simulation often has dramatic results
as the physics engine tries to bring into alignment two objects which are often dramatically out of alignment.
It is very common for the affected objects to build up enough kinetic energy to bounce themselves out of camera.

Rigid body dynamics can be baked to normal keyframes with *Bake To Keyframes*
in the Object ‣ Rigid Body menu.
user: Describe Mesh Sequence Cache Modifier from the Blender manual or Python API, including usage steps and snippets.

assistant: # Mesh Sequence Cache Modifier

The Mesh Sequence Cache modifier loads data from [Alembic](../../../files/import_export/alembic.html)
and [USD](../../../files/import_export/usd.html) files.
It supports static meshes, but is mostly used to load animated meshes.
Despite its name, this modifier also supports curves. It also handles file sequences,
as well as meshes and curves with varying topology (like the result of fluid simulations).

When importing an [Alembic](../../../files/import_export/alembic.html) or
[USD](../../../files/import_export/usd.html) file,
Mesh Sequence Cache modifiers 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.html#bpy-types-transformcacheconstraint) is used.
Files other than Alembic or USD, like MDD and PC2 files, can be loaded using
the [Mesh Cache modifier](mesh_cache.html).
user: Explain Example in complete detail according to the official Blender documentation.

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

assistant: Allows you to limit rendering to a 2D rectangular area. If you’re busy tweaking
just a small part of the scene, it can be quite wasteful to have the whole viewport in
[Rendered shading mode](../display/shading.xhtml#view3d-viewport-shading) or make full-frame renders,
so this feature lets you save time.

You can define Render Regions in two different contexts:

- If you define one while in [Camera View](camera_view.xhtml),
  it will apply not just to the viewport, but also to the final render.
  If you want to temporarily disable this region rather than clearing it entirely,
  you can do so in the Output tab of the [Properties](../../../render/output/properties/format.xhtml#bpy-types-rendersettings-use-border) editor.
- If you define one while not in Camera View, it will only apply to the viewport.
  If you want to temporarily disable this region rather than clearing it entirely,
  you can do so in the [Sidebar](../sidebar.xhtml#bpy-types-spaceview3d-use-render-border).

Both Render Regions can exist at the same time.

Render region and associated render.

|  |  |
| --- | --- |
| ../../../_images/editors_3dview_navigate_regions_render-border-1.png | ../../../_images/editors_3dview_navigate_regions_render-border-2.png |
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Curve
:   Standard geometry input.

Selection
:   Whether or not to resample each spline. True values mean spline will be resampled to a poly spline,
    false values mean the spline will be unaffected.

Mode
:   How to specify the amount of samples.

    Count:
    :   Sample the specified number of points along each spline.

    Length:
    :   Calculate the number of samples by splitting each spline into segments with the specified length.
        The length will be rounded down so that a whole number of samples will fit in each input spline.

    Evaluated:
    :   Evaluate the spline’s points based on the resolution attribute for NURBS and Bézier splines.
        Changes nothing for poly splines.

Count Count
:   The number of control points on the new splines.

Length Length
:   The approximate length between the control points of the new splines.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`NodeCombineBundle.bundle_items`](bpy.types.NodeCombineBundle.html#bpy.types.NodeCombineBundle.bundle_items "bpy.types.NodeCombineBundle.bundle_items") - [`NodeCombineBundleItems.new`](bpy.types.NodeCombineBundleItems.html#bpy.types.NodeCombineBundleItems.new "bpy.types.NodeCombineBundleItems.new") | - [`NodeCombineBundleItems.remove`](bpy.types.NodeCombineBundleItems.html#bpy.types.NodeCombineBundleItems.remove "bpy.types.NodeCombineBundleItems.remove") |
user: Show practical ways to work with Inserting Text in a Blender add-on or script – include code.

assistant: You can insert text in two ways: from the internal text buffer or from a text file.

Using an existing text data-block, you can convert it to an object from the Text editor’s header,
select Edit ‣ Text to 3D Object,
*One Object* or *One Object per Line* depending on your needs.

It is also possible to paste from the clipboard or a file, while editing 3D text.

### Accent Characters

Many special characters (such as accented chars, which are not directly available on your keyboard)
can be “composed” using a combination of two other characters. To do so,
type the main char, press `Alt`-`Backspace`,
and then press the desired “modifier” to produce the special character.
Some examples are given below:

|  |  |
| --- | --- |
| - ã: `A`, `Alt`-`Backspace`, `~` - á: `A`, `Alt`-`Backspace`, `'` - à: `A`, `Alt`-`Backspace`, `\` - â: `A`, `Alt`-`Backspace`, `^` - å: `A`, `Alt`-`Backspace`, `O` - æ: `A`, `Alt`-`Backspace`, `E` - ª: `A`, `Alt`-`Backspace`, `-` - ë: `E`, `Alt`-`Backspace`, `"` - ç: `C`, `Alt`-`Backspace`, `,` - ¢: `C`, `Alt`-`Backspace`, `|` | - ø: `O`, `Alt`-`Backspace`, `/` - §: `S`, `Alt`-`Backspace`, `S` - †: `|`, `Alt`-`Backspace`, `-` - ‡: `|`, `Alt`-`Backspace`, `=` - ©: `O`, `Alt`-`Backspace`, `C` - ®: `O`, `Alt`-`Backspace`, `R` - ™: `T`, `Alt`-`Backspace`, `M` - ½: `1`, `Alt`-`Backspace`, `2` - ÷: `-`, `Alt`-`Backspace`, `:` - ±: `-`, `Alt`-`Backspace`, `+` |
user: Show practical ways to work with Floor Constraint in a Blender add-on or script – include code.

assistant: # Floor Constraint

The *Floor* constraint sets up a flat and infinitely large floor (or wall, or ceiling)
which the constrained object or bone cannot pass through.

Like other constraints, the *Floor* constraint only looks at the
[origin](../../../scene_layout/object/origin.html) for objects; their geometry is not taken into account.
This means that, if a cube’s origin is at its center and a *Floor* constraint is added targeting a
floor plane, the cube will still be able to sink halfway into the plane.
The *Offset* can be used to mitigate this.
user: Give a detailed overview of Before Starting: syntax, arguments, return values, common patterns.

assistant: This document is intended to familiarize you with Blender Python API
but not to fully cover each topic.

A quick list of helpful things to know before starting:

- Enable [Developer Extra](https://docs.blender.org/manual/en/dev/editors/preferences/interface.html#bpy-types-preferencesview-show-developer-ui "(in Blender 5.1 Manual v5.1)")
  and [Python Tooltips](https://docs.blender.org/manual/en/dev/editors/preferences/interface.html#bpy-types-preferencesview-show-tooltips-python "(in Blender 5.1 Manual v5.1)").
- The [Python Console](https://docs.blender.org/manual/en/dev/editors/python_console.html#bpy-types-spaceconsole "(in Blender 5.1 Manual v5.1)")
  is great for testing one-liners; it has autocompletion so you can inspect the API quickly.
- Button tooltips show Python attributes and operator names (when enabled see above).
- The context menu of buttons directly links to this API documentation (when enabled see above).
- Many python examples can be found in the text editor’s template menu.
- To examine further scripts distributed with Blender, see:

  - `scripts/startup/bl_ui` for the user interface.
  - `scripts/startup/bl_operators` for operators.

  Exact location depends on platform, see:
  [directory layout docs](https://docs.blender.org/manual/en/dev/advanced/blender_directory_layout.html#blender-directory-layout "(in Blender 5.1 Manual v5.1)").

### Running Scripts

The two most common ways to execute Python scripts are using the built-in
text editor or entering commands in the Python console.
Both the *Text Editor* and *Python Console* are space types you can select from the header.
Rather than manually configuring your spaces for Python development,
you can use the *Scripting* workspace accessible from the Topbar tabs.

From the text editor you can open `.py` files or paste them from the clipboard, then test using *Run Script*.
The Python Console is typically used for typing in snippets and for testing to get immediate feedback,
but can also have entire scripts pasted into it.
Scripts can also run from the command line with Blender but to learn scripting in Blender this isn’t essential.
user: Provide the full official documentation entry for Time, preserving all code examples.

assistant: The maximum number of frames for each scene is currently 1,048,574, and allows for continuous shots for durations of:

24 fps:
:   12 hours, 8 minutes.

25 fps:
:   11 hours, 39 minutes.

30 fps:
:   9 hours, 42 minutes.

60 fps:
:   4 hours, 51 minutes.
user: Describe Accessing Brushes from the Blender manual or Python API, including usage steps and snippets.

assistant: In modes that use painting or sculpting functionality, the [Asset Shelf](../../interface/window_system/regions.xhtml#ui-region-asset-shelf) of the 3D
Viewport and Image Editor displays brush assets that can be used in that mode. Clicking a brush asset will activate
the Brush Tool if necessary, with the clicked brush set.

[image reference removed]

The Asset Shelf of the 3D Viewport, providing access to brush assets.

This asset shelf is also available as popup in the [Tool Settings](../../interface/window_system/regions.xhtml#ui-region-tool-settings), the
[Sidebar](../../interface/window_system/regions.xhtml#ui-region-sidebar), [Properties](../../editors/properties_editor.xhtml) and using a shortcut.
user: Show practical ways to work with Pivot Constraint in a Blender add-on or script – include code.

assistant: # Pivot Constraint

The *Pivot* constraint makes an object or bone rotate around a point other than
its [origin](../../../scene_layout/object/origin.xhtml). This can be a point that’s relative
to the same or another object/bone, or a point that’s fixed in space.
user: Explain KeyConfig(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # KeyConfig(bpy_struct)

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

*class* bpy.types.KeyConfig(*bpy_struct*)
:   Input configuration, including keymaps

    is_user_defined
    :   Indicates that a keyconfig was defined by the user

        Type:
        :   boolean, default False, (readonly)

    keymaps
    :   Key maps configured as part of this configuration

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

    name
    :   Name of the key configuration

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: - Lights can only have one color and do not support light node trees.
- Unlike in Cycles, the [Size](../../lights/light_object.html#bpy-types-spotlight-shadow-soft-size)
  of spot lights does not change the softness of the cone.
- The area light [Beam spread](../../lights/light_object.html#bpy-types-spotlight-spot-size) option is not supported.
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: R
:   The radial distance from the origin in the X-Y plane.

Phi
:   The angular position around the Z axis.

Z
:   The vertical component of the input vector, corresponding directly to its Z coordinate.
user: How do I use Final Considerations in Blender? Include parameters, examples, warnings and best practices.

assistant: As this guide showed, there is more to stereo 3D rendering than just generate two images.
The earlier the stereo pipeline is considered the smoother it will get.
The following sections are a more in-depth view of the individual components we visited in the workflow.
user: Explain Set Active Keying Set in complete detail according to the official Blender documentation.

assistant: There are several ways to designate the active keying set:

- Press `Shift`-`K` in the 3D Viewport.
- Select a keying set in the [Keying Set](#bpy-types-keyingsets) panel.
- Select a keying set in the [Keying popover](../animation_editors.xhtml#animation-editors-keying) in the Timeline header,