PGCRYPT/OpenBlender_Train huggingface dataset:
user: Explain ShaderNodeVectorCurve(ShaderNode) in complete detail according to the official Blender documentation.

assistant: # ShaderNodeVectorCurve(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.ShaderNodeVectorCurve(*ShaderNode*)
:   Map input vector components with curves

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

    *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: Explain Hints in complete detail according to the official Blender documentation.

assistant: - Make sure that the normals of the mesh surface are facing towards the particles/points
  for correct deflection. Negative scales on the object can have a similar effect.
  Make sure to recalculate the normals after applying the scale.
- Hair particles react directly to force fields,
  so if you use a force field with a short range you do not need necessarily collision.
- Hair particles avoid their emitting mesh if you edit them in *Particle Edit Mode*.
  So you can at least model the hair with collision.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Vector
:   Vector to be rotated.

Center
:   Point to rotate around.

Axis
:   Axis to rotate around.

Angle
:   Angle to rotate the input vector by.

Rotation
:   When *Type* is set to *Euler*, rotate the input vector
    by these angles around the X, Y, then Z axes in that order.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Image
:   Standard color input.

Factor
:   Controls the amount of influence the node exerts on the output image.

Type
:   The mathematical method to adjust the image’s colors.

    Lift/Gamma/Gain:
    :   Adjusts the colors and tonal range of an image by controlling the shadows, midtones, and highlights separately.

    Offset/Power/Slope (ASC-CDL):
    :   A standardized model for adjusting the colors and tonal range of an image.
        This allows the same values to be used across different application to yield the same result.
        See [Advanced](#advanced) for more details on the underlying implementation.

    White Point:
    :   Adjusts the color that should be considered white.
        The white point is specified as setting the inputs color temperature and then the desired output temperature.

Lift/Gamma/Gain

Lift
:   Adjusts the darkest areas of the image (the shadows).

Gamma
:   Primarily affects the midtones, the middle range of brightness in the image.

Gain
:   Controls the brightest parts of the image (the highlights).

Offset/Power/Slope (ASC-CDL)

Offset
:   Adjusts the darkest areas of the image (the shadows).

Basis
:   Additional offset, allows to specify a negative offset value.

Power
:   Primarily affects the midtones, the middle range of brightness in the image.

Slope
:   Controls the brightest parts of the image (the highlights).

### Input

Temperature
:   The blackbody temperature of the input’s primary illuminant. By default a D65 white point is used.

Tint
:   The amount of green/magenta shift of the input’s white point (the default of 10 matches daylight)

### Output

Temperature
:   The blackbody temperature of the output’s primary illuminant. By default a D65 white point is used.

Tint
:   The amount of green/magenta shift of the output’s white point (the default of 10 matches daylight)
user: How do I use Stretch To Constraint in Blender? Include parameters, examples, warnings and best practices.

assistant: # Stretch To Constraint

The *Stretch To* constraint makes an object or bone point at, and scale towards,
a target. Unlike the other “track” constraints, it can only do this using the local Y axis,
making it mainly useful for bones.

The constraint can also perform “volume preservation,” making the owner thinner when the
target moves away and thicker when it comes closer. This is useful for stretching
and squashing of stylized characters, for example. However, because it simply
adjusts the X and Z scales according to the Y scale, it works for any type of object,
not just meshes.
user: Describe GeometryNodeFieldToGrid(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeFieldToGrid(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.GeometryNodeFieldToGrid(*GeometryNode*)
:   Create new grids by evaluating new values on an existing volume grid topology

    active_index
    :   Index of the active item

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

    active_item
    :   Index of the active item

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

    data_type
    :   Data type for topology grid

        Type:
        :   enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items), default `'FLOAT'`

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

    *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: Describe NodeSocketVectorPercentage4D(NodeSocketStandard) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeSocketVectorPercentage4D(NodeSocketStandard)

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

*class* bpy.types.NodeSocketVectorPercentage4D(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   float array of 4 items in [-inf, inf], default (0.0, 0.0, 0.0, 0.0)

    links
    :   List of node links from or to this socket.

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: When you add a single still image (`*.jpg`, `*.png`, etc.),
by default, Blender will create a 25 frame long strip which renders the image throughout the strip’s range in the timeline.
This length can be adjusted by adding images through the “Add Image Strip” operator and changing the property in the sidebar.
user: Describe CompositorNodeConvertColorSpace(CompositorNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CompositorNodeConvertColorSpace(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.CompositorNodeConvertColorSpace(*CompositorNode*)
:   Convert between color spaces

    from_color_space
    :   Color space of the input image

        Type:
        :   enum in [Color Space Convert Default Items](bpy_types_enum_items/color_space_convert_default_items.html#rna-enum-color-space-convert-default-items), default `'NONE'`

    to_color_space
    :   Color space of the output image

        Type:
        :   enum in [Color Space Convert Default Items](bpy_types_enum_items/color_space_convert_default_items.html#rna-enum-color-space-convert-default-items), default `'NONE'`

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

assistant: Exposes the inputs of the node group. You can have multiple of these nodes in your tree to keep it clean,
bringing in each input right where you need it (rather than dragging long links all across your graph).

The input slots can be edited in the *Group* tab of the *Sidebar*.
user: How do I use ImageUser(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ImageUser(bpy_struct)

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

*class* bpy.types.ImageUser(*bpy_struct*)
:   Parameters defining how an Image data-block is used by another data-block

    frame_current
    :   Current frame number in image sequence or movie

        Type:
        :   int in [-1048574, 1048574], default 0

    frame_duration
    :   Number of images of a movie to use

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

    frame_offset
    :   Offset the number of the frame to use in the animation

        Type:
        :   int in [-inf, inf], default 0

    frame_start
    :   Global starting frame of the movie/sequence, assuming first picture has a #1

        Type:
        :   int in [-1048574, 1048574], default 0

    multilayer_layer
    :   Layer in multilayer image

        Type:
        :   int in [0, 32767], default 0, (readonly)

    multilayer_pass
    :   Pass in multilayer image

        Type:
        :   int in [0, 32767], default 0, (readonly)

    multilayer_view
    :   View in multilayer image

        Type:
        :   int in [0, 32767], default 0, (readonly)

    tile
    :   Tile in tiled image

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

    use_auto_refresh
    :   Always refresh image on frame changes

        Type:
        :   boolean, default False

    use_cyclic
    :   Cycle the images in the movie

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

assistant: Trims selected stroke to first loop or intersection.

|  |  |
| --- | --- |
| ../../../_images/grease-pencil_modes_edit_stroke-menu_trim-1.png   Original stroke. | ../../../_images/grease-pencil_modes_edit_stroke-menu_trim-2.png   Result of trim operation. |
user: Provide the full official documentation entry for Accessing Brushes, preserving all code examples.

assistant: In modes that use painting or sculpting functionality, the [Asset Shelf](../../interface/window_system/regions.xhtml#ui-region-asset-shelf) of the 3D
Viewport and Image Editor displays brush assets that can be used in that mode. Clicking a brush asset will activate
the Brush Tool if necessary, with the clicked brush set.

[image reference removed]

The Asset Shelf of the 3D Viewport, providing access to brush assets.

This asset shelf is also available as popup in the [Tool Settings](../../interface/window_system/regions.xhtml#ui-region-tool-settings), the
[Sidebar](../../interface/window_system/regions.xhtml#ui-region-sidebar), [Properties](../../editors/properties_editor.xhtml) and using a shortcut.
user: How do I use GeometryNodePointsToVolume(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodePointsToVolume(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.GeometryNodePointsToVolume(*GeometryNode*)
:   Generate a fog volume sphere around every point

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Opacity Factor samples.

|  |  |  |
| --- | --- | --- |
| ../../../_images/grease-pencil_modifiers_color_opacity_factor-03.png   Opacity Factor: 0.3. | ../../../_images/grease-pencil_modifiers_color_opacity_factor-1.png   Opacity Factor: 1.0 (original alpha). | ../../../_images/grease-pencil_modifiers_color_opacity_factor-2.png   Opacity Factor: 2.0 (fully opaque). |
user: What is Inputs and how is it used in Blender Python scripting?

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

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

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

assistant: Repeat Items
:   [List View](../../../interface/controls/templates/list_view.html#ui-list-view) for adding, removing, reordering, and renaming the inputs of the zone.

    Socket Type
    :   The [data type](../../../modeling/geometry_nodes/attributes_reference.html#attribute-data-types) of the selected input.

Inspection Index
:   The number of the iteration to show in [socket inspection](../../../modeling/geometry_nodes/inspection.html#socket-inspection)
    and in the [Viewer Node](../../../modeling/geometry_nodes/output/viewer.html).
user: Give a detailed overview of Limitations: syntax, arguments, return values, common patterns.

assistant: Most constraints of Blender as an application still apply:

Reloading Unsupported
:   Reloading the `bpy` module via `importlib.reload` will raise an exception
    instead of reloading and resetting the module.

    Instead, the operator `bpy.ops.wm.read_factory_settings()` can be used to reset the internal state.

Single Blend File Restriction
:   Only a single `.blend` file can be edited at a time.
user: Explain Deleting a Material in complete detail according to the official Blender documentation.

assistant: To delete a material, select the material and click X in the Available Materials List entry.

Although the material will seem to disappear immediately,
the Delete action can depend on how the material is used elsewhere.

If the material is linked to the object and there are other objects which use this material,
then the material will be removed from that object (but remain on all its other objects).

If the “Fake User” button has been lit in the Available Materials list,
then the material will be retained when the file is saved, even if it has no users.

Only if it has 0 “real” users, and no “Fake” user, will the material be permanently deleted.
Note that it will still remain in the Materials list until the blend-file is saved,
but will have disappeared when the file is reloaded.
user: Provide the full official documentation entry for limbs.spline_tentacle, preserving all code examples.

assistant: This rig type implements a flexible tentacle with an IK system using the Spline IK constraint. The control bones
define control points of a Bezier curve, and the bone chain follows the curve.

The curve control points are sorted into three groups: start, middle and end. The middle controls are always
visible and active, while the other two types can be shown and hidden dynamically using properties; when enabled
they appear next to the corresponding permanent start/end control and can be moved from there.

Extra Start Controls
:   Specifies the number of optional start controls to generate.

Middle Controls
:   Specifies the number of middle controls to generate.

Extra End Controls
:   Specifies the number of optional end controls to generate.

Tip Control:
:   Specifies how the curve stretching and the final control bone work:

    Stretch To Fit
    :   Stretches the whole bone chain to fit the length of the curve defined by the controls.

        An end twist control is generated to control the twist along the chain.

    Direct Tip Control
    :   Generates an IK end control, which directly controls the final bone of the chain similar to how
        regular IK works for limbs, as well as controlling the end of the bezier curve. The middle bones of
        the chain stretch to follow the curve and cover the gap.

        The rig automatically deduces twist of up to 180 degrees based on the orientation of the end control.
        Higher amounts of twist have to be dialed in through an End Twist Estimate slider to avoid flipping.

    Manual Squash & Stretch
    :   This mode allows full manual control over the chain scaling, while the chain covers as much of the curve
        as it can given its current length.

        The start control of the chain manages its uniform squash & stretch scale, while the end twist control
        manages both the twist of the chain, as well as its scale at the tip (blended gradually along the length).

Radius Scaling
:   Allows scaling the controls to control the thickness of the chain through the curve.

Maximum Radius
:   Specifies the maximum scale allowed by the Radius Scaling feature.

FK Controls
:   Generates an FK control chain and IK-FK snapping.

Assign FK Layers
:   If enabled, allows placing the FK chain in different bone collections from the IK bones.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Mesh
:   Standard Mesh input.

Selection
:   The meshes used to generate a point cloud.

Position
:   Positions of generated points. By default, this input is the same as
    if the [Position Node](../../geometry/read/position.html) was connected.

Radius
:   Radii of generated points.
user: Explain Star Node in complete detail according to the official Blender documentation.

assistant: # Star Node

[image reference removed]

The *Star* node generates a poly spline in a star pattern by connecting alternating points of two circles.
The points on the inner circle are offset by a rotation so that they lie in between the points on the outer circle.
This offset can be changed with the twist input.
user: How do I use Examples in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Here the node is used to copy the positions of one object to another. This recreates the behavior of the
*Transfer Attribute* node from Blender versions before 3.4. This works best when their geometries have
the same number of points and the same [Topology](../../../../glossary/index.xhtml#term-Topology).
user: Give a detailed overview of Strip Modifiers: syntax, arguments, return values, common patterns.

assistant: # Strip Modifiers

[[image reference removed]](../../../_images/video-editing_sequencer_strip_modifiers_panel.webp)

Modifiers are used to make adjustments to the image, like contrast,
brightness, saturation, color balance and applying masks.

You can add these modifiers directly to a media strip,
or you can use them within an [Adjustment Layer](strips/adjustment.html)
strip, making them apply to several media strips in one go.

Linear Modifiers
:   Calculates modifiers in [linear color space](../../../render/color_management/color_spaces.html#color-management-linear-space) instead of the
    [Sequencer color space](../../../render/color_management/color_spaces.html#bpy-types-colormanagedsequencercolorspacesettings-name).

    Calculating modifiers in linear space will match the image processing of the compositor.
    In most cases, this should be enabled; working in a non-linear workflow could have unpredictable results.
user: Explain Bpy.Types.Woodtexture in complete detail according to the official Blender documentation.

assistant: iew ID.override_create ID.override_hierarchy_create ID.user_clear ID.user_remap ID.make_local ID.user_of_id ID.animation_data_create ID.animation_data_clear ID.update_tag ID.preview_ensure ID.bl_rna_get_subclass ID.bl_rna_get_subclass_py Texture.evaluate Texture.bl_rna_get_subclass Texture.bl_rna_get_subclass_py Next WorkSpace(ID) Previous WireframeModifier(Modifier) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page WoodTexture(Texture) WoodTexture WoodTexture.nabla WoodTexture.noise_basis WoodTexture.noise_basis_2 WoodTexture.noise_scale WoodTexture.noise_type WoodTexture.turbulence WoodTexture.wood_type WoodTexture.users_material WoodTexture.users_object_modifier WoodTexture.bl_rna_get_subclass() WoodTexture.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Describe Commit Guidelines from the Blender manual or Python API, including usage steps and snippets.

assistant: # Commit Guidelines

Access to directly submit changes is limited to people with commit access to the repository. Once you are provided
with commit access you can start committing directly instead of creating a patch file.

You can make commits from your Git client or using the Git command line tool. The following command will create a
commit and send it to the central repository:

```
git commit -m "This is what I did"
git push
```

If you leave out `-m "message"`, you will be prompted to type the message in a text editor.
user: Provide the full official documentation entry for BlendDataProbes(bpy_struct), preserving all code examples.

assistant: # BlendDataProbes(bpy_struct)

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

*class* bpy.types.BlendDataProbes(*bpy_struct*)
:   Collection of light probes

    new(*name*, *type*)
    :   Add a new light probe to the main database

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – New name for the data-block
            - **type** (enum in [Lightprobes Type Items](bpy_types_enum_items/lightprobes_type_items.html#rna-enum-lightprobes-type-items)) – Type, The type of light probe to add

        Returns:
        :   New light probe data-block

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

    remove(*lightprobe*, *\**, *do_unlink=True*, *do_id_user=True*, *do_ui_user=True*)
    :   Remove a light probe from the current blendfile

        Parameters:
        :   - **lightprobe** ([`LightProbe`](bpy.types.LightProbe.html#bpy.types.LightProbe "bpy.types.LightProbe"), (never None)) – Light probe to remove
            - **do_unlink** (*boolean**,* *(**optional**)*) – Unlink all usages of this light probe before deleting it (WARNING: will also delete objects instancing that light probe data)
            - **do_id_user** (*boolean**,* *(**optional**)*) – Decrement user counter of all data-blocks used by this light probe
            - **do_ui_user** (*boolean**,* *(**optional**)*) – Make sure interface does not reference this light probe

    tag(*value*)
    :   tag

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

    *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: Describe Accessing Stroke Editing Tools from the Blender manual or Python API, including usage steps and snippets.

assistant: These are available through the different tools in the Toolbar,
the Stroke menu in the 3D Viewport header, and context menus in the 3D Viewport,
as well as individual shortcut keys.

### Toolbar

When you select a stroke and `Tab` into Edit Mode,
the [Toolbar](tools/index.xhtml) changes from *Object Tools* to *Stroke editing Tools*.
These are only some of the stroke editing tools.

### Menus

The [Stroke Menu](stroke_menu.xhtml) is located in the header.

### Context Menu

`RMB` brings up the complete [Stroke Menu](stroke_menu.xhtml).
user: Describe Header from the Blender manual or Python API, including usage steps and snippets.

assistant: Type
:   Strip type, represented by an icon.

Name
:   A text field to adjust the name of the strip, which is shown on the strip in the timeline.

    Color Tag
    :   Strips are given a [Default Color](../../../../video_editing/edit/montage/strips/introduction.xhtml#sequencer-strip-colors) based on their type;
        using the color tag, you can assign a custom color to help organize your sequence.

Mute
:   Uncheck to prevent the strip from producing output.
user: Explain Install from Zip in complete detail according to the official Blender documentation.

assistant: When choosing the zip-file, you have to manually extract Blender to the desired folder, where you can double-click the
executable to run Blender.

No start menu item will be created and no blend-file association will be registered,
but there is also no need for administrator rights. You can register the file association
manually by clicking [Register](../../editors/preferences/system.html#bpy-ops-preferences-associate-blend) on the System tab of the
[Preferences](../../editors/preferences/system.html). Alternatively, you can run `blender -r`
from the [Command Line](../../advanced/command_line/arguments.html).

To make the installation and configuration fully self-contained, set up a
[Portable Installation](../../advanced/blender_directory_layout.html#portable-installation).
user: What is Snap Target and how is it used in Blender Python scripting?

assistant: Increment
:   Snaps to grid points.

    This option snaps to an imaginary grid that starts at the selection’s original location and has the same
    resolution as the grid displayed in the editor. In other words, it lets you move the selection in
    “increments” of the grid cell size.

Grid
:   Snaps to grid points.

Vertex
:   Snaps to the vertex that’s closest to the mouse cursor.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Min Zenith
:   The minimum zenith (vertical) rotation angle.
    Defines the lower limit of the random rotation.

Max Zenith
:   The maximum zenith (vertical) rotation angle.
    Defines the upper limit of the random rotation.

ID
:   An ID to drive the random number generator seed. By default, this input uses the same value
    as the [ID Node](../geometry/read/id.xhtml), which is the `id` attribute of the context
    geometry if it exists, and otherwise the [index](../geometry/read/input_index.xhtml).

Seed
:   A field to [seed](../../../glossary/index.xhtml#term-Seed) the random number generator. This can be used to produce
    a different set of random rotations even when using the same *ID* input.
user: Provide the full official documentation entry for Expand, preserving all code examples.

assistant: # Expand

This is a multi-purpose modal operator to intuitively create and edit masks/face sets.
When executed, it uniformly expand outwards a pattern from the vertex under the cursor.

There is also a [full showcase of the Expand features and use cases](https://www.youtube.com/watch?v=XT7h6lmE5bc).

[image reference removed]

A preview of *Expand Mask by Topology*
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Points
:   Generated point cloud.

Tangent
:   The normalized [curve tangent](../read/curve_tangent.xhtml) at the sampled
    position, or the direct evaluated normal in *Evaluated* mode.

Normal
:   The normal value from the evaluated curve at each result point.
    This is the same value from the [Normal Node](../../geometry/read/normal.xhtml)
    at those positions.

Rotation
:   The [Euler](../../../../glossary/index.xhtml#term-Euler) rotation build from the *Tangent* and *Normal* outputs, for convenience.
user: Give a detailed overview of MatCaps: syntax, arguments, return values, common patterns.

assistant: This panel manages [MatCap](../../glossary/index.xhtml#term-MatCap) image files
which can used to light the view when [MatCap](../../render/workbench/lighting.xhtml#render-workbench-matcap) shading is enabled.

Two kinds of images are supported for MatCaps. Regular image files and
multilayered OpenEXR files. When using multilayered OpenEXR files,
the layer named “diffuse” will be used as a diffuse pass, the layer named “specular”
will be used as a specular pass. Regular images will be handled as “diffuse” and
will not support specular highlighting.

The diffuse pass is multiplied with the base color of the objects and the specular pass is added on top.
MatCaps, that only have a diffuse pass tend to look very metallic,
with a separate specular pass it is possible to simulate a wider variety of materials.
user: Provide the full official documentation entry for Usage, preserving all code examples.

assistant: The *Evaluate Closure* node is typically used to make a node group partially customizable while maintaining a stable,
reusable framework.

For example, a terrain generator might use *Evaluate Closure* to define how trees are distributed across a landscape:

1. Inside the generator group, replace the fixed tree placement logic with an *Evaluate Closure* node.
2. Expose the closure input on the group’s interface.
3. In the main node tree, connect a *Closure Zone* defining the desired tree distribution behavior.

Whenever the closure is evaluated, the connected node graph runs within the terrain generator’s context, producing a
customized result.

[image reference removed]

Example: custom tree distribution using *Evaluate Closure*.
user: Describe The Armature Object from the Blender manual or Python API, including usage steps and snippets.

assistant: As you can see, an armature is like any other object type in Blender:

- It has an origin, a position, a rotation and a scale factor.
- It has an Object Data data-block, that can be edited in *Edit Mode*.
- It can be linked to other scenes, and the same armature data can be reused on multiple objects.
- All animation you do in *Object Mode* is only working on the whole object,
  not the armature’s bones (use the *Pose Mode* to do this).

As armatures are designed to be posed, either for a static or animated scene,
they have a specific state, called “rest position”. This is the armature’s default “shape”,
the default position/rotation/scale of its bones, as set in *Edit Mode*.

In *Edit Mode*, you will always see your armature in rest position,
whereas in *Object Mode* and *Pose Mode*,
you usually get the current “pose” of the armature
(unless you enable the *Rest Position* button of the *Armature* panel).
user: Show practical ways to work with Object in a Blender add-on or script – include code.

assistant: The Viewport Display panel in the Object Properties has several settings that
are used by the Workbench Engine.

Shadow
:   When the *Shadow* in the [Options](options.xhtml) is enabled
    this object will cast a shadow.

In Front
:   When checked the object will be rendered in front of the other objects in the scene.

Color
:   The color to render the object in when object color needs to be rendered.
    The alpha channel can be used to render the object transparent.
user: Describe Boidrule Type Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Boidrule Type Items

GOAL:
:   Goal.

    Go to assigned object or loudest assigned signal source.

AVOID:
:   Avoid.

    Get away from assigned object or loudest assigned signal source.

AVOID_COLLISION:
:   Avoid Collision.

    Maneuver to avoid collisions with other boids and deflector objects in near future.

SEPARATE:
:   Separate.

    Keep from going through other boids.

FLOCK:
:   Flock.

    Move to center of neighbors and match their velocity.

FOLLOW_LEADER:
:   Follow Leader.

    Follow a boid or assigned object.

AVERAGE_SPEED:
:   Average Speed.

    Maintain speed, flight level or wander.

FIGHT:
:   Fight.

    Go to closest enemy and attack when in range.
user: How do I use RemeshModifier(Modifier) in Blender? Include parameters, examples, warnings and best practices.

assistant: # RemeshModifier(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.RemeshModifier(*Modifier*)
:   Generate a new surface with regular topology that follows the shape of the input mesh

    adaptivity
    :   Reduces the final face count by simplifying geometry where detail is not needed, generating triangles. A value greater than 0 disables Fix Poles.

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

    mode
    :   - `BLOCKS`
          Blocks – Output a blocky surface with no smoothing.
        - `SMOOTH`
          Smooth – Output a smooth surface with no sharp-features detection.
        - `SHARP`
          Sharp – Output a surface that reproduces sharp edges and corners from the input mesh.
        - `VOXEL`
          Voxel – Output a mesh corresponding to the volume of the original mesh.

        Type:
        :   enum in [`'BLOCKS'`, `'SMOOTH'`, `'SHARP'`, `'VOXEL'`], default `'VOXEL'`

    octree_depth
    :   Resolution of the octree; higher values give finer details

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

    scale
    :   The ratio of the largest dimension of the model over the size of the grid

        Type:
        :   float in [0, 0.99], default 0.9

    sharpness
    :   Tolerance for outliers; lower values filter noise while higher values will reproduce edges closer to the input

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

    threshold
    :   If removing disconnected pieces, minimum size of components to preserve as a ratio of the number of polygons in the largest component

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

    use_remove_disconnected
    :   Type:
        :   boolean, default True

    use_smooth_shade
    :   Output faces with smooth shading rather than flat shaded

        Type:
        :   boolean, default False

    voxel_size
    :   Size of the voxel in object space used for volume evaluation. Lower values preserve finer details.

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

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

assistant: This node is often used for additional control in color grading, replacing the
display and view transform in the color management settings.

To avoid doubling up transforms, it is recommended to:

- Add a second Convert to Display node with the Standard view transform and
  Inverse enabled, as the last node in the compositing node graph.
- Set the view transform to Standard in the scene color management settings.

The compositor will then output colors in the
[working space](../../../render/color_management/color_spaces.html#bpy-types-blendfilecolorspace-working-space) as usual,
but with color grading baked in. Unlike workflows using the Raw view
transform, this works correctly with the video sequencer and OpenEXR output.
user: What is Properties and how is it used in Blender Python scripting?

assistant: Normalize
:   If enabled, the X-coordinates of the *Segment Coordinates* output are remapped into a 0.0 to 1.0 range
    and a constant value of 1.0 is added to the Y-coordinates which makes the output range non-negative.

    |  |  |
    | --- | --- |
    | ../../../../_images/render_shader-nodes_radial_tiling_normalize-disabled.png   Normalize: Disabled. | ../../../../_images/render_shader-nodes_radial_tiling_normalize-enabled.png   Normalize: Enabled. |
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Mesh
:   Standard geometry input.

Selection
:   A standard Boolean selection input to determine which faces will be triangulated.

Quad Method
:   Beauty:
    :   Split the quads in nice triangles, slower method.

    Fixed:
    :   Split the quads on their 1st and 3rd vertices.

    Fixed Alternate:
    :   Split the quads on their 2nd and 4th vertices.

    Shortest Diagonal:
    :   Split the quads along their shortest diagonal.

    Longest Diagonal:
    :   Split the quads along their longest diagonal. This is the preferred mode for cloth simulations.

N-gon Method
:   Beauty:
    :   Arrange the new triangles nicely, slower method.

    Clip:
    :   Split n-gons using an ear-clipping algorithm
        (the same method of tessellation used for viewport display).
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Image
:   Standard color input image.

Radius
:   Controls how much surrounding area is sampled when detecting edges.
    Larger values affect broader regions and can enhance larger features,
    while smaller values focus on fine detail.

Factor
:   Controls the intensity of the sharpening effect.
    Higher values produce stronger edge contrast but can lead to halos or artifacts if overused.

Threshold
:   Defines how different a pixel must be from its surrounding area before sharpening is applied.
    Higher values limit sharpening to more distinct edges, reducing noise enhancement.
user: Explain CompositorNodeSplit(CompositorNode) in complete detail according to the official Blender documentation.

assistant: # CompositorNodeSplit(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.CompositorNodeSplit(*CompositorNode*)
:   Combine two images for side-by-side display. Typically used in combination with a Viewer node

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

assistant: # Armature Structure

[image reference removed]

Example of a very basic armature.

Armatures mimic real skeletons. They are made out of bones, which are (by default) rigid elements.
But you have more possibilities than with real skeletons: In addition to the “natural” rotation of bones,
you can also move and even scale them! And your bones do not have to be connected to each other;
they can be completely free if you want. However,
the most natural and useful setups imply that some bones are related to others, forming so-called “chains of bones”,
which create some sort of “limbs” in your armature, as detailed in [Chains of Bones](#chains-of-bones).