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

assistant: # GeometryNodeSubdivideCurve(GeometryNode)

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

*class* bpy.types.GeometryNodeSubdivideCurve(*GeometryNode*)
:   Dividing each curve segment into a specified number of pieces

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use Adding and Removing Vertices in Blender? Include parameters, examples, warnings and best practices.

assistant: It is not possible to add or remove vertices in a shape key.
The number of vertices and their connectivity is defined by the object’s topology (mesh, curve, surface, or lattice).
A shape key only stores the positions of existing vertices, so all shape keys always include every vertex.

When new vertices are added, all existing shape keys will record them at their creation position.
Although it is technically possible to add or delete vertices after creating shape keys,
it is best practice to finalize the mesh topology before creating shape keys.
user: Explain Combine Transform Node in complete detail according to the official Blender documentation.

assistant: # Combine Transform Node

[image reference removed]

The *Combine Transform* node combines a translation vector,
a rotation vector, and a scale vector into a [Transformation Matrix](../../../../glossary/index.xhtml#term-Transformation-Matrix).
user: How do I use Axis Angle Mode in Blender? Include parameters, examples, warnings and best practices.

assistant: This mode lets us define an axis (X, Y, Z) and a rotation angle (W) around that axis.

If we define the rotation using interactive rotations (with the rotation gizmo),
the values of X, Y and Z will not exceed 1.0 in absolute value, and W will be
comprised between 0 and 180 degrees.

If you wish to define rotations above 180° (e.g. to define multiple revolutions),
you will need to edit the W value directly, but as soon as you perform an interactive rotation,
that value will be adjusted again. Same thing goes for axis values.

This system is suitable for elements revolving around a fixed axis, or to animate one of the elements at a time
(either the axis or the angle).
The problem might come when animating (interpolating) both components at the same time: axis and angle.
The resulting effect might not be as expected.

The *Gimbal* gizmo in this rotation mode shows a set of three orthogonal axes in which the Z axis goes
along the defined rotation axis, i.e. it points towards the direction defined by the (X, Y, Z) point.

The axis-angle system is free from gimbal lock, but animation curves in this mode are not intuitive at all
when animating axis and angle at the same time, in which case they are difficult to understand and edit.
user: Show practical ways to work with Bpy.Types.Vertexweightmixmodifier in a Blender add-on or script – include code.

assistant: ruct.type_recast bpy_struct.values Modifier.bl_rna_get_subclass Modifier.bl_rna_get_subclass_py Next VertexWeightProximityModifier(Modifier) Previous VertexWeightEditModifier(Modifier) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page VertexWeightMixModifier(Modifier) VertexWeightMixModifier VertexWeightMixModifier.default_weight_a VertexWeightMixModifier.default_weight_b VertexWeightMixModifier.invert_mask_vertex_group VertexWeightMixModifier.invert_vertex_group_a VertexWeightMixModifier.invert_vertex_group_b VertexWeightMixModifier.mask_constant VertexWeightMixModifier.mask_tex_map_bone VertexWeightMixModifier.mask_tex_map_object VertexWeightMixModifier.mask_tex_mapping VertexWeightMixModifier.mask_tex_use_channel VertexWeightMixModifier.mask_tex_uv_layer VertexWeightMixModifier.mask_texture VertexWeightMixModifier.mask_vertex_group VertexWeightMixModifier.mix_mode VertexWeightMixModifier.mix_set VertexWeightMixModifier.normalize VertexWeightMixModifier.vertex_group_a VertexWeightMixModifier.vertex_group_b VertexWeightMixModifier.bl_rna_get_subclass() VertexWeightMixModifier.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Explain Inputs in complete detail according to the official Blender documentation.

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: Show practical ways to work with GeometryNodeInputID(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeInputID(GeometryNode)

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

*class* bpy.types.GeometryNodeInputID(*GeometryNode*)
:   Retrieve a stable random identifier value from the “id” attribute on the point domain, or the index if the attribute does not exist

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

assistant: Tension
:   Amount of damping in stretching behavior.

Compression
:   Amount of damping in compression behavior.

Structural
:   Amount of damping in stretching behavior (only in linear bending model).

Shear
:   Amount of damping in shearing behavior.

Bending
:   Amount of damping in bending behavior.
user: Show practical ways to work with Socket Syncing in a Blender add-on or script – include code.

assistant: Closures rely on matching socket names to connect inputs and outputs correctly.
If the connected *Closure Zone* and *Evaluate Closure* nodes have mismatched signatures, Blender can synchronize them
automatically.

- A sync icon appears when the socket layout differs.
- Clicking the icon updates sockets to match the connected closure.
- Automatic syncing occurs the first time a closure is connected.
- Existing sockets are never modified automatically afterward to prevent data loss.
user: How do I use CompositorNodeKeying(CompositorNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CompositorNodeKeying(CompositorNode)

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

*class* bpy.types.CompositorNodeKeying(*CompositorNode*)
:   Perform both chroma keying (to remove the backdrop) and despill (to correct color cast from the backdrop)

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Some Python modules will call `sys.exit()` themselves when an error occurs,
while not common behavior this is something to watch out for because it may seem
as if Blender is crashing since `sys.exit()` will close Blender immediately.

For example, the `argparse` module will print an error and exit if the arguments are invalid.

An dirty way of troubleshooting this is to set `sys.exit = None` and see what line of Python code is quitting,
you could of course replace `sys.exit` with your own function but manipulating Python in this way is bad practice.
user: Describe Single Image from the Blender manual or Python API, including usage steps and snippets.

assistant: ```
blender -b file.blend -f 10
```

`-b`
:   Render in the background (without UI).

`file.blend`
:   Path to the blend-file to render.

`-f 10`
:   Render only the 10th frame.

```
blender -b file.blend -o /project/renders/frame_##### -F OPEN_EXR -f -2
```

`-o /project/renders/frame_#####`
:   Path of where to save the rendered image, using five padded zeros for the frame number.

`-F OPEN_EXR`
:   Override the image format specified in the blend-file and save to an OpenEXR image.

`-f -2`
:   Render only the second last frame.
user: Describe Select Next/Previous from the Blender manual or Python API, including usage steps and snippets.

assistant: These operators will select the next or previous control point(s),
based on the current selection
(i.e. the control points following or preceding the selected ones along the curve).
In case of a cyclic curve, the first and last points are not considered as neighbors.
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Data Type
:   The data type that is used for mixing.
    The node supports float, vector, color, and rotation data types.

Factor Mode (Vector only)
:   The factor mode can be set to *Uniform* and *Non-Uniform*.
    In uniform mode, a single float controls the factor.
    In non-uniform mode, a vector controls the factor for
    each XYZ channel separately.

Mix (Color only)
:   The Blend modes can be selected in the select menu.
    See [Color Blend Modes](../../../../glossary/index.xhtml#term-Color-Blend-Modes) for details on each blending mode.

    Add, Subtract, Multiply, Screen, Divide, Difference,
    Darken, Lighten, Overlay, Color Dodge, Color Burn,
    Hue, Saturation, Value, Color, Soft Light, Linear Light

Clamp Factor
:   Limit the factor value between 0.0 and 1.0. If this option is
    unchecked then the node operates using *Extrapolation*.

Clamp Result (Color only)
:   Limit the Result to the range between 0.0 and 1.0.
user: Provide the full official documentation entry for Misc Options, preserving all code examples.

assistant: `--open-last`
:   Open the most recently opened blend file, instead of the default startup file.

`--app-template` `<template>`
:   Set the application template (matching the directory name), use `default` for none.

`--factory-startup`
:   Skip reading the `startup.blend` in the users home directory.

`--enable-event-simulate`
:   Enable event simulation testing feature `bpy.types.Window.event_simulate`.

`--env-system-datafiles`
:   Set the `BLENDER_SYSTEM_DATAFILES` environment variable.

`--env-system-scripts`
:   Set the `BLENDER_SYSTEM_SCRIPTS` environment variable.

`--env-system-extensions`
:   Set the `BLENDER_SYSTEM_EXTENSIONS` environment variable.

`--env-system-python`
:   Set the `BLENDER_SYSTEM_PYTHON` environment variable.

`-noaudio`
:   Force sound system to None.

`-setaudio`
:   Force sound system to a specific device.
    `None` `Default` `SDL` `OpenAL` `CoreAudio` `JACK` `PulseAudio` `WASAPI`.

`-c`, `--command` `<command>`
:   Run a command which consumes all remaining arguments.
    Use `-c help` to list all other commands.
    Pass `--help` after the command to see its help text.

    This implies `--background` mode.

`-h`, `--help`
:   Print this help text and exit.

`/?`
:   Print this help text and exit (Windows only).

`-r`, `--register`
:   Register blend-file extension for current user, then exit (Windows & Linux only).

`--register-allusers`
:   Register blend-file extension for all users, then exit (Windows & Linux only).

`--unregister`
:   Unregister blend-file extension for current user, then exit (Windows & Linux only).

`--unregister-allusers`
:   Unregister blend-file extension for all users, then exit (Windows & Linux only).

`--qos` `<level>`
:   Set the Quality of Service (QoS) mode for hybrid CPU architectures (Windows only).

    default: Uses the default behavior of the OS.
    high: Always makes use of performance cores.
    eco: Schedules Blender threads exclusively to efficiency cores.

`-v`, `--version`
:   Print Blender version and exit.

`--`
:   End option processing, following arguments passed unchanged. Access via Python’s `sys.argv`.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Mode
:   The color model to output.

    RGB:
    :   Combine the three inputs: Red, Green, and Blue color channels into a single image.

    HSV:
    :   Combine the three inputs: Hue, Saturation, and Value color channels into a single image.

    HSL:
    :   Combine the three inputs: Hue, Saturation, and Lightness color channels into a single image.

    YCbCr:
    :   Combine the three inputs: Luminance, Chrominance Blue, and Chrominance Red color channels into a single image.

        Color Space
        :   ITU 601, ITU 709, JPEG

    YUV:
    :   Combine the three inputs: Luminance, U chrominance, and V chrominance color channels into a single image.
user: What is What is an Asset? and how is it used in Blender Python scripting?

assistant: **An asset is a data-block with meaning**.

A blend-file is a database with multiple [Data-Blocks](../data_blocks.xhtml): objects, textures, materials,
etc. When planning to re-use or share these, the data needs a meaning. What is this? What is this for?
**Assets are curated data-blocks that are meant for easy reuse**.
user: Provide the full official documentation entry for Snapping, preserving all code examples.

assistant: # Snapping

[image reference removed]

Snap menu.

Snapping lets you easily align objects and mesh elements to others.
It can be toggled by clicking  (Snap Off) /  (Snap On)
in the 3D Viewport’s header, or more temporarily by holding `Ctrl`.
user: How do I use In Object Mode in Blender? Include parameters, examples, warnings and best practices.

assistant: When in Object Mode,
rotation and scaling happen around the origin of the active object,
which is the element with a lighter outline than the others.

The effect of the pivot point is shown in the image below, where the active object (the cube)
remains in the same location while the others move.

[image reference removed]

Starting point, rotation, and scaling.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

The Vertex Weight Mix modifier panel.

Vertex Group A, B
:   - **A**: The vertex group to affect.
    - **B**: The second vertex group to mix into the affected one.
      Leave it empty if you only want to mix in a simple value.

    Invert Weights A/B
    :   Invert the influence of the vertex group.

Default Weight A, B
:   - **A**: The default weight to assign to all vertices not in the given vertex group.
    - **B**: The default weight to assign to all vertices not in the given second vertex group.

Vertex Set
:   Choose which vertices will be affected.

    All:
    :   Affects all vertices, disregarding the vertex groups content.

    Vertex Group A:
    :   Affects only vertices belonging to the affected vertex group.

    Vertex Group B:
    :   Affects only vertices belonging to the second vertex group.

    Vertex Group A or B:
    :   Affects only vertices belonging to at least one of the vertex groups.

    Vertex Group A and B:
    :   Affects only vertices belonging to both vertex groups.

Mix Mode
:   How the vertex group weights are affected by the other vertex group’s weights.

    Replace:
    :   Replaces affected weights with the second group’s weights.

    Add:
    :   Adds the values of *Group B* to *Group A*.

    Subtract:
    :   Subtracts the values of *Group B* from *Group A*.

    Multiply:
    :   Multiplies the values of *Group B* with *Group A*.

    Divide:
    :   Divides the values of *Group A* by *Group B*.

    Difference:
    :   Subtracts the smaller of the two values from the larger.

    Average:
    :   Adds the values together, then divides by 2.

    Minimum:
    :   Uses the smallest weight value of VGroup A’s or VGroup B’s weights.

    Maximum:
    :   Uses the largest weight value of VGroup A’s or VGroup B’s weights.

Normalize Weights
:   Scale the weights in the vertex group to keep the relative weight
    but the lowest and highest values follow the full 0 - 1 range.

### Influence

Those settings are the same for the three *Vertex Weight* modifiers,
see the [Vertex Weight Edit modifier](weight_edit.xhtml#modeling-modifiers-weight-edit-influence-mask-options) page.
user: Show practical ways to work with Include & Exclude in a Blender add-on or script – include code.

assistant: Light receiver/blocker objects can be set to be either included or excluded.
The behavior is as follows:

- If only included objects are specified, the light only affects those objects.
- If only excluded objects are specified, the light affects all objects in the scene except those specified.
- If both included and excluded objects are specified, the light affects only included objects minus the excluded
  objects. This can be used to for example set a character collection to be included, and then exclude specific
  objects part of the character.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`SpaceFileBrowser.params`](bpy.types.SpaceFileBrowser.html#bpy.types.SpaceFileBrowser.params "bpy.types.SpaceFileBrowser.params") | - [`UILayout.template_file_select_path`](bpy.types.UILayout.html#bpy.types.UILayout.template_file_select_path "bpy.types.UILayout.template_file_select_path") |
user: Give a detailed overview of Separate Cylindrical Node: syntax, arguments, return values, common patterns.

assistant: # Separate Cylindrical Node

[image reference removed]

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

This node is useful for analyzing geometry or generating procedural effects that depend on
radial distance, angular position, or height – for example, creating spiral deformations,
cylindrical gradients, or radial masks.
user: How do I use Object Families in Blender? Include parameters, examples, warnings and best practices.

assistant: A “family” is a way to regroup several meta objects,
producing something very similar to having several metas inside the same object.

It is defined by the left part of an object’s name (the one before the first dot).
Remember, an object’s name is the one in the *Object Name* field, in most panels,
**not** the *Metaball Name* field, which is the meta data-block’s name…
For example, the *family* part of “MetaPlane.001” is `MetaPlane`.
Each meta object in the same “family” is associated with one another as discussed below.

[image reference removed]

Metaball family.

Families of metas are controlled by a *base* meta object which is identified by
an object name **without** a dot in it. For example,
if we have three metas called `MetaThing`, `MetaThing.001`,
`MetaThing.round`, the *base* meta object would be `MetaThing`.

The *base* meta object determines the basis, the resolution, the threshold,
*and* the transformations. It also has the material and texture area.
In a way, the *base* meta is the “owner” of the other metas in the family
(i.e. it is as if the other metas were “included” or joined into the base one).
user: What is Shadows and how is it used in Blender Python scripting?

assistant: Rays
:   Number of rays to trace for each light.
    Higher values reduces the noise caused by random shadow sampling.

Steps
:   Number of shadow map sample per shadow ray.
    Higher step count results in softer shadows but have a higher cost.

Volumetric Shadows
:   Approximate light absorption of the surrounding volume objects. This makes the volumes more opaque to light.
    This is a very computationally expensive option and has limitations.

    Steps
    :   Number of steps to compute volumetric shadowing.

Resolution
:   Resolution percentage of shadow maps.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Glow Visual Effect.

Mode
:   Determines the mode for the glow effect.

    Luminance:
    :   The glow light illuminates the entire object.

    Color:
    :   The glow light only affect a single color.

        Select Color
        :   Allows to select a single color to apply the glow light.

Threshold
:   Limits the colors affected by the glow light. (A value of 1 means no colors affected.)

Glow Color
:   Defines the glow color.

Blend Mode
:   The mask blending operation to perform. See [Color Blend Modes](../../glossary/index.html#term-Color-Blend-Modes).

Opacity
:   Control the Opacity of the glow over the object.

Size X, Y
:   Control the glow scale in pixels on the X and Y axis.

Rotation
:   Control the Rotation of the glow.

Samples
:   Number of Blur samples (0 disabled the blur effect).

Glow Under
:   When enabled, glow only affects alpha areas.
user: Give a detailed overview of Path Animation: syntax, arguments, return values, common patterns.

assistant: # Path Animation

The *Path Animation* settings can be used to determine how child objects move along a certain path.

[image reference removed]

Path Animation panel.

Frames
:   The number of frames that are needed to traverse the path,
    defining the maximum value for the *Evaluation Time* setting.

Evaluation Time
:   Parametric position along the length of the curve that object following it should be at
    (the position is evaluated by dividing by the *Frames* value).
    By default, it is linked to the global frame number,
    but could be keyframed to give more control over the path animation.

Clamp
:   Clamp the curve path children so they can’t travel past the start/end point of the curve.

Follow
:   Make the curve path children rotate along the curvature of the path.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: After the tool is run, these options are available in the [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel.

Error
:   Error distance in object units. This can be seen similar to a subdivision rate for the curve.
    Lower values give a result that is closer to the drawing stroke while higher values give more smoothed results.

Fit Method
:   Refit:
    :   Incrementally refits the curve (gives best results).

    Split:
    :   Splits the curve until the tolerance is met (gives a better drawing performance).

Corner Angle
:   Any angles above this are considered corners.

Cyclic
:   Toggles whether or not the curve is [Cyclic](../../../glossary/index.xhtml#term-Cyclic).
user: Give a detailed overview of Selecting Point Cloud Objects: syntax, arguments, return values, common patterns.

assistant: # Selecting Point Cloud Objects

This section describes the available selection operators when working with point cloud objects in *Edit Mode*.
These operators allow you to quickly select or deselect points for further editing or transformation.
user: Provide the full official documentation entry for Avoiding Alt-Mouse Conflict, preserving all code examples.

assistant: Some window managers default to `Alt`-`LMB` and `Alt`-`RMB` for moving and resizing windows.

Blender uses these for various operations, notably:

- [Emulate 3 Button Mouse](../../editors/preferences/input.xhtml#bpy-types-preferencesinput-use-mouse-emulate-3-button).
- [Select Edge Loops](../../modeling/meshes/selecting/loops.xhtml#bpy-ops-mesh-loop-multi-select).
- [Changing multiple properties at once](../../interface/keymap/blender_default.xhtml#keymap-common-properties).

To access Blender’s full feature set, you can change the window manager settings to use the *Meta* key instead (also
called *Super* or *Windows* key):

Gnome
:   Enter the following in a command line (effective at next login):

    ```
    gsettings set org.gnome.desktop.wm.preferences mouse-button-modifier '<Super>'
    ```

KDE
:   System Settings ‣ Window Management ‣ Window Behavior ‣ Window Actions,
    Switch from ‘Alt’ to ‘Meta’ key.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: Default Fade
:   Automatically calculates a linear fade over the length of the strip.

    Effect Fader
    :   Allows you to manually [keyframe](../../../../../animation/keyframes/index.html) a custom fade.
        This can be used with different [easings](../../../../../editors/graph_editor/fcurves/properties.html#editors-graph-fcurves-settings-easing)
        to fine-tune the fade in/out.
user: Give a detailed overview of Transferring UV Maps: syntax, arguments, return values, common patterns.

assistant: You can copy a UV map from one mesh to another in several ways. If the meshes have
the exact same topology and only differ in vertex positions, you can use
[Copy UV Maps](../../../../scene_layout/object/editing/link_transfer/link_data.html#bpy-ops-object-join-uvs). If they have (approximately) the same surface
but different topology, you can instead use
[Transfer Mesh Data](../../../../scene_layout/object/editing/link_transfer/transfer_mesh_data.html).
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`KeyingSet.paths`](bpy.types.KeyingSet.html#bpy.types.KeyingSet.paths "bpy.types.KeyingSet.paths") - [`KeyingSetPaths.active`](bpy.types.KeyingSetPaths.html#bpy.types.KeyingSetPaths.active "bpy.types.KeyingSetPaths.active") | - [`KeyingSetPaths.add`](bpy.types.KeyingSetPaths.html#bpy.types.KeyingSetPaths.add "bpy.types.KeyingSetPaths.add") - [`KeyingSetPaths.remove`](bpy.types.KeyingSetPaths.html#bpy.types.KeyingSetPaths.remove "bpy.types.KeyingSetPaths.remove") |
user: Describe Smooth from the Blender manual or Python API, including usage steps and snippets.

assistant: # Smooth

Smooths the positions of the vertices to either polish surfaces or remove volume from larger shapes.
Because this brush is so essential, it’s always accessible by holding `Shift` and sculpting.

Also available as a [Mesh Filter](../tools/mesh_filter.html)
to smooth all unmasked areas at once.
user: Give a detailed overview of LineStyleGeometryModifier_2DOffset(LineStyleGeometryModifier): syntax, arguments, return values, common patterns.

assistant: # LineStyleGeometryModifier_2DOffset(LineStyleGeometryModifier)

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

*class* bpy.types.LineStyleGeometryModifier_2DOffset(*LineStyleGeometryModifier*)
:   Add two-dimensional offsets to stroke backbone geometry

    end
    :   Displacement that is applied from the end of the stroke

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    start
    :   Displacement that is applied from the beginning of the stroke

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

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Geometry Modifier Type Items](bpy_types_enum_items/linestyle_geometry_modifier_type_items.html#rna-enum-linestyle-geometry-modifier-type-items), default `'2D_OFFSET'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

    x
    :   Displacement that is applied to the X coordinates of stroke vertices

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

    y
    :   Displacement that is applied to the Y coordinates of stroke vertices

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.LineStyleGeometryModifier_2DOffset.type "bpy.types.LineStyleGeometryModifier_2DOffset.type")
user: What is Shadow and how is it used in Blender Python scripting?

assistant: EEVEE uses a technique called *Virtual Shadow Mapping* along with *Shadow Map Raytracing*.
*Virtual Shadow Mapping* produces more accurate results than traditional shadow mapping by putting resolution
only where it is needed. It also includes a very efficient caching mechanism.
This technique offers better performance than ray tracing and is compatible
with any [Render Method](material_settings.html#bpy-types-material-surface-render-method).

Jitter
:   Enable jittered soft shadows to increase shadow precision.
    Has a high performance impact as the shadow map cannot be cached and needs to be updated for each render sample.

Overblur
:   Apply shadow tracing to each jittered sample to reduce under-sampling artifacts.

Filter
:   Blur shadow aliasing using PCF with a circular kernel.
    The effective world scale of the filter depends on the shadow map resolution at the shadowed pixel position.

Resolution Limit
:   Minimum size of a shadow map pixel. Higher values use less memory at the cost of shadow quality.
    Higher values also speed-up rendering of heavy scenes.
    Each shadow is scaled depending on the shadowed pixel on screen. This can create very sharp shadows
    but also requires a lot of memory if the shadowed pixel is close to the camera.
    This property limits the maximum amount of detail that the shadow map can capture.

Absolute Resolution Limit
:   Limit the resolution at 1 unit from the light origin instead of relative to the shadowed pixel.
    This makes [Resolution Limit](#bpy-types-light-shadow-maximum-resolution)
    act as a regular shadow map pixel size.
user: Describe Bpy.Ops.Paint from the Blender manual or Python API, including usage steps and snippets.

assistant: up with the current paint weight Next Paintcurve Operators Previous Outliner Operators Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page Paint Operators add_simple_uvs() add_texture_paint_slot() brush_colors_flip() face_select_all() face_select_hide() face_select_less() face_select_linked() face_select_linked_pick() face_select_loop() face_select_more() face_vert_reveal() grab_clone() hide_show() hide_show_all() hide_show_lasso_gesture() hide_show_line_gesture() hide_show_masked() hide_show_polyline_gesture() image_from_view() image_paint() mask_box_gesture() mask_flood_fill() mask_lasso_gesture() mask_line_gesture() mask_polyline_gesture() project_image() sample_color() texture_paint_toggle() vert_select_all() vert_select_hide() vert_select_less() vert_select_linked() vert_select_linked_pick() vert_select_more() vert_select_ungrouped() vertex_color_brightness_contrast() vertex_color_dirt() vertex_color_from_weight() vertex_color_hsv() vertex_color_invert() vertex_color_levels() vertex_color_set() vertex_color_smooth() vertex_paint() vertex_paint_toggle() visibility_filter() visibility_invert() weight_from_bones() weight_gradient() weight_paint() weight_paint_toggle() weight_sample() weight_sample_group() weight_set()
user: What is Boid Operators and how is it used in Blender Python scripting?

assistant: # Boid Operators

bpy.ops.boid.rule_add(*\**, *type='GOAL'*)
:   Add a boid rule to the current boid state

    Parameters:
    :   **type** (enum in [Boidrule Type Items](bpy_types_enum_items/boidrule_type_items.html#rna-enum-boidrule-type-items), (optional)) – Type

bpy.ops.boid.rule_del()
:   Delete current boid rule

bpy.ops.boid.rule_move_down()
:   Move boid rule down in the list

bpy.ops.boid.rule_move_up()
:   Move boid rule up in the list

bpy.ops.boid.state_add()
:   Add a boid state to the particle system

bpy.ops.boid.state_del()
:   Delete current boid state

bpy.ops.boid.state_move_down()
:   Move boid state down in the list

bpy.ops.boid.state_move_up()
:   Move boid state up in the list
user: What is CompositorNodeMapUV(CompositorNode) and how is it used in Blender Python scripting?

assistant: # CompositorNodeMapUV(CompositorNode)

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

*class* bpy.types.CompositorNodeMapUV(*CompositorNode*)
:   Map a texture using UV coordinates, to apply a texture to objects in compositing

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Color Parametrization
:   The shader provides three different ways, or *parametrizations*, to color the hair strands.

    Direct Coloring:
    :   Choose the desired RGB color and the shader will approximate
        the necessary *absorption coefficient* (below).

    Melanin Concentration:
    :   This mode defines the color as the quantity and
        ratio of the pigments which are commonly found in hair and fur,
        *eumelanin* (prevalent in brown-black hair) and *pheomelanin* (red hair).
        The quantity is specified in the *Melanin* input, and the ratio between them in *Melanin Redness*.
        Increasing concentrations darken the hair (the following are with *Melanin Redness* \(1\)):

        - White (Melanin \(0\))
        - Blonde (Melanin \(0.25\))
        - Reddish (Melanin \(0.5\))
        - Brown (Melanin \(0.75\))
        - Black (Melanin \(1\))

        Additionally, the *Tint* inputs allows to dye the hair with the desired color.

    Absorption Coefficient:
    :   Specifies the attenuation coefficient \(\sigma_{a}\), as applied by the [Beer-Lambert law](https://en.wikipedia.org/wiki/Beer%E2%80%93Lambert_law#Expression_with_attenuation_coefficient).
        This mode is intended mainly for technical users who want to use coefficients from the literature
        without any sort of conversion.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`ClothSettings.rest_shape_key`](bpy.types.ClothSettings.html#bpy.types.ClothSettings.rest_shape_key "bpy.types.ClothSettings.rest_shape_key") - [`Key.key_blocks`](bpy.types.Key.html#bpy.types.Key.key_blocks "bpy.types.Key.key_blocks") - [`Key.reference_key`](bpy.types.Key.html#bpy.types.Key.reference_key "bpy.types.Key.reference_key") - [`Object.active_shape_key`](bpy.types.Object.html#bpy.types.Object.active_shape_key "bpy.types.Object.active_shape_key") | - [`Object.shape_key_add`](bpy.types.Object.html#bpy.types.Object.shape_key_add "bpy.types.Object.shape_key_add") - [`Object.shape_key_remove`](bpy.types.Object.html#bpy.types.Object.shape_key_remove "bpy.types.Object.shape_key_remove") - [`ShapeKey.relative_key`](#bpy.types.ShapeKey.relative_key "bpy.types.ShapeKey.relative_key") |
user: Explain UVProjector(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # UVProjector(bpy_struct)

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

*class* bpy.types.UVProjector(*bpy_struct*)
:   UV projector used by the UV project modifier

    object
    :   Object to use as projector transform

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

    *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 Inflate: syntax, arguments, return values, common patterns.

assistant: # Inflate

Similar to [Draw](clay.xhtml),
except that vertices are moved in the direction of their own normals.
Especially useful when sculpting meshes with a lot of curvature.

Also available as a [Mesh Filter](../tools/mesh_filter.xhtml)
to inflate all unmasked areas at once.
user: What is Box Selection Node and how is it used in Blender Python scripting?

assistant: # Box Selection Node

[image reference removed]

The *Box Selection* node creates a selection of elements located within a defined 3D box.
It can be used to isolate geometry inside a specific region of space, such as selecting
points, faces, or instances within a bounded area.
user: Give a detailed overview of Deform: syntax, arguments, return values, common patterns.

assistant: # Deform

[image reference removed]

The Deform panel.

In this panel you can set deformation options for each bone.

Toggling the checkbox in the panel header off,
prevents the bone from deforming the geometry at all,
overriding any weights that it might have been assigned before; it mutes its influence.

It also excludes the active bone in the automatic weight calculation when the mesh is
parented to the armature using the *Armature Deform* tool with the *With Automatic Weights* option.
user: How do I use Objects Panel in Blender? Include parameters, examples, warnings and best practices.

assistant: # Objects Panel

[image reference removed]

Objects panel.

This panel contains a [list view](../../../../../interface/controls/templates/list_view.xhtml#ui-list-view) with all objects which can be used for tracking,
camera or object solving.
By default there is only one object in this list which is used for camera solving.
It cannot be deleted and other objects cannot be used for camera solving;
all added objects are used for object tracking and solving only.
These objects can be referenced from Follow Track and Object Solver constraints.
Follow Track uses the camera object by default.

If some tracks were added and tracked to the wrong object, they can be copied to another
object using Track ‣ Copy Tracks and Track ‣ Paste Tracks.

The usage for all kind of objects (used for camera and object tracking) is the same:
track features, set camera data, solve motion. Camera data is sharing between all objects and
refining of camera intrinsics happens when solving camera motion only.
user: Show practical ways to work with MeshStatVis(bpy_struct) in a Blender add-on or script – include code.

assistant: # MeshStatVis(bpy_struct)

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

*class* bpy.types.MeshStatVis(*bpy_struct*)
:   distort_max
    :   Maximum angle to display

        Type:
        :   float in [0, 3.14159], default 0.785398

    distort_min
    :   Minimum angle to display

        Type:
        :   float in [0, 3.14159], default 0.0872665

    overhang_axis
    :   Type:
        :   enum in [Object Axis Items](bpy_types_enum_items/object_axis_items.html#rna-enum-object-axis-items), default `'NEG_Z'`

    overhang_max
    :   Maximum angle to display

        Type:
        :   float in [0, 3.14159], default 0.785398

    overhang_min
    :   Minimum angle to display

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

    sharp_max
    :   Maximum angle to display

        Type:
        :   float in [-3.14159, 3.14159], default 3.14159

    sharp_min
    :   Minimum angle to display

        Type:
        :   float in [-3.14159, 3.14159], default 1.5708

    thickness_max
    :   Maximum for measuring thickness

        Type:
        :   float in [0, 1000], default 0.1

    thickness_min
    :   Minimum for measuring thickness

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

    thickness_samples
    :   Number of samples to test per face

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

    type
    :   Type of data to visualize/check

        Type:
        :   enum in [`'OVERHANG'`, `'THICKNESS'`, `'INTERSECT'`, `'DISTORT'`, `'SHARP'`], default `'OVERHANG'`

    *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.MeshStatVis.type "bpy.types.MeshStatVis.type")
user: Describe Common Options from the Blender manual or Python API, including usage steps and snippets.

assistant: These options can be specified in the [Adjust Last Operation](../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel,
which appears when the object is created.
Options included in more than one primitive are:

Generate UVs
:   Generates a default UV unwrapping of new geometry.
    This will be defined in the first UV layer (which will get added if needed).

Align to View, Location, Rotation
:   See [Common Object Options](../../scene_layout/object/types.html#object-common-options).