PGCRYPT/OpenBlender_Train huggingface dataset:
user: Give a detailed overview of Locking Vertex Groups: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Lock a vertex group.

Right after creation of a vertex group,
an open padlock icon shows up on the right side of the list entry.
This icon indicates that the vertex group can be edited.
You can add vertex assignments to the group or remove assignments from the group.
And you can change it with the weight paint brushes, etc.

When you click on the icon,
it changes to a closed padlock icon and all vertex group modifications get disabled.
You can only rename or delete the group, and unlock it again.
No other operations are allowed on locked vertex groups,
thus all corresponding buttons become disabled for locked vertex groups.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Data Type
:   Float:
    :   The output will be a single floating-point value.

    Vector:
    :   The output will be a vector of three floating-point values.
        All calculations are elementwise.

Domain
:   The [attribute domain](../attributes_reference.html#attribute-domains) used for the statistics
    and to evaluate the input *Attribute* field on.
user: Explain Extensions in complete detail according to the official Blender documentation.

assistant: The core glTF 2.0 format can be extended with extra information, using glTF extensions.
This allows the file format to hold details that were not considered universal at the time of first publication.
Not all glTF readers support all extensions, but some are fairly common.

Certain Blender features can only be exported to glTF via these extensions.
The following [glTF 2.0 extensions](https://github.com/KhronosGroup/glTF/tree/main/extensions)
are supported directly by this add-on:

Import

- `KHR_materials_pbrSpecularGlossiness`
- `KHR_materials_clearcoat`
- `KHR_materials_transmission`
- `KHR_materials_unlit`
- `KHR_materials_emissive_strength`
- `KHR_materials_volume`
- `KHR_materials_sheen`
- `KHR_materials_specular`
- `KHR_materials_anisotropy`
- `KHR_materials_ior`
- `KHR_materials_variants`
- `KHR_lights_punctual`
- `KHR_texture_transform`
- `KHR_mesh_quantization`
- `EXT_mesh_gpu_instancing`

Export

- `KHR_draco_mesh_compression`
- `KHR_lights_punctual`
- `KHR_materials_clearcoat`
- `KHR_materials_transmission`
- `KHR_materials_unlit`
- `KHR_materials_emissive_strength`
- `KHR_materials_volume`
- `KHR_materials_sheen`
- `KHR_materials_specular`
- `KHR_materials_anisotropy`
- `KHR_materials_ior`
- `KHR_materials_variants`
- `KHR_texture_transform`
- `EXT_mesh_gpu_instancing`

### Third-party glTF Extensions

It is possible for Python developers to add Blender support for additional glTF extensions by writing their
own third-party add-on, without modifying this glTF add-on. For more information, [see the example on GitHub](https://github.com/KhronosGroup/glTF-Blender-IO/tree/main/example-addons/) and if needed,
[register an extension prefix](https://github.com/KhronosGroup/glTF/blob/main/extensions/Prefixes.md).
user: What is Usage and how is it used in Blender Python scripting?

assistant: ### Selecting a Brush and Material

In the Tool Settings select the brush, material and color type to use with the tool.
The Circle tool uses *Draw Brush* types.
See [Brush Settings](../brushes/draw.html#grease-pencil-draw-common-options) for more information.

### Creating Circles

1. Click (`LMB` or the `Pen` tip) and drag the start point.
2. Release on the desired end point.
3. After releasing you can move the start and end point by clicking and dragging on the yellow manipulators.
4. Then confirm (`Return`/`MMB`) or cancel (`Esc`/`RMB`).

While dragging you can use `Shift` to make a perfect circle
or use `Alt` to create the circle from a center point.

`NumpadPlus` and `NumpadMinus` or using the mouse `Wheel`
will increase or decrease the amount of points in the final circle.

`F` will adjust the line thickness and `Shift`-`F` will adjust the opacity of the strokes.

|  |  |  |
| --- | --- | --- |
| <../../../../_images/grease-pencil_modes_draw_tools_circle_example-01.png>   Click and dragging the start point. | <../../../../_images/grease-pencil_modes_draw_tools_circle_example-02.png>   Moving start and end points with manipulators. | <../../../../_images/grease-pencil_modes_draw_tools_circle_example-03.png>   The circle after confirming. |
user: Give a detailed overview of Bend: syntax, arguments, return values, common patterns.

assistant: # Bend

Bend Transform with Clamp on and off.

|  |  |  |
| --- | --- | --- |
| <../../../../../_images/modeling_meshes_editing_mesh_transform_bend_example-clamp-1.png>   Before. | <../../../../../_images/modeling_meshes_editing_mesh_transform_bend_example-clamp-2.png>   Clamp on. | <../../../../../_images/modeling_meshes_editing_mesh_transform_bend_example-clamp-3.png>   Clamp off. |

This tool rotates a line of selected elements forming an arc between the mouse cursor and the 3D cursor.
user: Give a detailed overview of Example Script: syntax, arguments, return values, common patterns.

assistant: ```
# This example assumes we have a mesh object selected

import bpy
import bmesh

# Get the active mesh
me = bpy.context.object.data

# Get a BMesh representation
bm = bmesh.new()   # create an empty BMesh
bm.from_mesh(me)   # fill it in from a Mesh

# Modify the BMesh, can do anything here...
for v in bm.verts:
    v.co.x += 1.0

# Finish up, write the bmesh back to the mesh
bm.to_mesh(me)
bm.free()  # free and prevent further access
```

### Standalone Module

The BMesh module is written to be standalone except for [`mathutils`](mathutils.html#module-mathutils "mathutils")
which is used for vertex locations and normals.
The only other exception to this are when converting mesh data to and from [`bpy.types.Mesh`](bpy.types.Mesh.html#bpy.types.Mesh "bpy.types.Mesh").
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Image
:   Standard color input image.

Type
:   Defines the method used to generate the chromatic aberration effect.

    Offset:
    :   Offsets individual color channels along the X or Y axis.
        A simple and fast way to create horizontal or vertical color fringing.

    Scale:
    :   Scales each color channel differently from the image center,
        creating a radial dispersion effect.

    Directional Blur:
    :   Blurs color channels along a specific direction to simulate motion-like chromatic smearing.

    Lens Dispersion:
    :   Simulates wavelength-dependent refraction through a lens,
        creating realistic radial rainbow edges near the image borders.

Axis Offset
:   Determines the axis along which channel offsets occur.

    Vertical:
    :   Applies offsets vertically.

    Horizontal:
    :   Applies offsets horizontally.

Factor
:   Controls the intensity of the aberration.
    Higher values increase the separation between color channels and make the effect more visible.

Center Directional Blur
:   The pivot point around which directional transformations occur.
    Defined in normalized coordinates (0.0-1.0 across the image).

Samples Directional Blur
:   Sets the number of samples used to compute the directional blur.
    More samples produce a smoother result but increase computation time.
    The number of samples is *2ⁿ*, growing exponentially with this input.

Fit Lens Dispersion
:   Scales the resulting image to fit entirely within the frame,
    avoiding empty borders caused by radial dispersion.
user: How do I use Strip Menu in Blender? Include parameters, examples, warnings and best practices.

assistant: See [Editing Strips](../../../video_editing/edit/montage/editing.html) 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.html#bpy-ops-anim-keyframe-insert).

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

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

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

    Clear Keyframes `Shift`-`Alt`-`I`
    :   See [Clear Keyframes](../../../animation/keyframes/editing.html#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: What is Handling Time and how is it used in Blender Python scripting?

assistant: Unlike Blender and many other applications and file formats, Alembic files don’t have any concept of frames.
Alembic works purely with time, and values that are sampled over time. For example,
there is no way to distinguish 30 FPS with 2 samples per frame, and 60 FPS with 1 sample per frame.
This has caused many developers to just
[hard-coded 24 FPS](https://projects.blender.org/blender/blender/issues/55288)
when reading Alembic files.

Blender uses the current scene frame rate to convert a frame number (in Blender) to a time
in seconds (in Alembic). As a result, you can import an Alembic file that was produced at 120 FPS into
a Blender scene that is 30 FPS and still not see any time stretching.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Curves
:   The input geometry containing the curves whose segment lengths should be restored.

Selection
:   A boolean field selecting which points or segments are affected.
    Unselected elements remain unchanged.

Factor
:   Controls the overall influence of the length restoration.
    A value of 0.0 leaves the curves as they are, while 1.0 fully restores the original segment lengths.

Reference Position
:   The reference position of the curve points before deformation.
    This is used to compute the original segment lengths that the node will attempt to restore.

Pin at Parameter
:   Specifies a parameter along each curve to act as a fixed anchor point during restoration.
    The operation adjusts other points relative to this pinned location, preventing unwanted shifting.
user: What is Brush Settings and how is it used in Blender Python scripting?

assistant: ### General

### Unique

Persistent
:   Allows the cloth brush to not accumulate deformation after each stroke.
    This is convenient to always simulate the cloth based on the same initial shape,
    but applying different forces to it.

    When disabled, deformations accumulate after each stroke.

Set Persistent Base
:   Resets the base mesh so that you can add another layer of deformations.

Simulation Area
:   Selects the part of the mesh that is going to be simulated when the stroke is active.
    This can greatly affect performance depending on the complexity of the mesh.

    Local
    :   Simulates only a specific area around the brush limited by a fixed radius.

    Global
    :   Simulates the entire mesh.

    Dynamic
    :   The active simulation area moves with the brush while still being limited by a fixed radius.

Simulation Limit
:   The Factor added relative to the size of the radius to limit the cloth simulation effects.

Simulation Falloff
:   The area to apply deformation falloff to the effects of the simulation.
    This setting is a factor of the *Simulation Limit* and is shown as a dashed line around the cursor.

Pin Simulation Boundary
:   Lock the position of the vertices in the simulation falloff area to avoid artifacts
    and create a softer transition with unaffected areas.

Deformation
:   The type of cloth deformation that is used by the brush.

    Drag:
    :   Simulates pulling the cloth to the cursor,
        similar to placing a finger on a table cloth and pulling.

    Push:
    :   Simulates pushing the cloth away from the cursor,
        similar to placing a finger on a table cloth and pushing.

    Pinch Point:
    :   Simulates pulling the cloth into a point.

    Pinch Perpendicular:
    :   Simulates pulling the brush into a line.

    Inflate:
    :   Simulates air being blown under the cloth so that the cloth lifts up.

    Grab:
    :   Simulates picking up and moving the cloth.

    Expand:
    :   Simulates stretching the cloth out.

    Snake Hook:
    :   Simulates moving the cloth without producing any artifacts in the surface
        and creates more natural looking folds than any of the other deformation modes.
        This is accomplished by adjusting the strength of the deformation constraints per brush step
        to avoid affecting the results of the simulation as much as possible.

Force Falloff
:   Shape used in the brush to apply force to the cloth.

    Radial:
    :   Applies the force as a sphere.

    Plane:
    :   Applies the force as a plane.

Cloth Mass
:   Mass of each simulation particle.

Cloth Damping
:   How much the applied forces are propagated through the cloth.

Soft Body Plasticity
:   The amount the cloth preserves its original shape,
    acting as a [Soft Body](../../../physics/soft_body/index.xhtml).

Use Collisions
:   Enables the detection of collisions with other objects during the simulation.
    In order for the sculpt object to collide with objects,
    the collision object must have [Collision Physics](../../../physics/collision.xhtml) activated.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`Action.slots`](bpy.types.Action.html#bpy.types.Action.slots "bpy.types.Action.slots") - [`ActionChannelbag.slot`](bpy.types.ActionChannelbag.html#bpy.types.ActionChannelbag.slot "bpy.types.ActionChannelbag.slot") - [`ActionChannelbags.new`](bpy.types.ActionChannelbags.html#bpy.types.ActionChannelbags.new "bpy.types.ActionChannelbags.new") - [`ActionConstraint.action_slot`](bpy.types.ActionConstraint.html#bpy.types.ActionConstraint.action_slot "bpy.types.ActionConstraint.action_slot") - [`ActionConstraint.action_suitable_slots`](bpy.types.ActionConstraint.html#bpy.types.ActionConstraint.action_suitable_slots "bpy.types.ActionConstraint.action_suitable_slots") - [`ActionKeyframeStrip.channelbag`](bpy.types.ActionKeyframeStrip.html#bpy.types.ActionKeyframeStrip.channelbag "bpy.types.ActionKeyframeStrip.channelbag") - [`ActionKeyframeStrip.key_insert`](bpy.types.ActionKeyframeStrip.html#bpy.types.ActionKeyframeStrip.key_insert "bpy.types.ActionKeyframeStrip.key_insert") - [`ActionSlot.duplicate`](#bpy.types.ActionSlot.duplicate "bpy.types.ActionSlot.duplicate") | - [`ActionSlots.active`](bpy.types.ActionSlots.html#bpy.types.ActionSlots.active "bpy.types.ActionSlots.active") - [`ActionSlots.new`](bpy.types.ActionSlots.html#bpy.types.ActionSlots.new "bpy.types.ActionSlots.new") - [`ActionSlots.remove`](bpy.types.ActionSlots.html#bpy.types.ActionSlots.remove "bpy.types.ActionSlots.remove") - [`AnimData.action_slot`](bpy.types.AnimData.html#bpy.types.AnimData.action_slot "bpy.types.AnimData.action_slot") - [`AnimData.action_suitable_slots`](bpy.types.AnimData.html#bpy.types.AnimData.action_suitable_slots "bpy.types.AnimData.action_suitable_slots") - [`NlaStrip.action_slot`](bpy.types.NlaStrip.html#bpy.types.NlaStrip.action_slot "bpy.types.NlaStrip.action_slot") - [`NlaStrip.action_suitable_slots`](bpy.types.NlaStrip.html#bpy.types.NlaStrip.action_suitable_slots "bpy.types.NlaStrip.action_suitable_slots") |
user: What is Expand Active Face Set and how is it used in Blender Python scripting?

assistant: Expands an existing face set with a geodesic falloff.
This operator uses the same internal operator as [Expand](#bpy-ops-sculpt-expand)
meaning all the hotkeys and functionality works the same as that tool.

### Usage

Resizing Face Sets
:   Resize a Face Set along the surface distances.
    It is an alternative to [Grow/Shrink Face Sets](face_sets.xhtml#bpy-ops-sculpt-face-set-edit)
    which follows the topology instead of geodesic distances.

Joining Face Sets
:   When holding `Ctrl` the expansion will instead snap to other Face Sets.
    This is a fast way of joining multiple face sets into one.
user: How do I use Curve Widget in Blender? Include parameters, examples, warnings and best practices.

assistant: # Curve Widget

[image reference removed]

Curve widget.

This widget is used to edit two types of curves:

- *Profile* curves that simply describe a two-dimensional shape.
- *Mapping* curves that map an input value on the X axis to an output value on the Y axis.

The available options are slightly different depending on this type. Also, unlike profile curves,
mapping curves can’t have overhang: each X value must correspond to exactly one Y value.
user: Describe Generate Hair Curves from the Blender manual or Python API, including usage steps and snippets.

assistant: # Generate Hair Curves

The *Generate Hair Curves* node procedurally creates new hair curves on the surface of a mesh.
It generates curves from scratch at sampled point locations rather than using existing hair data.
For cases where curves should interpolate or follow existing guides, use the
[Interpolate Hair Curves](interpolate_hair_curves.xhtml) node instead.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Movie Clip
:   Used to select the movie clip whose distortion is to be used.
    This can be useful if more than one movie clips are present, each having a different distortion setting.
    For controls see [Data-Block Menu](../../../interface/controls/templates/data_block.xhtml#ui-data-block).
user: How do I use Frizz Hair Curves in Blender? Include parameters, examples, warnings and best practices.

assistant: # Frizz Hair Curves

The *Frizz Hair Curves* node introduces small random displacements along hair curves to create
a frizzy or irregular look.
It is commonly used to add natural variation to grooms by breaking up overly smooth or uniform
strand shapes.
user: Describe Placement from the Blender manual or Python API, including usage steps and snippets.

assistant: There are a few methods to position the 3D Cursor.

### Direct Placement with the Mouse

[image reference removed]

Positioning the 3D Cursor with two orthogonal views.

The Cursor tool offers the most flexibility. Simply select it in the Toolbar
and click a point in the scene with `LMB` to place the 3D Cursor there.
In the tool settings, you can choose how it should be oriented:
by default, it matches the view orientation, but you can also make it
match the surface normal of a piece of geometry,
or the [transform orientation](controls/orientation.xhtml).

Alternatively, you can press `Shift`-`RMB` with any tool selected.
In this case, the 3D Cursor will always be aligned to the view orientation.

For accuracy you should use two perpendicular orthogonal 3D Viewports,
i.e. any combination of top `Numpad7`, front `Numpad1` and side `Numpad3`.
That way you can control the positioning along two axes in one view and
determine the depth in the other.

By default, the depth of the geometry under the cursor is used.
This can be disabled using the *Cursor Surface Project* toggle
in the [Preferences](../preferences/editing.xhtml).

### Sidebar

[image reference removed]

The 3D Cursor panel of the Sidebar region.

The 3D Cursor can also be positioned and oriented by editing the
respective values in the Sidebar.

### Snapping

One more way of positioning the 3D Cursor is through the Snap menu,
which allows you to move the Cursor to the origin of the selected object
for example.
user: Describe Laptops from the Blender manual or Python API, including usage steps and snippets.

assistant: Laptops often have two GPUs for power saving purposes. One slower onboard GPU integrated into the main CPU (typically
Intel or AMD) that uses lower power, and one faster dedicated GPU for better performance (AMD or NVIDIA) that uses
more power.

For the best performance, the dedicated GPU should be used for Blender. Which GPU to use for which application can be
configured in your graphics driver or operating system settings.

If there is a graphics glitch or crash specific to the onboard GPU, then using the dedicated GPU can help avoid that.
Or vice versa, if the dedicated GPU causes issues, then using the onboard graphics can help.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

The Edge Split modifier.

Edge Angle
:   When enabled, an edge will be split if the angle between its
    two adjacent faces is greater than the *Split Angle*.

    Split Angle
    :   On 0: all edges are split. On 180: no edges are split.

Sharp Edges
:   When enabled, edges will be split if they were [marked as sharp](../../meshes/editing/edge/edge_data.xhtml#bpy-ops-mesh-mark-sharp).
user: Show practical ways to work with Selecting View Layers in a Blender add-on or script – include code.

assistant: At the top of the *View Layer Properties* tab is a list of all View Layers in the active scene.

[image reference removed]

View Layers list.

Name
:   The name of the active View Layer. Click to edit.

Add View Layer
:   Adds a new View Layer to the scene.

    - **New**: Adds an empty View Layer.
    - **Copy Settings**: Duplicates the current View Layer, including collection visibility and overrides.
    - **Blank**: Adds a new View Layer with all collections disabled.

Remove View Layer
:   Deletes the selected View Layer from the scene.
user: Show practical ways to work with Simulation Brushes in a Blender add-on or script – include code.

assistant: These brushes are similar to regular brushes but with an additional cloth simulation applied.
These are ideally used on a relatively low resolution, since the mesh density defines the size of cloth dynamics.

[image reference removed]

Drag Cloth
:   Brush Type: [Cloth](cloth.xhtml)

    Nudges the geometry along the surface while minimally affecting the overall shape of the object.

Push Cloth
:   Brush Type: [Cloth](cloth.xhtml)

    Pushes geometry inwards or outwards.

Grab Cloth
:   Brush Type: [Cloth](cloth.xhtml)

    Grabs geometry within the brush radius firmly, while surrounding geometry is being simulated to follow.

Grab Planar Cloth
:   Brush Type: [Cloth](cloth.xhtml)

    Similar to Grab Cloth but with a line as the brush radius instead of a circle.

Grab Random Cloth
:   Brush Type: [Cloth](cloth.xhtml)

    Similar to Grab Cloth but with a noise texture applied to create more random variation.

Inflate Cloth
:   Brush Type: [Cloth](cloth.xhtml)

    Inflates the geometry outwards or inwards.

Expand/Contract Cloth
:   Brush Type: [Cloth](cloth.xhtml)

    Creates compression or stretching on geometry.

Pinch Point Cloth
:   Brush Type: [Cloth](cloth.xhtml)

    Pinches geometry to the center point of the radius, creating folds from all sides.

Pinch Folds Cloth
:   Brush Type: [Cloth](cloth.xhtml)

    Pinches only from two perpendicular sides along the stroke direction, creating parallel folds along the stroke.

Bend/Twist Cloth
:   Brush Type: [Pose](pose.xhtml)

    A pose brush that rotates geometry.

Stretch/Move Cloth
:   Brush Type: [Pose](pose.xhtml)

    A pose brush that translates and scales geometry.

Bend Boundary Cloth
:   Brush Type: [Boundary](boundary.xhtml)

    Bend only open boundaries of the mesh, folding the surrounding geometry in the process.

Twist Boundary Cloth
:   Brush Type: [Boundary](boundary.xhtml)

    Twist open boundaries of the mesh, creating twisting folds.
user: Give a detailed overview of Driver(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # Driver(bpy_struct)

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

*class* bpy.types.Driver(*bpy_struct*)
:   Driver for the value of a setting based on an external value

    expression
    :   Expression to use for Scripted Expression

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

    is_simple_expression
    :   The scripted expression can be evaluated without using the full Python interpreter

        Type:
        :   boolean, default False, (readonly)

    is_valid
    :   Driver could not be evaluated in past, so should be skipped

        Type:
        :   boolean, default False

    type
    :   Driver type

        Type:
        :   enum in [`'AVERAGE'`, `'SUM'`, `'SCRIPTED'`, `'MIN'`, `'MAX'`], default `'AVERAGE'`

    use_self
    :   Include a ‘self’ variable in the name-space, so drivers can easily reference the data being modified (object, bone, etc…)

        Type:
        :   boolean, default False

    variables
    :   Properties acting as inputs for this driver

        Type:
        :   [`ChannelDriverVariables`](bpy.types.ChannelDriverVariables.html#bpy.types.ChannelDriverVariables "bpy.types.ChannelDriverVariables") [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`DriverVariable`](bpy.types.DriverVariable.html#bpy.types.DriverVariable "bpy.types.DriverVariable"), (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](#bpy.types.Driver.type "bpy.types.Driver.type")
user: Show practical ways to work with Bake Channels in a Blender add-on or script – include code.

assistant: Generates new keyframes for the selected curves.

Frame Range
:   The range that will be baked. Defaults to the scene range or preview range.

Frame Step
:   Distance between keyframes. Can be used to create a keyframe every 10 frames or even every half frame.

Remove Outside Range
:   Removes existing keys outside the specified baking range.

Interpolation Type
:   The [interpolation type](../fcurves/properties.html#editors-graph-fcurves-settings-interpolation) for the new keys.

Bake Modifiers
:   If enabled, the new keyframes are based on the modified curve, and the modifiers get deleted.

    If disabled, the new keyframes are based on the original curve, and the modifiers stay applied.
user: Provide the full official documentation entry for Bevel, preserving all code examples.

assistant: Apply a Bevel to turn the 1D line (or 2D ribbon when using [Extrude](#bpy-types-curve-extrude))
into a 3D tube.

### Round

The cross section of the tube becomes a circle (or pill when using Extrude).
You can also get a half circle by changing the [Fill Mode](shape.xhtml#bpy-types-curve-fill-mode).

Depth
:   The size of the cross section.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_curves_properties_geometry_bevel-depth.png   Small Depth. | ../../../_images/modeling_curves_properties_geometry_bevel.png   Large Depth. |

Resolution
:   Drives the number of vertices in the cross section.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_curves_properties_geometry_bevel-resolution.png   A low Resolution results in a blocky mesh. | ../../../_images/modeling_curves_properties_geometry_bevel.png   A high Resolution results in a smooth mesh. |

Fill Caps
:   Seals the ends of the tube.

### Object

This option lets you fully customize the shape of the cross section by selecting a separate Curve object.

[image reference removed]

Object
:   The curve that defines the cross section. It can be either closed ([cyclic](../editing/curve.xhtml#bpy-ops-curve-cyclic-toggle))
    or open.

### Profile

This option lets you customize the shape of the cross section without having to create a separate
Curve object. However, unlike the *Object* option where the curve defines the full cross section,
the *Profile* in the [Curve Widget](../../../interface/controls/templates/curve.xhtml#ui-curve-widget) only defines a quarter which is then repeated and mirrored.

[image reference removed]

The black dots on the profile represent the points where it’s sampled (that is, where mesh vertices
will be created). You can increase the *Resolution* to get more sample points, and thus a smoother result.

Preset
:   You can choose one of the predefined profiles instead of making your own.
    The *Support Loops* and *Steps* presets are generated dynamically based on the *Resolution*
    and need to be reapplied if you change it.

Reverse Path
:   Mirrors the profile around the diagonal.

Toggle Profile Clipping
:   Limits the X and Y coordinates of control points to the range [0, 1].

Sample Straight Edges
:   Whether to sample the profile in the middle of perfectly straight segments
    (lines between two control points with the *Vector* [handle type](../../../interface/controls/templates/curve.xhtml#ui-curve-widget-handle-type)).
    This is disabled by default, as it’s normally enough to sample the profile at the control
    points themselves.

Sample Even Lengths
:   By default, each profile segment receives the same number of sample points.
    By enabling this option, the sample points are instead distributed evenly
    along the whole length of the profile.
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: # Introduction

Constraints are a way of automatically controlling the location, rotation,
and scale of an [object](../../glossary/index.xhtml#term-Object) or [bone](../../glossary/index.xhtml#term-Bone). For example, they can
[attach](relationship/child_of.xhtml)
a sword to a knight’s hand, or make a tennis player’s eyes
[point towards](tracking/damped_track.xhtml) the ball.

Each object or bone can have a *stack* of constraints that’s evaluated from top to bottom.
In addition, each constraint has an [Influence](interface/common.xhtml#bpy-types-constraint-influence) factor
for weakening it or mixing it with other constraints. What’s more, this Influence can be
keyframed, which makes it possible to turn constraints on and off over the course of an animation.

|  |  |  |
| --- | --- | --- |
| ../../_images/animation_constraints_introduction_tab-object.png   Object | ../../_images/animation_constraints_introduction_tab-bone.png   Bone | ../../_images/animation_constraints_interface_stack_example.png   Constraint Stack |
user: Explain Sepia Node in complete detail according to the official Blender documentation.

assistant: # Sepia Node

[image reference removed]

The *Sepia* node applies a warm, brownish color tint to the image, emulating the look of
vintage photographs or old film prints.
It can be used to create nostalgic, cinematic, or stylized color grades that mimic
chemical sepia toning processes used in traditional photography.
user: What is Add-ons and how is it used in Blender Python scripting?

assistant: - 3D View
- Add Curve
- Add Mesh
- Animation
- Bake
- Camera
- Compositing
- Development
- Game Engine
- Geometry Nodes
- Grease Pencil
- Import-Export
- Lighting
- Material
- Modeling
- Mesh
- Node
- Object
- Paint
- Pipeline
- Physics
- Render
- Rigging
- Scene
- Sculpt
- Sequencer
- System
- Text Editor
- Tracking
- User Interface
- UV
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Geometry
:   Standard geometry input.

Selection
:   Whether or not to change the position of each point or instance.
    True values mean the position will be changed, false values mean it will remain the same.

Position
:   The new position for selected elements. By default, this is the same as
    if the [Position Node](../read/position.html) was connected,
    meaning the node will do nothing.

Offset
:   An optional translation for each point. This is evaluated at the same time as the *Position* input,
    meaning that fields evaluated for it will not reflect the changed position.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Mouse X
:   The region-space mouse X location, in pixels, increasing from 0 at the left.

Mouse Y
:   The region-space mouse Y location, in pixels, increasing from 0 at the bottom.

Region Width
:   The total X size of the [region](../../../../interface/window_system/regions.html) in pixels.

Region Height
:   The total Y size of the [region](../../../../interface/window_system/regions.html) in pixels.
user: How do I use Un-Subdivide in Blender? Include parameters, examples, warnings and best practices.

assistant: # Un-Subdivide

Un-subdivide functions as the reverse of subdivide by attempting to remove edges
that were the result of a subdivide operation.
If additional editing has been done after the subdivide operation,
unexpected results may occur.

Iterations
:   How many subdivisions to remove.
user: Explain Keeping a Correct State in complete detail according to the official Blender documentation.

assistant: When modeling in Blender there are certain assumptions made about the state of the mesh:

- Hidden geometry isn’t selected.
- When an edge is selected, its vertices are selected too.
- When a face is selected, its edges and vertices are selected.
- Duplicate edges / faces don’t exist.
- Faces have at least three vertices.

To give developers flexibility these conventions are not enforced,
yet tools must leave the mesh in a valid state or else other tools may behave incorrectly.
Any errors that arise from not following these conventions is considered a bug in the script,
not a bug in Blender.

### Selection / Flushing

As mentioned above, it is possible to create an invalid selection state
(by selecting a state and then deselecting one of its vertices for example),
mostly the best way to solve this is to flush the selection
after performing a series of edits. This validates the selection state.
user: How do I use TextureNodeTexMagic(TextureNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # TextureNodeTexMagic(TextureNode)

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

*class* bpy.types.TextureNodeTexMagic(*TextureNode*)
:   *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: Provide the full official documentation entry for limbs.super_finger, preserving all code examples.

assistant: Will create a bendy and stretchy finger chain with a master control bone that controls the rotation of
all joints through its scale.

Requirement: A chain of at least two connected bones.

Bend Rotation Axis (Automatic, X, Y, Z, -X, -Y, -Z)
:   Defines the automatic rotation axis to be linked to the scale of the master bone.

B-Bone Segments (integer)
:   Defines the number of b-bone segments each tweak control will be split into.

IK Control
:   Generates a very simple IK mechanism with only one control.

    IK starts its work with the shape of the finger defined by FK controls and adjusts it
    to make the fingertip touch the IK control. It is designed as a tool to temporarily keep
    the fingertip locked to a surface it touches, rather than a fully featured posing system.

    To improve performance, the switchable parent for the IK control contains only one option beside None.
    Thus it is advised to add a ‘held object’ control using the [basic.raw_copy](basic.html#rigify-rigs-basic-pivot)
    rig to act as the common parent for the fingers with a fully functional parent switch.

IK Local Location
:   Specifies the value of the Local Location option for IK controls, which decides if the location
    channels are aligned to the local control orientation or world.

Assign Tweak Layers
:   If enabled, allows placing the Tweak controls in different bone collections from the main controls.

Assign Extra IK Layers
:   If enabled, allows placing the extra IK control in different bone collections from the main controls.
user: How do I use Point to Target in Blender? Include parameters, examples, warnings and best practices.

assistant: All selected normals are set to point from their vertex to the target
after confirmed by `Return` or `LMB`.

A target is set by the keys:

- The mouse cursor `M`
- The pivot `L`
- The object origin `O`
- The cursor (set at this click) `Ctrl`-`LMB`
- A mesh item selection (set by this click) `Ctrl`-`RMB`

Mode
:   The tool operation can be modified; if one of the following keys has been previously pressed:

    Align `A`
    :   All normals will point in the same direction: from the center of selected points to the target.

    Spherize `S`
    :   Each normal will be an interpolation between its original value and the direction to the target.

    Invert `I`
    :   The normal directions are reversed from what was specified above.

Reset `R`
:   Will reset the custom normals back to what they were when the operation started.
user: Provide the full official documentation entry for Thickness, preserving all code examples.

assistant: # Thickness

Controls the thickness of the Freestyle strokes.

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

Line Style: Thickness.

Base Thickness
:   The base thickness for this line style.

Thickness Position
:   Control the position of stroke thickness from the original (backbone) stroke geometry. There are four choices:

    Center:
    :   The thickness is evenly split to the left and right side of the stroke geometry.

    Inside:
    :   The strokes are drawn within object boundary.

    Outside:
    :   The strokes are drawn outside the object boundary.

    Relative:
    :   Specifies the relative position by a number between 0.0 (inside) and 1.0 (outside),
        in the *Thickness Ratio* number field just below.
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_shader_glass_example.jpg   Sharp Glass example. | ../../../_images/render_shader-nodes_shader_glass_behavior-sharp.svg   Sharp Glass behavior. |
| ../../../_images/render_shader-nodes_shader_glass_example-rough.jpg   Rough Glass example. | ../../../_images/render_shader-nodes_shader_glass_behavior.svg   Rough Glass behavior. |
user: Show practical ways to work with Keeping Pages Up To Date in a Blender add-on or script – include code.

assistant: When the manual is updated, those translations which are outdated will be marked as fuzzy. To keep track with that,
you can use a tool we created for that task, see [How to install it](contribute.xhtml#translations-fuzzy-strings).
user: Give a detailed overview of ShaderFxGlow(ShaderFx): syntax, arguments, return values, common patterns.

assistant: # ShaderFxGlow(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.ShaderFxGlow(*ShaderFx*)
:   Glow effect

    blend_mode
    :   Blend mode

        Type:
        :   enum in [`'REGULAR'`, `'ADD'`, `'SUBTRACT'`, `'MULTIPLY'`, `'DIVIDE'`], default `'REGULAR'`

    glow_color
    :   Color used for generated glow

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

    mode
    :   Glow mode

        Type:
        :   enum in [`'LUMINANCE'`, `'COLOR'`], default `'LUMINANCE'`

    opacity
    :   Effect Opacity

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

    rotation
    :   Rotation of the effect

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

    samples
    :   Number of Blur Samples

        Type:
        :   int in [1, 32], default 4

    select_color
    :   Color selected to apply glow

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

    size
    :   Size of the effect

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

    threshold
    :   Limit to select color for glow effect

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

    use_glow_under
    :   Glow only areas with alpha (not supported with Regular blend mode)

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Show/Hide in complete detail according to the official Blender documentation.

assistant: # Show/Hide

Show Hidden Objects `Alt`-`H`
:   Reveals all hidden objects.

Hide Selected `H`
:   Hides all selected objects.

Hide Unselected `Shift`-`H`
:   Hides all unselected objects of the scene.
user: Provide the full official documentation entry for Points to SDF Grid, preserving all code examples.

assistant: # Points to SDF Grid

[image reference removed]

The *Points to SDF Grid* node generates a Signed Distance Field (SDF)\*grid
from a set of input points. Each voxel in the resulting grid stores the
shortest signed distance to the nearest point, allowing points to be
represented as smooth, volumetric shapes.

Positive values represent distances outside the influence of the points,
negative values represent distances inside, and zero corresponds to the surface
of the generated implicit sphere around each point.

This node is useful for constructing volumetric fields or collision volumes
from particles, instances, or procedurally generated point clouds.
user: Describe Common Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: Type
:   Defines the type of light.

Temperature
:   Blackbody temperature in Kelvin, for natural light emission colors.

Color
:   Color tint of the emitted light.

Exposure
:   Multiply the light intensity by \(2^{exposure}\).
    This makes it easy to control a large range of intensities with a single slider.

Normalize
:   By default, the total power of the light remains the same when the light size and shape changes.
    By disabling this option, more light will be emitted when making the light bigger.
user: What is F-Curves & Channels and how is it used in Blender Python scripting?

assistant: [F-Curves](../editors/graph_editor/fcurves/introduction.xhtml) are the fundamental
unit of animation in Blender, and are the main kind of animation data that
actions contain. Each F-Curve contains keyframes that define how a property
(such as the X location of an object) should change over time.

[image reference removed]

[Graph Editor](../editors/graph_editor/introduction.xhtml), displaying three
F-Curves for three different properties.

Blender’s animation editors (such as the dopesheet, graph editor, etc.) have a
**channel list** on their left side that display animated properties. For
actions, these channels correspond to the F-Curves that animate those
properties.

[image reference removed]

The [Dopesheet Editor’s](../editors/dope_sheet/introduction.xhtml) channel
list, with the animated channels of various bones grouped under their bone
names.

Channels also support a limited form of organization called “channel groups”.
For example, by default Blender creates a channel group for the channels of each
bone. There are a few features in Blender that rely on the groups, but mostly
they are just for your convenience.
user: Explain Glare Node in complete detail according to the official Blender documentation.

assistant: # Glare Node

[image reference removed]

The *Glare Node* enhances bright areas of an image by adding effects such as lens flares, bloom, and fog glow.
It simulates the way light interacts with lenses, creating realistic or artistic highlights and reflections.