PGCRYPT/OpenBlender_Train huggingface dataset:
user: Provide the full official documentation entry for Volumes, preserving all code examples.

assistant: # Volumes

Biased
:   Default volume rendering algorithm is based on null scattering, which is unbiased and has less artifacts,
    but could be noisier. Biased option uses ray marching, with controls for steps size and max steps.

Volume *Step* size is the distance between volume shader samples.
Cycles automatically estimates this distance based on voxel size in
volume objects and smoke simulations.

Render time can be reduced by increasing the step size, at the cost of
potentially losing some volume detail. For procedural volume shaders
that add detail, step size can be increased per object, material or world.

Step Rate Render Biased
:   Global multiplier on the step size for all volumes in renders.
    Increase to reduce render time, at the cost of losing detail.

Viewport Biased
:   Global multiplier on the step size for all volumes in the viewport.
    Increase for more responsive viewport rendering.

Max Steps Biased
:   Maximum number of steps through the volume before giving up,
    to protect from extremely long render times with big objects or small step sizes.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

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

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

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

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

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

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

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

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

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

    For example, if three faces meet at a vertex and have the face weights weak, medium, and strong,
    then only the normal associated with the strong face will be used to set the final result.

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

assistant: ### Types

- [2D Offset](modifiers/geometry/2d_offset.xhtml)
- [2D Transform](modifiers/geometry/2d_transform.xhtml)
- [Backbone Stretcher](modifiers/geometry/backbone_stretcher.xhtml)
- [Bézier Curve](modifiers/geometry/bezier_curve.xhtml)
- [Blueprint](modifiers/geometry/blueprint.xhtml)
- [Guiding Lines](modifiers/geometry/guiding_lines.xhtml)
- [Perlin Noise 1D](modifiers/geometry/perlin_noise_1d.xhtml)
- [Perlin Noise 2D](modifiers/geometry/perlin_noise_2d.xhtml)
- [Polygonization](modifiers/geometry/polygonization.xhtml)
- [Sampling](modifiers/geometry/sampling.xhtml)
- [Simplification](modifiers/geometry/simplification.xhtml)
- [Sinus Displacement](modifiers/geometry/sinus_displacement.xhtml)
- [Spatial Noise](modifiers/geometry/spatial_noise.xhtml)
- [Tip Remover](modifiers/geometry/tip_remover.xhtml)
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: Blend
:   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

Opacity
:   The amount of the blend of the second image gets composed onto the first.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: Scale X, Y, Z
:   The amount to resize the selection on the respected axis.

Orientation
:   Aligns the transformation axes to a specified orientation constraint.
    See [Transform Orientations](../../../../editors/3dview/controls/orientation.xhtml) for more information.

Proportional Editing
:   The extruded face will affect nearby geometry.
    See [Proportional Editing](../../../../editors/3dview/controls/proportional_editing.xhtml) for a full reference.
