PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe MovieTrackingMarkers(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # MovieTrackingMarkers(bpy_struct)

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

*class* bpy.types.MovieTrackingMarkers(*bpy_struct*)
:   Collection of markers for movie tracking track

    find_frame(*frame*, *\**, *exact=True*)
    :   Get marker for specified frame

        Parameters:
        :   - **frame** (*int in* *[**0**,* *1048574**]*) – Frame, Frame number to find marker for
            - **exact** (*boolean**,* *(**optional**)*) – Exact, Get marker at exact frame number rather than get estimated marker

        Returns:
        :   Marker for specified frame

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

    insert_frame(*frame*, *\**, *co=(0.0, 0.0)*)
    :   Insert a new marker at the specified frame

        Parameters:
        :   - **frame** (*int in* *[**0**,* *1048574**]*) – Frame, Frame number to insert marker to
            - **co** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-1, 1], (optional)) – Coordinate, Place new marker at the given frame using specified in normalized space coordinates

        Returns:
        :   Newly created marker

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

    delete_frame(*frame*)
    :   Delete marker at specified frame

        Parameters:
        :   **frame** (*int in* *[**0**,* *1048574**]*) – Frame, Frame number to delete marker from

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

assistant: # Despeckle Node

[image reference removed]

The *Despeckle* node is used to smooth areas of an image in which noise is noticeable,
while leaving complex areas untouched.

This works by the standard deviation of each pixel and its neighbors is calculated to determine
if the area is one of high complexity or low complexity.
If the complexity is lower than the threshold then the area is smoothed using a simple mean filter.
user: Give a detailed overview of Smooth Hair Curves: syntax, arguments, return values, common patterns.

assistant: # Smooth Hair Curves

The *Smooth Hair Curves* node relaxes and evens out the shape of hair curves by averaging
their control points over multiple iterations.
It is useful for reducing noise, smoothing deformation artifacts, or refining groomed hair shapes
after other operations such as frizz or noise deformation.
user: Describe Tags and Translations from the Blender manual or Python API, including usage steps and snippets.

