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

assistant: Upgrading to the latest graphics drivers often solves problems. Newer drivers have bug fixes that help Blender
function correctly.

On Windows, drivers are provided by the graphics card manufacturer. Windows Update automatically installs graphics
drivers, or your computer manufacturer may provide its own version of the graphics drivers.
user: What is Multiframe and how is it used in Blender Python scripting?

assistant: # Multiframe

[image reference removed]

Multiframe pop-over.

Multiframe allows you to draw, edit, sculpt, or weight painting on several frames at the same time.
Extremely useful to avoid repeating a task one frame at a time when animating.

Use Falloff
:   When enabled, the effects on the strokes start to falloff from the current frame
    as defined by a [curve widget](../interface/controls/templates/curve.html).
user: How do I use Struct(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # Struct(bpy_struct)

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

*class* bpy.types.Struct(*bpy_struct*)
:   RNA structure definition

    base
    :   Struct definition this is derived from

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

    description
    :   Description of the Struct’s purpose

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

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

    identifier
    :   Unique name used in the code and scripting

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

    name
    :   Human readable name

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

    name_property
    :   Property that gives the name of the struct

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

    nested
    :   Struct in which this struct is always nested, and to which it logically belongs

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

    properties
    :   Properties in the struct

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

    property_tags
    :   Tags that properties can use to influence behavior

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

    translation_context
    :   Translation context of the struct’s name

        Type:
        :   string, default “”, (readonly, 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 "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 Add-on Extensions, preserving all code examples.

assistant: Add-ons should follow [semantic versioning](https://semver.org/) in spirit.

Semantic versioning was designed for software libraries with APIs, and that’s
not (typically) what add-ons are. Rather, add-ons provide user-facing
functionality, and therefore semantic versioning doesn’t strictly apply.

Nevertheless, we recommend following the *spirit* of semantic versioning with
add-ons in the following way:

- Version numbers should use the **MAJOR.MINOR.PATCH** format (e.g. 2.3.1).
- **The MAJOR number** should be incremented for changes that remove or alter
  existing functionality in such a way that users can’t just continue using the
  add-on as they previously were. Rules of thumb:

  > - If the new version doesn’t work with data created for/by the previous
  >   version, increment the MAJOR number.
  > - If the user needs to relearn anything non-trivial about the add-on to
  >   continue using it as they already were, increment the MAJOR number.
- **The MINOR number** should be incremented when introducing new functionality,
  but *without* significantly affecting existing functionality. Rule of thumb:

  > - If new functionality was introduced, but the user can simply ignore it (if
  >   desired) and continue working with the add-on as they already were,
  >   increment the MINOR number.
- **The PATCH number** should be incremented for bug fixes and small changes
  that don’t affect the add-on’s intended functionality. Rule of thumb:

  > - If the new version isn’t notably different from an end-user perspective
  >   aside from bug fixes, increment the PATCH number.

These guidelines won’t cover every possible situation, but hopefully they give a
good sense of how to approach the common cases. Extension developers should use
their best judgment when dealing with situations not covered well by these
guidelines.
user: Explain Mask From Cavity in complete detail according to the official Blender documentation.

assistant: Generates a mask based on the cavity of the surface. The settings of the operation can be changed
in the [Adjust Last Operation](../../../interface/undo_redo.xhtml) panel.

Mode
:   Choose how the newly created mask is mixed with the existing one. By default it will replace the old mask via
    “Mix”.

Mix Factor
:   The factor of the mix effect. Choose how strong the new mask is applied on the existing one.

Automask Settings
:   The same settings as the [Auto-Masking](../controls.xhtml) settings are applied.

Factor
:   Same as [Auto-Masking](../controls.xhtml).

Blur
:   Same as [Auto-Masking](../controls.xhtml).

Invert
:   Same as [Auto-Masking](../controls.xhtml).

Custom Curve
:   Same as [Auto-Masking](../controls.xhtml).
user: Show practical ways to work with Interface in a Blender add-on or script – include code.

assistant: Color Picker
:   The large color field lets you pick two color components at once, depending on the selected picker type.
    The third component (such as value or saturation) is controlled with a slider next to the color field.

    The picker’s appearance and behavior depend on the type chosen in the Preferences; see [Types](#types) below.

Value/Lightness
:   The vertical slider with a gradient background defines the brightness or lightness of the selected color.
    You can scroll the `Wheel` for fine adjustments or click and drag the handle.

Below the color picking widget are a few options, the first affects how the color component’s values are computed.

Linear:
:   Displays color component values in the scene’s [linear working](../../../render/color_management/color_spaces.xhtml#bpy-types-blendfilecolorspace-working-space)
    color space used internally for rendering and compositing.

Perceptual:
:   Displays color component values in the color picking space (*sRGB* by default),
    which matches the visual appearance of the color widgets and is more intuitive for user selection.

The next set of options change the [Color Model](../../../glossary/index.xhtml#term-Color-Model) that is used.
The available options depend on the [Color Picker Type](../../../editors/preferences/interface.xhtml#bpy-types-preferencesview-color-picker-type).

RGB:
:   Defines a color by directly mixing *Red*, *Green*, and *Blue* components.

HSV/HSL:
:   Defines a color by adjusting *Hue*, *Saturation*, and *Value* (or Lightness).
    Useful for adjusting color tone and intensity independently.

Component Values
:   The numeric fields below the picker show the component values (RGB or HSV/HSL).
    Blender expresses these in the range **0.0 to 1.0**.
    For color inputs that include an [Alpha Channel](../../../glossary/index.xhtml#term-Alpha-Channel), an additional slider and field are shown.

Hex
:   Displays or accepts the color’s hexadecimal (hex) representation.
    Hex shorthand notation can be used (for example, `FC0` for `FFCC00`).

Eyedropper
:   Samples a color from anywhere inside the Blender window using the [Eyedropper](../buttons/eyedropper.xhtml#ui-eyedropper).

    The sampled colors are read in **linear color space**, so they do not account for display transformations
    such as view or exposure adjustments.
    Sampling colors from overlays, reference images, or video preview regions may be inaccurate
    since those may be drawn after color management transforms.
user: Give a detailed overview of Usage: syntax, arguments, return values, common patterns.

assistant: ### Managing Inputs/Outputs

You can add, remove, and reorder input and output sockets in the *Group* panel in the Sidebar.
New sockets can also be created directly by dragging a link to or from the hollow socket
on the *Group Input* or *Group Output* node to another socket in the node editor.

### Reusing Node Groups

Existing node groups can be placed again after they’re initially defined, be it in the same
node tree or a different one. It’s also possible to import node groups from a different blend-file
using File ‣ Link/Append.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Stretch To constraint.

[Target](../interface/common.html#rigging-constraints-interface-common-target)
:   The object or bone to stretch towards.

Original Length
:   The rest distance between owner and target, i.e.
    the distance at which there is no stretching of the owner.

    (Reset Original Length)
    :   Sets the *Original Length* to the current distance between owner and target.

Volume Variation
:   Exponent that either exaggerates (> 1) or reduces (< 1) the thickness change caused
    by volume preservation. Setting this to 0 is the same as setting *Maintain Volume* to
    *None*.

Volume Min, Max
:   Lower and upper limits for the thickness factor applied by volume preservation.

    If *Maintain Volume* is set to XZ, the X and Z factors are each bound to the square
    root of these limits. For example, if *Volume Max* is set to 4, both the X and Z scale
    can grow to no more than twice their original value.

    If *Maintain Volume* is set to X or Z, the factor for the chosen axis is bound to these
    limits. In the above example, the axis could grow to no more than 4 times its original value
    (while the other axis would not grow or shrink at all).

Smooth
:   A higher value will slow down the thickness change as it approaches the limits.
    This prevents an abrupt stop once the limits are reached.

Maintain Volume
:   Whether to make the owner thicker/thinner as it contracts/stretches to meet the target.

    XZ:
    :   Scale along both the X and Z axes.

    X:
    :   Scale along the X axis only.

    Z:
    :   Scale along the Z axis only.

    None:
    :   Don’t change the X and Z scales.

Rotation
:   How the owner should be rotated to track the target with its Y axis.

    XZ:
    :   Tries to keep the local X axis close to its original orientation.

    ZX:
    :   Tries to keep the local Z axis close to its original orientation.

    Swing:
    :   Uses a [swing](../../../glossary/index.html#term-Swing) rotation, much like the [Damped Track Constraint](damped_track.html).

[Influence](../interface/common.html#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: Provide the full official documentation entry for Main Region, preserving all code examples.

assistant: The main region displays the attribute data in a spreadsheet format.
Each column corresponds to an attribute or data property,
and each row represents an element such as a vertex, face, spline, or instance.

Column names and row indices remain visible while scrolling both vertically and horizontally.

- Columns can be resized by clicking and dragging the vertical line between columns.
- Double clicking the vertical line automatically sizes the column to fit the content.
- Columns can be reordered by clicking and dragging the column header.
user: What is Absolute Shape Keys and how is it used in Blender Python scripting?

assistant: [image reference removed]

Absolute Shape Keys options.

See [Relative or Absolute Shape Keys](introduction.xhtml#animation-shapekeys-relative-vs-absolute).

With absolute shape keys, the value shown for each shape in the list represents
the *Evaluation Time* at which that shape key will be active.

Re-Time Shape Keys (clock icon)
:   Absolute shape keys are timed, by order in the list, at a constant interval.
    This button resets the timing for the keys. Useful if keys were removed or re-ordered.

Interpolation
:   Controls the interpolation between shape keys.

    Linear, Cardinal, Catmull-Rom, B-Spline

    [image reference removed]

    Different types of interpolation.

    The red line represents interpolated values between keys (black dots).

Evaluation Time
:   Controls the shape key influence. Scrub to see the effect of the current configuration.
    Typically, this property is keyed for animation or rigged with a driver.
user: Describe Geometry from the Blender manual or Python API, including usage steps and snippets.

assistant: # Geometry

[image reference removed]

Geometry panel.

The Geometry panel lets you turn a curve from a 1D line into a 2D ribbon or a 3D tube.

[image reference removed]

Three copies of the same base curve: one without geometry (bright orange line);
one with Offset and Extrude applied (blue ribbon); and one with Offset, Extrude,
and Bevel applied (gray tube).

Offset
:   Moves the control points along their normals.

Extrude
:   Turns the curve from a line into a ribbon by extruding it to the “sides”:
    at each point, the curve normal is calculated as the “up” direction,
    and the curve is extruded to the “left” and “right.”

Taper Object
:   A separate Curve object, consisting of a single, non-[cyclic](../editing/curve.xhtml#bpy-ops-curve-cyclic-toggle),
    2D spline, that controls the scale factor of the geometry along the length of each of the curve’s splines.

    Specifically, the *Taper Object* defines a graph where the X axis represents the position on the
    curve and the Y axis represents the scale:

    - The first control point of the *Taper Object* spline corresponds to the first control point of
      each geometry spline. Same thing for the last points.
    - The first *Taper* point should have the highest X coordinate, and the last point the lowest
      (try [Switch Direction](../editing/segments.xhtml#bpy-ops-curve-switch-direction) if the scaling doesn’t seem to be working).
      The specific range of X coordinates doesn’t matter: it could be [-10, 10], [-1, 1], or anything else.
    - A Y coordinate of 1.0 leaves the geometry unchanged. A coordinate of 0.5 makes it half as large,
      while 2.0 makes it twice as large.

    The Z coordinates of the *Taper Object* control points are ignored, but if you want,
    you can set the object’s [Shape](shape.xhtml#bpy-types-curve-dimensions) to “2D” to force them to 0.

Taper Radius
:   How to combine the scale graph of the *Taper Object* with the radii of the control points.

    Override:
    :   The *Taper Object* (scale curve) overrides the radii (scales) of the curve’s control points.

    Multiply:
    :   The scale given by the *Taper Object* is multiplied by that of the control points.

    Add:
    :   The scale given by the *Taper Object* is added to that of the control points.

    Examples of a curve with a Radius of 0 on the left and 1 on the right.

    |  |  |  |
    | --- | --- | --- |
    | ../../../_images/modeling_curves_properties_geometry_taper-mode-override.png   Override mode. | ../../../_images/modeling_curves_properties_geometry_taper-mode-multiply.png   Multiply mode. | ../../../_images/modeling_curves_properties_geometry_taper-mode-add.png   Add mode. |

Map Taper
:   If geometry is only generated for part of the curve (which can be achieved by changing
    [Factor Start/End](#bpy-types-curve-bevel-factor-start)), enabling *Map Taper* will
    make the endpoints of the *Taper Object* correspond to those of the geometry instead of
    those of the curve.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Geometry
:   The input geometry containing the hair curves to straighten.

Amount
:   Controls how much each curve is straightened.
    A value of 0.0 leaves the hair unchanged, while 1.0 fully aligns points along a straight line.
    Negative values exaggerate curve irregularities, causing crumpling or distortion.

Shape
:   Defines how the straightening influence changes along the length of each curve.
    A value of 0.0 applies a constant effect, while 0.5 produces a linear falloff from root to tip.

Preserve Length
:   When enabled, keeps the original length of each curve during deformation.
    When disabled, curves may shorten or stretch slightly as they are straightened.
user: Provide the full official documentation entry for Property Override Flag Items, preserving all code examples.

assistant: # Property Override Flag Items

LIBRARY_OVERRIDABLE:
:   Library Overridable.

    Make that property editable in library overrides of linked data-blocks.
    NOTE: For a property to be overridable, its whole chain of parent properties must also be defined as overridable.
user: How do I use Node Integer Math Items in Blender? Include parameters, examples, warnings and best practices.

assistant: # Node Integer Math Items

**Functions**

ADD:
:   Add.

    A + B.

SUBTRACT:
:   Subtract.

    A - B.

MULTIPLY:
:   Multiply.

    A \* B.

DIVIDE:
:   Divide.

    A / B.

MULTIPLY_ADD:
:   Multiply Add.

    A \* B + C.

---

ABSOLUTE:
:   Absolute.

    Non-negative value of A, abs(A).

NEGATE:
:   Negate.

    -A.

POWER:
:   Power.

    A power B, pow(A,B).

**Comparison**

MINIMUM:
:   Minimum.

    The minimum value from A and B, min(A,B).

MAXIMUM:
:   Maximum.

    The maximum value from A and B, max(A,B).

SIGN:
:   Sign.

    Return the sign of A, sign(A).

**Rounding**

DIVIDE_ROUND:
:   Divide Round.

    Divide and round result toward zero.

DIVIDE_FLOOR:
:   Divide Floor.

    Divide and floor result, the largest integer smaller than or equal A.

DIVIDE_CEIL:
:   Divide Ceiling.

    Divide and ceil result, the smallest integer greater than or equal A.

---

FLOORED_MODULO:
:   Floored Modulo.

    Modulo that is periodic for both negative and positive operands.

MODULO:
:   Modulo.

    Modulo which is the remainder of A / B.

---

GCD:
:   Greatest Common Divisor.

    The largest positive integer that divides into each of the values A and B, e.g. GCD(8,12) = 4.

LCM:
:   Least Common Multiple.

    The smallest positive integer that is divisible by both A and B, e.g. LCM(6,10) = 30.
user: Describe Mask Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Mask Node

[image reference removed]

The Mask node can be used to select a [Mask data-block](../../../movie_clip/masking/index.xhtml).
This node can be used with other nodes, for example to Invert, Multiply or Mix, or used as a factor input.
user: Provide the full official documentation entry for Asset Libraries, preserving all code examples.

assistant: Name and on-drive directory paths of asset libraries.
To make Blender aware of an asset library, add it to this list.
The name is for your reference only, and will appear in asset library selectors.
The path should point to the location of the asset library.

[image reference removed]

Name and Location of asset libraries in the Preferences.

To create a new asset library, just create an empty directory and add it to the [List View](../../interface/controls/templates/list_view.xhtml#ui-list-view).
Any asset from any blend-file contained in that directory
(or subdirectories thereof) will appear in the [Asset Browser](../asset_browser.xhtml).

Import Method
:   Determines how data is managed when an asset is imported,
    unless overridden by the [Asset Browser](../asset_browser.xhtml#bpy-types-fileassetselectparams-import-method).

    [Link](../../files/linked_libraries/link_append.xhtml#bpy-ops-wm-link)
    :   The asset will be linked to the current blend-file, and thus be read-only.
        Later changes to the asset file will be reflected in all files that link it in.

    [Append](../../files/linked_libraries/link_append.xhtml#bpy-ops-wm-append)
    :   All of the asset and all its dependencies will be appended to the current file.
        Dragging a material into the scene three times will result in three independent copies.
        Dragging an object into the scene three times will also result in three independent copies.

        “Dependencies” in this case means everything the asset refers to.
        For an object, this can be its mesh and materials, but also other objects
        used by modifiers, constraints, or drivers.

        Since the file now has its own copy of the asset, later changes to
        the asset file will not be reflected in the file it’s appended to.

    Append (Reuse Data)
    :   *Specific to the Asset Browser*.

        The first time an asset is used, it will be appended, including its dependencies,
        just like described previously. However, Blender will keep track of where it originated,
        and the next time the asset is used, as much data as possible will be reused.
        Dragging a material into the scene three times will only load it once,
        and just assign the same material three times.
        Dragging an object into the scene three times will create three copies of the object,
        but all copies will share their mesh data, materials, etc.

        Since the file now has its own copy of the asset, later changes to
        the asset file will not be reflected in the file it’s appended to.

    Pack
    :   Imports the asset as *linked* data and immediately packs it into the current blend-file.
        This ensures that the asset remains available even if the original library data is modified
        or becomes unavailable.

        Useful for maintaining self-contained files that do not rely on external asset library paths.

Relative Path
:   Use relative path when linking assets from this asset library.
user: How do I use Snapping in Blender? Include parameters, examples, warnings and best practices.

assistant: Transform operations use the [snapping settings](../../editors/3dview/controls/snapping.html) set in the scene.
However, some options can be changed during the transformation.

### Snap Invert

Even if the magnetic icon is disabled, you can still enable snapping during a transformation.
The default hotkey in this case is `Ctrl`.

### Set Snap Base

The Snap Base is automatically determined based on the [Snap Base](../../editors/3dview/controls/snapping.html#bpy-types-toolsettings-snap-target) options.
However, this automatic snap detection point of origin may not always align with the user’s intentions.
Therefore, transform operations include a utility to set a new snap origin point during the transformation.
The new Snap Base will correspond to the snap point whose target is defined by the
[Snap Target](../../editors/3dview/controls/snapping.html#bpy-types-toolsettings-snap-elements-base).

By default the hotkey is `B`.

### Add Snap Point

While you’re transforming a selection with snapping enabled,
you can press `A` whenever there’s a highlighted snap target to
mark it. With multiple such targets marked, the selection will
then be snapped to their average location.

Marking a target more than once will give it more weight.

[image reference removed]

Multiple snapping targets.
user: Provide the full official documentation entry for White Noise Texture Node, preserving all code examples.

assistant: # White Noise Texture Node

The *White Noise Texture* node returns a random number based on an input [Seed](../../../glossary/index.html#term-Seed).
The seed can be a number, a 2D vector, a 3D vector, or a 4D vector; depending on the *Dimensions* property.
The output number ranges between zero and one.

[image reference removed]
user: Explain Scripts in Blend-Files in complete detail according to the official Blender documentation.

assistant: ### Auto Execution

Here are the different ways blend-files may automatically run scripts.

Registered Text-Blocks
:   A text data-block can have its *Register* option enabled which means it will load on start.

Animation Drivers
:   Python expressions can be used to *Drive* values and are often used in more advanced rigs and animations.

### Manual Execution

There are other ways scripts in a blend-file may execute that require user
interaction (therefore will run even when auto execution is off),
but you should be aware that this is the case since it is not necessarily obvious.

- Running a script in the Text editor.
- Rendering with Freestyle, because Freestyle uses scripts to control line styles.
user: Show practical ways to work with Extrude to Cursor or Add in a Blender add-on or script – include code.

assistant: # Extrude to Cursor or Add

Interactively places new vertices with `Ctrl`-`RMB` at the mouse cursor position.

The most basic element, a vertex, can be added with a `Ctrl`-`RMB` click
when no other vertices are selected.
Because the camera space (computer screen) is two-dimensional,
Blender cannot determine all three vertex coordinates from a single mouse click,
so the new vertex is placed at the depth of the 3D cursor.

To create interconnected vertices, you can add a vertex and continuously make subsequent `Ctrl`-`RMB`
operations with the last vertex selected.
This will link the last selected vertex with the vertex created at the mouse position with an edge
(see Fig. [Adding vertices one by one.](#fig-mesh-basics-add-one)),
and will continuously create and connect new vertices if you continue repeating this operation.

[image reference removed]

Adding vertices one by one.
user: How do I use Submenus in Blender? Include parameters, examples, warnings and best practices.

assistant: This menu demonstrates some different functions.

```
import bpy

class SubMenu(bpy.types.Menu):
    bl_idname = "OBJECT_MT_select_submenu"
    bl_label = "Select"

    def draw(self, context):
        layout = self.layout

        layout.operator("object.select_all", text="Select/Deselect All").action = 'TOGGLE'
        layout.operator("object.select_all", text="Inverse").action = 'INVERT'
        layout.operator("object.select_random", text="Random")

        # Access this operator as a sub-menu.
        layout.operator_menu_enum("object.select_by_type", "type", text="Select All by Type...")

        layout.separator()

        # Expand each operator option into this menu.
        layout.operator_enum("object.light_add", "type")

        layout.separator()

        # Use existing menu.
        layout.menu("VIEW3D_MT_transform")

bpy.utils.register_class(SubMenu)

# Test call to display immediately.
bpy.ops.wm.call_menu(name="OBJECT_MT_select_submenu")
```
user: How do I use Creating a Force Field in Blender? Include parameters, examples, warnings and best practices.

assistant: To create a single force field,
you can select Add ‣ Force Field and select the desired force field.
This method creates an empty with the force field attached.

Examples of an empty with the force field attached.

|  |  |  |
| --- | --- | --- |
| ../../../_images/physics_forces_force-fields_types_vortex_visualzation.png   Vortex: force field. | ../../../_images/physics_forces_force-fields_types_wind_visualzation.png   Wind: force field. | ../../../_images/physics_forces_force-fields_types_force_visualzation.png   Force: force field. |

To create a field from an existing object you have to select the object and
change to the *Physics* tab. Select the field type in the *Fields* menu.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Width / Bottom Width / Top Width
:   The X axis size of the shape.

Height
:   The Y axis size of the shape.

Bottom Height / Top Height
:   The distance between the bottom or top point and the X axis, in *Kite* mode.

Offset
:   In *Parallelogram* mode, the relative X difference between the top and bottom edge.
    In *Trapezoid* mode, the amount to move the top edge in the positive X axis.

Point 1 - 4
:   Input vectors for the *Points* mode.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeFieldToGrid.grid_items`](bpy.types.GeometryNodeFieldToGrid.html#bpy.types.GeometryNodeFieldToGrid.grid_items "bpy.types.GeometryNodeFieldToGrid.grid_items") |  |
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Value
:   Special gizmo value socket.
    Everything that linked into this socket will be modified when the gizmo is moved.

Position
:   Position of the gizmo in the local space of the object.

Direction
:   Specifies the direction in with the gizmo points or is moved.
user: Give a detailed overview of SpreadsheetColumn(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # SpreadsheetColumn(bpy_struct)

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

*class* bpy.types.SpreadsheetColumn(*bpy_struct*)
:   Persistent data associated with a spreadsheet column

    data_type
    :   The data type of the corresponding column visible in the spreadsheet

        Type:
        :   enum in [`'INT32'`, `'FLOAT'`, `'BOOLEAN'`, `'INSTANCES'`], default `'BOOLEAN'`, (readonly)

    id
    :   Data used to identify the corresponding data from the data source

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Brush Settings: syntax, arguments, return values, common patterns.

assistant: # Brush Settings

Radius
:   This option controls the radius of the brush, measured in pixels.
    `F` allows you to change the brush size interactively by
    dragging the mouse and then `LMB` (the texture of the brush should be visible inside the circle).
    Typing a number then enter while using `F` allows you to enter the size numerically.

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

Strength
:   Controls how much each application of the brush affects the model.
    For example, higher values cause the *Randomize* brush to add noise to the strokes more quickly,
    and cause the *Smooth* brush to soften the strokes more quickly.

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

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

Use Falloff
:   When enabled, use Strength falloff for the brush.
    Brush Strength decays with the distance from the center of the brush.

Sculpt Strokes
:   Filters the effect of the brush over the strokes.
    Applies to *Smooth* and *Randomize* brushes only.

    Affect Position
    :   Toggles the brush effect on the position of the stroke points.

    Affect Strength
    :   Toggles the brush effect on the strength (alpha) of the stroke points.

    Affect Thickness
    :   Toggles the brush effect on the thickness of the stroke points.

    Affect UV
    :   Toggles the brush effect on the UV rotation of the stroke points.

Direction
:   The influence direction of the brush. This can be Add or Subtract.
user: Describe Realizing Instances from the Blender manual or Python API, including usage steps and snippets.

assistant: The term “realizing” instances referes to converting the instances into unique geometry.
When instances are realized they will take up more memory and manipulation to geometry
will have to be processed individually rather the once per instancing geometry.

To realize instance use the [Realize Instances Node](instances/realize_instances.xhtml).
user: Describe Examples from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_shader_translucent_example.jpg   Translucent shader example. | <../../../_images/render_shader-nodes_shader_translucent_behavior.svg>   Translucent shader behavior. |
user: Give a detailed overview of Cross References and Links: syntax, arguments, return values, common patterns.

assistant: Internal document links:

```
:doc:`Link Title </section/path/to/file>`
```

Link to a specific section using explicit labels:

```
.. _my-section-label:

Section Title
=============

Reference this section later with :ref:`Optional Title <my-section-label>`
```

Implicit references within the same document:

```
Section Title
=============

Reference it implicitly later using `Section Title`_
```

External website links:

```
`Blender's Official Website <https://www.blender.org>`__
```

### Context-Sensitive Manual Access

To link Blender UI properties and operators directly to manual entries:

1. Right-click the property/operator in Blender and select *Online Python Reference*
   to get the RNA tag (shown in the OS console).
2. In the documentation, use an external reference matching Blender’s RNA tag:

```
.. _bpy.types.FluidDomainSettings.use_fractions:

Fractional Obstacles
   Enables finer resolution in fluid/obstacle regions.
```

For operators:

```
.. _bpy.ops.curve.subdivide:

Subdivide
=========
```

Blender uses these tags to link UI elements directly to documentation entries via the “Online Manual” option.
user: Give a detailed overview of Quick Start: syntax, arguments, return values, common patterns.

assistant: Open a terminal, then go to the directory where Blender is installed,
and run Blender like this:

```
cd <blender installation directory>
./blender
```

If you have Blender installed in your `PATH`
(usually when Blender is installed through a distribution package), you can simply run:

```
blender
```
user: How do I use Interface in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Panel layout (Thickness modifier as an example).

Each modifier’s interface shares the same basic components like modifiers for meshes.

See [Modifiers Interface](../../modeling/modifiers/introduction.html#bpy-types-modifier-show) for more information.

### Applying Modifiers

Applying a modifier makes the effects of the modifier “real”;
converts the strokes to match the applied modifier’s results, and deletes the modifier.

When applying a modifier to an object that shares Object Data between multiple objects,
the object must first be made a [Single User](../../files/data_blocks.html#data-system-datablock-make-single-user)
which can be performed by confirming the pop-up message.

Apply (Active Keyframe) `Ctrl`-`A`
:   Applies the modifier for the current keyframe.

Apply (All Keyframes)
:   Applies the modifier for all keyframes.

### Influence Filters

Most Grease Pencil modifiers share a set of options that control where the modifier is applied.
These filters restrict the modifier’s effect to specific layers, materials, or geometry components.

For each filter, you can invert the selection by clicking
the  (Invert) icon next to the control.

Layer / Group
:   Restricts the effect to points or strokes of the specified [layer](../properties/layers.html).
    Alternatively, to filter by layer groups, click the  icon.

Layer Pass
:   Restricts the effect to points or strokes in layers with a matching
    [Pass Index](../properties/layers.html#bpy-types-greasepencillayer-pass-index).

Material
:   Restricts the effect to points or strokes using the specified material.

Material Pass
:   Restricts the effect to points or strokes whose material has a matching
    [Pass Index](../materials/properties.html#bpy-types-materialgpencilstyle-pass-index).

Vertex Group
:   Restricts the effect to points or strokes assigned to a specific vertex group.

Custom Curve
:   When enabled, applies a custom falloff curve to control how the modifier’s influence varies
    along each stroke from start to end.
user: What is Usage and how is it used in Blender Python scripting?

assistant: The curves are useful to see if particular trackers are moving differently than the average.
A line that spikes from the rest of the curve usually means a tracking error.

You can manually edit the curve by selecting a point in the curve and dragging it or deleting,
that will affect the corresponding tracker on that particular frame.

Lock to Selection `L`
:   Locks the view to selected markers during playback.
user: Describe BlendDataAnnotations(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # BlendDataAnnotations(bpy_struct)

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

*class* bpy.types.BlendDataAnnotations(*bpy_struct*)
:   Collection of annotations

    tag(*value*)
    :   tag

        Parameters:
        :   **value** (*boolean*) – Value

    new(*name*)
    :   Add a new annotation data-block to the main database

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – New name for the data-block

        Returns:
        :   New annotation data-block

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

    remove(*annotation*, *\**, *do_unlink=True*, *do_id_user=True*, *do_ui_user=True*)
    :   Remove annotation instance from the current blendfile

        Parameters:
        :   - **annotation** ([`Annotation`](bpy.types.Annotation.html#bpy.types.Annotation "bpy.types.Annotation"), (never None)) – Grease Pencil to remove
            - **do_unlink** (*boolean**,* *(**optional**)*) – Unlink all usages of this annotation before deleting it
            - **do_id_user** (*boolean**,* *(**optional**)*) – Decrement user counter of all data-blocks used by this annotation
            - **do_ui_user** (*boolean**,* *(**optional**)*) – Make sure interface does not reference this annotation

    *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 FunctionNodeTransformPoint(FunctionNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # FunctionNodeTransformPoint(FunctionNode)

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

*class* bpy.types.FunctionNodeTransformPoint(*FunctionNode*)
:   Apply a transformation matrix to the given vector

    *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 Snapping, preserving all code examples.

assistant: ### Move

[[image reference removed]](../../../../../_images/scene-layout_object_editing_transform_control_precision_units.png)

One unit (default zoom level).

Snapping while moving objects changes the object location in 1 unit increments.
While in an [aligned view](../../../../../editors/3dview/navigate/align.html),
The increment amount is changed based on the [zoom level](../../../../../editors/3dview/navigate/navigation.html#bpy-ops-view3d-zoom).
For example, at a base zoom level objects are moved in increments of 1 unit (i.e. between the two light gray lines).
Zooming in enough to see the next set of gray lines will snap in increments of 1/10 of a unit.
Zooming in further until will snap in increments of 1/100 of a unit and so on until the zoom limit is reached.
Zooming out will have the opposite effect and
cause movement to happen by increments of 10, 100 units, etc.

### Rotation

Holding `Ctrl` will cause rotations of 5 degrees.

### Scale

Holding `Ctrl` will cause size changes in increments of 0.1 units.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

The Volume to Mesh modifier.

Object
:   The source volume object.

Grid Name
:   The name of the grid that will be converted.
    This has to be a scalar grid.

Resolution Mode
:   Mode for how the resolution of the final mesh is controlled.

    Grid
    :   This makes the resolution dependent on the resolution of the grid that is converted.
        Higher resolution grids result in a higher resolution mesh.
        In many cases, that is the most efficient mode.

    Voxel Amount
    :   Specifies the approximate resolution of the final mesh.
        The voxel size is adapted to the size of the entire volume.

    Voxel Size
    :   Use a fixed resolution that does not change when the volume changes.

Threshold
:   Voxels with a larger value are considered to be inside the mesh and all other voxels outside.
    The mesh will be generated on the boundary of inside and outside voxels.
    This is sometimes also called the “iso value”.

Adaptivity
:   This is similar to decimating the final to reduce resolution where it is not needed.

Smooth Shading
:   Enables smooth shading on the generated mesh.
user: Give a detailed overview of History: syntax, arguments, return values, common patterns.

assistant: [Laplacian Surface Editing](https://igl.ethz.ch/projects/Laplacian-mesh-processing/Laplacian-mesh-editing/laplacian-mesh-editing.pdf)
is a method developed by Olga Sorkine and others in 2004.
This method preserves geometric details as much as possible while the user makes editing operations.
This method uses [differential coordinates](https://igl.ethz.ch/projects/Laplacian-mesh-processing/Laplacian-mesh-editing/diffcoords-editing.pdf)
corresponding to the difference between a vector and the weighted average
of its neighbors to represent the local geometric detail of the mesh.

[image reference removed]

Differential Coordinate.
user: What is Set Curve Normal Node and how is it used in Blender Python scripting?

assistant: # Set Curve Normal Node

[image reference removed]

The *Set Curve Normal* controls the method used to calculate curve normals for every curve.

The node doesn’t set the normals directly, those are calculated later as necessary.
Combined with the [tilt](../read/curve_tilt.xhtml) attribute value
at each control point, this will define the final normals accessible with the
[Normal Node](../../geometry/read/normal.xhtml).

Internally this node adjusts the values of the `normal_mode` attribute on each curve.
user: Explain Solidify Faces in complete detail according to the official Blender documentation.

assistant: # Solidify Faces

This takes a selection of faces and solidifies them by extruding them
uniformly to give volume to a [Non-manifold](../../../../glossary/index.html#term-Non-manifold) surface.
This is also available as a [Modifier](../../../modifiers/generate/solidify.html).
After using the tool, you can set the offset distance in the [Adjust Last Operation](../../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel.

Thickness
:   Amount to offset the newly created surface.
    Positive values offset the surface inward relative to the normals direction.
    Negative values offset outward.

|  |  |  |
| --- | --- | --- |
| <../../../../_images/modeling_meshes_editing_face_solidify-faces_before.png>   Mesh before solidify operation. | <../../../../_images/modeling_meshes_editing_face_solidify-faces_after.png>   Solidify with a positive thickness. | <../../../../_images/modeling_meshes_editing_face_solidify-faces_after2.png>   Solidify with a negative thickness. |
user: Show practical ways to work with Memory in a Blender add-on or script – include code.

assistant: Shadow Pool
:   A bigger pool size allows for more shadows in the scene
    but might not fit into GPU memory and decreases performance.
    Increasing the size might fix the *Shadow buffer full* error.

Light Probes Volume Pool
:   A bigger pool size allows for more irradiance grids in the scene
    but might not fit into GPU memory and decreases performance.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`ParticleSettings.active_instanceweight`](bpy.types.ParticleSettings.html#bpy.types.ParticleSettings.active_instanceweight "bpy.types.ParticleSettings.active_instanceweight") | - [`ParticleSettings.instance_weights`](bpy.types.ParticleSettings.html#bpy.types.ParticleSettings.instance_weights "bpy.types.ParticleSettings.instance_weights") |