user: How do I use ShaderNodeMixShader(ShaderNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ShaderNodeMixShader(ShaderNode)

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

*class* bpy.types.ShaderNodeMixShader(*ShaderNode*)
:   Mix two shaders together. Typically used for material layering

    *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: Show practical ways to work with Mix Shader in a Blender add-on or script – include code.

assistant: # Mix Shader

[image reference removed]

The *Mix* node is used to mix two shaders together. Mixing can be used for material layering,
where the *Factor* input may, for example, be connected to a *Blend Weight* node.
user: Describe Import Anim Operators from the Blender manual or Python API, including usage steps and snippets.

assistant: # Import Anim Operators

bpy.ops.import_anim.bvh(*\**, *filepath=''*, *filter_glob='\*.bvh'*, *target='ARMATURE'*, *global_scale=1.0*, *frame_start=1*, *use_fps_scale=False*, *update_scene_fps=False*, *update_scene_duration=False*, *use_cyclic=False*, *rotate_mode='NATIVE'*, *axis_forward='-Z'*, *axis_up='Y'*)
:   Load a BVH motion capture file

    Parameters:
    :   - **filepath** (*string**,* *(**optional**,* *never None**)*) – File Path, Filepath used for importing the file
        - **filter_glob** (*string**,* *(**optional**,* *never None**)*) – filter_glob
        - **target** (enum in [`'ARMATURE'`, `'OBJECT'`], (optional)) – Target, Import target type
        - **global_scale** (*float in* *[**0.0001**,* *1e+06**]**,* *(**optional**)*) – Scale, Scale the BVH by this value
        - **frame_start** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Start Frame, Starting frame for the animation
        - **use_fps_scale** (*boolean**,* *(**optional**)*) – Scale FPS, Scale the framerate from the BVH to the current scenes, otherwise each BVH frame maps directly to a Blender frame
        - **update_scene_fps** (*boolean**,* *(**optional**)*) – Update Scene FPS, Set the scene framerate to that of the BVH file (note that this nullifies the ‘Scale FPS’ option, as the scale will be 1:1)
        - **update_scene_duration** (*boolean**,* *(**optional**)*) – Update Scene Duration, Extend the scene’s duration to the BVH duration (never shortens the scene)
        - **use_cyclic** (*boolean**,* *(**optional**)*) – Loop, Loop the animation playback
        - **rotate_mode** (enum in [`'QUATERNION'`, `'NATIVE'`, `'XYZ'`, `'XZY'`, `'YXZ'`, `'YZX'`, `'ZXY'`, `'ZYX'`], (optional)) –

          Rotation, Rotation conversion

          - `QUATERNION`
            Quaternion – Convert rotations to quaternions.
          - `NATIVE`
            Euler (Native) – Use the rotation order defined in the BVH file.
          - `XYZ`
            Euler (XYZ) – Convert rotations to euler XYZ.
          - `XZY`
            Euler (XZY) – Convert rotations to euler XZY.
          - `YXZ`
            Euler (YXZ) – Convert rotations to euler YXZ.
          - `YZX`
            Euler (YZX) – Convert rotations to euler YZX.
          - `ZXY`
            Euler (ZXY) – Convert rotations to euler ZXY.
          - `ZYX`
            Euler (ZYX) – Convert rotations to euler ZYX.
        - **axis_forward** (enum in [`'X'`, `'Y'`, `'Z'`, `'-X'`, `'-Y'`, `'-Z'`], (optional)) – Forward
        - **axis_up** (enum in [`'X'`, `'Y'`, `'Z'`, `'-X'`, `'-Y'`, `'-Z'`], (optional)) – Up

    File:
    :   [addons_core/io_anim_bvh/__init__.py:118](https://projects.blender.org/blender/blender/src/branch/main/scripts/addons_core/io_anim_bvh/__init__.py#L118)
user: What is Link & Append and how is it used in Blender Python scripting?

assistant: # Link & Append

These functions help you reuse objects, materials and other [data-blocks](../data_blocks.xhtml)
from another blend-file.
You can build libraries of common content and share them across multiple referencing files.
user: Explain TrackToConstraint(Constraint) in complete detail according to the official Blender documentation.

assistant: # TrackToConstraint(Constraint)

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

*class* bpy.types.TrackToConstraint(*Constraint*)
:   Aim the constrained object toward the target

    head_tail
    :   Target along length of bone: Head is 0, Tail is 1

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

    subtarget
    :   Armature bone, mesh or lattice vertex group, …

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

    target
    :   Target object

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

    track_axis
    :   Axis that points to the target object

        Type:
        :   enum in [`'TRACK_X'`, `'TRACK_Y'`, `'TRACK_Z'`, `'TRACK_NEGATIVE_X'`, `'TRACK_NEGATIVE_Y'`, `'TRACK_NEGATIVE_Z'`], default `'TRACK_X'`

    up_axis
    :   Axis that points upward

        Type:
        :   enum in [`'UP_X'`, `'UP_Y'`, `'UP_Z'`], default `'UP_X'`

    use_bbone_shape
    :   Follow shape of B-Bone segments when calculating Head/Tail position

        Type:
        :   boolean, default False

    use_target_z
    :   Target’s Z axis, not World Z axis, will constrain the Up direction

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Options and how is it used in Blender Python scripting?

assistant: There are no options for this noise.

Often used for
:   White noise in an animation. This is not well suited if you do not want an animation.
    For material displacement or bump, use clouds instead.

Result(s)
:   Intensity.
user: Explain Moving Bones between Collections in complete detail according to the official Blender documentation.

assistant: Blender should be in *Edit Mode* or *Pose Mode* to move bones between collections.
Note that as with objects, bones can be assigned to in several collections at once.

Move to Bone Collection
:   Shows a list of the Armature’s *editable* bone collections. Choosing a bone
    collection unassign the selected bones from all other bone collections, then
    assigns them to the chosen one.

    Available as Pose ‣ Move to Collection (*Pose Mode*)
    Armature ‣ Move to Collection (*Edit Mode*), and `M` (either mode).

Bone Collections
:   Shows a list of the Armature’s *editable* bone collections. The collections
    that the active bone is assigned to are prefixed with a `-`, and choosing
    those will unassign all selected bones from that collection. Similarly,
    choosing a bone collection prefixed with a `+` will assign all selected bones
    to that collection.

    Available as Pose ‣ Bone Collections (*Pose Mode*)
    Armature ‣ Bone Collections (*Edit Mode*), and `Shift`-`M` (either mode).
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Mesh
:   Standard geometry output.

Top
:   A boolean attribute field with a selection of the faces on the top of the cylinder. If the *Fill Type*
    property is *None*, then this will be a selection of the top edges instead. If the *Radius* is
    zero, this will be a selection of the top point.

Side
:   A boolean attribute field with a selection of the faces on the side of the cylinder.

Bottom
:   This is the same as the *Top* selection output, but on the bottom side of the geometry instead.

UV Map
:   A 2D vector representing the default X/Y coordinates of the [UV Map](../../../../glossary/index.xhtml#term-UV-Map) for the primitive’s shape.
    This can be connected to the [Store Named Attribute Node](../../attribute/store_named_attribute.xhtml),
    to be used once the Geometry Nodes Modifier get applied.
    The UV map must be stored on the face corner in order to be accessed.
user: Provide the full official documentation entry for Brush Gpencil Vertex Types Items, preserving all code examples.

assistant: # Brush Gpencil Vertex Types Items

DRAW:
:   Draw.

    Paint a color on stroke points.

BLUR:
:   Blur.

    Smooth out the colors of adjacent stroke points.

AVERAGE:
:   Average.

    Smooth out colors with the average color under the brush.

SMEAR:
:   Smear.

    Smudge colors by grabbing and dragging them.

REPLACE:
:   Replace.

    Replace the color of stroke points that already have a color applied.
user: Provide the full official documentation entry for Examples, preserving all code examples.

assistant: The *Split* node is typically used for comparing two images directly in the compositor.
It can be connected to a [Viewer Node](../output/viewer.html)
to preview before-and-after results, such as comparing an ungraded render against
a color-corrected version.

It can also be used to align transitions between scenes or shots by displaying
the last frame of one scene alongside the first frame of another,
helping ensure visual consistency.

[[image reference removed]](../../../_images/compositing_types_color_gamma_example.jpg)

Comparing two images using the Split node.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Count
:   Number of vertices on the line.

Resolution
:   Length of individual edges.
    The node tries to fit as many vertices as possible between the start and end point.
    The exact end point might not be hit.
    This is only available when the mode is set to *End Points* and the count mode is set to *Resolution*.

Start Location
:   Position of the first vertex.

Offset
:   Controls the direction of the line and distance between the vertices.
    This is only available when the mode is set to *Offset*.

End Location
:   Position of the last vertex.
    This is only available when the mode is set to *End Points*.
user: Describe Saving from the Blender manual or Python API, including usage steps and snippets.

assistant: If the header menu item Image has an asterisk next to it
means that the image has been changed, but not saved.
Use [Save Image](../../editors/image/editing.xhtml#bpy-ops-image-save) or [Save Image As](../../editors/image/editing.xhtml#bpy-ops-image-save-as)
to save your work with a different name or overwrite the original image.

The image format for saving is independent of the format for rendering.
The format for saving a UV image is selected in the header of the File Browser,
and defaults to `PNG` (`.png`).

If Packing is enabled in the File Browser’s header, or if you [manually pack](../../editors/image/editing.xhtml#bpy-ops-image-pack),
saving your images to a separate file is not necessary.
user: Explain PrimitiveString(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # PrimitiveString(bpy_struct)

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

*class* bpy.types.PrimitiveString(*bpy_struct*)
:   RNA wrapped string

    value
    :   Type:
        :   byte 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.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 Enable Output Node in complete detail according to the official Blender documentation.

assistant: # Enable Output Node

[image reference removed]

The *Enable Output* node toggles the visibility and value
of a socket for a [Node Group](../../groups.html) outputs.
It can be used to conditionally show or hide outputs from a node group depending on an input value or condition.
user: Provide the full official documentation entry for Assignment, preserving all code examples.

assistant: # Assignment

Materials are data-blocks that can be created and then assigned to one or more objects.
An object can also have multiple materials assigned in different material slots,
which correspond to different parts of an object. If a smooth transition between
materials is desired, then mixing shader nodes with a [Mix shader](../shader_nodes/shader/mix.html)
is a better solution.
user: Show practical ways to work with Refining the Layout in a Blender add-on or script – include code.

assistant: After using the unwrapping tools, you may want to manually tweak the UV map,
for example scaling up an area so it receives more pixels of the texture
and can thus be more detailed. You can also use [Minimize Stretch](../editing.xhtml#bpy-ops-uv-minimize-stretch)
if the UV map is too warped compared to the 3D mesh.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

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

Rotate By
:   Specifies how much an Euler rotation is rotated. This input is only available
    when the rotation type is set to *Euler*.

Axis
:   The axis to rotate around. This input is only available when the rotation type is set to *Axis Angle*.

Angle
:   The angle to rotate by around the specified axis. This input is only available
    when the rotation type is set to *Axis Angle*.
user: How do I use Whole Character Keying Set in Blender? Include parameters, examples, warnings and best practices.

assistant: The built-in *Whole Character* Keying Set is made to keyframe all properties
that are likely to get animated in a character rig.

This keying set ignores bones whose name starts with one of the following prefixes,
as it assumes these are technical bones that are not meant to be animated directly.
The built-in Rigify addon generates such bones, for example.

- COR (Corrective)
- DEF (Deformation)
- GEO (Geometry)
- MCH (Mechanism)
- ORG (Original from meta rig)
- VIS (Visualization)
user: Provide the full official documentation entry for Levels Node, preserving all code examples.

assistant: # Levels Node

[image reference removed]

The Levels Node read the input color channels and outputs analytical values.
The output is one-dimensional meaning the visualization will be a uniform gray color.
user: Provide the full official documentation entry for skin.anchor, preserving all code examples.

assistant: This rig effectively acts as a zero-length chain with highest priority,
ensuring that it becomes the owner when merging controls with other chains.
And also allowing one to input custom automation influence into the skin system.

All constraints on the meta-rig bone are moved to the created control.

Generate Deform Bone
:   Creates a deformation bone parented to the control.

Suppress Control
:   Makes the control a hidden mechanism bone to hide it from the user.

Widget Type
:   Selects which widget to generate for the control.

Relink Constraints
:   Operates the same as in [basic.raw_copy](basic.html#rigify-rigs-basic-raw-copy),
    except all constraints are moved from ORG to the control bone.

Orientation
:   Specifies the bone used to orient the control, like for other chains.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`Context.window`](bpy.types.Context.html#bpy.types.Context.window "bpy.types.Context.window") - [`Window.parent`](#bpy.types.Window.parent "bpy.types.Window.parent") | - [`WindowManager.event_timer_add`](bpy.types.WindowManager.html#bpy.types.WindowManager.event_timer_add "bpy.types.WindowManager.event_timer_add") - [`WindowManager.windows`](bpy.types.WindowManager.html#bpy.types.WindowManager.windows "bpy.types.WindowManager.windows") |
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`LatticePoint.groups`](bpy.types.LatticePoint.html#bpy.types.LatticePoint.groups "bpy.types.LatticePoint.groups") | - [`MeshVertex.groups`](bpy.types.MeshVertex.html#bpy.types.MeshVertex.groups "bpy.types.MeshVertex.groups") |
user: Explain Beztriple Interpolation Easing Items in complete detail according to the official Blender documentation.

assistant: # Beztriple Interpolation Easing Items

AUTO:
:   Automatic Easing.

    Easing type is chosen automatically based on what the type of interpolation used (e.g. Ease In for transitional types, and Ease Out for dynamic effects).

EASE_IN:
:   Ease In.

    Only on the end closest to the next keyframe.

EASE_OUT:
:   Ease Out.

    Only on the end closest to the first keyframe.

EASE_IN_OUT:
:   Ease In and Out.

    Segment between both keyframes.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Geometry
:   Standard geometry input.

Selection
:   A boolean field input for each element indicating whether to include its value in the statistics result
    If the boolean is false, the corresponding value from the *Attribute* input will be ignored.

Attribute
:   The attribute field to query a statistic from.
user: Give a detailed overview of GeometryNodeImageTexture(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeImageTexture(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.GeometryNodeImageTexture(*GeometryNode*)
:   Sample values from an image texture

    extension
    :   How the image is extrapolated past its original bounds

        - `REPEAT`
          Repeat – Cause the image to repeat horizontally and vertically.
        - `EXTEND`
          Extend – Extend by repeating edge pixels of the image.
        - `CLIP`
          Clip – Clip to image size and set exterior pixels as transparent.
        - `MIRROR`
          Mirror – Repeatedly flip the image horizontally and vertically.

        Type:
        :   enum in [`'REPEAT'`, `'EXTEND'`, `'CLIP'`, `'MIRROR'`], default `'REPEAT'`

    interpolation
    :   Method for smoothing values between pixels

        - `Linear`
          Linear – Linear interpolation.
        - `Closest`
          Closest – No interpolation (sample closest texel).
        - `Cubic`
          Cubic – Cubic interpolation.

        Type:
        :   enum in [`'Linear'`, `'Closest'`, `'Cubic'`], default `'Linear'`

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

assistant: |  |  |
| --- | --- |
| - [`Lightgroups.add`](bpy.types.Lightgroups.html#bpy.types.Lightgroups.add "bpy.types.Lightgroups.add") - [`Lightgroups.remove`](bpy.types.Lightgroups.html#bpy.types.Lightgroups.remove "bpy.types.Lightgroups.remove") | - [`ViewLayer.active_lightgroup`](bpy.types.ViewLayer.html#bpy.types.ViewLayer.active_lightgroup "bpy.types.ViewLayer.active_lightgroup") - [`ViewLayer.lightgroups`](bpy.types.ViewLayer.html#bpy.types.ViewLayer.lightgroups "bpy.types.ViewLayer.lightgroups") |
user: Describe CastModifier(Modifier) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CastModifier(Modifier)

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

*class* bpy.types.CastModifier(*Modifier*)
:   Modifier to cast to other shapes

    cast_type
    :   Target object shape

        Type:
        :   enum in [`'SPHERE'`, `'CYLINDER'`, `'CUBOID'`], default `'SPHERE'`

    factor
    :   Type:
        :   float in [-inf, inf], default 0.5

    invert_vertex_group
    :   Invert vertex group influence

        Type:
        :   boolean, default False

    object
    :   Control object: if available, its location determines the center of the effect

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

    radius
    :   Only deform vertices within this distance from the center of the effect (leave as 0 for infinite.)

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

    size
    :   Size of projection shape (leave as 0 for auto)

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

    use_radius_as_size
    :   Use radius as size of projection shape (0 = auto)

        Type:
        :   boolean, default True

    use_transform
    :   Use object transform to control projection shape

        Type:
        :   boolean, default False

    use_x
    :   Type:
        :   boolean, default True

    use_y
    :   Type:
        :   boolean, default True

    use_z
    :   Type:
        :   boolean, default True

    vertex_group
    :   Vertex group name

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: [[image reference removed]](../../../_images/modeling_modifiers_deform_displace_panel.png)

The Displace modifier.

Texture
:   The name of the texture from which the displacement for each vertex is derived.
    If this field is empty, the modifier defaults to 1.0 (white).

    Coordinates
    :   The texture coordinate system to use when retrieving values from the texture for each vertex.

        See [common masking options](../common_options.html#modifiers-common-options-masking) for a complete reference.

Direction
:   The direction along which to displace the vertices.
    Can be one of the following:

    X, Y, Z
    :   Displace along an axis.

    Normal
    :   Displace along the vertex normal.

    Custom Normal
    :   Displace along (averaged) [custom normals](../../meshes/structure.html#modeling-meshes-normals-custom), instead of vertex normals.

    RGB to XYZ
    :   Displace along local XYZ axes individually using the RGB components of the texture
        (Red values displaced along the X axis, Green along the Y, Blue along the Z).

Space
:   With a direction set to X, Y, Z, or XYZ the modifier can either displace along local or global axes.

Strength
:   The strength of the displacement. After offsetting by the *Midlevel* value,
    the displacement will be multiplied by the *Strength* value to give the final vertex offset.

    \(vertex\_offset = displacement × Strength\)

    A negative strength can be used to invert the effect of the modifier.

Midlevel
:   The texture value which will be treated as no displacement by the modifier.
    Texture values below this threshold will result in negative displacement along the selected direction,
    while texture values above it will result in positive displacement.

    \(displacement = texture\_value - Midlevel\)

    Recall that color/luminosity values are typically between (0.0 to 1.0) in Blender,
    and not between (0 to 255).

Vertex Group
:   The name of a vertex group which is used to control the influence of the modifier.
    If left empty, the modifier affects all vertices equally.

    Invert
    :   Inverts the influence of the selected vertex group, meaning that the group
        now represents vertices that will not be deformed by the modifier.

        The setting reverses the weight values of the group.
user: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

Grease Pencil has their own set of modifiers.
Modifiers are automatic operations that affect an object in a non-destructive way.
With modifiers, you can perform many effects automatically that would otherwise be
too tedious to do manually and without affecting the base geometry of your object.

With [Geometry Nodes](../../modeling/geometry_nodes/index.xhtml), it is possible to create custom Grease Pencil modifiers.

They work by changing how an object is displayed and rendered, but not the geometry which you can edit directly.
You can add several modifiers to a single object forming the modifier stack
and [Apply](#grease-pencil-modifiers-apply) a modifier if you wish to make its changes permanent.

There are four types of modifiers for Grease Pencil:

Edit
:   These are tools similar to the Deform ones (see below), however, they usually do not directly
    affect the geometry of the object, but some other data, such as vertex groups.

Generate
:   The *Generate* group of modifiers includes constructive tools that either change
    the general appearance of or automatically add new geometry to an object.

Deform
:   The *Deform* group of modifiers only changes the shape of an object without adding new geometry,

Color
:   The *Color* group of modifiers change the object color output.
user: How do I use StripColorBalanceData(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # StripColorBalanceData(bpy_struct)

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

subclasses —
[`StripColorBalance`](bpy.types.StripColorBalance.html#bpy.types.StripColorBalance "bpy.types.StripColorBalance")

*class* bpy.types.StripColorBalanceData(*bpy_struct*)
:   Color balance parameters for a sequence strip and its modifiers

    correction_method
    :   - `LIFT_GAMMA_GAIN`
          Lift/Gamma/Gain.
        - `OFFSET_POWER_SLOPE`
          Offset/Power/Slope (ASC-CDL) – ASC-CDL standard color correction.

        Type:
        :   enum in [`'LIFT_GAMMA_GAIN'`, `'OFFSET_POWER_SLOPE'`], default `'LIFT_GAMMA_GAIN'`

    gain
    :   Color balance gain (highlights)

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

    gamma
    :   Color balance gamma (midtones)

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

    invert_gain
    :   Invert the gain color

        Type:
        :   boolean, default False

    invert_gamma
    :   Invert the gamma color

        Type:
        :   boolean, default False

    invert_lift
    :   Invert the lift color

        Type:
        :   boolean, default False

    invert_offset
    :   Invert the offset color

        Type:
        :   boolean, default False

    invert_power
    :   Invert the power color

        Type:
        :   boolean, default False

    invert_slope
    :   Invert the slope color

        Type:
        :   boolean, default False

    lift
    :   Color balance lift (shadows)

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

    offset
    :   Correction for entire tonal range

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

    power
    :   Correction for midtones

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

    slope
    :   Correction for highlights

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: For Scene strips only – Updates the strip’s [Time](../../../editors/video_sequencer/sequencer/sidebar/strip.xhtml#sequencer-strips-properties-time)
properties to match the referenced scene’s frame range.
This operator should be used when the referenced scene’s length is extended or shortened.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Curve
:   Standard geometry input, containing curves.

Selection
:   Whether or not to change the value on each curve.

Mode
:   The method for evaluation of the curve’s normals

    Minimum Twist:
    :   The final normals are calculated to have the smallest twist around
        the curve tangent across the whole curve.

    Z-Up:
    :   The final normals are calculated so that they are perpendicular to the Z axis and the tangent.
        If a series of points is vertical, the X axis is used.

    Free:
    :   Use the stored custom normal attribute (`custom_normal`) as the final normals.

        This mode adds a *Normal* input that can be used to set the value of the custom normal.

Normal Free
:   Input for the custom normal attribute (`custom_normal`) when using *Free* mode.
user: Give a detailed overview of Volumes: syntax, arguments, return values, common patterns.

assistant: # Volumes

Biased
:   Default volume rendering algorithm is based on null scattering, which is unbiased and has less artifacts,
    but could be noisier. Biased option uses ray marching, with controls for steps size and max steps.

Volume *Step* size is the distance between volume shader samples.
Cycles automatically estimates this distance based on voxel size in
volume objects and smoke simulations.

Render time can be reduced by increasing the step size, at the cost of
potentially losing some volume detail. For procedural volume shaders
that add detail, step size can be increased per object, material or world.

Step Rate Render Biased
:   Global multiplier on the step size for all volumes in renders.
    Increase to reduce render time, at the cost of losing detail.

Viewport Biased
:   Global multiplier on the step size for all volumes in the viewport.
    Increase for more responsive viewport rendering.

Max Steps Biased
:   Maximum number of steps through the volume before giving up,
    to protect from extremely long render times with big objects or small step sizes.
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Subsurface Method
:   Rendering method to simulate subsurface scattering.

    Christensen-Burley:
    :   An approximation to physically-based volume scattering.
        This method is less accurate than *Random Walk* however,
        in some situations this method will resolve noise faster.

    Random Walk (Fixed Radius):
    :   Provides accurate results for thin and curved objects.
        Random Walk uses true volumetric scattering inside the mesh,
        which means that it works best for closed meshes.
        Overlapping faces and holes in the mesh can cause problems.

    Random Walk:
    :   Behaves similarly to *Random Walk (Fixed Radius)* but modulates
        the *Radius* based on the *Color*, *Anisotropy*, and *IOR*.
        This method thereby attempts to retain greater surface detail and color
        than *Random Walk (Fixed Radius)*.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`BlenderRNA.structs`](bpy.types.BlenderRNA.html#bpy.types.BlenderRNA.structs "bpy.types.BlenderRNA.structs") - [`CollectionProperty.fixed_type`](bpy.types.CollectionProperty.html#bpy.types.CollectionProperty.fixed_type "bpy.types.CollectionProperty.fixed_type") - [`PointerProperty.fixed_type`](bpy.types.PointerProperty.html#bpy.types.PointerProperty.fixed_type "bpy.types.PointerProperty.fixed_type") | - [`Property.srna`](bpy.types.Property.html#bpy.types.Property.srna "bpy.types.Property.srna") - [`Struct.base`](#bpy.types.Struct.base "bpy.types.Struct.base") - [`Struct.nested`](#bpy.types.Struct.nested "bpy.types.Struct.nested") |
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: [image reference removed]

The Lattice modifier.

Object
:   The [Lattice](../../../animation/lattice.xhtml) object with which to deform the base object.

Vertex Group
:   An optional vertex group name which lets you limit the modifier’s effect to a part of the base mesh.

    Invert
    :   Inverts the influence of the selected vertex group, meaning that the group
        now represents vertices that will not be deformed by the modifier.

        The setting reverses the weight values of the group.

Strength
:   A factor to control blending between original and deformed vertex positions.
user: Show practical ways to work with ShaderNodeMixRGB(ShaderNode) in a Blender add-on or script – include code.

assistant: # ShaderNodeMixRGB(ShaderNode)

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

*class* bpy.types.ShaderNodeMixRGB(*ShaderNode*)
:   Mix two input colors

    blend_type
    :   Type:
        :   enum in [Ramp Blend Items](bpy_types_enum_items/ramp_blend_items.html#rna-enum-ramp-blend-items), default `'MIX'`

    use_alpha
    :   Include alpha of second input in this operation

        Type:
        :   boolean, default False

    use_clamp
    :   Clamp result of the node to 0.0 to 1.0 range

        Type:
        :   boolean, default False

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

assistant: # NlaTracks(bpy_struct)

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

*class* bpy.types.NlaTracks(*bpy_struct*)
:   Collection of NLA Tracks

    active
    :   Active NLA Track

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

    new(*\**, *prev=None*)
    :   Add a new NLA Track

        Parameters:
        :   **prev** ([`NlaTrack`](bpy.types.NlaTrack.html#bpy.types.NlaTrack "bpy.types.NlaTrack"), (optional)) – NLA Track to add the new one after

        Returns:
        :   New NLA Track

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

    remove(*track*)
    :   Remove a NLA Track

        Parameters:
        :   **track** ([`NlaTrack`](bpy.types.NlaTrack.html#bpy.types.NlaTrack "bpy.types.NlaTrack"), (never None)) – NLA Track to remove

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Transform and how is it used in Blender Python scripting?

assistant: Standard transformation operators such as **Move**, **Rotate**, and **Scale**
can be used to manipulate selected points within the point cloud.

These operators are useful for repositioning, aligning, or reshaping clusters of points manually.
user: What is Examples and how is it used in Blender Python scripting?

assistant: [image reference removed]

Combined with the [Geometry to Instance Node](../geometry_to_instance.xhtml),
this can be used to create a basic efficient “Array” operation. This should be more efficient
because the duplicates are [instances](../../instances.xhtml).

The “Duplicate Index” is used to move each instance in the result a different amount.
user: Describe Network from the Blender manual or Python API, including usage steps and snippets.

assistant: Allow Online Access
:   Allow Blender to access the internet.

    Add-ons that follow this setting will only connect to the internet if enabled.
    However, Blender cannot prevent third-party add-ons from violating this rule.

Time Out
:   The time (in seconds) that online operations may wait before timing out.

    Use the systems default when zero.

Connection Limit
:   The maximum number of simultaneous connections an online operation may make.

    Do not limit the number of connections when zero.