assistant: If you are planning to use a different set of [tags](../tags.html#extensions-tags) than the ones used by
Blender Extensions Platform, remember to submit a pull request to
[tags.py](https://projects.blender.org/blender/blender/src/scripts/modules/_bpy_internal/extensions/tags.py).

This way they can be shown translated within Blender.
user: Provide the full official documentation entry for Specials, preserving all code examples.

assistant: Show All
:   Unhides any hidden bone collections.

Un-Solo All
:   Clear the ‘solo’ setting on all bone collections

Remove Unused
:   Remove all bone collections that have neither bones nor children.
    This is done recursively, so bone collections that only have unused children are also removed.
user: Show practical ways to work with Usage in a Blender add-on or script – include code.

assistant: ### Visibility Management

Each [Scene](../../scene_layout/scene/introduction.xhtml) consists of one or more
[Collections](../../scene_layout/collections/collections.xhtml).
Collections can be enabled or disabled per View Layer, allowing you to control what appears in each layer’s render.

This makes it easy to separate lighting, characters, props, or effects into their own passes.

Collection visibility for each View Layer can be adjusted in the [Outliner](../../editors/outliner/editing.xhtml#editors-outliner-editing-collections) or [Collection View Layer Properties](../../scene_layout/collections/collections.xhtml#bpy-types-layercollection).

[image reference removed]

View Layer collections in the Outliner.

From the Outliner, you can:

- Enable or disable collections per View Layer.
- Set holdout and indirect-only options (Cycles only).
- Manage what objects contribute to the render or compositing.

### Rendering & Compositing

When a scene is rendered, each View Layer is available in the
[Compositor](../../compositing/introduction.xhtml) using they [Render Layers Node](../../compositing/types/input/scene/render_layers.xhtml).
This allows you to process each layer independently, combining or adjusting them to create the final output.

Each View Layer can output multiple [Render Passes](passes.xhtml) including:

- Combined (final image)
- Diffuse, Glossy, Transmission components
- Shadow, Mist, Ambient Occlusion
- Cryptomatte and Object/Material/ID Masks
- Data passes like Normal, UV, and Depth

These passes make it possible to perform detailed color grading,
masking, relighting, and other post-processing operations in a non-destructive workflow.
user: Show practical ways to work with Animation & Overrides in a Blender add-on or script – include code.

assistant: Due to current design of animation data in Blender, what is editable in overrides’ animations can
change greatly depending on whether animation data was already defined in the linked reference
data-block. Animation data is created for a datablock if it gets animated by keyframes, or
through drivers.

In general, an overrides can do much more with its animation data if no animation data exists
in its linked reference data-block.

**Keyframes (a.k.a. F-Curves)**

[Keyframed animation](../../animation/keyframes/introduction.html) belongs to another data-block
(an Action one). So it is possible to assign a purely local Action data-block replacing
the one linked from the library. This will completely replace the keyframed animation
from the linked data though, and not override it in any way.

Overridden Action data-blocks only support a very limited amount of editing.
For example, an existing F-Curve can be muted, but its keyframes cannot be edited,
and no new F-Curve can be added.

**Drivers**

If the linked reference data has animation data, then its overrides only have
limited possibilities to edit the existing [drivers](../../animation/drivers/introduction.html).
For example, it will be possible to change the exisitng target of a driver,
but it won’t be possible to add new drivers, or new targets to an existing driver.

If the linked reference data has no animation data, then its overrides will create a new one
when they get some drivers defined. Drivers can then be fully edited, added or removed,
just as with purely local data-blocks.

**NLA**

The [NLA editor](../../editors/nla/introduction.html) data also belongs to the animation data
of a data-block. However, this data does support some greater level of editing in overrides,
including moving or resizing existing strips from the linked data, and adding new local strips.
user: Describe Visibility from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Ray Visibility

Objects can be set to be invisible to particular ray types.
This can be used, for example, to make an emitting mesh invisible to camera rays.
For instanced objects, visibility is inherited; if the parent object is hidden for some ray types,
the children will be hidden for these too.

In terms of performance, using these options is more efficient that using a shader node setup
that achieves the same effect.

Camera
:   Makes the object visible to the [Camera](../../cameras.xhtml);
    this includes the viewport’s perspective in viewport rendering.

Shadow
:   Enables the object to cast shadows. The object will not be capture inside the shadow maps.

### Light Probes

Objects can be set to not be captured by certain [light probe](../light_probes/index.xhtml).
This can be used, for example, to avoid animated object being recorded into static light probes.
For instanced objects, visibility is inherited; if the parent object is hidden for some ray types,
the children will be hidden for these too.

Volume
:   Makes the object visible during light probe volumes [baking](../light_probes/volume.xhtml#eevee-lightprobe-volume-bake).

Sphere
:   Makes the object visible during light probe sphere capture.

Plane
:   Makes the object visible during light probe plane capture.
user: Provide the full official documentation entry for Armature Modifier, preserving all code examples.

assistant: # Armature Modifier

The *Armature* Modifier is used for building skeletal systems for animating
the poses of characters and anything else which needs to be posed.

By adding an armature to an object,
this object can be deformed accurately so that geometry does not have to be animated by hand.
user: Show practical ways to work with The Big Picture in a Blender add-on or script – include code.

assistant: - Activate Freestyle by the Properties ‣ Render ‣ Freestyle checkbox.
- Freestyle settings are located in the [View Layer](../layers/index.html) properties.
- One view layer can only have one view map. A view map holds the edge detection settings
  (Crease Angle, Culling toggle, Face Smoothness toggle, Material Boundaries toggle,
  Sphere Radius, and Kr Derivative Epsilon advanced options).
- A view map can have multiple Line Sets.
- A line set controls which line types and selections will be rendered, from lines based on your scene.
- Each line set uses one line style (which can be shared between multiple Line Sets).
- A line style tells Freestyle how to render the linked Line Sets in terms of color, alpha,
  thickness and other aspects.

[image reference removed]

Block diagram of Freestyle view map and processes.
user: What is Image Info Node and how is it used in Blender Python scripting?

assistant: # Image Info Node

[[image reference removed]](../../../../_images/node-types_GeometryNodeImageInfo.webp)

The *Image Info* node gets information from image and animation.
This can be useful to generate parameters in the geometry node for arbitrary images. Image information can be either
general or frame-specific.
user: Describe Point from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Marker schematic.

The whole marker can be moved with `RMB` or by dragging the anchor point (black dot) with `LMB`.
Pressing `G` also moves the whole marker. When pressing `G` twice the marker will be moved
while keeping the anchor in place. Note that the anchor point outside the pattern area is shown as a cross connected
with marker position with a dashed line.

`S` scales the whole marker.
The whole pattern area only will be scaled by pressing `S` twice;
The Pattern can also be rotated using the `R` key which, depending on the used pivot point,
will either rotate patterns around their own centers or rotate the whole markers around e.g. the median point.

To match the perspective transformation of a marker on a plane, the individual corners must be edited manually.
Each marker corner can deform individually to define the shapes.
Corner positions can be edited by dragging them with a mouse.
Dragging with `LMB` will change the position of an individual corner.

The Search area can not be rotated; this is intentional. It doesn’t make sense to deform the search area.
user: Describe ArmatureConstraint(Constraint) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ArmatureConstraint(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.ArmatureConstraint(*Constraint*)
:   Applies transformations done by the Armature modifier

    targets
    :   Target Bones

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

    use_bone_envelopes
    :   Multiply weights by envelope for all bones, instead of acting like Vertex Group based blending. The specified weights are still used, and only the listed bones are considered.

        Type:
        :   boolean, default False

    use_current_location
    :   Use the current bone location for envelopes and choosing B-Bone segments instead of rest position

        Type:
        :   boolean, default False

    use_deform_preserve_volume
    :   Deform rotation interpolation with quaternions

        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: What is Plane Track and how is it used in Blender Python scripting?

assistant: # Plane Track

[image reference removed]

Plane Track panel.

Its properties are shown only when a plane track is selected.

Name
:   The name of the selected plane track is shown. It can also be changed from here.

Auto Keyframe
:   Toggles the auto-keyframing for corners of the plane track.
    With this enabled, keyframes will automatically get inserted when any corner is moved.

Image
:   Field to select or create an image which will be displayed inside the plane track.
    This image is for preview purposes in the Movie Clip editor only.
    To include it in your final render,
    see [Plane Track Deform node](../../../../../compositing/types/tracking/plane_track_deform.xhtml).

New Image from Plane Track
:   Creates an image from the pixels of the Movie Clip that the plane marker “sees” at the current frame.
    This allows to create an unwarped texture of any flat surface in the footage.
    The resulting image can then be used for editing and retouching, for example to paint out certain parts
    of the footage.

Update Image from Plane Track
:   Updates the pixels of the active Plane Track’s image.

Opacity
:   Used to set the opacity of this image. Again,
    this is for display purposes only, and will not affect your final render.
user: Describe CollectionExport(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CollectionExport(bpy_struct)

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

*class* bpy.types.CollectionExport(*bpy_struct*)
:   export_properties
    :   Properties associated with the configured exporter

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

    filepath
    :   The file path used for exporting

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

    is_open
    :   Whether the panel is expanded or closed

        Type:
        :   boolean, default False

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Component
:   There are two components that can be used to control the look of the hair.
    Usually you are going to want each of these and use a [Mix Node](mix.html).

    Reflection:
    :   The light that bounces off the surface of the hair.

    Transmission:
    :   The light that passes through the hair and exits on the other side.

    [image reference removed]

    With Mix node: 0 is full Reflection, 1 is full Transmission.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`BlendData.window_managers`](bpy.types.BlendData.html#bpy.types.BlendData.window_managers "bpy.types.BlendData.window_managers") | - [`Context.window_manager`](bpy.types.Context.html#bpy.types.Context.window_manager "bpy.types.Context.window_manager") |
user: How do I use Rigid Body Cache in Blender? Include parameters, examples, warnings and best practices.

assistant: The *Cache* subpanel specifies the frame range in which the simulation is active.
Can be used to bake the simulation.

Start/End
:   First and last frame of the simulation.

Bake
:   Calculates the simulation and protects the cache. You need to be in *Object Mode* to bake.

Delete Bake
:   Active after the baking of simulation. Clears the baked cache.

Calculate to Frame
:   Bake physics to current frame.

Current Cache to Bake
:   Bake from Cache.

Bake All Dynamics
:   Bake all physics.

Delete All Bakes
:   Deletes all baked caches of all objects in the current scene.

Update All to Frame
:   Update cache to current frame.

If you have not saved the blend-file, the cache is created in memory,
so save your file first or the cache may be lost.
user: What is View Tab and how is it used in Blender Python scripting?

assistant: ### Display

You can set the editor’s display options in this panel.

Aspect Ratio X, Y
:   Display aspect for this image. Does not affect rendering.

Repeat Image
:   Tile the image so it completely fills the editor.

Pixel Coordinates
:   Use pixel coordinates rather than relative coordinates (0 to 1) for the UV Vertex
    and 2D Cursor Location fields.

### 2D Cursor

Location X, Y
:   View and change the location of the 2D Cursor.

### Annotations

Options for the [Annotate tool](../../interface/annotate_tool.xhtml).
user: Give a detailed overview of Transform: syntax, arguments, return values, common patterns.

assistant: Tools for moving control points.

Move, Rotate, Scale
:   See [Basic Transformations](../../../scene_layout/object/editing/transform/introduction.xhtml).

To Sphere, Shear, Bend, Push/Pull, Warp, Randomize
:   See [Mesh Transformations](../../meshes/editing/mesh/transform/index.xhtml).

Move/Scale Texture Space
:   See [Texture Space](../../meshes/uv/uv_texture_spaces.xhtml#properties-texture-space).
user: Describe Usage from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Creating a Sequencer Scene

To start using the Sequencer, you first need to create or use an existing Scene.

1. Open a workspace that contains a [Video Sequence Editor](../editors/video_sequencer/index.xhtml).
2. Press the “New” button in the [Sequencer header region](../editors/video_sequencer/sequencer/navigating.xhtml) to
   create a new Sequencer Scene, or select an existing Scene.

### Working with Multiple Scenes

Since the sequencer scene is separate from the active scene in the window
it is possible to work with scene strips in the sequencer while also viewing
and editing the referenced scenes within the same workspace.

A common setup includes:

- Workspace with a Video Sequence Editor and a 3D Viewport.
- In the VSE, a Sequencer Scene (e.g. called “Edit”).
- Multiple other scenes in the same file e.g. for different locations or shots.

Now add a few scene strips in the sequencer using the existing scenes (or new scenes).
Then enable the Sync Scene Time option in the Sequencer Playback Controls region.
This will update the active scene (and therefor what is visible in the 3D Viewport)
with whatever scene the current scene strip in the Sequencer references.

This setup allows to quicky switch between different scenes just by scrubbing/playing
the Sequencer timeline.
user: Give a detailed overview of ShaderFxSwirl(ShaderFx): syntax, arguments, return values, common patterns.

assistant: # ShaderFxSwirl(ShaderFx)

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

*class* bpy.types.ShaderFxSwirl(*ShaderFx*)
:   Swirl effect

    angle
    :   Angle of rotation

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

    object
    :   Object to determine center location

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

    radius
    :   Radius to apply

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

    use_transparent
    :   Make image transparent outside of radius

        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: What is Interpolate Sequence and how is it used in Blender Python scripting?

assistant: Interpolate strokes between the previous and next keyframe by adding *multiple* keyframes.
When you are on a frame between two keyframes and click the sequence button
a breakdown keyframe will be added on every frame between the previous and next keyframe.

Step
:   The number of frames between generated interpolated frames.

Layer
:   Restrict the interpolation to Active or All layers.

Only Selected Edit Mode
:   When enabled, only selected strokes will be interpolated.

Exclude Breakdowns
:   Exclude existing [Breakdowns keyframes](../../animation/keyframes/introduction.html#keyframe-type) as interpolation extremes.

Flip Mode
:   Invert strokes start and end. Automatic will try to found the right mode for every stroke.

Smooth
:   Amount of smoothing to apply to interpolated strokes for reducing jitter/noise.

Iterations
:   Number of time to smooth newly created strokes.

Type
:   Interpolation method to use for the sequence.
user: Describe Geometry from the Blender manual or Python API, including usage steps and snippets.

assistant: # Geometry

In this tab you control the geometry of your strokes.
It contains only the option to add modifiers.

As they always completely apply to the strokes’ geometry (like object modifiers do).
They take the resulting two-dimensional strokes from the Freestyle line set and
displace or deform them in various ways.

As with other modifier stacks in Blender, they are applied from top to bottom.

[[image reference removed]](../../../../_images/render_freestyle_parameter-editor_line-style_geometry_tab.png)

Line Style: Geometry.
user: Give a detailed overview of Select Similar: syntax, arguments, return values, common patterns.

assistant: Selects control points that are similar in some way to a selected control point.
The [Adjust Last Operation](../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel provides options for this:

Type
:   Which property to compare for determining similarity.

    Type:
    :   This option does not apply for Surfaces because, unlike Curves, they only support one handle type.

    Radius:
    :   Selects control points that have a similar Radius value.
        See [Transform Panel](properties/transform_panel.xhtml).

    Weight:
    :   Selects control points that have a similar Weight value.
        See [Transform Panel](properties/transform_panel.xhtml).

    Direction:
    :   Selects control points that have a similar normal vector.

Compare
:   How to compare unselected control points to selected ones.

    Equal:
    :   Select control points whose property is equal to that of a selected point.

    Greater:
    :   Select control points whose property is greater than or equal to the smallest property
        among the selected points.

    Less:
    :   Select control points whose property is less than or equal to the greatest property
        among the selected points.

Threshold
:   Tolerance value for also including control points whose property is close to the property
    of a selected point. For example, if a selected control point has a Weight of 0.6 and
    the *Threshold* is set to 0.1, *Select Similar* will include all control points that have
    a Weight between 0.5 and 0.7.
user: Explain ByteIntAttributeValue(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # ByteIntAttributeValue(bpy_struct)

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

*class* bpy.types.ByteIntAttributeValue(*bpy_struct*)
:   8-bit value in geometry attribute

    value
    :   Type:
        :   int in [-128, 127], default 0

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Capture Attribute Node: syntax, arguments, return values, common patterns.

assistant: # Capture Attribute Node

[image reference removed]

The *Capture Attribute* node stores one or more fields on a geometry,
and outputs those same fields so they can be read by other nodes.

This storing and retrieving of a field can also be done with the
[Store Named Attribute Node](store_named_attribute.xhtml)
and the [Named Attribute Node](../geometry/read/named_attribute.xhtml)
respectively. The difference is that the *Capture Attribute* node creates
an [anonymous attribute](../attributes_reference.xhtml#anonymous-attributes), meaning there’s no
need to specify a name and there’s no clutter at the end.
This makes the node ideal for temporary data storage.

A common use case is saving information that would normally be lost while
converting geometry – see the example below.
user: Provide the full official documentation entry for Store Named Attribute Node, preserving all code examples.

assistant: # Store Named Attribute Node

[image reference removed]

The *Store Named Attribute* node stores the result of a field on a geometry
as an attribute with the specified name. If the attribute already exists, the data
type and domain will be updated to the values chosen in the node.
However, keep in mind that the domain and data type of [Built-In Attributes](../attributes_reference.html#geometry-nodes-builtin-attributes)
cannot be changed.

Compared with the [Capture Attribute Node](capture_attribute.html), this node basically
does the same thing, but the attribute gets a name instead of an anonymous reference.
For reusing the data in the same node tree, the *Capture Attribute* node might be preferable
since it does not create the chance for name conflicts in the input geometry.
user: Show practical ways to work with Text Fields in a Blender add-on or script – include code.

assistant: Fixed strings are used internally, and while it is not useful to list all limits, here are some common limits.
*Used for data-block names, modifiers, vertex groups, UV layers…*

directory:
:   767

file-name:
:   255

file-path:
:   1023

identifier:
:   63
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Weighting Mode
:   The normals around a vertex will be combined to create a custom (per face corner) normal
    using various weights for each. The *Weighting Mode* defines how to compute the weights.

    Face Area
    :   Weight according to the area of the face that the normal originates.
        A larger area means that the normal from that face will get a higher weight in final result.

    Corner Angle
    :   Weight according to the angle each face forms at the vertex.
        This is the method Blender uses by default when combining face normals to compute a vertex one.

    Face Area and Angle
    :   Weights are obtained by multiplying the face area and corner angle ones.

Weight
:   Determines how strongly the weights are biased according to the face areas and/or corner angles,
    a bit like a contrast setting for a picture.

    A value of 50 means all faces are weighted uniformly.
    More than 50 means faces with higher area or angles are given even more weight (more “contrast”).
    Less than 50 means faces with higher area or angles are given lesser weights (less “contrast”).

Threshold
:   A weight-rounding threshold which means that, if two angles or areas differ by less than that threshold,
    they will get equal weights.

Keep Sharp
:   Preserve [sharp edges](../../geometry_nodes/attributes_reference.xhtml#geometry-nodes-builtin-attributes),
    though smoothing will still happen if there are multiple faces between any two sharp edges.

Face Influence
:   Use face weights (weak, medium, or strong) as assigned by
    the [Set Strength](../../meshes/editing/mesh/normals.xhtml) tool or
    by the *Set Strength* mode of a [Bevel](../generate/bevel.xhtml) modifier.

    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.

Vertex Group
:   If a vertex group is specified, the modifier will only affect those vertices.
    The “arrow” button to its right will invert the selection (only affect the vertices *not* in the vertex group).
user: Give a detailed overview of Edit Mode: syntax, arguments, return values, common patterns.

assistant: - [Mesh Edit Mode](../../modeling/meshes/selecting/index.xhtml)
- [Curve Edit Mode](../../modeling/curves/selecting.xhtml)
- [Surface Edit Mode](../../modeling/surfaces/selecting.xhtml)
- [Metaball Edit Mode](../../modeling/metas/toolbar/index.xhtml#meta-toolbar-index)
- [Text Edit Mode](../../modeling/texts/selecting.xhtml)
- [Grease Pencil Edit Mode](../../grease_pencil/modes/edit/selecting.xhtml)
- [Bone Edit Mode](../../animation/armatures/bones/selecting.xhtml)
- [Lattice Edit Mode](../../animation/lattice.xhtml)
user: Describe Header from the Blender manual or Python API, including usage steps and snippets.

assistant: A header is a small horizontal strip, which sits either at the top or bottom of an area.
All editors have a header acting as a container for menus and commonly used tools.
[Menus](../controls/buttons/menus.xhtml#bpy-types-uipopupmenu) and buttons will change with the editor type and
the selected object and mode.

[image reference removed]

The Header of the 3D Viewport.

### Context Menu

`RMB` on a header reveals a context menu with a couple options:

Show Header
:   Toggles the visibility of the header.
    If a header is hidden, it can be made visible again by clicking or dragging
    the small arrow that appears at the top/bottom right of the editor.

Show Tool Settings
:   Toggles the visibility of the [Tool Settings](#tool-settings).

Show Menus
:   Toggles whether the [Menus](../controls/buttons/menus.xhtml#bpy-types-uipopupmenu) are collapsed or not.

Flip to Bottom/Top
:   Toggles whether the header or Tool Settings appear on the top or bottom of the editor.

Vertical/Horizontal Split
:   Shows an indicator line that lets you select the area and position where to split.
    `Tab` switches between vertical/horizontal.

Maximize Area / Focus Mode
:   See [Maximize Area](areas.xhtml#bpy-ops-screen-screen-full-area).

Duplicate Area into New Window
:   See [Duplicate Area into New Window](areas.xhtml#bpy-ops-screen-area-dupli).

Close Area
:   Closes the area and replaces it with the expansion of a neighboring area.
user: How do I use Clear Parent in Blender? Include parameters, examples, warnings and best practices.

assistant: You can *remove* a parent-child relationship via `Alt`-`P`.

Clear Parent
:   If the parent in the group is selected, nothing is done.
    If a child or children are selected, they are disassociated from the parent,
    or freed, and they return to their *original* location, rotation, and size.

Clear and Keep Transformation
:   Frees the children from the parent, and *keeps* the location, rotation, and size given to them by the parent.

    See [Non-Uniform Scale](#non-uniform-scale) which may apply here.

Clear Parent Inverse
:   Instead of removing the hierarchical parent-child relationship, this clears
    the [Parent Inverse](#parent-inverse) matrix from the selected objects. With an empty matrix,
    the location, rotation and scale properties of the children are interpreted
    in the coordinate space of the parent.
user: Explain Surface in complete detail according to the official Blender documentation.

assistant: Surface
:   The curve surface is an optional mesh that is used to anchor the curves, and behave as a scalp for hair grooming.
    When adding a new Curves object via the **Add Menu** the active object is automatically set as the surface.

    To set a new surface press `Ctrl`-`P` and select *Object (Attach Curves to Surface)*
    in the *Set Parent To* pop-up menu. This option can be seen as part of the Curves settings in the Properties
    Editor.

    [image reference removed]

Surface UV Map
:   The name of the attribute on the surface mesh used to define the attachment of each curve.
user: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

[image reference removed]

Cycles is Blender’s physically-based path tracer for production rendering.
It is designed to provide physically based results out-of-the-box,
with artistic control and flexible shading nodes for production needs.

To use Cycles, select it as the *Render Engine* in the Render properties.
For [GPU accelerated rendering](gpu_rendering.xhtml),
enable compatible devices in Preferences ‣ System ‣ Cycles Render Devices.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Instances
:   Standard geometry input.

Selection
:   Boolean field used to determine if an instance will be rotated.

Rotation
:   The [Euler](../../../glossary/index.html#term-Euler) rotation to rotate the instances by.

Pivot Point
:   The position around which each instance is rotated. If the *Local Space* input is true,
    the location is relative to the initial transform of the instance.

Local Space
:   If enabled, the instances are rotated in local space. In other words,
    they are rotated around the axes described by the initial transform of each instance.
    When the input is disabled, the pivot point and rotation are specified in
    the local space of the modifier object.
user: Describe Example from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Render result, left and right views.

The views to render are defined in the current scene views,
in a similar way as you define the composite output resolution in the current scene render panel,
regardless of the Image nodes resolutions or Render Layers from different scenes.
user: How do I use Select More/Less in Blender? Include parameters, examples, warnings and best practices.

assistant: Expands or contracts the selection based on the currently selected control points.

More
:   Adds the neighbors of the selected control points to the selection.

Less
:   Removes the control points with at least one unselected neighbor from the selection.
user: What is Example and how is it used in Blender Python scripting?

assistant: Lattice modifier example.

|  |  |
| --- | --- |
| ../../../_images/grease-pencil_modifiers_deform_lattice_original.png   Original model. | ../../../_images/grease-pencil_modifiers_deform_lattice_edit.png   After lattice editing. |
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Color
:   Color of the surface, or physically speaking, the probability that light is reflected for each wavelength.

Size
:   Parameter between 0.0 and 1.0 that gives an angle of reflection between 0° and 90°.

Smooth
:   This value specifies an angle over which a smooth transition from full to no reflection happens.

Normal
:   Normal used for shading; if nothing is connected the default shading normal is used.
user: Provide the full official documentation entry for Collection, preserving all code examples.

assistant: # Collection

*Instance Collections* allows you to create an instance of a collection for each instance of another object.
Collections may contain animations, objects with physics simulations and even other nested collections.
user: Show practical ways to work with GeometryNodeInputTangent(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeInputTangent(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.GeometryNodeInputTangent(*GeometryNode*)
:   Retrieve the direction of curves at each control point

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

assistant: # Introduction

Scenes are a way to organize your work. Each blend-file can contain multiple scenes,
which may share other data such as objects, materials, and collections.

A scene defines the visible objects, camera view, lighting setup,
and render settings that make up a specific part of a project.
For example, a single blend-file may include multiple scenes for different shots,
lighting setups, or stages of a production pipeline.

Scene management and library linking are based on Blender’s
[Library and Data System](../../files/index.xhtml).
If you are not familiar with the concepts of data-blocks, linking, and appending,
it is recommended to read that page first.
user: Explain String to Value Node in complete detail according to the official Blender documentation.

assistant: # String to Value Node

[image reference removed]

The *String to Value* node converts a text string into a numerical value.
This is useful for parsing numbers from text input, file data, or dynamically generated strings.

The node reads characters from the beginning of the string until a valid number is parsed.
If parsing is unsuccessful, the node outputs a floating-point value of 0.
user: What is Thickness and how is it used in Blender Python scripting?

assistant: Printers have a limited *wall-thickness* where very thin areas cannot be printed,
this test uses ray casting and a distance range to the thickness of the geometry.

Minimum/Maximum
:   Minimum/Maximum thickness to display.

Samples
:   Number of samples to use to calculate the thickness.

[image reference removed]

Thickness.
user: Show practical ways to work with Notes in a Blender add-on or script – include code.

assistant: In some configurations of the node, especially for low values of *Randomness*,
rendering artifacts may occur. This happens due to the same reasons described
in the [Notes section](white_noise.xhtml#shader-white-noise-notes) in the White Noise Texture page
and can be fixed in a similar manner as described there.
user: Explain GpPaint(Paint) in complete detail according to the official Blender documentation.

assistant: # GpPaint(Paint)

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

*class* bpy.types.GpPaint(*Paint*)
:   color_mode
    :   Paint Mode

        - `MATERIAL`
          Material – Paint using the active material base color.
        - `VERTEXCOLOR`
          Color Attribute – Paint the material with a color attribute.

        Type:
        :   enum in [`'MATERIAL'`, `'VERTEXCOLOR'`], default `'MATERIAL'`

    *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 Line Set in complete detail according to the official Blender documentation.

assistant: # Line Set

A line set selects, among the lines (edges) detected by Freestyle,
which ones will be rendered using its attached
[line style](line_style/index.html), through various methods.

[image reference removed]

Freestyle Line Set panel.

Select By
:   Image Border
    :   Causes Freestyle to only take geometry within the image border into consideration for line calculation.
        This reduces render times but increases continuity problems when geometry is moved out of and
        into camera view.
user: Give a detailed overview of Primitives: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Empty Display Types.

### Plain Axes

Displays as six lines, initially with one pointing in each of the +X, -X, +Y, -Y, +Z, and -Z axis directions.

### Arrows

Displays as arrows, initially pointing in the positive X, Y, and Z axis directions, each with a label.

### Single Arrow

Displays as a single arrow, initially pointing in the +Z axis direction.

### Circle

Displays as a circle initially in the XZ plane.

### Cube

Displays as a cube, initially aligned to the XYZ axes.

### Sphere

Displays as an implied sphere defined by three circles.
Initially, the circles are aligned, one each, to the X, Y, and Z axes.

### Cone

Displays as a cone, initially pointing in the +Y axis direction.

### Image

Empties can display images. This can be used to create reference images,
including blueprints or character sheets to model from.
The image is displayed regardless of the 3D display mode.

Empty Displays settings can be accessed from Properties ‣ Object Data ‣ Empty panel.

Offset X, Y
:   Offset the image origin
    (where 1.0 represents the width/height of the image).

    X=0.5, Y=0.5:
    :   Object origin at image center.

    X=0.0, Y=0.0:
    :   Object origin at image bottom, left.

    X=1.0, Y=1.0:
    :   Object origin at image top, right.

Depth
:   Default:
    :   Use normal depth behavior.

    Front:
    :   Always display on top of other objects.

    Back:
    :   Always display behind of other objects.

Side
:   Both:
    :   Display both the front and back of the empty.

    Front:
    :   Only display the front of the image.

    Back:
    :   Only display the back of the image.

Show in
:   Orthographic
    :   Show in orthographic view.

    Perspective
    :   Show in perspective view.

    Only Axis Aligned
    :   Only displays the image contents when the view is aligned with the object’s local axis.

Opacity
:   Blends the image with the background. The value slider adjusts the opacity of the image,
    changing how much of the image is blended with the background.
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Axis
:   Local axis of the object that is to be rotated towards the vector input.

Pivot
:   The local axis to rotate around.

    Auto:
    :   The best rotation angle is computed automatically.
        This minimizes the angle of rotation.

    X, Y, Z:
    :   Rotate around a specific local axis.